1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
#pragma once
#include <memory>
#include <string>
#include <vector>
namespace blobs
{
enum OpenFlags
{
read = (1 << 0),
write = (1 << 1),
/* bits 3-7 reserved. */
/* bits 8-15 given blob-specific definitions */
};
enum StateFlags
{
open_read = (1 << 0),
open_write = (1 << 1),
committing = (1 << 2),
committed = (1 << 3),
commit_error = (1 << 4),
};
struct BlobMeta
{
uint16_t blobState;
uint32_t size;
std::vector<uint8_t> metadata;
};
/*
* All blob specific objects implement this interface.
*/
class GenericBlobInterface
{
public:
virtual ~GenericBlobInterface() = default;
/**
* Checks if the handler will manage this file path.
*
* @param[in] blobId.
* @return bool whether it will manage the file path.
*/
virtual bool canHandleBlob(const std::string& path) = 0;
/**
* Return the name(s) of the blob(s). Used during GetCount.
*
* @return List of blobIds this handler manages.
*/
virtual std::vector<std::string> getBlobIds() = 0;
/**
* Attempt to delete the blob specified by the path.
*
* @param[in] path - the blobId to try and delete.
* @return bool - whether it was able to delete the blob.
*/
virtual bool deleteBlob(const std::string& path) = 0;
/**
* Return metadata about the blob.
*
* @param[in] path - the blobId for metadata.
* @param[in,out] meta - a pointer to a blobmeta.
* @return bool - true if it was successful.
*/
virtual bool stat(const std::string& path, struct BlobMeta* meta) = 0;
/* The methods below are per session. */
/**
* Attempt to open a session from this path.
*
* @param[in] session - the session id.
* @param[in] flags - the open flags.
* @param[in] path - the blob path.
* @return bool - was able to open the session.
*/
virtual bool open(uint16_t session, uint16_t flags,
const std::string& path) = 0;
/**
* Attempt to read from a blob.
*
* @param[in] session - the session id.
* @param[in] offset - offset into the blob.
* @param[in] requestedSize - number of bytes to read.
* @return Bytes read back (0 length on error).
*/
virtual std::vector<uint8_t> read(uint16_t session, uint32_t offset,
uint32_t requestedSize) = 0;
/**
* Attempt to write to a blob.
*
* @param[in] session - the session id.
* @param[in] offset - offset into the blob.
* @param[in] data - the data to write.
* @return bool - was able to write.
*/
virtual bool write(uint16_t session, uint32_t offset,
const std::vector<uint8_t>& data) = 0;
/**
* Attempt to write metadata to a blob.
*
* @param[in] session - the session id.
* @param[in] offset - offset into the blob.
* @param[in] data - the data to write.
* @return bool - was able to write.
*/
virtual bool writeMeta(uint16_t session, uint32_t offset,
const std::vector<uint8_t>& data) = 0;
/**
* Attempt to commit to a blob.
*
* @param[in] session - the session id.
* @param[in] data - optional commit data.
* @return bool - was able to start commit.
*/
virtual bool commit(uint16_t session, const std::vector<uint8_t>& data) = 0;
/**
* Attempt to close your session.
*
* @param[in] session - the session id.
* @return bool - was able to close session.
*/
virtual bool close(uint16_t session) = 0;
/**
* Attempt to return metadata for the session's view of the blob.
*
* @param[in] session - the session id.
* @param[in,out] meta - pointer to update with the BlobMeta.
* @return bool - wether it was successful.
*/
virtual bool stat(uint16_t session, struct BlobMeta* meta) = 0;
/**
* Attempt to expire a session. This is called when a session has been
* inactive for at least 10 minutes.
*
* @param[in] session - the session id.
* @return bool - whether the session was able to be closed.
*/
virtual bool expire(uint16_t session) = 0;
};
} // namespace blobs
#ifdef __cplusplus
extern "C" {
#endif
/**
* All Blob handlers need to implement this method. It is called after loading
* the library to then get a handle to the blob handler.
*
* @return a unique pointer to your blob handler instance.
*/
std::unique_ptr<blobs::GenericBlobInterface> createHandler();
#ifdef __cplusplus
}
#endif
|
