/usr/include/rados/librados.hpp is in librados-dev 0.41-1ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 | #ifndef __LIBRADOS_HPP
#define __LIBRADOS_HPP
#include <stdbool.h>
#include <string>
#include <list>
#include <map>
#include <tr1/memory>
#include <vector>
#include <utility>
#include "buffer.h"
#include "librados.h"
class CephContext;
namespace librados
{
using ceph::bufferlist;
class AioCompletionImpl;
class IoCtx;
class IoCtxImpl;
class ObjectOperationImpl;
class ObjListCtx;
class PoolAsyncCompletionImpl;
class RadosClient;
typedef void *list_ctx_t;
typedef uint64_t snap_t;
typedef uint64_t auid_t;
struct cluster_stat_t {
uint64_t kb, kb_used, kb_avail;
uint64_t num_objects;
};
struct pool_stat_t {
uint64_t num_bytes; // in bytes
uint64_t num_kb; // in KB
uint64_t num_objects;
uint64_t num_object_clones;
uint64_t num_object_copies; // num_objects * num_replicas
uint64_t num_objects_missing_on_primary;
uint64_t num_objects_unfound;
uint64_t num_objects_degraded;
uint64_t num_rd, num_rd_kb, num_wr, num_wr_kb;
};
typedef std::map<std::string, pool_stat_t> stats_map;
typedef void *completion_t;
typedef void (*callback_t)(completion_t cb, void *arg);
struct SnapContext {
snap_t seq;
std::vector<snap_t> snaps;
};
class ObjectIterator : public std::iterator <std::forward_iterator_tag, std::string> {
public:
static const ObjectIterator __EndObjectIterator;
ObjectIterator() {}
ObjectIterator(ObjListCtx *ctx_);
~ObjectIterator();
bool operator==(const ObjectIterator& rhs) const;
bool operator!=(const ObjectIterator& rhs) const;
const std::pair<std::string, std::string>& operator*() const;
const std::pair<std::string, std::string>* operator->() const;
ObjectIterator &operator++(); // Preincrement
ObjectIterator operator++(int); // Postincrement
friend class IoCtx;
private:
void get_next();
std::tr1::shared_ptr < ObjListCtx > ctx;
std::pair<std::string, std::string> cur_obj;
};
class WatchCtx {
public:
virtual ~WatchCtx();
virtual void notify(uint8_t opcode, uint64_t ver, bufferlist& bl) = 0;
};
struct AioCompletion {
AioCompletion(AioCompletionImpl *pc_) : pc(pc_) {}
int set_complete_callback(void *cb_arg, callback_t cb);
int set_safe_callback(void *cb_arg, callback_t cb);
int wait_for_complete();
int wait_for_safe();
bool is_complete();
bool is_safe();
int get_return_value();
int get_version();
void release();
AioCompletionImpl *pc;
};
struct PoolAsyncCompletion {
PoolAsyncCompletion(PoolAsyncCompletionImpl *pc_) : pc(pc_) {}
int set_callback(void *cb_arg, callback_t cb);
int wait();
bool is_complete();
int get_return_value();
void release();
PoolAsyncCompletionImpl *pc;
};
enum ObjectOperationFlags {
OP_EXCL = 1,
OP_FAILOK = 2,
};
/*
* ObjectOperation : compount object operation
* Batch multiple object operations into a single request, to be applied
* atomically.
*/
class ObjectOperation
{
public:
ObjectOperation();
virtual ~ObjectOperation();
size_t size();
void set_op_flags(ObjectOperationFlags flags);
void cmpxattr(const char *name, uint8_t op, const bufferlist& val);
void cmpxattr(const char *name, uint8_t op, uint64_t v);
void src_cmpxattr(const std::string& src_oid,
const char *name, int op, const bufferlist& val);
void src_cmpxattr(const std::string& src_oid,
const char *name, int op, uint64_t v);
void exec(const char *cls, const char *method, bufferlist& inbl);
protected:
ObjectOperationImpl *impl;
ObjectOperation(const ObjectOperation& rhs);
ObjectOperation& operator=(const ObjectOperation& rhs);
friend class IoCtx;
friend class Rados;
};
/*
* ObjectWriteOperation : compount object write operation
* Batch multiple object operations into a single request, to be applied
* atomically.
*/
class ObjectWriteOperation : public ObjectOperation
{
protected:
time_t *pmtime;
public:
ObjectWriteOperation() : pmtime(NULL) {}
~ObjectWriteOperation() {}
void mtime(time_t *pt) {
pmtime = pt;
}
void create(bool exclusive);
void create(bool exclusive, const std::string& category);
void write(uint64_t off, const bufferlist& bl);
void write_full(const bufferlist& bl);
void append(const bufferlist& bl);
void remove();
void truncate(uint64_t off);
void zero(uint64_t off, uint64_t len);
void rmxattr(const char *name);
void setxattr(const char *name, const bufferlist& bl);
void tmap_update(const bufferlist& cmdbl);
void clone_range(uint64_t dst_off,
const std::string& src_oid, uint64_t src_off,
size_t len);
friend class IoCtx;
};
/*
* ObjectReadOperation : compount object operation that return value
* Batch multiple object operations into a single request, to be applied
* atomically.
*/
class ObjectReadOperation : public ObjectOperation
{
public:
ObjectReadOperation() {}
~ObjectReadOperation() {}
void stat(uint64_t *psize, time_t *pmtime, int *prval);
void getxattr(const char *name, bufferlist *pbl, int *prval);
void getxattrs(std::map<std::string, bufferlist> *pattrs, int *prval);
void read(size_t off, uint64_t len, bufferlist *pbl, int *prval);
};
/* IoCtx : This is a context in which we can perform I/O.
* It includes a Pool,
*
* Typical use (error checking omitted):
*
* IoCtx p;
* rados.ioctx_create("my_pool", p);
* p->stat(&stats);
* ... etc ...
*/
class IoCtx
{
public:
IoCtx();
static void from_rados_ioctx_t(rados_ioctx_t p, IoCtx &pool);
IoCtx(const IoCtx& rhs);
IoCtx& operator=(const IoCtx& rhs);
~IoCtx();
// Close our pool handle
void close();
// deep copy
void dup(const IoCtx& rhs);
// set pool auid
int set_auid(uint64_t auid_);
// set pool auid
int set_auid_async(uint64_t auid_, PoolAsyncCompletion *c);
// get pool auid
int get_auid(uint64_t *auid_);
// create an object
int create(const std::string& oid, bool exclusive);
int create(const std::string& oid, bool exclusive, const std::string& category);
int write(const std::string& oid, bufferlist& bl, size_t len, uint64_t off);
int append(const std::string& oid, bufferlist& bl, size_t len);
int write_full(const std::string& oid, bufferlist& bl);
int clone_range(const std::string& dst_oid, uint64_t dst_off,
const std::string& src_oid, uint64_t src_off,
size_t len);
int read(const std::string& oid, bufferlist& bl, size_t len, uint64_t off);
int remove(const std::string& oid);
int trunc(const std::string& oid, uint64_t size);
int mapext(const std::string& o, uint64_t off, size_t len, std::map<uint64_t,uint64_t>& m);
int sparse_read(const std::string& o, std::map<uint64_t,uint64_t>& m, bufferlist& bl, size_t len, uint64_t off);
int getxattr(const std::string& oid, const char *name, bufferlist& bl);
int getxattrs(const std::string& oid, std::map<std::string, bufferlist>& attrset);
int setxattr(const std::string& oid, const char *name, bufferlist& bl);
int rmxattr(const std::string& oid, const char *name);
int stat(const std::string& oid, uint64_t *psize, time_t *pmtime);
int exec(const std::string& oid, const char *cls, const char *method,
bufferlist& inbl, bufferlist& outbl);
int tmap_update(const std::string& oid, bufferlist& cmdbl);
int tmap_put(const std::string& oid, bufferlist& bl);
int tmap_get(const std::string& oid, bufferlist& bl);
void snap_set_read(snap_t seq);
int selfmanaged_snap_set_write_ctx(snap_t seq, std::vector<snap_t>& snaps);
// Create a snapshot with a given name
int snap_create(const char *snapname);
// Look up a snapshot by name.
// Returns 0 on success; error code otherwise
int snap_lookup(const char *snapname, snap_t *snap);
// Gets a timestamp for a snap
int snap_get_stamp(snap_t snapid, time_t *t);
// Gets the name of a snap
int snap_get_name(snap_t snapid, std::string *s);
// Remove a snapshot from this pool
int snap_remove(const char *snapname);
int snap_list(std::vector<snap_t> *snaps);
int rollback(const std::string& oid, const char *snapname);
int selfmanaged_snap_create(uint64_t *snapid);
int selfmanaged_snap_remove(uint64_t snapid);
int selfmanaged_snap_rollback(const std::string& oid, uint64_t snapid);
ObjectIterator objects_begin();
const ObjectIterator& objects_end() const;
uint64_t get_last_version();
int aio_read(const std::string& oid, AioCompletion *c,
bufferlist *pbl, size_t len, uint64_t off);
int aio_sparse_read(const std::string& oid, AioCompletion *c,
std::map<uint64_t,uint64_t> *m, bufferlist *data_bl,
size_t len, uint64_t off);
int aio_write(const std::string& oid, AioCompletion *c, const bufferlist& bl,
size_t len, uint64_t off);
int aio_append(const std::string& oid, AioCompletion *c, const bufferlist& bl,
size_t len);
int aio_write_full(const std::string& oid, AioCompletion *c, const bufferlist& bl);
int aio_flush();
int aio_exec(const std::string& oid, AioCompletion *c, const char *cls, const char *method,
bufferlist& inbl, bufferlist *outbl);
// compound object operations
int operate(const std::string& oid, ObjectWriteOperation *op);
int operate(const std::string& oid, ObjectReadOperation *op, bufferlist *pbl);
int aio_operate(const std::string& oid, AioCompletion *c, ObjectOperation *op);
// watch/notify
int watch(const std::string& o, uint64_t ver, uint64_t *handle,
librados::WatchCtx *ctx);
int unwatch(const std::string& o, uint64_t handle);
int notify(const std::string& o, uint64_t ver, bufferlist& bl);
void set_notify_timeout(uint32_t timeout);
// assert version for next sync operations
void set_assert_version(uint64_t ver);
void set_assert_src_version(const std::string& o, uint64_t ver);
const std::string& get_pool_name() const;
void locator_set_key(const std::string& key);
int64_t get_id();
CephContext *cct();
private:
/* You can only get IoCtx instances from Rados */
IoCtx(IoCtxImpl *io_ctx_impl_);
friend class Rados; // Only Rados can use our private constructor to create IoCtxes.
IoCtxImpl *io_ctx_impl;
};
class Rados
{
public:
static void version(int *major, int *minor, int *extra);
Rados();
~Rados();
int init(const char * const id);
int init_with_context(CephContext *cct_);
int connect();
void shutdown();
int conf_read_file(const char * const path) const;
int conf_parse_argv(int argc, const char ** argv) const;
int conf_parse_env(const char *env) const;
int conf_set(const char *option, const char *value);
int conf_get(const char *option, std::string &val);
int pool_create(const char *name);
int pool_create(const char *name, uint64_t auid);
int pool_create(const char *name, uint64_t auid, __u8 crush_rule);
int pool_create_async(const char *name, PoolAsyncCompletion *c);
int pool_create_async(const char *name, uint64_t auid, PoolAsyncCompletion *c);
int pool_create_async(const char *name, uint64_t auid, __u8 crush_rule, PoolAsyncCompletion *c);
int pool_delete(const char *name);
int pool_delete_async(const char *name, PoolAsyncCompletion *c);
int64_t pool_lookup(const char *name);
int ioctx_create(const char *name, IoCtx &pioctx);
/* listing objects */
int pool_list(std::list<std::string>& v);
int get_pool_stats(std::list<std::string>& v,
std::map<std::string, stats_map>& stats);
int get_pool_stats(std::list<std::string>& v,
std::string& category,
std::map<std::string, stats_map>& stats);
int cluster_stat(cluster_stat_t& result);
/* pool aio */
static PoolAsyncCompletion *pool_async_create_completion();
// -- aio --
static AioCompletion *aio_create_completion();
static AioCompletion *aio_create_completion(void *cb_arg, callback_t cb_complete,
callback_t cb_safe);
friend std::ostream& operator<<(std::ostream &oss, const Rados& r);
private:
// We don't allow assignment or copying
Rados(const Rados& rhs);
const Rados& operator=(const Rados& rhs);
RadosClient *client;
};
}
#endif
|