{
public:
ACLID_S3() {}
- ~ACLID_S3() {}
+ ~ACLID_S3() override {}
string& to_str() { return data; }
};
{
public:
ACLURI_S3() {}
- ~ACLURI_S3() {}
+ ~ACLURI_S3() override {}
};
class ACLEmail_S3 : public XMLObj
{
public:
ACLEmail_S3() {}
- ~ACLEmail_S3() {}
+ ~ACLEmail_S3() override {}
};
class ACLDisplayName_S3 : public XMLObj
{
public:
ACLDisplayName_S3() {}
- ~ACLDisplayName_S3() {}
+ ~ACLDisplayName_S3() override {}
};
bool ACLOwner_S3::xml_end(const char *el) {
{
public:
ACLPermission_S3() {}
- ~ACLPermission_S3() {}
+ ~ACLPermission_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out);
};
{
public:
ACLGrantee_S3() {}
- ~ACLGrantee_S3() {}
+ ~ACLGrantee_S3() override {}
bool xml_start(const char *el, const char **attr);
};
{
public:
ACLGrant_S3() {}
- ~ACLGrant_S3() {}
+ ~ACLGrant_S3() override {}
void to_xml(CephContext *cct, ostream& out);
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
bool xml_start(const char *el, const char **attr);
static ACLGroupTypeEnum uri_to_group(string& uri);
{
public:
explicit RGWAccessControlList_S3(CephContext *_cct) : RGWAccessControlList(_cct) {}
- ~RGWAccessControlList_S3() {}
+ ~RGWAccessControlList_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out);
int create_canned(ACLOwner& owner, ACLOwner& bucket_owner, const string& canned_acl);
{
public:
ACLOwner_S3() {}
- ~ACLOwner_S3() {}
+ ~ACLOwner_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out);
};
{
public:
explicit RGWAccessControlPolicy_S3(CephContext *_cct) : RGWAccessControlPolicy(_cct) {}
- ~RGWAccessControlPolicy_S3() {}
+ ~RGWAccessControlPolicy_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out);
int rebuild(RGWRados *store, ACLOwner *owner, RGWAccessControlPolicy& dest);
- bool compare_group_name(string& id, ACLGroupTypeEnum group);
+ bool compare_group_name(string& id, ACLGroupTypeEnum group) override;
virtual int create_canned(ACLOwner& _owner, ACLOwner& bucket_owner, string canned_acl) {
RGWAccessControlList_S3& _acl = static_cast<RGWAccessControlList_S3 &>(acl);
{
CephContext *cct;
- XMLObj *alloc_obj(const char *el);
+ XMLObj *alloc_obj(const char *el) override;
public:
explicit RGWACLXMLParser_S3(CephContext *_cct) : cct(_cct) {}
};
explicit RGWAccessControlPolicy_SWIFT(CephContext* const cct)
: RGWAccessControlPolicy(cct) {
}
- ~RGWAccessControlPolicy_SWIFT() = default;
+ ~RGWAccessControlPolicy_SWIFT() override = default;
int create(RGWRados *store,
const rgw_user& id,
RGWAccessControlPolicy_SWIFTAcct(CephContext * const cct)
: RGWAccessControlPolicy(cct) {
}
- ~RGWAccessControlPolicy_SWIFTAcct() {}
+ ~RGWAccessControlPolicy_SWIFTAcct() override {}
void add_grants(RGWRados *store,
const std::vector<std::string>& uids,
public:
RGWAsioClientIO(tcp::socket&& socket, request_type&& request);
- ~RGWAsioClientIO();
+ ~RGWAsioClientIO() override;
void init_env(CephContext *cct) override;
size_t complete_request() override;
std::unique_ptr<Impl> impl;
public:
RGWAsioFrontend(const RGWProcessEnv& env);
- ~RGWAsioFrontend();
+ ~RGWAsioFrontend() override;
int init() override;
int run() override;
typedef std::unique_ptr<RGWAuthApplier> aplptr_t;
RGWAuthApplier(CephContext * const cct) : cct(cct) {}
- virtual ~RGWAuthApplier() {};
+ ~RGWAuthApplier() override {};
/* Fill provided RGWUserInfo with information about the account that
* RGWOp will operate on. Errors are handled solely through exceptions.
mtime = m;
}
- void dump(Formatter *f) const {
+ void dump(Formatter *f) const override {
ep.dump(f);
}
};
mtime = m;
}
- void dump(Formatter *f) const {
+ void dump(Formatter *f) const override {
info.dump(f);
}
public:
ChangesRenewThread(CephContext *_cct, RGWDataChangesLog *_log) : cct(_cct), log(_log), lock("ChangesRenewThread::lock") {}
- void *entry();
+ void *entry() override;
void stop();
};
return normal_name(obj.pool, obj.oid);
}
- int init_rados() {
+ int init_rados() override {
int ret;
cache.set_ctx(T::cct);
ret = T::init_rados();
return 0;
}
- bool need_watch_notify() {
+ bool need_watch_notify() override {
return true;
}
int watch_cb(uint64_t notify_id,
uint64_t cookie,
uint64_t notifier_id,
- bufferlist& bl);
+ bufferlist& bl) override;
- void set_cache_enabled(bool state) {
+ void set_cache_enabled(bool state) override {
cache.set_enabled(state);
}
public:
RGWCache() {}
- void register_chained_cache(RGWChainedCache *cc) {
+ void register_chained_cache(RGWChainedCache *cc) override {
cache.chain_cache(cc);
}
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
- real_time set_mtime);
- int put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl, off_t ofs, bool exclusive);
+ real_time set_mtime) override;
+ int put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl, off_t ofs, bool exclusive) override;
int get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
RGWObjVersionTracker *objv_tracker, rgw_raw_obj& obj,
bufferlist& bl, off_t ofs, off_t end,
map<string, bufferlist> *attrs,
- rgw_cache_entry_info *cache_info);
+ rgw_cache_entry_info *cache_info) override;
int raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs,
- bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker);
+ bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker) override;
- int delete_system_obj(rgw_raw_obj& obj, RGWObjVersionTracker *objv_tracker);
+ int delete_system_obj(rgw_raw_obj& obj, RGWObjVersionTracker *objv_tracker) override;
- bool chain_cache_entry(list<rgw_cache_entry_info *>& cache_info_entries, RGWChainedCache::Entry *chained_entry) {
+ bool chain_cache_entry(list<rgw_cache_entry_info *>& cache_info_entries, RGWChainedCache::Entry *chained_entry) override {
return cache.chain_cache_entry(cache_info_entries, chained_entry);
}
};
size_t dump_date_header();
public:
- void init_env(CephContext *cct);
+ void init_env(CephContext *cct) override;
size_t send_status(int status, const char *status_name) override;
size_t send_100_continue() override;
SHA256 *sha256_hash;
public:
- virtual ~RGWRestfulIO() {}
+ ~RGWRestfulIO() override {}
RGWRestfulIO(rgw::io::RestfulClient* engine)
: AccountingFilter<rgw::io::RestfulClient*>(std::move(engine)),
setg(nullptr, nullptr, nullptr);
}
- std::streambuf::int_type underflow() {
+ std::streambuf::int_type underflow() override {
if (gptr() < egptr()) {
return traits_type::to_int_type(*gptr());
}
RGWCompressionInfo* cs_info_,
bool partial_content_,
RGWGetDataCB* next);
- virtual ~RGWGetObj_Decompress() {}
+ ~RGWGetObj_Decompress() override {}
- virtual int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override;
- virtual void fixup_range(off_t& ofs, off_t& end) override;
+ int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override;
+ void fixup_range(off_t& ofs, off_t& end) override;
};
RGWPutObj_Compress(CephContext* cct_, CompressorRef compressor,
RGWPutObjDataProcessor* next)
: RGWPutObj_Filter(next), cct(cct_), compressor(compressor) {}
- virtual ~RGWPutObj_Compress(){}
- virtual int handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again) override;
+ ~RGWPutObj_Compress() override{}
+ int handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again) override;
bool is_compressed() { return compressed; }
vector<compression_block>& get_compression_blocks() { return blocks; }
void _complete(RGWAioCompletionNotifier *cn, void *user_info);
public:
RGWCompletionManager(CephContext *_cct);
- ~RGWCompletionManager();
+ ~RGWCompletionManager() override;
void complete(RGWAioCompletionNotifier *cn, void *user_info);
int get_next(void **user_info);
public:
RGWAioCompletionNotifier(RGWCompletionManager *_mgr, void *_user_data);
- ~RGWAioCompletionNotifier() {
+ ~RGWAioCompletionNotifier() override {
c->release();
lock.Lock();
bool need_unregister = registered;
public:
RGWCoroutine(CephContext *_cct) : status(_cct), _yield_ret(false), cct(_cct), stack(NULL), retcode(0), state(RGWCoroutine_Run) {}
- virtual ~RGWCoroutine();
+ ~RGWCoroutine() override;
virtual int operate() = 0;
bool collect_next(RGWCoroutine *op, int *ret, RGWCoroutinesStack **collected_stack); /* returns true if found a stack to collect */
public:
RGWCoroutinesStack(CephContext *_cct, RGWCoroutinesManager *_ops_mgr, RGWCoroutine *start = NULL);
- ~RGWCoroutinesStack();
+ ~RGWCoroutinesStack() override;
int operate(RGWCoroutinesEnv *env);
public:
RGWCoroutinesManagerRegistry(CephContext *_cct) : cct(_cct), lock("RGWCoroutinesRegistry::lock") {}
- ~RGWCoroutinesManagerRegistry();
+ ~RGWCoroutinesManagerRegistry() override;
void add(RGWCoroutinesManager *mgr);
void remove(RGWCoroutinesManager *mgr);
int hook_to_admin_command(const string& command);
bool call(std::string command, cmdmap_t& cmdmap, std::string format,
- bufferlist& out);
+ bufferlist& out) override;
void dump(Formatter *f) const;
};
class RGWSimpleCoroutine : public RGWCoroutine {
bool called_cleanup;
- int operate();
+ int operate() override;
int state_init();
int state_send_request();
public:
RGWSimpleCoroutine(CephContext *_cct) : RGWCoroutine(_cct), called_cleanup(false) {}
- ~RGWSimpleCoroutine();
+ ~RGWSimpleCoroutine() override;
virtual int init() { return 0; }
virtual int send_request() = 0;
class CORSRuleID_S3 : public XMLObj {
public:
CORSRuleID_S3() {}
- ~CORSRuleID_S3() {}
+ ~CORSRuleID_S3() override {}
};
class CORSRuleAllowedOrigin_S3 : public XMLObj {
public:
CORSRuleAllowedOrigin_S3() {}
- ~CORSRuleAllowedOrigin_S3() {}
+ ~CORSRuleAllowedOrigin_S3() override {}
};
class CORSRuleAllowedMethod_S3 : public XMLObj {
public:
CORSRuleAllowedMethod_S3() {}
- ~CORSRuleAllowedMethod_S3() {}
+ ~CORSRuleAllowedMethod_S3() override {}
};
class CORSRuleAllowedHeader_S3 : public XMLObj {
public:
CORSRuleAllowedHeader_S3() {}
- ~CORSRuleAllowedHeader_S3() {}
+ ~CORSRuleAllowedHeader_S3() override {}
};
class CORSRuleMaxAgeSeconds_S3 : public XMLObj {
public:
CORSRuleMaxAgeSeconds_S3() {}
- ~CORSRuleMaxAgeSeconds_S3() {}
+ ~CORSRuleMaxAgeSeconds_S3() override {}
};
class CORSRuleExposeHeader_S3 : public XMLObj {
public:
CORSRuleExposeHeader_S3() {}
- ~CORSRuleExposeHeader_S3() {}
+ ~CORSRuleExposeHeader_S3() override {}
};
XMLObj *RGWCORSXMLParser_S3::alloc_obj(const char *el) {
{
public:
RGWCORSRule_S3() {}
- ~RGWCORSRule_S3() {}
+ ~RGWCORSRule_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(XMLFormatter& f);
};
{
public:
RGWCORSConfiguration_S3() {}
- ~RGWCORSConfiguration_S3() {}
+ ~RGWCORSConfiguration_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out);
};
{
CephContext *cct;
- XMLObj *alloc_obj(const char *el);
+ XMLObj *alloc_obj(const char *el) override;
public:
explicit RGWCORSXMLParser_S3(CephContext *_cct) : cct(_cct) {}
};
RGWAsyncRadosRequest(RGWCoroutine *_caller, RGWAioCompletionNotifier *_cn) : caller(_caller), notifier(_cn), retcode(0),
lock("RGWAsyncRadosRequest::lock") {
}
- virtual ~RGWAsyncRadosRequest() {
+ ~RGWAsyncRadosRequest() override {
if (notifier) {
notifier->put();
}
RGWWQ(RGWAsyncRadosProcessor *p, time_t timeout, time_t suicide_timeout, ThreadPool *tp)
: ThreadPool::WorkQueue<RGWAsyncRadosRequest>("RGWWQ", timeout, suicide_timeout, tp), processor(p) {}
- bool _enqueue(RGWAsyncRadosRequest *req);
- void _dequeue(RGWAsyncRadosRequest *req) {
+ bool _enqueue(RGWAsyncRadosRequest *req) override;
+ void _dequeue(RGWAsyncRadosRequest *req) override {
ceph_abort();
}
- bool _empty();
- RGWAsyncRadosRequest *_dequeue();
+ bool _empty() override;
+ RGWAsyncRadosRequest *_dequeue() override;
using ThreadPool::WorkQueue<RGWAsyncRadosRequest>::_process;
- void _process(RGWAsyncRadosRequest *req, ThreadPool::TPHandle& handle);
+ void _process(RGWAsyncRadosRequest *req, ThreadPool::TPHandle& handle) override;
void _dump_queue();
- void _clear() {
+ void _clear() override {
assert(processor->m_req_queue.empty());
}
} req_wq;
off_t ofs;
off_t end;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncGetSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store, RGWObjectCtx *_obj_ctx,
RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
bufferlist bl;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncPutSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
const rgw_raw_obj& _obj, bool _exclusive,
map<string, bufferlist> *attrs;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncPutSystemObjAttrs(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
uint32_t duration_secs;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncLockSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
string cookie;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncUnlockSystemObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
RGWObjVersionTracker *_objv_tracker, const rgw_raw_obj& _obj,
: RGWSimpleCoroutine(_store->ctx()), async_rados(_async_rados), store(_store),
obj_ctx(store), obj(_obj), result(_result),
empty_on_enoent(empty_on_enoent) {}
- ~RGWSimpleRadosReadCR() {
+ ~RGWSimpleRadosReadCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request();
- int request_complete();
+ int send_request() override;
+ int request_complete() override;
virtual int handle_data(T& data) {
return 0;
obj(_obj),
pattrs(_pattrs),
req(NULL) { }
- ~RGWSimpleRadosReadAttrsCR() {
+ ~RGWSimpleRadosReadAttrsCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request();
- int request_complete();
+ int send_request() override;
+ int request_complete() override;
};
template <class T>
::encode(_data, bl);
}
- ~RGWSimpleRadosWriteCR() {
+ ~RGWSimpleRadosWriteCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncPutSystemObj(this, stack->create_completion_notifier(),
store, obj, false, bl);
async_rados->queue(req);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
};
obj(_obj),
attrs(_attrs), req(NULL) {
}
- ~RGWSimpleRadosWriteAttrsCR() {
+ ~RGWSimpleRadosWriteAttrsCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncPutSystemObjAttrs(this, stack->create_completion_notifier(),
store, NULL, obj, &attrs);
async_rados->queue(req);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
};
const rgw_raw_obj& _obj,
map<string, bufferlist>& _entries);
- ~RGWRadosSetOmapKeysCR();
+ ~RGWRadosSetOmapKeysCR() override;
- int send_request();
- int request_complete();
+ int send_request() override;
+ int request_complete() override;
};
class RGWRadosGetOmapKeysCR : public RGWSimpleCoroutine {
const string& _marker,
map<string, bufferlist> *_entries, int _max_entries);
- ~RGWRadosGetOmapKeysCR();
+ ~RGWRadosGetOmapKeysCR() override;
- int send_request();
+ int send_request() override;
- int request_complete() {
+ int request_complete() override {
return rval;
}
};
const rgw_raw_obj& _obj,
const set<string>& _keys);
- ~RGWRadosRemoveOmapKeysCR();
+ ~RGWRadosRemoveOmapKeysCR() override;
- int send_request();
+ int send_request() override;
- int request_complete() {
+ int request_complete() override {
return rval;
}
};
const string& _lock_name,
const string& _cookie,
uint32_t _duration);
- ~RGWSimpleRadosLockCR() {
+ ~RGWSimpleRadosLockCR() override {
request_cleanup();
}
- void request_cleanup();
+ void request_cleanup() override;
- int send_request();
- int request_complete();
+ int send_request() override;
+ int request_complete() override;
static std::string gen_random_cookie(CephContext* cct) {
#define COOKIE_LEN 16
const rgw_raw_obj& _obj,
const string& _lock_name,
const string& _cookie);
- ~RGWSimpleRadosUnlockCR() {
+ ~RGWSimpleRadosUnlockCR() override {
request_cleanup();
}
- void request_cleanup();
+ void request_cleanup() override;
- int send_request();
- int request_complete();
+ int send_request() override;
+ int request_complete() override;
};
#define OMAP_APPEND_MAX_ENTRIES_DEFAULT 100
RGWOmapAppend(RGWAsyncRadosProcessor *_async_rados, RGWRados *_store,
const rgw_raw_obj& _obj,
uint64_t _window_size = OMAP_APPEND_MAX_ENTRIES_DEFAULT);
- int operate();
+ int operate() override;
void flush_pending();
bool append(const string& s);
bool finish();
Cond *cond;
utime_t interval;
protected:
- int _send_request() {
+ int _send_request() override {
Mutex::Locker l(*lock);
return cond->WaitInterval(*lock, interval);
}
int _secs) : RGWSimpleCoroutine(_cct), cct(_cct),
async_rados(_async_rados), lock(_lock), cond(_cond), secs(_secs), req(NULL) {
}
- ~RGWWaitCR() {
+ ~RGWWaitCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
wakeup();
req->finish();
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncWait(this, stack->create_completion_notifier(), cct, lock, cond, secs);
async_rados->queue(req);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
RGWBucketInfo *bucket_info;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncGetBucketInstanceInfo(RGWCoroutine *caller, RGWAioCompletionNotifier *cn,
RGWRados *_store, const rgw_bucket& bucket,
const rgw_bucket& bucket, RGWBucketInfo *_bucket_info)
: RGWSimpleCoroutine(_store->ctx()), async_rados(_async_rados), store(_store),
bucket(bucket), bucket_info(_bucket_info), req(NULL) {}
- ~RGWGetBucketInstanceInfoCR() {
+ ~RGWGetBucketInstanceInfoCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncGetBucketInstanceInfo(this, stack->create_completion_notifier(), store, bucket, bucket_info);
async_rados->queue(req);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
};
bool copy_if_newer;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncFetchRemoteObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
const string& _source_zone,
copy_if_newer(_if_newer), req(NULL) {}
- ~RGWFetchRemoteObjCR() {
+ ~RGWFetchRemoteObjCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncFetchRemoteObj(this, stack->create_completion_notifier(), store, source_zone, bucket_info,
key, versioned_epoch, copy_if_newer);
async_rados->queue(req);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
};
map<string, bufferlist> *pattrs;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncStatRemoteObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
const string& _source_zone,
req(NULL) {}
- ~RGWStatRemoteObjCR() {
+ ~RGWStatRemoteObjCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncStatRemoteObj(this, stack->create_completion_notifier(), store, source_zone,
bucket_info, key, pmtime, psize, pattrs);
async_rados->queue(req);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
};
ceph::real_time timestamp;
protected:
- int _send_request();
+ int _send_request() override;
public:
RGWAsyncRemoveObj(RGWCoroutine *caller, RGWAioCompletionNotifier *cn, RGWRados *_store,
const string& _source_zone,
owner_display_name = *_owner_display_name;
}
}
- ~RGWRemoveObjCR() {
+ ~RGWRemoveObjCR() override {
request_cleanup();
}
- void request_cleanup() {
+ void request_cleanup() override {
if (req) {
req->finish();
req = NULL;
}
}
- int send_request() {
+ int send_request() override {
req = new RGWAsyncRemoveObj(this, stack->create_completion_notifier(), store, source_zone, bucket_info,
key, owner, owner_display_name, versioned, versioned_epoch,
delete_marker, del_if_older, timestamp);
return 0;
}
- int request_complete() {
+ int request_complete() override {
return req->get_ret_status();
}
};
interval(_interval), lock("RGWContinuousLeaseCR"), caller(_caller)
{}
- int operate();
+ int operate() override;
bool is_locked() {
Mutex::Locker l(lock);
public:
RGWRadosTimelogAddCR(RGWRados *_store, const string& _oid,
const cls_log_entry& entry);
- ~RGWRadosTimelogAddCR();
+ ~RGWRadosTimelogAddCR() override;
- int send_request();
- int request_complete();
+ int send_request() override;
+ int request_complete() override;
};
class RGWRadosTimelogTrimCR : public RGWSimpleCoroutine {
const real_time& start_time, const real_time& end_time,
const std::string& from_marker,
const std::string& to_marker);
- ~RGWRadosTimelogTrimCR();
+ ~RGWRadosTimelogTrimCR() override;
int send_request() override;
int request_complete() override;
const RGWBucketInfo& _bucket_info, const rgw_obj& obj, uint64_t *psize = nullptr,
real_time* pmtime = nullptr, uint64_t *pepoch = nullptr,
RGWObjVersionTracker *objv_tracker = nullptr);
- ~RGWStatObjCR() {
+ ~RGWStatObjCR() override {
request_cleanup();
}
- void request_cleanup();
+ void request_cleanup() override;
int send_request() override;
int request_complete() override;
path(_path), params(make_param_list(params)), result(_result)
{}
- ~RGWReadRESTResourceCR() {
+ ~RGWReadRESTResourceCR() override {
request_cleanup();
}
- int send_request() {
+ int send_request() override {
auto op = boost::intrusive_ptr<RGWRESTReadResource>(
new RGWRESTReadResource(conn, path, params, NULL, http_manager));
return 0;
}
- int request_complete() {
+ int request_complete() override {
int ret = http_op->wait(result);
auto op = std::move(http_op); // release ref on return
if (ret < 0) {
return 0;
}
- void request_cleanup() {
+ void request_cleanup() override {
if (http_op) {
http_op->put();
http_op = NULL;
input(_input)
{}
- ~RGWSendRESTResourceCR() {
+ ~RGWSendRESTResourceCR() override {
request_cleanup();
}
- int send_request() {
+ int send_request() override {
auto op = boost::intrusive_ptr<RGWRESTSendResource>(
new RGWRESTSendResource(conn, method, path, params, NULL, http_manager));
return 0;
}
- int request_complete() {
+ int request_complete() override {
int ret;
if (result) {
ret = http_op->wait(result);
return 0;
}
- void request_cleanup() {
+ void request_cleanup() override {
if (http_op) {
http_op->put();
http_op = NULL;
path(_path), params(make_param_list(_params))
{}
- ~RGWDeleteRESTResourceCR() {
+ ~RGWDeleteRESTResourceCR() override {
request_cleanup();
}
- int send_request() {
+ int send_request() override {
auto op = boost::intrusive_ptr<RGWRESTDeleteResource>(
new RGWRESTDeleteResource(conn, path, params, nullptr, http_manager));
return 0;
}
- int request_complete() {
+ int request_complete() override {
int ret;
bufferlist bl;
ret = http_op->wait_bl(&bl);
return 0;
}
- void request_cleanup() {
+ void request_cleanup() override {
if (http_op) {
http_op->put();
http_op = NULL;
shard_info(_shard_info) {
}
- ~RGWReadRemoteDataLogShardInfoCR() {
+ ~RGWReadRemoteDataLogShardInfoCR() override {
if (http_op) {
http_op->put();
}
entries(_entries),
truncated(_truncated) {
}
- ~RGWReadRemoteDataLogShardCR() {
+ ~RGWReadRemoteDataLogShardCR() override {
if (http_op) {
http_op->put();
}
path = "/admin/metadata/bucket.instance";
num_shards = sync_status->sync_info.num_shards;
}
- ~RGWListBucketIndexesCR() {
+ ~RGWListBucketIndexesCR() override {
delete entries_index;
}
status_oid(RGWBucketSyncStatusManager::status_oid(sync_env->source_zone, bs)) {
logger.init(sync_env, "Bucket", bs.get_key());
}
- ~RGWRunBucketSyncCoroutine() {
+ ~RGWRunBucketSyncCoroutine() override {
if (lease_cr) {
lease_cr->abort();
}
logger.init(sync_env, "DataShard", status_oid);
}
- ~RGWDataSyncShardCR() {
+ ~RGWDataSyncShardCR() override {
delete marker_tracker;
if (lease_cr) {
lease_cr->abort();
reset_backoff(_reset_backoff), logger(sync_env, "Data", "all") {
}
- ~RGWDataSyncCR() {
+ ~RGWDataSyncCR() override {
for (auto iter : shard_crs) {
iter.second->put();
}
void invalidate();
- virtual bool reclaim();
+ bool reclaim() override;
typedef cohort::lru::LRU<std::mutex> FhLRU;
typedef cohort::lru::TreeX<RGWFileHandle, FhTree, FhLT, FhEQ, fh_key,
std::mutex> FHCache;
- virtual ~RGWFileHandle();
+ ~RGWFileHandle() override;
friend std::ostream& operator<<(std::ostream &os,
RGWFileHandle const &rgw_fh);
: fs(fs), fs_inst(fs_inst), parent(parent), fhk(fhk), name(name),
flags(flags) {}
- void recycle (cohort::lru::Object* o) {
+ void recycle (cohort::lru::Object* o) override {
/* re-use an existing object */
o->~Object(); // call lru::Object virtual dtor
// placement new!
new (o) RGWFileHandle(fs, fs_inst, parent, fhk, name, flags);
}
- cohort::lru::Object* alloc() {
+ cohort::lru::Object* alloc() override {
return new RGWFileHandle(fs, fs_inst, parent, fhk, name, flags);
}
}; /* Factory */
op = this;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "GET";
s->op = OP_GET;
return 0;
}
- int get_params() {
+ int get_params() override {
limit = -1; /* no limit */
return 0;
}
- virtual void send_response_begin(bool has_buckets) {
+ void send_response_begin(bool has_buckets) override {
sent_data = true;
}
- virtual void send_response_data(RGWUserBuckets& buckets) {
+ void send_response_data(RGWUserBuckets& buckets) override {
if (!sent_data)
return;
map<string, RGWBucketEnt>& m = buckets.get_buckets();
}
} /* send_response_data */
- virtual void send_response_end() {
+ void send_response_end() override {
// do nothing
}
op = this;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "GET";
s->op = OP_GET;
return 0;
}
- virtual int get_params() {
+ int get_params() override {
max = default_max;
return 0;
}
- virtual void send_response() {
+ void send_response() override {
struct req_state* s = get_state();
for (const auto& iter : objs) {
op = this;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int read_permissions(RGWOp* op_obj) {
+ int read_permissions(RGWOp* op_obj) override {
/* we ARE a 'create bucket' request (cf. rgw_rest.cc, ll. 1305-6) */
return 0;
}
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "PUT";
return 0;
}
- virtual int get_params() {
+ int get_params() override {
struct req_state* s = get_state();
RGWAccessControlPolicy_S3 s3policy(s->cct);
/* we don't have (any) headers, so just create canned ACLs */
return ret;
}
- virtual void send_response() {
+ void send_response() override {
/* TODO: something (maybe) */
}
}; /* RGWCreateBucketRequest */
op = this;
}
- virtual bool only_bucket() { return true; }
+ bool only_bucket() override { return true; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "DELETE";
return 0;
}
- virtual void send_response() {}
+ void send_response() override {}
}; /* RGWDeleteBucketRequest */
op = this;
}
- virtual bool only_bucket() { return true; }
+ bool only_bucket() override { return true; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "PUT";
return 0;
}
- virtual int get_params() {
+ int get_params() override {
struct req_state* s = get_state();
RGWAccessControlPolicy_S3 s3policy(s->cct);
/* we don't have (any) headers, so just create canned ACLs */
return ret;
}
- virtual int get_data(buffer::list& _bl) {
+ int get_data(buffer::list& _bl) override {
/* XXX for now, use sharing semantics */
_bl.claim(bl);
uint32_t len = _bl.length();
return len;
}
- virtual void send_response() {}
+ void send_response() override {}
- virtual int verify_params() {
+ int verify_params() override {
if (bl.length() > cct->_conf->rgw_max_put_size)
return -ERR_TOO_LARGE;
return 0;
RGWGetObj::end = off + len;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "GET";
return 0;
}
- virtual int get_params() {
+ int get_params() override {
return 0;
}
- virtual int send_response_data(ceph::buffer::list& bl, off_t bl_off,
- off_t bl_len) {
+ int send_response_data(ceph::buffer::list& bl, off_t bl_off,
+ off_t bl_len) override {
size_t bytes;
for (auto& bp : bl.buffers()) {
/* if for some reason bl_off indicates the start-of-data is not at
return 0;
}
- virtual int send_response_data_error() {
+ int send_response_data_error() override {
/* S3 implementation just sends nothing--there is no side effect
* to simulate here */
return 0;
op = this;
}
- virtual bool only_bucket() { return true; }
+ bool only_bucket() override { return true; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "DELETE";
return 0;
}
- virtual void send_response() {}
+ void send_response() override {}
}; /* RGWDeleteObjRequest */
RGWGetObj::end = UINT64_MAX;
}
- virtual const string name() { return "stat_obj"; }
- virtual RGWOpType get_type() { return RGW_OP_STAT_OBJ; }
+ const string name() override { return "stat_obj"; }
+ RGWOpType get_type() override { return RGW_OP_STAT_OBJ; }
real_time get_mtime() const {
return lastmod;
return (iter != attrs.end()) ? &(iter->second) : nullptr;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "GET";
return 0;
}
- virtual int get_params() {
+ int get_params() override {
return 0;
}
- virtual int send_response_data(ceph::buffer::list& _bl, off_t s_off,
- off_t e_off) {
+ int send_response_data(ceph::buffer::list& _bl, off_t s_off,
+ off_t e_off) override {
/* NOP */
/* XXX save attrs? */
return 0;
}
- virtual int send_response_data_error() {
+ int send_response_data_error() override {
/* NOP */
return 0;
}
- virtual void execute() {
+ void execute() override {
RGWGetObj::execute();
_size = get_state()->obj_size;
}
return bucket.creation_time;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "GET";
return 0;
}
- virtual void send_response() {
+ void send_response() override {
bucket.creation_time = get_state()->bucket_info.creation_time;
std::swap(attrs, get_state()->bucket_attrs);
}
op = this;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "GET";
return 0;
}
- virtual int get_params() {
+ int get_params() override {
max = default_max;
return 0;
}
- virtual void send_response() {
+ void send_response() override {
struct req_state* s = get_state();
// try objects
for (const auto& iter : objs) {
op = this;
}
- virtual bool only_bucket() { return true; }
+ bool only_bucket() override { return true; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "PUT";
return 0;
}
- virtual RGWPutObjProcessor *select_processor(RGWObjectCtx& obj_ctx,
- bool *is_multipart) {
+ RGWPutObjProcessor *select_processor(RGWObjectCtx& obj_ctx,
+ bool *is_multipart) override {
struct req_state* s = get_state();
uint64_t part_size = s->cct->_conf->rgw_obj_stripe_size;
RGWPutObjProcessor_Atomic *processor =
return processor;
}
- virtual int get_params() {
+ int get_params() override {
struct req_state* s = get_state();
RGWAccessControlPolicy_S3 s3policy(s->cct);
/* we don't have (any) headers, so just create canned ACLs */
return ret;
}
- virtual int get_data(buffer::list& _bl) {
+ int get_data(buffer::list& _bl) override {
/* XXX for now, use sharing semantics */
uint32_t len = data.length();
_bl.claim(data);
ofs = off; /* consumed in exec_continue() */
}
- virtual int exec_start();
- virtual int exec_continue();
- virtual int exec_finish();
+ int exec_start() override;
+ int exec_continue() override;
+ int exec_finish() override;
- virtual void send_response() {}
+ void send_response() override {}
- virtual int verify_params() {
+ int verify_params() override {
return 0;
}
}; /* RGWWriteRequest */
attrs_mod = RGWRados::ATTRSMOD_MERGE;
}
- virtual bool only_bucket() { return true; }
+ bool only_bucket() override { return true; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "PUT"; // XXX check
return 0;
}
- virtual int get_params() {
+ int get_params() override {
struct req_state* s = get_state();
RGWAccessControlPolicy_S3 s3policy(s->cct);
/* we don't have (any) headers, so just create canned ACLs */
return ret;
}
- virtual void send_response() {}
- virtual void send_partial_response(off_t ofs) {}
+ void send_response() override {}
+ void send_partial_response(off_t ofs) override {}
}; /* RGWCopyObjRequest */
op = this;
}
- virtual bool only_bucket() { return false; }
+ bool only_bucket() override { return false; }
- virtual int op_init() {
+ int op_init() override {
// assign store, s, and dialect_handler
RGWObjectCtx* rados_ctx
= static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
return 0;
}
- virtual int header_init() {
+ int header_init() override {
struct req_state* s = get_state();
s->info.method = "PUT";
return 0;
}
- virtual int get_params() {
+ int get_params() override {
return 0;
}
- virtual void send_response() {}
+ void send_response() override {}
}; /* RGWSetAttrsRequest */
void reset_buf();
public:
explicit RGWFormatter_Plain(bool use_kv = false);
- virtual ~RGWFormatter_Plain();
-
- virtual void set_status(int status, const char* status_name) {};
- virtual void output_header() {};
- virtual void output_footer() {};
- virtual void flush(ostream& os);
- virtual void reset();
-
- virtual void open_array_section(const char *name);
- virtual void open_array_section_in_ns(const char *name, const char *ns);
- virtual void open_object_section(const char *name);
- virtual void open_object_section_in_ns(const char *name, const char *ns);
- virtual void close_section();
- virtual void dump_unsigned(const char *name, uint64_t u);
- virtual void dump_int(const char *name, int64_t u);
- virtual void dump_float(const char *name, double d);
- virtual void dump_string(const char *name, const std::string& s);
- virtual std::ostream& dump_stream(const char *name);
- virtual void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap);
- virtual int get_len() const;
- virtual void write_raw_data(const char *data);
+ ~RGWFormatter_Plain() override;
+
+ void set_status(int status, const char* status_name) override {};
+ void output_header() override {};
+ void output_footer() override {};
+ void flush(ostream& os) override;
+ void reset() override;
+
+ void open_array_section(const char *name) override;
+ void open_array_section_in_ns(const char *name, const char *ns) override;
+ void open_object_section(const char *name) override;
+ void open_object_section_in_ns(const char *name, const char *ns) override;
+ void close_section() override;
+ void dump_unsigned(const char *name, uint64_t u) override;
+ void dump_int(const char *name, int64_t u) override;
+ void dump_float(const char *name, double d) override;
+ void dump_string(const char *name, const std::string& s) override;
+ std::ostream& dump_stream(const char *name) override;
+ void dump_format_va(const char *name, const char *ns, bool quoted, const char *fmt, va_list ap) override;
+ int get_len() const override;
+ void write_raw_data(const char *data) override;
private:
void write_data(const char *fmt, ...);
class RGWStreamFlusher : public RGWFormatterFlusher {
ostream& os;
protected:
- virtual void do_flush() {
+ void do_flush() override {
formatter->flush(os);
}
public:
: conf(_conf), pprocess(nullptr), env(pe), thread(nullptr) {
}
- ~RGWProcessFrontend() {
+ ~RGWProcessFrontend() override {
delete thread;
delete pprocess;
}
- int run() {
+ int run() override {
assert(pprocess); /* should have initialized by init() */
thread = new RGWProcessControlThread(pprocess);
thread->create("rgw_frontend");
return 0;
}
- void stop();
+ void stop() override;
- void join() {
+ void join() override {
thread->join();
}
RGWFCGXFrontend(RGWProcessEnv& pe, RGWFrontendConfig* _conf)
: RGWProcessFrontend(pe, _conf) {}
- int init() {
+ int init() override {
pprocess = new RGWFCGXProcess(g_ceph_context, &env,
g_conf->rgw_thread_pool_size, conf);
return 0;
RGWLoadGenFrontend(RGWProcessEnv& pe, RGWFrontendConfig *_conf)
: RGWProcessFrontend(pe, _conf) {}
- int init() {
+ int init() override {
int num_threads;
conf->get_val("num_threads", g_conf->rgw_thread_pool_size, &num_threads);
RGWLoadGenProcess *pp = new RGWLoadGenProcess(g_ceph_context, &env,
if (pauser)
pauser->pause();
}
- void resume(RGWRados *store) {
+ void resume(RGWRados *store) override {
for (auto frontend : frontends)
frontend->unpause_with_new_config(store);
if (pauser)
public:
GCWorker(CephContext *_cct, RGWGC *_gc) : cct(_cct), gc(_gc), lock("GCWorker") {}
- void *entry();
+ void *entry() override;
void stop();
};
}
protected:
- virtual int receive_header(void *ptr, size_t len) override;
+ int receive_header(void *ptr, size_t len) override;
- virtual int receive_data(void *ptr, size_t len) override {
+ int receive_data(void *ptr, size_t len) override {
return 0;
}
- virtual int send_data(void *ptr, size_t len) override {
+ int send_data(void *ptr, size_t len) override {
return 0;
}
public:
ReqsThread(RGWHTTPManager *_m) : manager(_m) {}
- void *entry();
+ void *entry() override;
};
ReqsThread *reqs_thread;
cache(cache),
lock("RGWKeystoneTokenCache::RevokeThread") {
}
- void *entry();
+ void *entry() override;
void stop();
int check_revoked();
} revocator;
KeystoneAdminTokenRequestVer2(CephContext * const _cct)
: cct(_cct) {
}
- void dump(Formatter *f) const;
+ void dump(Formatter *f) const override;
};
class KeystoneAdminTokenRequestVer3 : public KeystoneAdminTokenRequest {
KeystoneAdminTokenRequestVer3(CephContext * const _cct)
: cct(_cct) {
}
- void dump(Formatter *f) const;
+ void dump(Formatter *f) const override;
};
#endif
public:
LCWorker(CephContext *_cct, RGWLC *_lc) : cct(_cct), lc(_lc), lock("LCWorker") {}
- void *entry();
+ void *entry() override;
void stop();
bool should_work(utime_t& now);
int schedule_next_start_time(utime_t& start, utime_t& now);
{
public:
LCID_S3() {}
- ~LCID_S3() {}
+ ~LCID_S3() override {}
string& to_str() { return data; }
};
{
public:
LCPrefix_S3() {}
- ~LCPrefix_S3() {}
+ ~LCPrefix_S3() override {}
string& to_str() { return data; }
};
{
public:
LCStatus_S3() {}
- ~LCStatus_S3() {}
+ ~LCStatus_S3() override {}
string& to_str() { return data; }
};
{
public:
LCDays_S3() {}
- ~LCDays_S3() {}
+ ~LCDays_S3() override {}
string& to_str() { return data; }
};
{
public:
LCNoncurDays_S3() {}
- ~LCNoncurDays_S3() {}
+ ~LCNoncurDays_S3() override {}
string& to_str() {
return data;
}
{
public:
LCExpiration_S3() {}
- ~LCExpiration_S3() {}
+ ~LCExpiration_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out) {
out << "<Expiration>" << "<Days>" << days << "</Days>"<< "</Expiration>";
}
{
public:
LCNoncurExpiration_S3() {}
- ~LCNoncurExpiration_S3() {}
+ ~LCNoncurExpiration_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out) {
out << "<NoncurrentVersionExpiration>" << "<NoncurrentDays>" << days << "</NoncurrentDays>"<< "</NoncurrentVersionExpiration>";
}
{
public:
LCRule_S3() {}
- ~LCRule_S3() {}
+ ~LCRule_S3() override {}
void to_xml(CephContext *cct, ostream& out);
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
bool xml_start(const char *el, const char **attr);
void dump_xml(Formatter *f) const {
f->open_object_section("Rule");
{
CephContext *cct;
- XMLObj *alloc_obj(const char *el);
+ XMLObj *alloc_obj(const char *el) override;
public:
RGWLCXMLParser_S3(CephContext *_cct) : cct(_cct) {}
};
public:
RGWLifecycleConfiguration_S3(CephContext *_cct) : RGWLifecycleConfiguration(_cct) {}
RGWLifecycleConfiguration_S3() : RGWLifecycleConfiguration(NULL) {}
- ~RGWLifecycleConfiguration_S3() {}
+ ~RGWLifecycleConfiguration_S3() override {}
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void to_xml(ostream& out) {
out << "<LifecycleConfiguration xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">";
RGWLibIO(const RGWUserInfo &_user_info)
: user_info(_user_info) {}
- virtual void init_env(CephContext *cct) override {}
+ void init_env(CephContext *cct) override {}
const RGWUserInfo& get_user() {
return user_info;
class RGWRESTMgr_Lib : public RGWRESTMgr {
public:
RGWRESTMgr_Lib() {}
- virtual ~RGWRESTMgr_Lib() {}
+ ~RGWRESTMgr_Lib() override {}
}; /* RGWRESTMgr_Lib */
/* XXX */
friend class RGWRESTMgr_Lib;
public:
- virtual int authorize();
+ int authorize() override;
RGWHandler_Lib() {}
- virtual ~RGWHandler_Lib() {}
+ ~RGWHandler_Lib() override {}
static int init_from_header(struct req_state *s);
}; /* RGWHandler_Lib */
RGWUserInfo* get_user() { return user; }
- virtual int postauth_init() { return 0; }
+ int postauth_init() override { return 0; }
/* descendant equivalent of *REST*::init_from_header(...):
* prepare request for execute()--should mean, fixup URI-alikes
virtual bool only_bucket() = 0;
- virtual int read_permissions(RGWOp *op);
+ int read_permissions(RGWOp *op) override;
}; /* RGWLibRequest */
RGWFrontendConfig* _conf) :
RGWProcess(cct, pe, num_threads, _conf), gen(0), shutdown(false) {}
- void run();
+ void run() override;
void checkpoint();
void stop() {
} /* enqueue_req */
/* "regular" requests */
- void handle_request(RGWRequest* req); // async handler, deletes req
+ void handle_request(RGWRequest* req) override; // async handler, deletes req
int process_request(RGWLibRequest* req);
int process_request(RGWLibRequest* req, RGWLibIO* io);
void set_access_key(RGWAccessKey& key) { access_key = key; }
RGWLibFrontend(RGWProcessEnv& pe, RGWFrontendConfig *_conf)
: RGWProcessFrontend(pe, _conf) {}
- int init();
+ int init() override;
- virtual void stop() {
+ void stop() override {
RGWProcessFrontend::stop();
get_process()->stop();
}
void formatter_to_bl(bufferlist& bl);
protected:
- void init_connection(bufferlist& bl);
+ void init_connection(bufferlist& bl) override;
public:
OpsLogSocket(CephContext *cct, uint64_t _backlog);
- ~OpsLogSocket();
+ ~OpsLogSocket() override;
void log(struct rgw_log_entry& entry);
};
boost::optional<info_callback_t> callback; //< cleared on cancel
public:
RGWMetadataLogInfoCompletion(info_callback_t callback);
- virtual ~RGWMetadataLogInfoCompletion();
+ ~RGWMetadataLogInfoCompletion() override;
librados::IoCtx& get_io_ctx() { return io_ctx; }
cls_log_header& get_header() { return header; }
{
public:
RGWMultiCompleteUpload() {}
- ~RGWMultiCompleteUpload() {}
- bool xml_end(const char *el);
+ ~RGWMultiCompleteUpload() override {}
+ bool xml_end(const char *el) override;
std::map<int, string> parts;
};
int num;
public:
RGWMultiPart() : num(0) {}
- ~RGWMultiPart() {}
- bool xml_end(const char *el);
+ ~RGWMultiPart() override {}
+ bool xml_end(const char *el) override;
string& get_etag() { return etag; }
int get_num() { return num; }
{
public:
RGWMultiPartNumber() {}
- ~RGWMultiPartNumber() {}
+ ~RGWMultiPartNumber() override {}
};
class RGWMultiETag : public XMLObj
{
public:
RGWMultiETag() {}
- ~RGWMultiETag() {}
+ ~RGWMultiETag() override {}
};
class RGWMultiXMLParser : public RGWXMLParser
{
- XMLObj *alloc_obj(const char *el);
+ XMLObj *alloc_obj(const char *el) override;
public:
RGWMultiXMLParser() {}
- ~RGWMultiXMLParser() {}
+ ~RGWMultiXMLParser() override {}
};
#endif
{
public:
RGWMultiDelDelete() :quiet(false) {}
- ~RGWMultiDelDelete() {}
- bool xml_end(const char *el);
+ ~RGWMultiDelDelete() override {}
+ bool xml_end(const char *el) override;
std::vector<rgw_obj_key> objects;
bool quiet;
{
public:
RGWMultiDelQuiet() {}
- ~RGWMultiDelQuiet() {}
+ ~RGWMultiDelQuiet() override {}
};
class RGWMultiDelObject : public XMLObj
string version_id;
public:
RGWMultiDelObject() {}
- ~RGWMultiDelObject() {}
- bool xml_end(const char *el);
+ ~RGWMultiDelObject() override {}
+ bool xml_end(const char *el) override;
const string& get_key() { return key; }
const string& get_version_id() { return version_id; }
{
public:
RGWMultiDelKey() {}
- ~RGWMultiDelKey() {}
+ ~RGWMultiDelKey() override {}
};
class RGWMultiDelVersionId : public XMLObj
{
public:
RGWMultiDelVersionId() {}
- ~RGWMultiDelVersionId() {}
+ ~RGWMultiDelVersionId() override {}
};
class RGWMultiDelXMLParser : public RGWXMLParser
{
- XMLObj *alloc_obj(const char *el);
+ XMLObj *alloc_obj(const char *el) override;
public:
RGWMultiDelXMLParser() {}
- ~RGWMultiDelXMLParser() {}
+ ~RGWMultiDelXMLParser() override {}
};
lock("OEWorker") {
}
- void *entry();
+ void *entry() override;
void stop();
};
RGWPutObj *op;
public:
RGWPutObj_CB(RGWPutObj *_op) : op(_op) {}
- ~RGWPutObj_CB() {}
+ ~RGWPutObj_CB() override {}
int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
return op->get_data_cb(bl, bl_ofs, bl_len);
cur_ofs = 0;
}
- bool prefetch_data();
+ bool prefetch_data() override;
void set_get_data(bool get_data) {
this->get_data = get_data;
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
int read_user_manifest_part(rgw_bucket& bucket,
const rgw_bucket_dir_entry& ent,
RGWAccessControlPolicy *bucket_policy,
virtual int send_response_data_error() = 0;
virtual int send_response_data(bufferlist& bl, off_t ofs, off_t len) = 0;
- virtual const string name() { return "get_obj"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_OBJ; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ const string name() override { return "get_obj"; }
+ RGWOpType get_type() override { return RGW_OP_GET_OBJ; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
virtual bool need_object_expiration() { return false; }
};
RGWGetObj *op;
public:
explicit RGWGetObj_CB(RGWGetObj *_op) : op(_op) {}
- virtual ~RGWGetObj_CB() {}
+ ~RGWGetObj_CB() override {}
- int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) {
+ int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
return op->get_data_cb(bl, bl_ofs, bl_len);
}
};
RGWGetDataCB* next;
public:
RGWGetObj_Filter(RGWGetDataCB* next): next(next) {}
- virtual ~RGWGetObj_Filter() {}
+ ~RGWGetObj_Filter() override {}
/**
* Passes data through filter.
* Filter can modify content of bl.
* When bl_len == 0 , it means 'flush
*/
- virtual int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
+ int handle_data(bufferlist& bl, off_t bl_ofs, off_t bl_len) override {
return next->handle_data(bl, bl_ofs, bl_len);
}
/**
* Flushes any cached data. Used by RGWGetObjFilter.
* Return logic same as handle_data.
*/
- virtual int flush() override {
+ int flush() override {
return next->flush();
}
/**
* Allows filter to extend range required for successful filtering
*/
- virtual void fixup_range(off_t& ofs, off_t& end) override {
+ void fixup_range(off_t& ofs, off_t& end) override {
next->fixup_range(ofs, end);
}
};
: deleter(nullptr) {
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_data(std::list<acct_path_t>& items,
bool * is_truncated) = 0;
- virtual void send_response() = 0;
+ void send_response() override = 0;
- virtual const string name() { return "bulk_delete"; }
- virtual RGWOpType get_type() { return RGW_OP_BULK_DELETE; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_DELETE; }
+ const string name() override { return "bulk_delete"; }
+ RGWOpType get_type() override { return RGW_OP_BULK_DELETE; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
};
inline ostream& operator<<(ostream& out, const RGWBulkDelete::acct_path_t &o) {
is_truncated = false;
}
- int verify_permission();
- void execute();
+ int verify_permission() override;
+ void execute() override;
virtual int get_params() = 0;
virtual void send_response_begin(bool has_buckets) = 0;
virtual void send_response_data(RGWUserBuckets& buckets) = 0;
virtual void send_response_end() = 0;
- virtual void send_response() {}
+ void send_response() override {}
virtual bool should_get_stats() { return false; }
virtual bool supports_account_metadata() { return false; }
- virtual const string name() { return "list_buckets"; }
- virtual RGWOpType get_type() { return RGW_OP_LIST_BUCKETS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ const string name() override { return "list_buckets"; }
+ RGWOpType get_type() override { return RGW_OP_LIST_BUCKETS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWGetUsage : public RGWOp {
RGWGetUsage() : sent_data(false), show_log_entries(true), show_log_sum(true){
}
- int verify_permission();
- void execute();
+ int verify_permission() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() {}
+ void send_response() override {}
virtual bool should_get_stats() { return false; }
- virtual const string name() { return "get_usage"; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ const string name() override { return "get_usage"; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWStatAccount : public RGWOp {
buckets_size_rounded = 0;
}
- int verify_permission();
- virtual void execute();
+ int verify_permission() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "stat_account"; }
- virtual RGWOpType get_type() { return RGW_OP_STAT_ACCOUNT; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "stat_account"; }
+ RGWOpType get_type() override { return RGW_OP_STAT_ACCOUNT; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWListBucket : public RGWOp {
public:
RGWListBucket() : list_versions(false), max(0),
default_max(0), is_truncated(false), shard_id(-1) {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "list_bucket"; }
- virtual RGWOpType get_type() { return RGW_OP_LIST_BUCKET; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "list_bucket"; }
+ RGWOpType get_type() override { return RGW_OP_LIST_BUCKET; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
virtual bool need_container_stats() { return false; }
};
class RGWGetBucketLogging : public RGWOp {
public:
RGWGetBucketLogging() {}
- int verify_permission();
- void execute() { }
+ int verify_permission() override;
+ void execute() override { }
- virtual void send_response() = 0;
- virtual const string name() { return "get_bucket_logging"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_BUCKET_LOGGING; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_bucket_logging"; }
+ RGWOpType get_type() override { return RGW_OP_GET_BUCKET_LOGGING; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWGetBucketLocation : public RGWOp {
public:
RGWGetBucketLocation() {}
- ~RGWGetBucketLocation() {}
- int verify_permission();
- void execute() { }
+ ~RGWGetBucketLocation() override {}
+ int verify_permission() override;
+ void execute() override { }
- virtual void send_response() = 0;
- virtual const string name() { return "get_bucket_location"; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_bucket_location"; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWGetBucketVersioning : public RGWOp {
public:
RGWGetBucketVersioning() : versioned(false), versioning_enabled(false) {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "get_bucket_versioning"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_BUCKET_VERSIONING; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_bucket_versioning"; }
+ RGWOpType get_type() override { return RGW_OP_GET_BUCKET_VERSIONING; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWSetBucketVersioning : public RGWOp {
public:
RGWSetBucketVersioning() : enable_versioning(false) {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() { return 0; }
- virtual void send_response() = 0;
- virtual const string name() { return "set_bucket_versioning"; }
- virtual RGWOpType get_type() { return RGW_OP_SET_BUCKET_VERSIONING; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "set_bucket_versioning"; }
+ RGWOpType get_type() override { return RGW_OP_SET_BUCKET_VERSIONING; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWGetBucketWebsite : public RGWOp {
public:
RGWGetBucketWebsite() {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "get_bucket_website"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_BUCKET_WEBSITE; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_bucket_website"; }
+ RGWOpType get_type() override { return RGW_OP_GET_BUCKET_WEBSITE; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWSetBucketWebsite : public RGWOp {
public:
RGWSetBucketWebsite() {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() { return 0; }
- virtual void send_response() = 0;
- virtual const string name() { return "set_bucket_website"; }
- virtual RGWOpType get_type() { return RGW_OP_SET_BUCKET_WEBSITE; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "set_bucket_website"; }
+ RGWOpType get_type() override { return RGW_OP_SET_BUCKET_WEBSITE; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWDeleteBucketWebsite : public RGWOp {
public:
RGWDeleteBucketWebsite() {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "delete_bucket_website"; }
- virtual RGWOpType get_type() { return RGW_OP_SET_BUCKET_WEBSITE; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "delete_bucket_website"; }
+ RGWOpType get_type() override { return RGW_OP_SET_BUCKET_WEBSITE; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWStatBucket : public RGWOp {
public:
RGWStatBucket() {}
- ~RGWStatBucket() {}
+ ~RGWStatBucket() override {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "stat_bucket"; }
- virtual RGWOpType get_type() { return RGW_OP_STAT_BUCKET; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "stat_bucket"; }
+ RGWOpType get_type() override { return RGW_OP_STAT_BUCKET; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWCreateBucket : public RGWOp {
attrs.emplace(std::move(key), std::move(bl)); /* key and bl are r-value refs */
}
- int verify_permission();
- void pre_exec();
- void execute();
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
virtual int get_params() { return 0; }
- virtual void send_response() = 0;
- virtual const string name() { return "create_bucket"; }
- virtual RGWOpType get_type() { return RGW_OP_CREATE_BUCKET; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "create_bucket"; }
+ RGWOpType get_type() override { return RGW_OP_CREATE_BUCKET; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWDeleteBucket : public RGWOp {
public:
RGWDeleteBucket() {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "delete_bucket"; }
- virtual RGWOpType get_type() { return RGW_OP_DELETE_BUCKET; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_DELETE; }
+ void send_response() override = 0;
+ const string name() override { return "delete_bucket"; }
+ RGWOpType get_type() override { return RGW_OP_DELETE_BUCKET; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
};
struct rgw_slo_entry {
slo_info(NULL),
olh_epoch(0) {}
- ~RGWPutObj() {
+ ~RGWPutObj() override {
delete slo_info;
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
virtual RGWPutObjProcessor *select_processor(RGWObjectCtx& obj_ctx, bool *is_multipart);
void dispose_processor(RGWPutObjDataProcessor *processor);
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
int get_data_cb(bufferlist& bl, off_t bl_ofs, off_t bl_len);
int get_data(const off_t fst, const off_t lst, bufferlist& bl);
virtual int get_params() = 0;
virtual int get_data(bufferlist& bl) = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "put_obj"; }
- virtual RGWOpType get_type() { return RGW_OP_PUT_OBJ; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "put_obj"; }
+ RGWOpType get_type() override { return RGW_OP_PUT_OBJ; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWPutObj_Filter : public RGWPutObjDataProcessor
public:
RGWPutObj_Filter(RGWPutObjDataProcessor* next) :
next(next){}
- virtual ~RGWPutObj_Filter() {}
- virtual int handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again) override {
+ ~RGWPutObj_Filter() override {}
+ int handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again) override {
return next->handle_data(bl, ofs, phandle, pobj, again);
}
- virtual int throttle_data(void *handle, const rgw_raw_obj& obj, uint64_t size, bool need_to_wait) override {
+ int throttle_data(void *handle, const rgw_raw_obj& obj, uint64_t size, bool need_to_wait) override {
return next->throttle_data(handle, obj, size, need_to_wait);
}
}; /* RGWPutObj_Filter */
attrs.emplace(std::move(key), std::move(bl)); /* key and bl are r-value refs */
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
virtual int get_data(bufferlist& bl) = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "post_obj"; }
- virtual RGWOpType get_type() { return RGW_OP_POST_OBJ; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "post_obj"; }
+ RGWOpType get_type() override { return RGW_OP_POST_OBJ; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWPutMetadataAccount : public RGWOp {
has_policy(false) {
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
- int init_processing();
- int verify_permission();
- void pre_exec() { }
- void execute();
+ int init_processing() override;
+ int verify_permission() override;
+ void pre_exec() override { }
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
+ void send_response() override = 0;
virtual void filter_out_temp_url(map<string, bufferlist>& add_attrs,
const set<string>& rmattr_names,
map<int, string>& temp_url_keys);
- virtual const string name() { return "put_account_metadata"; }
- virtual RGWOpType get_type() { return RGW_OP_PUT_METADATA_ACCOUNT; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ const string name() override { return "put_account_metadata"; }
+ RGWOpType get_type() override { return RGW_OP_PUT_METADATA_ACCOUNT; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWPutMetadataBucket : public RGWOp {
attrs.emplace(std::move(key), std::move(bl)); /* key and bl are r-value refs */
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "put_bucket_metadata"; }
- virtual RGWOpType get_type() { return RGW_OP_PUT_METADATA_BUCKET; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "put_bucket_metadata"; }
+ RGWOpType get_type() override { return RGW_OP_PUT_METADATA_BUCKET; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWPutMetadataObject : public RGWOp {
: dlo_manifest(NULL)
{}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "put_obj_metadata"; }
- virtual RGWOpType get_type() { return RGW_OP_PUT_METADATA_OBJECT; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "put_obj_metadata"; }
+ RGWOpType get_type() override { return RGW_OP_PUT_METADATA_OBJECT; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
virtual bool need_object_expiration() { return false; }
};
deleter(nullptr) {
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
int handle_slo_manifest(bufferlist& bl);
virtual int get_params() { return 0; }
- virtual void send_response() = 0;
- virtual const string name() { return "delete_obj"; }
- virtual RGWOpType get_type() { return RGW_OP_DELETE_OBJ; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_DELETE; }
+ void send_response() override = 0;
+ const string name() override { return "delete_obj"; }
+ RGWOpType get_type() override { return RGW_OP_DELETE_OBJ; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
virtual bool need_object_expiration() { return false; }
};
attrs.emplace(std::move(key), std::move(bl));
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
dest_policy.set_ctx(s->cct);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
void progress_cb(off_t ofs);
virtual int init_dest_policy() { return 0; }
virtual int get_params() = 0;
virtual void send_partial_response(off_t ofs) {}
- virtual void send_response() = 0;
- virtual const string name() { return "copy_obj"; }
- virtual RGWOpType get_type() { return RGW_OP_COPY_OBJ; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "copy_obj"; }
+ RGWOpType get_type() override { return RGW_OP_COPY_OBJ; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWGetACLs : public RGWOp {
public:
RGWGetACLs() {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "get_acls"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_ACLS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_acls"; }
+ RGWOpType get_type() override { return RGW_OP_GET_ACLS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWPutACLs : public RGWOp {
len = 0;
data = NULL;
}
- virtual ~RGWPutACLs() {
+ ~RGWPutACLs() override {
free(data);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_policy_from_state(RGWRados *store, struct req_state *s, stringstream& ss) { return 0; }
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "put_acls"; }
- virtual RGWOpType get_type() { return RGW_OP_PUT_ACLS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "put_acls"; }
+ RGWOpType get_type() override { return RGW_OP_PUT_ACLS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWGetLC : public RGWOp {
public:
RGWGetLC() { }
- virtual ~RGWGetLC() { }
+ ~RGWGetLC() override { }
- int verify_permission();
- void pre_exec();
- virtual void execute() = 0;
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "get_lifecycle"; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "get_lifecycle"; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWPutLC : public RGWOp {
len = 0;
data = NULL;
}
- virtual ~RGWPutLC() {
+ ~RGWPutLC() override {
free(data);
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *dialect_handler) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *dialect_handler) override {
#define COOKIE_LEN 16
char buf[COOKIE_LEN + 1];
cookie = buf;
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
// virtual int get_policy_from_state(RGWRados *store, struct req_state *s, stringstream& ss) { return 0; }
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "put_lifecycle"; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "put_lifecycle"; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWDeleteLC : public RGWOp {
len = 0;
data = NULL;
}
- virtual ~RGWDeleteLC() {
+ ~RGWDeleteLC() override {
free(data);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "delete_lifecycle"; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "delete_lifecycle"; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWGetCORS : public RGWOp {
public:
RGWGetCORS() {}
- int verify_permission();
- void execute();
+ int verify_permission() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "get_cors"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_CORS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_cors"; }
+ RGWOpType get_type() override { return RGW_OP_GET_CORS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWPutCORS : public RGWOp {
public:
RGWPutCORS() {}
- virtual ~RGWPutCORS() {}
+ ~RGWPutCORS() override {}
- int verify_permission();
- void execute();
+ int verify_permission() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "put_cors"; }
- virtual RGWOpType get_type() { return RGW_OP_PUT_CORS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "put_cors"; }
+ RGWOpType get_type() override { return RGW_OP_PUT_CORS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWDeleteCORS : public RGWOp {
public:
RGWDeleteCORS() {}
- int verify_permission();
- void execute();
+ int verify_permission() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "delete_cors"; }
- virtual RGWOpType get_type() { return RGW_OP_DELETE_CORS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "delete_cors"; }
+ RGWOpType get_type() override { return RGW_OP_DELETE_CORS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWOptionsCORS : public RGWOp {
req_hdrs(NULL), req_meth(NULL) {
}
- int verify_permission() {return 0;}
+ int verify_permission() override {return 0;}
int validate_cors_request(RGWCORSConfiguration *cc);
- void execute();
+ void execute() override;
void get_response_params(string& allowed_hdrs, string& exp_hdrs, unsigned *max_age);
- virtual void send_response() = 0;
- virtual const string name() { return "options_cors"; }
- virtual RGWOpType get_type() { return RGW_OP_OPTIONS_CORS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "options_cors"; }
+ RGWOpType get_type() override { return RGW_OP_OPTIONS_CORS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWGetRequestPayment : public RGWOp {
public:
RGWGetRequestPayment() : requester_pays(0) {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "get_request_payment"; }
- virtual RGWOpType get_type() { return RGW_OP_GET_REQUEST_PAYMENT; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "get_request_payment"; }
+ RGWOpType get_type() override { return RGW_OP_GET_REQUEST_PAYMENT; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWSetRequestPayment : public RGWOp {
public:
RGWSetRequestPayment() : requester_pays(false) {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() { return 0; }
- virtual void send_response() = 0;
- virtual const string name() { return "set_request_payment"; }
- virtual RGWOpType get_type() { return RGW_OP_SET_REQUEST_PAYMENT; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "set_request_payment"; }
+ RGWOpType get_type() override { return RGW_OP_SET_REQUEST_PAYMENT; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWInitMultipart : public RGWOp {
public:
RGWInitMultipart() {}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy.set_ctx(s->cct);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "init_multipart"; }
- virtual RGWOpType get_type() { return RGW_OP_INIT_MULTIPART; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "init_multipart"; }
+ RGWOpType get_type() override { return RGW_OP_INIT_MULTIPART; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWCompleteMultipart : public RGWOp {
data = NULL;
len = 0;
}
- virtual ~RGWCompleteMultipart() {
+ ~RGWCompleteMultipart() override {
free(data);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "complete_multipart"; }
- virtual RGWOpType get_type() { return RGW_OP_COMPLETE_MULTIPART; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "complete_multipart"; }
+ RGWOpType get_type() override { return RGW_OP_COMPLETE_MULTIPART; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWAbortMultipart : public RGWOp {
public:
RGWAbortMultipart() {}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
- virtual void send_response() = 0;
- virtual const string name() { return "abort_multipart"; }
- virtual RGWOpType get_type() { return RGW_OP_ABORT_MULTIPART; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_DELETE; }
+ void send_response() override = 0;
+ const string name() override { return "abort_multipart"; }
+ RGWOpType get_type() override { return RGW_OP_ABORT_MULTIPART; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
};
class RGWListMultipart : public RGWOp {
truncated = false;
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
policy = RGWAccessControlPolicy(s->cct);
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "list_multipart"; }
- virtual RGWOpType get_type() { return RGW_OP_LIST_MULTIPART; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "list_multipart"; }
+ RGWOpType get_type() override { return RGW_OP_LIST_MULTIPART; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
#define MP_META_SUFFIX ".meta"
default_max = 0;
}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWOp::init(store, s, h);
max_uploads = default_max;
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "list_bucket_multiparts"; }
- virtual RGWOpType get_type() { return RGW_OP_LIST_BUCKET_MULTIPARTS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_READ; }
+ void send_response() override = 0;
+ const string name() override { return "list_bucket_multiparts"; }
+ RGWOpType get_type() override { return RGW_OP_LIST_BUCKET_MULTIPARTS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWGetCrossDomainPolicy : public RGWOp {
public:
RGWGetCrossDomainPolicy() = default;
- ~RGWGetCrossDomainPolicy() = default;
+ ~RGWGetCrossDomainPolicy() override = default;
int verify_permission() override {
return 0;
class RGWGetHealthCheck : public RGWOp {
public:
RGWGetHealthCheck() = default;
- ~RGWGetHealthCheck() = default;
+ ~RGWGetHealthCheck() override = default;
int verify_permission() override {
return 0;
quiet = false;
status_dumped = false;
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
virtual void send_status() = 0;
virtual void send_partial_response(rgw_obj_key& key, bool delete_marker,
const string& marker_version_id, int ret) = 0;
virtual void end_response() = 0;
- virtual const string name() { return "multi_object_delete"; }
- virtual RGWOpType get_type() { return RGW_OP_DELETE_MULTI_OBJ; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_DELETE; }
+ const string name() override { return "multi_object_delete"; }
+ RGWOpType get_type() override { return RGW_OP_DELETE_MULTI_OBJ; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_DELETE; }
};
class RGWInfo: public RGWOp {
public:
RGWInfo() = default;
- ~RGWInfo() = default;
+ ~RGWInfo() override = default;
int verify_permission() override { return 0; }
const string name() override { return "get info"; }
public:
RGWSetAttrs() {}
- virtual ~RGWSetAttrs() {}
+ ~RGWSetAttrs() override {}
void emplace_attr(std::string&& key, buffer::list&& bl) {
attrs.emplace(std::move(key), std::move(bl));
}
- int verify_permission();
- void pre_exec();
- void execute();
+ int verify_permission() override;
+ void pre_exec() override;
+ void execute() override;
virtual int get_params() = 0;
- virtual void send_response() = 0;
- virtual const string name() { return "set_attrs"; }
- virtual RGWOpType get_type() { return RGW_OP_SET_ATTRS; }
- virtual uint32_t op_mask() { return RGW_OP_TYPE_WRITE; }
+ void send_response() override = 0;
+ const string name() override { return "set_attrs"; }
+ RGWOpType get_type() override { return RGW_OP_SET_ATTRS; }
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWGetObjLayout : public RGWOp {
public RGWRealmReloader::Pauser {
public:
RGWPeriodPusher(RGWRados* store);
- ~RGWPeriodPusher();
+ ~RGWPeriodPusher() override;
/// respond to realm notifications by pushing new periods to other zones
void handle_notify(RGWRealmNotify type, bufferlist::iterator& p) override;
: ThreadPool::WorkQueue<RGWRequest>("RGWWQ", timeout, suicide_timeout,
tp), process(p) {}
- bool _enqueue(RGWRequest* req) {
+ bool _enqueue(RGWRequest* req) override {
process->m_req_queue.push_back(req);
perfcounter->inc(l_rgw_qlen);
dout(20) << "enqueued request req=" << hex << req << dec << dendl;
return true;
}
- void _dequeue(RGWRequest* req) {
+ void _dequeue(RGWRequest* req) override {
ceph_abort();
}
- bool _empty() {
+ bool _empty() override {
return process->m_req_queue.empty();
}
- RGWRequest* _dequeue() {
+ RGWRequest* _dequeue() override {
if (process->m_req_queue.empty())
return NULL;
RGWRequest *req = process->m_req_queue.front();
void _dump_queue();
- void _clear() {
+ void _clear() override {
assert(process->m_req_queue.empty());
}
} req_wq;
max_connections(num_threads + (num_threads >> 3)) {
}
- void run();
- void handle_request(RGWRequest* req);
+ void run() override;
+ void handle_request(RGWRequest* req) override;
};
class RGWProcessControlThread : public Thread {
public:
RGWProcessControlThread(RGWProcess *_pprocess) : pprocess(_pprocess) {}
- void *entry() {
+ void *entry() override {
pprocess->run();
return NULL;
}
RGWLoadGenProcess(CephContext* cct, RGWProcessEnv* pe, int num_threads,
RGWFrontendConfig* _conf) :
RGWProcess(cct, pe, num_threads, _conf) {}
- void run();
+ void run() override;
void checkpoint();
- void handle_request(RGWRequest* req);
+ void handle_request(RGWRequest* req) override;
void gen_request(const string& method, const string& resource,
int content_length, atomic_t* fail_flag);
user_sync_thread = NULL;
}
}
- ~RGWUserStatsCache() {
+ ~RGWUserStatsCache() override {
stop();
}
public:
RGWSyncProcessorThread(RGWRados *_store, const string& thread_name = "radosgw") : RGWRadosThread(_store, thread_name) {}
RGWSyncProcessorThread(RGWRados *_store) : RGWRadosThread(_store) {}
- ~RGWSyncProcessorThread() {}
+ ~RGWSyncProcessorThread() override {}
int init() override = 0 ;
int process() override = 0;
};
total_read(0), lock("get_obj_data"), data_lock("get_obj_data::data_lock"),
client_cb(NULL),
throttle(cct, "get_obj_data", cct->_conf->rgw_get_obj_window_size, false) {}
- ~get_obj_data() { }
+ ~get_obj_data() override { }
void set_cancelled(int r) {
cancelled.set(1);
err_code.set(r);
: RGWSystemMetaObj(id, name), realm_id(_realm_id) {}
rgw_pool get_pool(CephContext *cct);
- const string get_default_oid(bool old_format = false);
- const string& get_names_oid_prefix();
- const string& get_info_oid_prefix(bool old_format = false);
- const string& get_predefined_name(CephContext *cct);
+ const string get_default_oid(bool old_format = false) override;
+ const string& get_names_oid_prefix() override;
+ const string& get_info_oid_prefix(bool old_format = false) override;
+ const string& get_predefined_name(CephContext *cct) override;
int init(CephContext *_cct, RGWRados *_store, bool setup_obj = true,
bool old_format = false);
using RGWSystemMetaObj::init;
- int read_default_id(string& default_id, bool old_format = false);
+ int read_default_id(string& default_id, bool old_format = false) override;
int set_as_default(bool exclusive = false) override;
int create_default(bool old_format = false);
- int create(bool exclusive = true);
+ int create(bool exclusive = true) override;
int fix_pool_names();
const string& get_compression_type(const string& placement_rule) const;
- void encode(bufferlist& bl) const {
+ void encode(bufferlist& bl) const override {
ENCODE_START(9, 1, bl);
::encode(domain_root, bl);
::encode(control_pool, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::iterator& bl) override {
DECODE_START(9, bl);
::decode(domain_root, bl);
::decode(control_pool, bl);
}
void post_process_params();
- void encode(bufferlist& bl) const {
+ void encode(bufferlist& bl) const override {
ENCODE_START(4, 1, bl);
::encode(name, bl);
::encode(api_name, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::iterator& bl) override {
DECODE_START(4, bl);
::decode(name, bl);
::decode(api_name, bl);
DECODE_FINISH(bl);
}
- int read_default_id(string& default_id, bool old_format = false);
+ int read_default_id(string& default_id, bool old_format = false) override;
int set_as_default(bool exclusive = false) override;
int create_default(bool old_format = false);
int equals(const string& other_zonegroup) const;
int remove_zone(const std::string& zone_id);
int rename_zone(const RGWZoneParams& zone_params);
rgw_pool get_pool(CephContext *cct);
- const string get_default_oid(bool old_region_format = false);
- const string& get_info_oid_prefix(bool old_region_format = false);
- const string& get_names_oid_prefix();
- const string& get_predefined_name(CephContext *cct);
+ const string get_default_oid(bool old_region_format = false) override;
+ const string& get_info_oid_prefix(bool old_region_format = false) override;
+ const string& get_names_oid_prefix() override;
+ const string& get_predefined_name(CephContext *cct) override;
void dump(Formatter *f) const;
void decode_json(JSONObj *obj);
RGWRealm(CephContext *_cct, RGWRados *_store): RGWSystemMetaObj(_cct, _store) {}
RGWRealm(const string& _name, CephContext *_cct, RGWRados *_store): RGWSystemMetaObj(_name, _cct, _store){}
- void encode(bufferlist& bl) const {
+ void encode(bufferlist& bl) const override {
ENCODE_START(1, 1, bl);
RGWSystemMetaObj::encode(bl);
::encode(current_period, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::iterator& bl) override {
DECODE_START(1, bl);
RGWSystemMetaObj::decode(bl);
::decode(current_period, bl);
DECODE_FINISH(bl);
}
- int create(bool exclusive = true);
+ int create(bool exclusive = true) override;
int delete_obj();
rgw_pool get_pool(CephContext *cct);
- const string get_default_oid(bool old_format = false);
- const string& get_names_oid_prefix();
- const string& get_info_oid_prefix(bool old_format = false);
- const string& get_predefined_name(CephContext *cct);
+ const string get_default_oid(bool old_format = false) override;
+ const string& get_names_oid_prefix() override;
+ const string& get_info_oid_prefix(bool old_format = false) override;
+ const string& get_predefined_name(CephContext *cct) override;
using RGWSystemMetaObj::read_id; // expose as public for radosgw-admin
class RGWOpState : public RGWStateLog {
protected:
- bool dump_entry_internal(const cls_statelog_entry& entry, Formatter *f);
+ bool dump_entry_internal(const cls_statelog_entry& entry, Formatter *f) override;
public:
enum OpState {
map<RGWObjCategory, RGWStorageStats> *stats;
public:
explicit RGWGetBucketStats_CB(rgw_bucket& _bucket) : bucket(_bucket), stats(NULL) {}
- virtual ~RGWGetBucketStats_CB() {}
+ ~RGWGetBucketStats_CB() override {}
virtual void handle_response(int r) = 0;
virtual void set_response(map<RGWObjCategory, RGWStorageStats> *_stats) {
stats = _stats;
RGWStorageStats stats;
public:
explicit RGWGetUserStats_CB(const rgw_user& _user) : user(_user) {}
- virtual ~RGWGetUserStats_CB() {}
+ ~RGWGetUserStats_CB() override {}
virtual void handle_response(int r) = 0;
virtual void set_response(RGWStorageStats& _stats) {
stats = _stats;
return store->chain_cache_entry(cache_info_entries, &chain_entry);
}
- void chain_cb(const string& key, void *data) {
+ void chain_cb(const string& key, void *data) override {
T *entry = static_cast<T *>(data);
RWLock::WLocker wl(lock);
entries[key] = *entry;
}
- void invalidate(const string& key) {
+ void invalidate(const string& key) override {
RWLock::WLocker wl(lock);
entries.erase(key);
}
- void invalidate_all() {
+ void invalidate_all() override {
RWLock::WLocker wl(lock);
entries.clear();
}
is_complete(false),
bucket_info(_bi),
canceled(false) {}
- virtual ~RGWPutObjProcessor() {}
+ ~RGWPutObjProcessor() override {}
virtual int prepare(RGWRados *_store, string *oid_rand) {
store = _store;
return 0;
int handle_obj_data(rgw_raw_obj& obj, bufferlist& bl, off_t ofs, off_t abs_ofs, void **phandle, bool exclusive);
public:
- int prepare(RGWRados *store, string *oid_rand);
- int throttle_data(void *handle, const rgw_raw_obj& obj, uint64_t size, bool need_to_wait);
+ int prepare(RGWRados *store, string *oid_rand) override;
+ int throttle_data(void *handle, const rgw_raw_obj& obj, uint64_t size, bool need_to_wait) override;
RGWPutObjProcessor_Aio(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info) : RGWPutObjProcessor(obj_ctx, bucket_info) {}
- virtual ~RGWPutObjProcessor_Aio();
+ ~RGWPutObjProcessor_Aio() override;
}; /* RGWPutObjProcessor_Aio */
class RGWPutObjProcessor_Atomic : public RGWPutObjProcessor_Aio
int prepare_init(RGWRados *store, string *oid_rand);
public:
- ~RGWPutObjProcessor_Atomic() {}
+ ~RGWPutObjProcessor_Atomic() override {}
RGWPutObjProcessor_Atomic(RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info,
rgw_bucket& _b, const string& _o, uint64_t _p, const string& _t, bool versioned) :
RGWPutObjProcessor_Aio(obj_ctx, bucket_info),
bucket(_b),
obj_str(_o),
unique_tag(_t) {}
- int prepare(RGWRados *store, string *oid_rand);
+ int prepare(RGWRados *store, string *oid_rand) override;
virtual bool immutable_head() { return false; }
- virtual int handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again);
+ int handle_data(bufferlist& bl, off_t ofs, void **phandle, rgw_raw_obj *pobj, bool *again) override;
void set_olh_epoch(uint64_t epoch) {
olh_epoch = epoch;
};
RGWRealmReloader(RGWRados*& store, Pauser* frontends);
- ~RGWRealmReloader();
+ ~RGWRealmReloader() override;
/// respond to realm notifications by scheduling a reload()
void handle_notify(RGWRealmNotify type, bufferlist::iterator& p) override;
};
RGWRealmWatcher(CephContext* cct, RGWRealm& realm);
- ~RGWRealmWatcher();
+ ~RGWRealmWatcher() override;
/// register a watcher for the given notification type
void add_watcher(RGWRealmNotify type, Watcher& watcher);
qr->dequeue(&fcgx);
}
- ~RGWFCGXRequest() {
+ ~RGWFCGXRequest() override {
FCGX_Finish_r(fcgx);
qr->enqueue(fcgx);
}
struct req_state *s;
RGWOp *op;
protected:
- virtual void do_flush();
- virtual void do_start(int ret);
+ void do_flush() override;
+ void do_start(int ret) override;
public:
RGWRESTFlusher(struct req_state *_s, RGWOp *_op) :
RGWFormatterFlusher(_s->formatter), s(_s), op(_op) {}
public:
RGWGetObj_ObjStore() : sent_header(false) {}
- virtual void init(RGWRados *store, struct req_state *s, RGWHandler *h) {
+ void init(RGWRados *store, struct req_state *s, RGWHandler *h) override {
RGWGetObj::init(store, s, h);
sent_header = false;
}
- int get_params();
+ int get_params() override;
};
class RGWListBuckets_ObjStore : public RGWListBuckets {
public:
RGWListBuckets_ObjStore() {}
- ~RGWListBuckets_ObjStore() {}
+ ~RGWListBuckets_ObjStore() override {}
};
class RGWGetUsage_ObjStore : public RGWGetUsage {
public:
RGWGetUsage_ObjStore() {}
- ~RGWGetUsage_ObjStore() {}
+ ~RGWGetUsage_ObjStore() override {}
};
class RGWListBucket_ObjStore : public RGWListBucket {
public:
RGWListBucket_ObjStore() {}
- ~RGWListBucket_ObjStore() {}
+ ~RGWListBucket_ObjStore() override {}
};
class RGWStatAccount_ObjStore : public RGWStatAccount {
public:
RGWStatAccount_ObjStore() {}
- ~RGWStatAccount_ObjStore() {}
+ ~RGWStatAccount_ObjStore() override {}
};
class RGWStatBucket_ObjStore : public RGWStatBucket {
public:
RGWStatBucket_ObjStore() {}
- ~RGWStatBucket_ObjStore() {}
+ ~RGWStatBucket_ObjStore() override {}
};
class RGWCreateBucket_ObjStore : public RGWCreateBucket {
public:
RGWCreateBucket_ObjStore() {}
- ~RGWCreateBucket_ObjStore() {}
+ ~RGWCreateBucket_ObjStore() override {}
};
class RGWDeleteBucket_ObjStore : public RGWDeleteBucket {
public:
RGWDeleteBucket_ObjStore() {}
- ~RGWDeleteBucket_ObjStore() {}
+ ~RGWDeleteBucket_ObjStore() override {}
};
class RGWPutObj_ObjStore : public RGWPutObj
{
public:
RGWPutObj_ObjStore() {}
- ~RGWPutObj_ObjStore() {}
+ ~RGWPutObj_ObjStore() override {}
- virtual int verify_params();
- virtual int get_params();
- virtual int get_data(bufferlist& bl);
+ int verify_params() override;
+ int get_params() override;
+ int get_data(bufferlist& bl) override;
int get_padding_last_aws4_chunk_encoded(bufferlist &bl, uint64_t chunk_size);
};
{
public:
RGWPostObj_ObjStore() {}
- ~RGWPostObj_ObjStore() {}
+ ~RGWPostObj_ObjStore() override {}
- virtual int verify_params();
+ int verify_params() override;
};
class RGWPutMetadataAccount_ObjStore : public RGWPutMetadataAccount
{
public:
RGWPutMetadataAccount_ObjStore() {}
- ~RGWPutMetadataAccount_ObjStore() {}
+ ~RGWPutMetadataAccount_ObjStore() override {}
};
class RGWPutMetadataBucket_ObjStore : public RGWPutMetadataBucket
{
public:
RGWPutMetadataBucket_ObjStore() {}
- ~RGWPutMetadataBucket_ObjStore() {}
+ ~RGWPutMetadataBucket_ObjStore() override {}
};
class RGWPutMetadataObject_ObjStore : public RGWPutMetadataObject
{
public:
RGWPutMetadataObject_ObjStore() {}
- ~RGWPutMetadataObject_ObjStore() {}
+ ~RGWPutMetadataObject_ObjStore() override {}
};
class RGWDeleteObj_ObjStore : public RGWDeleteObj {
public:
RGWDeleteObj_ObjStore() {}
- ~RGWDeleteObj_ObjStore() {}
+ ~RGWDeleteObj_ObjStore() override {}
};
class RGWGetCrossDomainPolicy_ObjStore : public RGWGetCrossDomainPolicy {
public:
RGWGetCrossDomainPolicy_ObjStore() = default;
- ~RGWGetCrossDomainPolicy_ObjStore() = default;
+ ~RGWGetCrossDomainPolicy_ObjStore() override = default;
};
class RGWGetHealthCheck_ObjStore : public RGWGetHealthCheck {
public:
RGWGetHealthCheck_ObjStore() = default;
- ~RGWGetHealthCheck_ObjStore() = default;
+ ~RGWGetHealthCheck_ObjStore() override = default;
};
class RGWCopyObj_ObjStore : public RGWCopyObj {
public:
RGWCopyObj_ObjStore() {}
- ~RGWCopyObj_ObjStore() {}
+ ~RGWCopyObj_ObjStore() override {}
};
class RGWGetACLs_ObjStore : public RGWGetACLs {
public:
RGWGetACLs_ObjStore() {}
- ~RGWGetACLs_ObjStore() {}
+ ~RGWGetACLs_ObjStore() override {}
};
class RGWPutACLs_ObjStore : public RGWPutACLs {
public:
RGWPutACLs_ObjStore() {}
- ~RGWPutACLs_ObjStore() {}
+ ~RGWPutACLs_ObjStore() override {}
- virtual int get_params();
+ int get_params() override;
};
class RGWGetLC_ObjStore : public RGWGetLC {
public:
RGWGetLC_ObjStore() {}
- ~RGWGetLC_ObjStore() {}
+ ~RGWGetLC_ObjStore() override {}
};
class RGWPutLC_ObjStore : public RGWPutLC {
public:
RGWPutLC_ObjStore() {}
- ~RGWPutLC_ObjStore() {}
+ ~RGWPutLC_ObjStore() override {}
- int get_params();
+ int get_params() override;
};
class RGWDeleteLC_ObjStore : public RGWDeleteLC {
public:
RGWDeleteLC_ObjStore() {}
- ~RGWDeleteLC_ObjStore() {}
+ ~RGWDeleteLC_ObjStore() override {}
};
class RGWGetCORS_ObjStore : public RGWGetCORS {
public:
RGWGetCORS_ObjStore() {}
- ~RGWGetCORS_ObjStore() {}
+ ~RGWGetCORS_ObjStore() override {}
};
class RGWPutCORS_ObjStore : public RGWPutCORS {
public:
RGWPutCORS_ObjStore() {}
- ~RGWPutCORS_ObjStore() {}
+ ~RGWPutCORS_ObjStore() override {}
};
class RGWDeleteCORS_ObjStore : public RGWDeleteCORS {
public:
RGWDeleteCORS_ObjStore() {}
- ~RGWDeleteCORS_ObjStore() {}
+ ~RGWDeleteCORS_ObjStore() override {}
};
class RGWOptionsCORS_ObjStore : public RGWOptionsCORS {
public:
RGWOptionsCORS_ObjStore() {}
- ~RGWOptionsCORS_ObjStore() {}
+ ~RGWOptionsCORS_ObjStore() override {}
};
class RGWInitMultipart_ObjStore : public RGWInitMultipart {
public:
RGWInitMultipart_ObjStore() {}
- ~RGWInitMultipart_ObjStore() {}
+ ~RGWInitMultipart_ObjStore() override {}
};
class RGWCompleteMultipart_ObjStore : public RGWCompleteMultipart {
public:
RGWCompleteMultipart_ObjStore() {}
- ~RGWCompleteMultipart_ObjStore() {}
+ ~RGWCompleteMultipart_ObjStore() override {}
- virtual int get_params();
+ int get_params() override;
};
class RGWAbortMultipart_ObjStore : public RGWAbortMultipart {
public:
RGWAbortMultipart_ObjStore() {}
- ~RGWAbortMultipart_ObjStore() {}
+ ~RGWAbortMultipart_ObjStore() override {}
};
class RGWListMultipart_ObjStore : public RGWListMultipart {
public:
RGWListMultipart_ObjStore() {}
- ~RGWListMultipart_ObjStore() {}
+ ~RGWListMultipart_ObjStore() override {}
- int get_params();
+ int get_params() override;
};
class RGWListBucketMultiparts_ObjStore : public RGWListBucketMultiparts {
public:
RGWListBucketMultiparts_ObjStore() {}
- ~RGWListBucketMultiparts_ObjStore() {}
+ ~RGWListBucketMultiparts_ObjStore() override {}
- int get_params();
+ int get_params() override;
};
class RGWBulkDelete_ObjStore : public RGWBulkDelete {
public:
RGWBulkDelete_ObjStore() {}
- ~RGWBulkDelete_ObjStore() {}
+ ~RGWBulkDelete_ObjStore() override {}
};
class RGWDeleteMultiObj_ObjStore : public RGWDeleteMultiObj {
public:
RGWDeleteMultiObj_ObjStore() {}
- ~RGWDeleteMultiObj_ObjStore() {}
+ ~RGWDeleteMultiObj_ObjStore() override {}
- virtual int get_params();
+ int get_params() override;
};
class RGWInfo_ObjStore : public RGWInfo {
public:
RGWInfo_ObjStore() = default;
- ~RGWInfo_ObjStore() = default;
+ ~RGWInfo_ObjStore() override = default;
};
class RGWRESTOp : public RGWOp {
RGWRESTFlusher flusher;
public:
RGWRESTOp() : http_ret(0) {}
- virtual void init(RGWRados *store, struct req_state *s,
- RGWHandler *dialect_handler) {
+ void init(RGWRados *store, struct req_state *s,
+ RGWHandler *dialect_handler) override {
RGWOp::init(store, s, dialect_handler);
flusher.init(s, this);
}
- virtual void send_response();
+ void send_response() override;
virtual int check_caps(RGWUserCaps& caps)
{ return -EPERM; } /* should to be implemented! */
- virtual int verify_permission();
+ int verify_permission() override;
};
class RGWHandler_REST : public RGWHandler {
static constexpr int MAX_OBJ_NAME_LEN = 1024;
RGWHandler_REST() {}
- virtual ~RGWHandler_REST() {}
+ ~RGWHandler_REST() override {}
static int validate_tenant_name(const string& bucket);
static int validate_bucket_name(const string& bucket);
static int validate_object_name(const string& object);
- int init_permissions(RGWOp* op);
- int read_permissions(RGWOp* op);
+ int init_permissions(RGWOp* op) override;
+ int read_permissions(RGWOp* op) override;
virtual RGWOp* get_op(RGWRados* store);
virtual void put_op(RGWOp* op);
class RGWRESTMgr_Admin : public RGWRESTMgr {
public:
RGWRESTMgr_Admin() {}
- virtual ~RGWRESTMgr_Admin() {}
+ ~RGWRESTMgr_Admin() override {}
};
class RGWHandler_Bucket : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
- RGWOp *op_put();
- RGWOp *op_post();
- RGWOp *op_delete();
+ RGWOp *op_get() override;
+ RGWOp *op_put() override;
+ RGWOp *op_post() override;
+ RGWOp *op_delete() override;
public:
RGWHandler_Bucket() {}
- virtual ~RGWHandler_Bucket() {}
+ ~RGWHandler_Bucket() override {}
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
};
class RGWRESTMgr_Bucket : public RGWRESTMgr {
public:
RGWRESTMgr_Bucket() = default;
- virtual ~RGWRESTMgr_Bucket() = default;
+ ~RGWRESTMgr_Bucket() override = default;
RGWHandler_REST* get_handler(struct req_state*,
const std::string&) override {
params = *_params;
}
- int receive_header(void *ptr, size_t len);
- virtual int receive_data(void *ptr, size_t len);
- virtual int send_data(void *ptr, size_t len);
+ int receive_header(void *ptr, size_t len) override;
+ int receive_data(void *ptr, size_t len) override;
+ int send_data(void *ptr, size_t len) override;
bufferlist& get_response() { return response; }
RGWHTTPManager http_manager;
public:
int add_output_data(bufferlist& bl);
- int send_data(void *ptr, size_t len);
+ int send_data(void *ptr, size_t len) override;
RGWRESTStreamWriteRequest(CephContext *_cct, const string& _url, param_vec_t *_headers,
param_vec_t *_params) : RGWRESTSimpleRequest(_cct, _url, _headers, _params),
lock("RGWRESTStreamWriteRequest"), cb(NULL), http_manager(_cct) {}
- ~RGWRESTStreamWriteRequest();
+ ~RGWRESTStreamWriteRequest() override;
int put_obj_init(RGWAccessKey& key, rgw_obj& obj, uint64_t obj_size, map<string, bufferlist>& attrs);
int complete(string& etag, real_time *mtime);
const char *method;
uint64_t write_ofs;
protected:
- int handle_header(const string& name, const string& val);
+ int handle_header(const string& name, const string& val) override;
public:
- int send_data(void *ptr, size_t len);
- int receive_data(void *ptr, size_t len);
+ int send_data(void *ptr, size_t len) override;
+ int receive_data(void *ptr, size_t len) override;
RGWRESTStreamRWRequest(CephContext *_cct, const char *_method, const string& _url, RGWGetDataCB *_cb,
param_vec_t *_headers, param_vec_t *_params) : RGWRESTSimpleRequest(_cct, _url, _headers, _params),
lock("RGWRESTStreamReadRequest"), cb(_cb),
chunk_ofs(0), ofs(0), http_manager(_cct), method(_method), write_ofs(0) {
}
- virtual ~RGWRESTStreamRWRequest() {}
+ ~RGWRESTStreamRWRequest() override {}
int get_obj(RGWAccessKey& key, map<string, string>& extra_headers, rgw_obj& obj);
int get_resource(RGWAccessKey& key, map<string, string>& extra_headers, const string& resource, RGWHTTPManager *mgr = NULL);
int complete(string& etag, real_time *mtime, uint64_t *psize, map<string, string>& attrs);
bool old_format;
public:
RGWOp_ZoneGroupMap_Get(bool _old_format):old_format(_old_format) {}
- ~RGWOp_ZoneGroupMap_Get() {}
+ ~RGWOp_ZoneGroupMap_Get() override {}
- int verify_permission() {
+ int verify_permission() override {
return 0;
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
if (old_format) {
return "get_region_map";
} else {
class RGWHandler_Config : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
+ RGWOp *op_get() override;
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
public:
RGWHandler_Config() : RGWHandler_Auth_S3() {}
- virtual ~RGWHandler_Config() {}
+ ~RGWHandler_Config() override {}
};
class RGWRESTMgr_Config : public RGWRESTMgr {
public:
RGWRESTMgr_Config() = default;
- virtual ~RGWRESTMgr_Config() = default;
+ ~RGWRESTMgr_Config() override = default;
RGWHandler_REST* get_handler(struct req_state*,
const std::string&) override {
bufferlist& bl;
public:
RGWStreamIntoBufferlist(bufferlist& _bl) : bl(_bl) {}
- int handle_data(bufferlist& inbl, off_t bl_ofs, off_t bl_len) {
+ int handle_data(bufferlist& inbl, off_t bl_ofs, off_t bl_len) override {
bl.claim_append(inbl);
return bl_len;
}
bool sent_header;
public:
RGWOp_BILog_List() : sent_header(false) {}
- ~RGWOp_BILog_List() {}
+ ~RGWOp_BILog_List() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("bilog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- virtual void send_response();
+ void send_response() override;
virtual void send_response(list<rgw_bi_log_entry>& entries, string& marker);
virtual void send_response_end();
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "list_bucket_index_log";
}
};
string max_marker;
public:
RGWOp_BILog_Info() : bucket_ver(), master_ver() {}
- ~RGWOp_BILog_Info() {}
+ ~RGWOp_BILog_Info() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("bilog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- virtual void send_response();
- void execute();
- virtual const string name() {
+ void send_response() override;
+ void execute() override;
+ const string name() override {
return "bucket_index_log_info";
}
};
class RGWOp_BILog_Delete : public RGWRESTOp {
public:
RGWOp_BILog_Delete() {}
- ~RGWOp_BILog_Delete() {}
+ ~RGWOp_BILog_Delete() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("bilog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "trim_bucket_index_log";
}
};
bool truncated;
public:
RGWOp_MDLog_List() : truncated(false) {}
- ~RGWOp_MDLog_List() {}
+ ~RGWOp_MDLog_List() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "list_metadata_log";
}
};
RGWPeriodHistory::Cursor period;
public:
RGWOp_MDLog_Info() : num_objects(0) {}
- ~RGWOp_MDLog_Info() {}
+ ~RGWOp_MDLog_Info() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "get_metadata_log_info";
}
};
RGWMetadataLogInfo info;
public:
RGWOp_MDLog_ShardInfo() {}
- ~RGWOp_MDLog_ShardInfo() {}
+ ~RGWOp_MDLog_ShardInfo() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "get_metadata_log_shard_info";
}
};
class RGWOp_MDLog_Lock : public RGWRESTOp {
public:
RGWOp_MDLog_Lock() {}
- ~RGWOp_MDLog_Lock() {}
+ ~RGWOp_MDLog_Lock() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "lock_mdlog_object";
}
};
class RGWOp_MDLog_Unlock : public RGWRESTOp {
public:
RGWOp_MDLog_Unlock() {}
- ~RGWOp_MDLog_Unlock() {}
+ ~RGWOp_MDLog_Unlock() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "unlock_mdlog_object";
}
};
class RGWOp_MDLog_Notify : public RGWRESTOp {
public:
RGWOp_MDLog_Notify() {}
- ~RGWOp_MDLog_Notify() {}
+ ~RGWOp_MDLog_Notify() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "mdlog_notify";
}
};
class RGWOp_MDLog_Delete : public RGWRESTOp {
public:
RGWOp_MDLog_Delete() {}
- ~RGWOp_MDLog_Delete() {}
+ ~RGWOp_MDLog_Delete() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("mdlog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "trim_metadata_log";
}
};
bool extra_info;
public:
RGWOp_DATALog_List() : truncated(false), extra_info(false) {}
- ~RGWOp_DATALog_List() {}
+ ~RGWOp_DATALog_List() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "list_data_changes_log";
}
};
unsigned num_objects;
public:
RGWOp_DATALog_Info() : num_objects(0) {}
- ~RGWOp_DATALog_Info() {}
+ ~RGWOp_DATALog_Info() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "get_data_changes_log_info";
}
};
RGWDataChangesLogInfo info;
public:
RGWOp_DATALog_ShardInfo() {}
- ~RGWOp_DATALog_ShardInfo() {}
+ ~RGWOp_DATALog_ShardInfo() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "get_data_changes_log_shard_info";
}
};
class RGWOp_DATALog_Lock : public RGWRESTOp {
public:
RGWOp_DATALog_Lock() {}
- ~RGWOp_DATALog_Lock() {}
+ ~RGWOp_DATALog_Lock() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "lock_datalog_object";
}
};
class RGWOp_DATALog_Unlock : public RGWRESTOp {
public:
RGWOp_DATALog_Unlock() {}
- ~RGWOp_DATALog_Unlock() {}
+ ~RGWOp_DATALog_Unlock() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "unlock_datalog_object";
}
};
class RGWOp_DATALog_Notify : public RGWRESTOp {
public:
RGWOp_DATALog_Notify() {}
- ~RGWOp_DATALog_Notify() {}
+ ~RGWOp_DATALog_Notify() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "datalog_notify";
}
};
class RGWOp_DATALog_Delete : public RGWRESTOp {
public:
RGWOp_DATALog_Delete() {}
- ~RGWOp_DATALog_Delete() {}
+ ~RGWOp_DATALog_Delete() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("datalog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "trim_data_changes_log";
}
};
class RGWHandler_Log : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
- RGWOp *op_delete();
- RGWOp *op_post();
+ RGWOp *op_get() override;
+ RGWOp *op_delete() override;
+ RGWOp *op_post() override;
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
public:
RGWHandler_Log() : RGWHandler_Auth_S3() {}
- virtual ~RGWHandler_Log() {}
+ ~RGWHandler_Log() override {}
};
class RGWRESTMgr_Log : public RGWRESTMgr {
public:
RGWRESTMgr_Log() = default;
- virtual ~RGWRESTMgr_Log() = default;
+ ~RGWRESTMgr_Log() override = default;
RGWHandler_REST* get_handler(struct req_state* const,
const std::string& frontend_prefixs) override {
class RGWOp_Metadata_List : public RGWRESTOp {
public:
RGWOp_Metadata_List() {}
- ~RGWOp_Metadata_List() {}
+ ~RGWOp_Metadata_List() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_READ);
}
- void execute();
- virtual const string name();
+ void execute() override;
+ const string name() override;
};
class RGWOp_Metadata_Get : public RGWRESTOp {
public:
RGWOp_Metadata_Get() {}
- ~RGWOp_Metadata_Get() {}
+ ~RGWOp_Metadata_Get() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_READ);
}
- void execute();
- virtual const string name();
+ void execute() override;
+ const string name() override;
};
class RGWOp_Metadata_Put : public RGWRESTOp {
obj_version ondisk_version;
public:
RGWOp_Metadata_Put() {}
- ~RGWOp_Metadata_Put() {}
+ ~RGWOp_Metadata_Put() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_WRITE);
}
- void execute();
- void send_response();
- virtual const string name() { return "set_metadata"; }
- RGWOpType get_type() { return RGW_OP_ADMIN_SET_METADATA; }
+ void execute() override;
+ void send_response() override;
+ const string name() override { return "set_metadata"; }
+ RGWOpType get_type() override { return RGW_OP_ADMIN_SET_METADATA; }
};
class RGWOp_Metadata_Delete : public RGWRESTOp {
public:
RGWOp_Metadata_Delete() {}
- ~RGWOp_Metadata_Delete() {}
+ ~RGWOp_Metadata_Delete() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() { return "remove_metadata"; }
+ void execute() override;
+ const string name() override { return "remove_metadata"; }
};
class RGWOp_Metadata_Lock : public RGWRESTOp {
public:
RGWOp_Metadata_Lock() {}
- ~RGWOp_Metadata_Lock() {}
+ ~RGWOp_Metadata_Lock() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "lock_metadata_object";
}
};
class RGWOp_Metadata_Unlock : public RGWRESTOp {
public:
RGWOp_Metadata_Unlock() {}
- ~RGWOp_Metadata_Unlock() {}
+ ~RGWOp_Metadata_Unlock() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("metadata", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "unlock_metadata_object";
}
};
class RGWHandler_Metadata : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
- RGWOp *op_put();
- RGWOp *op_delete();
- RGWOp *op_post();
+ RGWOp *op_get() override;
+ RGWOp *op_put() override;
+ RGWOp *op_delete() override;
+ RGWOp *op_post() override;
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
public:
RGWHandler_Metadata() : RGWHandler_Auth_S3() {}
- virtual ~RGWHandler_Metadata() {}
+ ~RGWHandler_Metadata() override {}
};
class RGWRESTMgr_Metadata : public RGWRESTMgr {
public:
RGWRESTMgr_Metadata() = default;
- virtual ~RGWRESTMgr_Metadata() = default;
+ ~RGWRESTMgr_Metadata() override = default;
RGWHandler_REST* get_handler(struct req_state* const s,
const std::string& frontend_prefix) override {
bool sent_header;
public:
RGWOp_Opstate_List() : sent_header(false) {}
- ~RGWOp_Opstate_List() {}
+ ~RGWOp_Opstate_List() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("opstate", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
+ void execute() override;
+ void send_response() override;
virtual void send_response(list<cls_statelog_entry> entries);
virtual void send_response_end();
- virtual const string name() {
+ const string name() override {
return "opstate_list";
}
};
class RGWOp_Opstate_Set : public RGWRESTOp {
public:
RGWOp_Opstate_Set() {}
- ~RGWOp_Opstate_Set() {}
+ ~RGWOp_Opstate_Set() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("opstate", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "set_opstate";
}
};
class RGWOp_Opstate_Renew : public RGWRESTOp {
public:
RGWOp_Opstate_Renew() {}
- ~RGWOp_Opstate_Renew() {}
+ ~RGWOp_Opstate_Renew() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("opstate", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "renew_opstate";
}
};
class RGWOp_Opstate_Delete : public RGWRESTOp {
public:
RGWOp_Opstate_Delete() {}
- ~RGWOp_Opstate_Delete() {}
+ ~RGWOp_Opstate_Delete() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("opstate", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "delete_opstate";
}
};
class RGWHandler_Opstate : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get() {
+ RGWOp *op_get() override {
return new RGWOp_Opstate_List;
}
- RGWOp *op_delete() {
+ RGWOp *op_delete() override {
return new RGWOp_Opstate_Delete;
}
- RGWOp *op_post();
+ RGWOp *op_post() override;
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
public:
RGWHandler_Opstate() : RGWHandler_Auth_S3() {}
- virtual ~RGWHandler_Opstate() {}
+ ~RGWHandler_Opstate() override {}
};
class RGWRESTMgr_Opstate : public RGWRESTMgr {
public:
RGWRESTMgr_Opstate() = default;
- virtual ~RGWRESTMgr_Opstate() = default;
+ ~RGWRESTMgr_Opstate() override = default;
RGWHandler_REST* get_handler(struct req_state*,
const std::string&) override {
public:
RGWOp_OBJLog_GetBounds(const char *_prefix, const char *type)
: prefix(_prefix), obj_type(type){}
- ~RGWOp_OBJLog_GetBounds() {}
+ ~RGWOp_OBJLog_GetBounds() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap(obj_type.c_str(), RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
string s = "replica";
s.append(obj_type);
s.append("_getbounds");
public:
RGWOp_OBJLog_SetBounds(const char *_prefix, const char *type)
: prefix(_prefix), obj_type(type){}
- ~RGWOp_OBJLog_SetBounds() {}
+ ~RGWOp_OBJLog_SetBounds() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap(obj_type.c_str(), RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
string s = "replica";
s.append(obj_type);
s.append("_updatebounds");
public:
RGWOp_OBJLog_DeleteBounds(const char *_prefix, const char *type)
: prefix(_prefix), obj_type(type){}
- ~RGWOp_OBJLog_DeleteBounds() {}
+ ~RGWOp_OBJLog_DeleteBounds() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap(obj_type.c_str(), RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
string s = "replica";
s.append(obj_type);
s.append("_deletebound");
RGWReplicaBounds bounds;
public:
RGWOp_BILog_GetBounds() {}
- ~RGWOp_BILog_GetBounds() {}
+ ~RGWOp_BILog_GetBounds() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("bilog", RGW_CAP_READ);
}
- int verify_permission() {
+ int verify_permission() override {
return check_caps(s->user->caps);
}
- void execute();
- virtual void send_response();
- virtual const string name() {
+ void execute() override;
+ void send_response() override;
+ const string name() override {
return "replicabilog_getbounds";
}
};
class RGWOp_BILog_SetBounds : public RGWRESTOp {
public:
RGWOp_BILog_SetBounds() {}
- ~RGWOp_BILog_SetBounds() {}
+ ~RGWOp_BILog_SetBounds() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("bilog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "replicabilog_updatebounds";
}
};
class RGWOp_BILog_DeleteBounds : public RGWRESTOp {
public:
RGWOp_BILog_DeleteBounds() {}
- ~RGWOp_BILog_DeleteBounds() {}
+ ~RGWOp_BILog_DeleteBounds() override {}
- int check_caps(RGWUserCaps& caps) {
+ int check_caps(RGWUserCaps& caps) override {
return caps.check_cap("bilog", RGW_CAP_WRITE);
}
- void execute();
- virtual const string name() {
+ void execute() override;
+ const string name() override {
return "replicabilog_deletebound";
}
};
class RGWHandler_ReplicaLog : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
- RGWOp *op_delete();
- RGWOp *op_post();
+ RGWOp *op_get() override;
+ RGWOp *op_delete() override;
+ RGWOp *op_post() override;
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
public:
RGWHandler_ReplicaLog() : RGWHandler_Auth_S3() {}
- virtual ~RGWHandler_ReplicaLog() {}
+ ~RGWHandler_ReplicaLog() override {}
};
class RGWRESTMgr_ReplicaLog : public RGWRESTMgr {
public:
RGWRESTMgr_ReplicaLog() = default;
- virtual ~RGWRESTMgr_ReplicaLog() = default;
+ ~RGWRESTMgr_ReplicaLog() override = default;
RGWHandler_REST* get_handler(struct req_state*,
const std::string&) override {
string path_prefix;
public:
- virtual void send_response() override;
+ void send_response() override;
};
class RGWRoleRead : public RGWRestRole {
public:
RGWRoleRead() = default;
- virtual int verify_permission() override;
- virtual uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
+ int verify_permission() override;
+ uint32_t op_mask() override { return RGW_OP_TYPE_READ; }
};
class RGWRoleWrite : public RGWRestRole {
public:
RGWRoleWrite() = default;
- virtual int verify_permission() override;
- virtual uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
+ int verify_permission() override;
+ uint32_t op_mask() override { return RGW_OP_TYPE_WRITE; }
};
class RGWCreateRole : public RGWRoleWrite {
public:
RGWSetBucketVersioningParser() {}
- ~RGWSetBucketVersioningParser() {}
+ ~RGWSetBucketVersioningParser() override {}
int get_versioning_status(bool *status) {
XMLObj *config = find_first("VersioningConfiguration");
{
public:
RGWLocationConstraint() {}
- ~RGWLocationConstraint() {}
+ ~RGWLocationConstraint() override {}
bool xml_end(const char *el) override {
if (!el)
return false;
{
public:
RGWCreateBucketConfig() {}
- ~RGWCreateBucketConfig() {}
+ ~RGWCreateBucketConfig() override {}
};
class RGWCreateBucketParser : public RGWXMLParser
public:
RGWCreateBucketParser() {}
- ~RGWCreateBucketParser() {}
+ ~RGWCreateBucketParser() override {}
bool get_location_constraint(string& zone_group) {
XMLObj *config = find_first("CreateBucketConfiguration");
public:
RGWSetRequestPaymentParser() {}
- ~RGWSetRequestPaymentParser() {}
+ ~RGWSetRequestPaymentParser() override {}
int get_request_payment_payer(bool *requester_pays) {
XMLObj *config = find_first("RequestPaymentConfiguration");
int custom_http_ret = 0;
public:
RGWGetObj_ObjStore_S3() {}
- ~RGWGetObj_ObjStore_S3() {}
+ ~RGWGetObj_ObjStore_S3() override {}
- int send_response_data_error();
- int send_response_data(bufferlist& bl, off_t ofs, off_t len);
+ int send_response_data_error() override;
+ int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
void set_custom_http_response(int http_ret) { custom_http_ret = http_ret; }
};
class RGWListBuckets_ObjStore_S3 : public RGWListBuckets_ObjStore {
public:
RGWListBuckets_ObjStore_S3() {}
- ~RGWListBuckets_ObjStore_S3() {}
+ ~RGWListBuckets_ObjStore_S3() override {}
- int get_params() {
+ int get_params() override {
limit = -1; /* no limit */
return 0;
}
- virtual void send_response_begin(bool has_buckets);
- virtual void send_response_data(RGWUserBuckets& buckets);
- virtual void send_response_end();
+ void send_response_begin(bool has_buckets) override;
+ void send_response_data(RGWUserBuckets& buckets) override;
+ void send_response_end() override;
};
class RGWGetUsage_ObjStore_S3 : public RGWGetUsage_ObjStore {
public:
RGWGetUsage_ObjStore_S3() {}
- ~RGWGetUsage_ObjStore_S3() {}
+ ~RGWGetUsage_ObjStore_S3() override {}
- int get_params() ;
- virtual void send_response();
+ int get_params() override ;
+ void send_response() override;
};
class RGWListBucket_ObjStore_S3 : public RGWListBucket_ObjStore {
RGWListBucket_ObjStore_S3() : objs_container(false) {
default_max = 1000;
}
- ~RGWListBucket_ObjStore_S3() {}
+ ~RGWListBucket_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
void send_versioned_response();
};
class RGWGetBucketLogging_ObjStore_S3 : public RGWGetBucketLogging {
public:
RGWGetBucketLogging_ObjStore_S3() {}
- ~RGWGetBucketLogging_ObjStore_S3() {}
+ ~RGWGetBucketLogging_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWGetBucketLocation_ObjStore_S3 : public RGWGetBucketLocation {
public:
RGWGetBucketLocation_ObjStore_S3() {}
- ~RGWGetBucketLocation_ObjStore_S3() {}
+ ~RGWGetBucketLocation_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWGetBucketVersioning_ObjStore_S3 : public RGWGetBucketVersioning {
public:
RGWGetBucketVersioning_ObjStore_S3() {}
- ~RGWGetBucketVersioning_ObjStore_S3() {}
+ ~RGWGetBucketVersioning_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWSetBucketVersioning_ObjStore_S3 : public RGWSetBucketVersioning {
public:
RGWSetBucketVersioning_ObjStore_S3() {}
- ~RGWSetBucketVersioning_ObjStore_S3() {}
+ ~RGWSetBucketVersioning_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWGetBucketWebsite_ObjStore_S3 : public RGWGetBucketWebsite {
public:
RGWGetBucketWebsite_ObjStore_S3() {}
- ~RGWGetBucketWebsite_ObjStore_S3() {}
+ ~RGWGetBucketWebsite_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWSetBucketWebsite_ObjStore_S3 : public RGWSetBucketWebsite {
public:
RGWSetBucketWebsite_ObjStore_S3() {}
- ~RGWSetBucketWebsite_ObjStore_S3() {}
+ ~RGWSetBucketWebsite_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWDeleteBucketWebsite_ObjStore_S3 : public RGWDeleteBucketWebsite {
public:
RGWDeleteBucketWebsite_ObjStore_S3() {}
- ~RGWDeleteBucketWebsite_ObjStore_S3() {}
+ ~RGWDeleteBucketWebsite_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWStatBucket_ObjStore_S3 : public RGWStatBucket_ObjStore {
public:
RGWStatBucket_ObjStore_S3() {}
- ~RGWStatBucket_ObjStore_S3() {}
+ ~RGWStatBucket_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWCreateBucket_ObjStore_S3 : public RGWCreateBucket_ObjStore {
public:
RGWCreateBucket_ObjStore_S3() {}
- ~RGWCreateBucket_ObjStore_S3() {}
+ ~RGWCreateBucket_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWDeleteBucket_ObjStore_S3 : public RGWDeleteBucket_ObjStore {
public:
RGWDeleteBucket_ObjStore_S3() {}
- ~RGWDeleteBucket_ObjStore_S3() {}
+ ~RGWDeleteBucket_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWPutObj_ObjStore_S3 : public RGWPutObj_ObjStore {
public:
RGWPutObj_ObjStore_S3() {}
- ~RGWPutObj_ObjStore_S3() {}
+ ~RGWPutObj_ObjStore_S3() override {}
- int get_params();
- int get_data(bufferlist& bl);
- void send_response();
+ int get_params() override;
+ int get_data(bufferlist& bl) override;
+ void send_response() override;
int validate_aws4_single_chunk(char *chunk_str,
char *chunk_data_str,
void rebuild_key(string& key);
public:
RGWPostObj_ObjStore_S3() {}
- ~RGWPostObj_ObjStore_S3() {}
+ ~RGWPostObj_ObjStore_S3() override {}
- int get_params();
+ int get_params() override;
int complete_get_params();
- void send_response();
- int get_data(bufferlist& bl);
+ void send_response() override;
+ int get_data(bufferlist& bl) override;
};
class RGWDeleteObj_ObjStore_S3 : public RGWDeleteObj_ObjStore {
public:
RGWDeleteObj_ObjStore_S3() {}
- ~RGWDeleteObj_ObjStore_S3() {}
+ ~RGWDeleteObj_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWCopyObj_ObjStore_S3 : public RGWCopyObj_ObjStore {
bool sent_header;
public:
RGWCopyObj_ObjStore_S3() : sent_header(false) {}
- ~RGWCopyObj_ObjStore_S3() {}
+ ~RGWCopyObj_ObjStore_S3() override {}
- int init_dest_policy();
- int get_params();
- void send_partial_response(off_t ofs);
- void send_response();
+ int init_dest_policy() override;
+ int get_params() override;
+ void send_partial_response(off_t ofs) override;
+ void send_response() override;
};
class RGWGetACLs_ObjStore_S3 : public RGWGetACLs_ObjStore {
public:
RGWGetACLs_ObjStore_S3() {}
- ~RGWGetACLs_ObjStore_S3() {}
+ ~RGWGetACLs_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWPutACLs_ObjStore_S3 : public RGWPutACLs_ObjStore {
public:
RGWPutACLs_ObjStore_S3() {}
- ~RGWPutACLs_ObjStore_S3() {}
+ ~RGWPutACLs_ObjStore_S3() override {}
- int get_policy_from_state(RGWRados *store, struct req_state *s, stringstream& ss);
- void send_response();
- int get_params();
+ int get_policy_from_state(RGWRados *store, struct req_state *s, stringstream& ss) override;
+ void send_response() override;
+ int get_params() override;
};
class RGWGetLC_ObjStore_S3 : public RGWGetLC_ObjStore {
RGWLifecycleConfiguration_S3 config;
public:
RGWGetLC_ObjStore_S3() {}
- ~RGWGetLC_ObjStore_S3() {}
- virtual void execute();
+ ~RGWGetLC_ObjStore_S3() override {}
+ void execute() override;
- void send_response();
+ void send_response() override;
};
class RGWPutLC_ObjStore_S3 : public RGWPutLC_ObjStore {
public:
RGWPutLC_ObjStore_S3() {}
- ~RGWPutLC_ObjStore_S3() {}
+ ~RGWPutLC_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWDeleteLC_ObjStore_S3 : public RGWDeleteLC_ObjStore {
public:
RGWDeleteLC_ObjStore_S3() {}
- ~RGWDeleteLC_ObjStore_S3() {}
+ ~RGWDeleteLC_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWGetCORS_ObjStore_S3 : public RGWGetCORS_ObjStore {
public:
RGWGetCORS_ObjStore_S3() {}
- ~RGWGetCORS_ObjStore_S3() {}
+ ~RGWGetCORS_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWPutCORS_ObjStore_S3 : public RGWPutCORS_ObjStore {
public:
RGWPutCORS_ObjStore_S3() {}
- ~RGWPutCORS_ObjStore_S3() {}
+ ~RGWPutCORS_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWDeleteCORS_ObjStore_S3 : public RGWDeleteCORS_ObjStore {
public:
RGWDeleteCORS_ObjStore_S3() {}
- ~RGWDeleteCORS_ObjStore_S3() {}
+ ~RGWDeleteCORS_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWOptionsCORS_ObjStore_S3 : public RGWOptionsCORS_ObjStore {
public:
RGWOptionsCORS_ObjStore_S3() {}
- ~RGWOptionsCORS_ObjStore_S3() {}
+ ~RGWOptionsCORS_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWGetRequestPayment_ObjStore_S3 : public RGWGetRequestPayment {
public:
RGWGetRequestPayment_ObjStore_S3() {}
- ~RGWGetRequestPayment_ObjStore_S3() {}
+ ~RGWGetRequestPayment_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWSetRequestPayment_ObjStore_S3 : public RGWSetRequestPayment {
public:
RGWSetRequestPayment_ObjStore_S3() {}
- ~RGWSetRequestPayment_ObjStore_S3() {}
+ ~RGWSetRequestPayment_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWInitMultipart_ObjStore_S3 : public RGWInitMultipart_ObjStore {
public:
RGWInitMultipart_ObjStore_S3() {}
- ~RGWInitMultipart_ObjStore_S3() {}
+ ~RGWInitMultipart_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWCompleteMultipart_ObjStore_S3 : public RGWCompleteMultipart_ObjStore {
public:
RGWCompleteMultipart_ObjStore_S3() {}
- ~RGWCompleteMultipart_ObjStore_S3() {}
+ ~RGWCompleteMultipart_ObjStore_S3() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWAbortMultipart_ObjStore_S3 : public RGWAbortMultipart_ObjStore {
public:
RGWAbortMultipart_ObjStore_S3() {}
- ~RGWAbortMultipart_ObjStore_S3() {}
+ ~RGWAbortMultipart_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWListMultipart_ObjStore_S3 : public RGWListMultipart_ObjStore {
public:
RGWListMultipart_ObjStore_S3() {}
- ~RGWListMultipart_ObjStore_S3() {}
+ ~RGWListMultipart_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWListBucketMultiparts_ObjStore_S3 : public RGWListBucketMultiparts_ObjStore {
RGWListBucketMultiparts_ObjStore_S3() {
default_max = 1000;
}
- ~RGWListBucketMultiparts_ObjStore_S3() {}
+ ~RGWListBucketMultiparts_ObjStore_S3() override {}
- void send_response();
+ void send_response() override;
};
class RGWDeleteMultiObj_ObjStore_S3 : public RGWDeleteMultiObj_ObjStore {
public:
RGWDeleteMultiObj_ObjStore_S3() {}
- ~RGWDeleteMultiObj_ObjStore_S3() {}
+ ~RGWDeleteMultiObj_ObjStore_S3() override {}
- int get_params();
- void send_status();
- void begin_response();
+ int get_params() override;
+ void send_status() override;
+ void begin_response() override;
void send_partial_response(rgw_obj_key& key, bool delete_marker,
- const string& marker_version_id, int ret);
- void end_response();
+ const string& marker_version_id, int ret) override;
+ void end_response() override;
};
class RGWGetObjLayout_ObjStore_S3 : public RGWGetObjLayout {
get_str_vec(cct->_conf->rgw_keystone_accepted_roles, accepted_roles);
}
- int receive_header(void *ptr, size_t len) {
+ int receive_header(void *ptr, size_t len) override {
return 0;
}
- int receive_data(void *ptr, size_t len) {
+ int receive_data(void *ptr, size_t len) override {
rx_buffer.append((char *)ptr, len);
return 0;
}
- int send_data(void *ptr, size_t len) {
+ int send_data(void *ptr, size_t len) override {
if (!tx_buffer_it.get_remaining())
return 0; // nothing left to send
friend class RGWRESTMgr_S3;
public:
RGWHandler_Auth_S3() : RGWHandler_REST() {}
- virtual ~RGWHandler_Auth_S3() {}
+ ~RGWHandler_Auth_S3() override {}
static int validate_bucket_name(const string& bucket);
static int validate_object_name(const string& bucket);
- virtual int init(RGWRados *store,
- struct req_state *s,
- rgw::io::BasicClient *cio);
- virtual int authorize() {
+ int init(RGWRados *store,
+ struct req_state *s,
+ rgw::io::BasicClient *cio) override;
+ int authorize() override {
return RGW_Auth_S3::authorize(store, s);
}
- int postauth_init() { return 0; }
+ int postauth_init() override { return 0; }
};
class RGWHandler_REST_S3 : public RGWHandler_REST {
static int init_from_header(struct req_state *s, int default_formatter, bool configurable_format);
RGWHandler_REST_S3() : RGWHandler_REST() {}
- virtual ~RGWHandler_REST_S3() {}
+ ~RGWHandler_REST_S3() override {}
- virtual int init(RGWRados *store,
- struct req_state *s,
- rgw::io::BasicClient *cio);
- virtual int authorize() {
+ int init(RGWRados *store,
+ struct req_state *s,
+ rgw::io::BasicClient *cio) override;
+ int authorize() override {
return RGW_Auth_S3::authorize(store, s);
}
- int postauth_init();
+ int postauth_init() override;
};
class RGWHandler_REST_Service_S3 : public RGWHandler_REST_S3 {
bool is_usage_op() {
return s->info.args.exists("usage");
}
- RGWOp *op_get();
- RGWOp *op_head();
- RGWOp *op_post();
+ RGWOp *op_get() override;
+ RGWOp *op_head() override;
+ RGWOp *op_post() override;
public:
RGWHandler_REST_Service_S3() {}
- virtual ~RGWHandler_REST_Service_S3() {}
+ ~RGWHandler_REST_Service_S3() override {}
};
class RGWHandler_REST_Bucket_S3 : public RGWHandler_REST_S3 {
bool is_lc_op() {
return s->info.args.exists("lifecycle");
}
- bool is_obj_update_op() {
+ bool is_obj_update_op() override {
return is_acl_op() || is_cors_op();
}
bool is_request_payment_op() {
}
RGWOp *get_obj_op(bool get_data);
- RGWOp *op_get();
- RGWOp *op_head();
- RGWOp *op_put();
- RGWOp *op_delete();
- RGWOp *op_post();
- RGWOp *op_options();
+ RGWOp *op_get() override;
+ RGWOp *op_head() override;
+ RGWOp *op_put() override;
+ RGWOp *op_delete() override;
+ RGWOp *op_post() override;
+ RGWOp *op_options() override;
public:
RGWHandler_REST_Bucket_S3() {}
- virtual ~RGWHandler_REST_Bucket_S3() {}
+ ~RGWHandler_REST_Bucket_S3() override {}
};
class RGWHandler_REST_Obj_S3 : public RGWHandler_REST_S3 {
bool is_cors_op() {
return s->info.args.exists("cors");
}
- bool is_obj_update_op() {
+ bool is_obj_update_op() override {
return is_acl_op();
}
RGWOp *get_obj_op(bool get_data);
- RGWOp *op_get();
- RGWOp *op_head();
- RGWOp *op_put();
- RGWOp *op_delete();
- RGWOp *op_post();
- RGWOp *op_options();
+ RGWOp *op_get() override;
+ RGWOp *op_head() override;
+ RGWOp *op_put() override;
+ RGWOp *op_delete() override;
+ RGWOp *op_post() override;
+ RGWOp *op_options() override;
public:
RGWHandler_REST_Obj_S3() {}
- virtual ~RGWHandler_REST_Obj_S3() {}
+ ~RGWHandler_REST_Obj_S3() override {}
};
class RGWRESTMgr_S3 : public RGWRESTMgr {
: enable_s3website(enable_s3website) {
}
- virtual ~RGWRESTMgr_S3() = default;
+ ~RGWRESTMgr_S3() override = default;
RGWHandler_REST *get_handler(struct req_state* s,
const std::string& frontend_prefix) override;
class RGWHandler_REST_S3Website : public RGWHandler_REST_S3 {
protected:
- int retarget(RGWOp *op, RGWOp **new_op);
+ int retarget(RGWOp *op, RGWOp **new_op) override;
// TODO: this should be virtual I think, and ensure that it's always
// overridden, but that conflates that op_get/op_head are defined in this
// class and call this; and don't need to be overridden later.
virtual RGWOp *get_obj_op(bool get_data) { return NULL; }
- RGWOp *op_get();
- RGWOp *op_head();
+ RGWOp *op_get() override;
+ RGWOp *op_head() override;
// Only allowed to use GET+HEAD
- RGWOp *op_put() { return NULL; }
- RGWOp *op_delete() { return NULL; }
- RGWOp *op_post() { return NULL; }
- RGWOp *op_copy() { return NULL; }
- RGWOp *op_options() { return NULL; }
+ RGWOp *op_put() override { return NULL; }
+ RGWOp *op_delete() override { return NULL; }
+ RGWOp *op_post() override { return NULL; }
+ RGWOp *op_copy() override { return NULL; }
+ RGWOp *op_options() override { return NULL; }
int serve_errordoc(int http_ret, const string &errordoc_key);
public:
RGWHandler_REST_S3Website() : RGWHandler_REST_S3() {}
- virtual ~RGWHandler_REST_S3Website() {}
- virtual int error_handler(int err_no, string *error_content);
+ ~RGWHandler_REST_S3Website() override {}
+ int error_handler(int err_no, string *error_content) override;
};
class RGWHandler_REST_Service_S3Website : public RGWHandler_REST_S3Website {
protected:
- virtual RGWOp *get_obj_op(bool get_data);
+ RGWOp *get_obj_op(bool get_data) override;
public:
RGWHandler_REST_Service_S3Website() {}
- virtual ~RGWHandler_REST_Service_S3Website() {}
+ ~RGWHandler_REST_Service_S3Website() override {}
};
class RGWHandler_REST_Obj_S3Website : public RGWHandler_REST_S3Website {
protected:
- virtual RGWOp *get_obj_op(bool get_data);
+ RGWOp *get_obj_op(bool get_data) override;
public:
RGWHandler_REST_Obj_S3Website() {}
- virtual ~RGWHandler_REST_Obj_S3Website() {}
+ ~RGWHandler_REST_Obj_S3Website() override {}
};
/* The cross-inheritance from Obj to Bucket is deliberate!
*/
class RGWHandler_REST_Bucket_S3Website : public RGWHandler_REST_S3Website {
protected:
- RGWOp *get_obj_op(bool get_data);
+ RGWOp *get_obj_op(bool get_data) override;
public:
RGWHandler_REST_Bucket_S3Website() {}
- virtual ~RGWHandler_REST_Bucket_S3Website() {}
+ ~RGWHandler_REST_Bucket_S3Website() override {}
};
// TODO: do we actually need this?
public:
RGWGetObj_ObjStore_S3Website() : is_errordoc_request(false) {}
explicit RGWGetObj_ObjStore_S3Website(bool is_errordoc_request) : is_errordoc_request(false) { this->is_errordoc_request = is_errordoc_request; }
- ~RGWGetObj_ObjStore_S3Website() {}
- int send_response_data_error();
- int send_response_data(bufferlist& bl, off_t ofs, off_t len);
+ ~RGWGetObj_ObjStore_S3Website() override {}
+ int send_response_data_error() override;
+ int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
// We override RGWGetObj_ObjStore::get_params here, to allow ignoring all
// conditional params for error pages.
- int get_params() {
+ int get_params() override {
if (is_errordoc_request) {
range_str = NULL;
if_mod = NULL;
int custom_http_ret = 0;
public:
RGWGetObj_ObjStore_SWIFT() {}
- ~RGWGetObj_ObjStore_SWIFT() {}
+ ~RGWGetObj_ObjStore_SWIFT() override {}
int verify_permission() override;
- int get_params();
- int send_response_data_error();
- int send_response_data(bufferlist& bl, off_t ofs, off_t len);
+ int get_params() override;
+ int send_response_data_error() override;
+ int send_response_data(bufferlist& bl, off_t ofs, off_t len) override;
void set_custom_http_response(const int http_ret) {
custom_http_ret = http_ret;
}
- bool need_object_expiration() {
+ bool need_object_expiration() override {
return true;
}
};
}
public:
RGWListBuckets_ObjStore_SWIFT() : need_stats(true) {}
- ~RGWListBuckets_ObjStore_SWIFT() {}
+ ~RGWListBuckets_ObjStore_SWIFT() override {}
- int get_params();
- void send_response_begin(bool has_buckets);
- void send_response_data(RGWUserBuckets& buckets);
- void send_response_end();
+ int get_params() override;
+ void send_response_begin(bool has_buckets) override;
+ void send_response_data(RGWUserBuckets& buckets) override;
+ void send_response_end() override;
- bool should_get_stats() { return need_stats; }
- bool supports_account_metadata() { return true; }
+ bool should_get_stats() override { return need_stats; }
+ bool supports_account_metadata() override { return true; }
};
class RGWListBucket_ObjStore_SWIFT : public RGWListBucket_ObjStore {
RGWListBucket_ObjStore_SWIFT() {
default_max = 10000;
}
- ~RGWListBucket_ObjStore_SWIFT() {}
+ ~RGWListBucket_ObjStore_SWIFT() override {}
- int get_params();
- void send_response();
- bool need_container_stats() { return true; }
+ int get_params() override;
+ void send_response() override;
+ bool need_container_stats() override { return true; }
};
class RGWStatAccount_ObjStore_SWIFT : public RGWStatAccount_ObjStore {
public:
RGWStatAccount_ObjStore_SWIFT() {
}
- ~RGWStatAccount_ObjStore_SWIFT() {}
+ ~RGWStatAccount_ObjStore_SWIFT() override {}
- void execute();
- void send_response();
+ void execute() override;
+ void send_response() override;
};
class RGWStatBucket_ObjStore_SWIFT : public RGWStatBucket_ObjStore {
public:
RGWStatBucket_ObjStore_SWIFT() {}
- ~RGWStatBucket_ObjStore_SWIFT() {}
+ ~RGWStatBucket_ObjStore_SWIFT() override {}
- void send_response();
+ void send_response() override;
};
class RGWCreateBucket_ObjStore_SWIFT : public RGWCreateBucket_ObjStore {
bool need_metadata_upload() const override { return true; }
public:
RGWCreateBucket_ObjStore_SWIFT() {}
- ~RGWCreateBucket_ObjStore_SWIFT() {}
+ ~RGWCreateBucket_ObjStore_SWIFT() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWDeleteBucket_ObjStore_SWIFT : public RGWDeleteBucket_ObjStore {
public:
RGWDeleteBucket_ObjStore_SWIFT() {}
- ~RGWDeleteBucket_ObjStore_SWIFT() {}
+ ~RGWDeleteBucket_ObjStore_SWIFT() override {}
- void send_response();
+ void send_response() override;
};
class RGWPutObj_ObjStore_SWIFT : public RGWPutObj_ObjStore {
string lo_etag;
public:
RGWPutObj_ObjStore_SWIFT() {}
- ~RGWPutObj_ObjStore_SWIFT() {}
+ ~RGWPutObj_ObjStore_SWIFT() override {}
int verify_permission() override;
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWPutMetadataAccount_ObjStore_SWIFT : public RGWPutMetadataAccount_ObjStore {
public:
RGWPutMetadataAccount_ObjStore_SWIFT() {}
- ~RGWPutMetadataAccount_ObjStore_SWIFT() {}
+ ~RGWPutMetadataAccount_ObjStore_SWIFT() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWPutMetadataBucket_ObjStore_SWIFT : public RGWPutMetadataBucket_ObjStore {
public:
RGWPutMetadataBucket_ObjStore_SWIFT() {}
- ~RGWPutMetadataBucket_ObjStore_SWIFT() {}
+ ~RGWPutMetadataBucket_ObjStore_SWIFT() override {}
- int get_params();
- void send_response();
+ int get_params() override;
+ void send_response() override;
};
class RGWPutMetadataObject_ObjStore_SWIFT : public RGWPutMetadataObject_ObjStore {
public:
RGWPutMetadataObject_ObjStore_SWIFT() {}
- ~RGWPutMetadataObject_ObjStore_SWIFT() {}
+ ~RGWPutMetadataObject_ObjStore_SWIFT() override {}
- int get_params();
- void send_response();
- bool need_object_expiration() { return true; }
+ int get_params() override;
+ void send_response() override;
+ bool need_object_expiration() override { return true; }
};
class RGWDeleteObj_ObjStore_SWIFT : public RGWDeleteObj_ObjStore {
public:
RGWDeleteObj_ObjStore_SWIFT() {}
- ~RGWDeleteObj_ObjStore_SWIFT() {}
+ ~RGWDeleteObj_ObjStore_SWIFT() override {}
int verify_permission() override;
- int get_params();
- bool need_object_expiration() { return true; }
- void send_response();
+ int get_params() override;
+ bool need_object_expiration() override { return true; }
+ void send_response() override;
};
class RGWCopyObj_ObjStore_SWIFT : public RGWCopyObj_ObjStore {
void dump_copy_info();
public:
RGWCopyObj_ObjStore_SWIFT() : sent_header(false) {}
- ~RGWCopyObj_ObjStore_SWIFT() {}
+ ~RGWCopyObj_ObjStore_SWIFT() override {}
- int init_dest_policy();
- int get_params();
- void send_response();
- void send_partial_response(off_t ofs);
+ int init_dest_policy() override;
+ int get_params() override;
+ void send_response() override;
+ void send_partial_response(off_t ofs) override;
};
class RGWGetACLs_ObjStore_SWIFT : public RGWGetACLs_ObjStore {
public:
RGWGetACLs_ObjStore_SWIFT() {}
- ~RGWGetACLs_ObjStore_SWIFT() {}
+ ~RGWGetACLs_ObjStore_SWIFT() override {}
- void send_response() {}
+ void send_response() override {}
};
class RGWPutACLs_ObjStore_SWIFT : public RGWPutACLs_ObjStore {
public:
RGWPutACLs_ObjStore_SWIFT() : RGWPutACLs_ObjStore() {}
- virtual ~RGWPutACLs_ObjStore_SWIFT() {}
+ ~RGWPutACLs_ObjStore_SWIFT() override {}
- void send_response() {}
+ void send_response() override {}
};
class RGWOptionsCORS_ObjStore_SWIFT : public RGWOptionsCORS_ObjStore {
public:
RGWOptionsCORS_ObjStore_SWIFT() {}
- ~RGWOptionsCORS_ObjStore_SWIFT() {}
+ ~RGWOptionsCORS_ObjStore_SWIFT() override {}
- void send_response();
+ void send_response() override;
};
class RGWBulkDelete_ObjStore_SWIFT : public RGWBulkDelete_ObjStore {
public:
RGWBulkDelete_ObjStore_SWIFT() {}
- ~RGWBulkDelete_ObjStore_SWIFT() {}
+ ~RGWBulkDelete_ObjStore_SWIFT() override {}
int get_data(std::list<RGWBulkDelete::acct_path_t>& items,
- bool * is_truncated);
- void send_response();
+ bool * is_truncated) override;
+ void send_response() override;
};
class RGWInfo_ObjStore_SWIFT : public RGWInfo_ObjStore {
static const vector<pair<string, struct info>> swift_info;
public:
RGWInfo_ObjStore_SWIFT() {}
- ~RGWInfo_ObjStore_SWIFT() {}
+ ~RGWInfo_ObjStore_SWIFT() override {}
void execute() override;
void send_response() override;
const std::string& frontend_prefix);
public:
RGWHandler_REST_SWIFT() {}
- virtual ~RGWHandler_REST_SWIFT() {}
+ ~RGWHandler_REST_SWIFT() override {}
static int validate_bucket_name(const string& bucket);
- int init(RGWRados *store, struct req_state *s, rgw::io::BasicClient *cio);
+ int init(RGWRados *store, struct req_state *s, rgw::io::BasicClient *cio) override;
int authorize() override;
int postauth_init() override;
RGWOp *op_delete() override;
public:
RGWHandler_REST_Service_SWIFT() {}
- virtual ~RGWHandler_REST_Service_SWIFT() {}
+ ~RGWHandler_REST_Service_SWIFT() override {}
};
class RGWHandler_REST_Bucket_SWIFT : public RGWHandler_REST_SWIFT {
* initialization (see the init() method). */
boost::optional<RGWSwiftWebsiteHandler> website_handler;
protected:
- bool is_obj_update_op() {
+ bool is_obj_update_op() override {
return s->op == OP_POST;
}
RGWOp *op_options() override;
public:
RGWHandler_REST_Bucket_SWIFT() {}
- virtual ~RGWHandler_REST_Bucket_SWIFT() {}
+ ~RGWHandler_REST_Bucket_SWIFT() override {}
int error_handler(int err_no, std::string *error_content) override {
return website_handler->error_handler(err_no, error_content);
* initialization (see the init() method). */
boost::optional<RGWSwiftWebsiteHandler> website_handler;
protected:
- bool is_obj_update_op() {
+ bool is_obj_update_op() override {
return s->op == OP_POST;
}
public:
RGWHandler_REST_Obj_SWIFT() {}
- virtual ~RGWHandler_REST_Obj_SWIFT() {}
+ ~RGWHandler_REST_Obj_SWIFT() override {}
int error_handler(int err_no, std::string *error_content) override {
return website_handler->error_handler(err_no, error_content);
public:
RGWRESTMgr_SWIFT() = default;
- virtual ~RGWRESTMgr_SWIFT() = default;
+ ~RGWRESTMgr_SWIFT() override = default;
RGWHandler_REST *get_handler(struct req_state *s,
const std::string& frontend_prefix) override;
: public RGWGetCrossDomainPolicy_ObjStore {
public:
RGWGetCrossDomainPolicy_ObjStore_SWIFT() = default;
- ~RGWGetCrossDomainPolicy_ObjStore_SWIFT() = default;
+ ~RGWGetCrossDomainPolicy_ObjStore_SWIFT() override = default;
void send_response() override;
};
: public RGWGetHealthCheck_ObjStore {
public:
RGWGetHealthCheck_ObjStore_SWIFT() = default;
- ~RGWGetHealthCheck_ObjStore_SWIFT() = default;
+ ~RGWGetHealthCheck_ObjStore_SWIFT() override = default;
void send_response() override;
};
class RGWHandler_SWIFT_CrossDomain : public RGWHandler_REST {
public:
RGWHandler_SWIFT_CrossDomain() = default;
- ~RGWHandler_SWIFT_CrossDomain() = default;
+ ~RGWHandler_SWIFT_CrossDomain() override = default;
RGWOp *op_get() override {
return new RGWGetCrossDomainPolicy_ObjStore_SWIFT();
public:
RGWRESTMgr_SWIFT_CrossDomain() = default;
- ~RGWRESTMgr_SWIFT_CrossDomain() = default;
+ ~RGWRESTMgr_SWIFT_CrossDomain() override = default;
RGWHandler_REST* get_handler(struct req_state* const s,
const std::string&) override {
class RGWHandler_SWIFT_HealthCheck : public RGWHandler_REST {
public:
RGWHandler_SWIFT_HealthCheck() = default;
- ~RGWHandler_SWIFT_HealthCheck() = default;
+ ~RGWHandler_SWIFT_HealthCheck() override = default;
RGWOp *op_get() override {
return new RGWGetHealthCheck_ObjStore_SWIFT();
public:
RGWRESTMgr_SWIFT_HealthCheck() = default;
- ~RGWRESTMgr_SWIFT_HealthCheck() = default;
+ ~RGWRESTMgr_SWIFT_HealthCheck() override = default;
RGWHandler_REST* get_handler(struct req_state* const s,
const std::string&) override {
class RGWHandler_REST_SWIFT_Info : public RGWHandler_REST_SWIFT {
public:
RGWHandler_REST_SWIFT_Info() = default;
- ~RGWHandler_REST_SWIFT_Info() = default;
+ ~RGWHandler_REST_SWIFT_Info() override = default;
RGWOp *op_get() override {
return new RGWInfo_ObjStore_SWIFT();
class RGWRESTMgr_SWIFT_Info : public RGWRESTMgr {
public:
RGWRESTMgr_SWIFT_Info() = default;
- virtual ~RGWRESTMgr_SWIFT_Info() = default;
+ ~RGWRESTMgr_SWIFT_Info() override = default;
RGWHandler_REST *get_handler(struct req_state* s,
const std::string& frontend_prefix) override;
class RGWHandler_Usage : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
- RGWOp *op_delete();
+ RGWOp *op_get() override;
+ RGWOp *op_delete() override;
public:
RGWHandler_Usage() {}
- virtual ~RGWHandler_Usage() {}
+ ~RGWHandler_Usage() override {}
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
};
class RGWRESTMgr_Usage : public RGWRESTMgr {
public:
RGWRESTMgr_Usage() = default;
- virtual ~RGWRESTMgr_Usage() = default;
+ ~RGWRESTMgr_Usage() override = default;
RGWHandler_REST* get_handler(struct req_state*,
const std::string&) override {
class RGWHandler_User : public RGWHandler_Auth_S3 {
protected:
- RGWOp *op_get();
- RGWOp *op_put();
- RGWOp *op_post();
- RGWOp *op_delete();
+ RGWOp *op_get() override;
+ RGWOp *op_put() override;
+ RGWOp *op_post() override;
+ RGWOp *op_delete() override;
public:
RGWHandler_User() {}
- virtual ~RGWHandler_User() {}
+ ~RGWHandler_User() override {}
- int read_permissions(RGWOp*) {
+ int read_permissions(RGWOp*) override {
return 0;
}
};
class RGWRESTMgr_User : public RGWRESTMgr {
public:
RGWRESTMgr_User() = default;
- virtual ~RGWRESTMgr_User() = default;
+ ~RGWRESTMgr_User() override = default;
RGWHandler_REST *get_handler(struct req_state*,
const std::string&) override {
: RGWLocalAuthApplier(cct, user_info, RGWLocalAuthApplier::NO_SUBUSER) {
};
- virtual void modify_request_state(req_state * s) const override; /* in/out */
+ void modify_request_state(req_state * s) const override; /* in/out */
struct Factory {
virtual ~Factory() {}
class RGW_SWIFT_Auth_Get : public RGWOp {
public:
RGW_SWIFT_Auth_Get() {}
- ~RGW_SWIFT_Auth_Get() {}
+ ~RGW_SWIFT_Auth_Get() override {}
- int verify_permission() { return 0; }
- void execute();
- virtual const string name() { return "swift_auth_get"; }
+ int verify_permission() override { return 0; }
+ void execute() override;
+ const string name() override { return "swift_auth_get"; }
};
class RGWHandler_SWIFT_Auth : public RGWHandler_REST {
public:
RGWHandler_SWIFT_Auth() {}
- ~RGWHandler_SWIFT_Auth() {}
- RGWOp *op_get();
+ ~RGWHandler_SWIFT_Auth() override {}
+ RGWOp *op_get() override;
- int init(RGWRados *store, struct req_state *state, rgw::io::BasicClient *cio);
- int authorize();
- int postauth_init() { return 0; }
- int read_permissions(RGWOp *op) { return 0; }
+ int init(RGWRados *store, struct req_state *state, rgw::io::BasicClient *cio) override;
+ int authorize() override;
+ int postauth_init() override { return 0; }
+ int read_permissions(RGWOp *op) override { return 0; }
virtual RGWAccessControlPolicy *alloc_policy() { return NULL; }
virtual void free_policy(RGWAccessControlPolicy *policy) {}
class RGWRESTMgr_SWIFT_Auth : public RGWRESTMgr {
public:
RGWRESTMgr_SWIFT_Auth() = default;
- virtual ~RGWRESTMgr_SWIFT_Auth() = default;
+ ~RGWRESTMgr_SWIFT_Auth() override = default;
- virtual RGWRESTMgr *get_resource_mgr(struct req_state* const s,
- const std::string& uri,
- std::string* const out_uri) override {
+ RGWRESTMgr *get_resource_mgr(struct req_state* const s,
+ const std::string& uri,
+ std::string* const out_uri) override {
return this;
}
- virtual RGWHandler_REST* get_handler(struct req_state*,
- const std::string&) override {
+ RGWHandler_REST* get_handler(struct req_state*,
+ const std::string&) override {
return new RGWHandler_SWIFT_Auth;
}
};
shard_id(_shard_id), pmarker(_marker), max_entries(_max_entries),
entries(_entries), truncated(_truncated) {}
- ~RGWReadMDLogEntriesCR() {
+ ~RGWReadMDLogEntriesCR() override {
if (req) {
req->finish();
}
status(status), shards_info(status.num_shards),
lease_cr(nullptr), lease_stack(nullptr) {}
- ~RGWInitSyncStatusCoroutine() {
+ ~RGWInitSyncStatusCoroutine() override {
if (lease_cr) {
lease_cr->abort();
lease_cr->put();
lost_lock(false), failed(false), markers(_markers) {
}
- ~RGWFetchAllMetaCR() {
+ ~RGWFetchAllMetaCR() override {
if (lease_cr) {
lease_cr->put();
}
raw_key(_raw_key), bl(_bl), req(NULL) {
}
- ~RGWMetaStoreEntryCR() {
+ ~RGWMetaStoreEntryCR() override {
if (req) {
req->finish();
}
raw_key(_raw_key), req(NULL) {
}
- ~RGWMetaRemoveEntryCR() {
+ ~RGWMetaRemoveEntryCR() override {
if (req) {
req->finish();
}
*new_marker = marker;
}
}
- ~RGWCloneMetaLogCoroutine() {
+ ~RGWCloneMetaLogCoroutine() override {
if (http_op) {
http_op->put();
}
*reset_backoff = false;
}
- ~RGWMetaSyncShardCR() {
+ ~RGWMetaSyncShardCR() override {
delete marker_tracker;
if (lease_cr) {
lease_cr->abort();
reset_backoff(false), exit_on_error(_exit_on_error) {
}
- virtual ~RGWBackoffControlCR() {
+ ~RGWBackoffControlCR() override {
if (cr) {
cr->put();
}
virtual RGWCoroutine *alloc_cr() = 0;
virtual RGWCoroutine *alloc_finisher_cr() { return NULL; }
- int operate();
+ int operate() override;
};
struct RGWMetaSyncEnv {
http_manager(store->ctx(), completion_mgr),
status_manager(_sm), error_logger(NULL), meta_sync_cr(NULL) {}
- ~RGWRemoteMetaLog();
+ ~RGWRemoteMetaLog() override;
int init();
void finish();
error_injection = (sync_env->cct->_conf->rgw_sync_meta_inject_err_probability > 0);
}
- int operate();
+ int operate() override;
};
class RGWShardCollectCR : public RGWCoroutine {
status(0) {}
virtual bool spawn_next() = 0;
- int operate();
+ int operate() override;
};
public:
RGWStatRemoteObjCBCR(RGWDataSyncEnv *_sync_env,
RGWBucketInfo& _bucket_info, rgw_obj_key& _key);
- virtual ~RGWStatRemoteObjCBCR() {}
+ ~RGWStatRemoteObjCBCR() override {}
void set_result(ceph::real_time& _mtime,
uint64_t _size,
RGWCallStatRemoteObjCR(RGWDataSyncEnv *_sync_env,
RGWBucketInfo& _bucket_info, rgw_obj_key& _key);
- virtual ~RGWCallStatRemoteObjCR() {}
+ ~RGWCallStatRemoteObjCR() override {}
int operate() override;
conf(_conf) {
}
- ~RGWElasticHandleRemoteObjCR() {}
+ ~RGWElasticHandleRemoteObjCR() override {}
RGWStatRemoteObjCBCR *allocate_callback() override {
return new RGWElasticHandleRemoteObjCBCR(sync_env, bucket_info, key, conf);
conf.id = string("elastic:") + elastic_endpoint;
conf.conn = new RGWRESTConn(cct, nullptr, conf.id, { elastic_endpoint });
}
- ~RGWElasticDataSyncModule() {
+ ~RGWElasticDataSyncModule() override {
delete conf.conn;
}
RGWBucketInfo& _bucket_info, rgw_obj_key& _key) : RGWCallStatRemoteObjCR(_sync_env, _bucket_info, _key) {
}
- ~RGWLogStatRemoteObjCR() {}
+ ~RGWLogStatRemoteObjCR() override {}
RGWStatRemoteObjCBCR *allocate_callback() override {
return new RGWLogStatRemoteObjCBCR(sync_env, bucket_info, key);
}
public:
RGWXMLParser();
- virtual ~RGWXMLParser();
+ ~RGWXMLParser() override;
bool init();
bool xml_start(const char *el, const char **attr);
- bool xml_end(const char *el);
+ bool xml_end(const char *el) override;
void handle_data(const char *s, int len);
bool parse(const char *buf, int len, int done);
class XMLParser : public RGWXMLParser {
public:
XMLParser() {}
- virtual ~XMLParser() {}
+ ~XMLParser() override {}
} parser;
explicit RGWXMLDecoder(bufferlist& bl) {
projects / ceph-ci.git / commitdiff