}
}
-int RGWGetObj_REST::get_params()
+int RGWGetObj_ObjStore::get_params()
{
range_str = s->env->get("HTTP_RANGE");
if_mod = s->env->get("HTTP_IF_MODIFIED_SINCE");
}
-int RGWPutObj_REST::verify_params()
+int RGWPutObj_ObjStore::verify_params()
{
if (s->length) {
off_t len = atoll(s->length);
return 0;
}
-int RGWPutObj_REST::get_params()
+int RGWPutObj_ObjStore::get_params()
{
supplied_md5_b64 = s->env->get("HTTP_CONTENT_MD5");
return 0;
}
-int RGWPutObj_REST::get_data(bufferlist& bl)
+int RGWPutObj_ObjStore::get_data(bufferlist& bl)
{
size_t cl;
if (s->length) {
return len;
}
-int RGWPutACLs_REST::get_params()
+int RGWPutACLs_ObjStore::get_params()
{
size_t cl = 0;
if (s->length)
return ret;
}
-int RGWInitMultipart_REST::get_params()
+int RGWInitMultipart_ObjStore::get_params()
{
if (!s->args.exists("uploads")) {
ret = -ENOTSUP;
return 0;
}
-int RGWCompleteMultipart_REST::get_params()
+int RGWCompleteMultipart_ObjStore::get_params()
{
upload_id = s->args.get("uploadId");
return ret;
}
-int RGWListMultipart_REST::get_params()
+int RGWListMultipart_ObjStore::get_params()
{
upload_id = s->args.get("uploadId");
return ret;
}
-int RGWListBucketMultiparts_REST::get_params()
+int RGWListBucketMultiparts_ObjStore::get_params()
{
delimiter = s->args.get("delimiter");
prefix = s->args.get("prefix");
return 0;
}
-int RGWDeleteMultiObj_REST::get_params()
+int RGWDeleteMultiObj_ObjStore::get_params()
{
bucket_name = s->bucket_name;
// This function enforces Amazon's spec for bucket names.
// (The requirements, not the recommendations.)
-int RGWHandler_REST::validate_bucket_name(const string& bucket)
+int RGWHandler_ObjStore::validate_bucket_name(const string& bucket)
{
int len = bucket.size();
if (len < 3) {
// is at most 1024 bytes long."
// However, we can still have control characters and other nasties in there.
// Just as long as they're utf-8 nasties.
-int RGWHandler_REST::validate_object_name(const string& object)
+int RGWHandler_ObjStore::validate_object_name(const string& object)
{
int len = object.size();
if (len > 1024) {
return OP_UNKNOWN;
}
-int RGWHandler_REST::preprocess(struct req_state *s, RGWClientIO *cio)
+int RGWHandler_ObjStore::preprocess(struct req_state *s, RGWClientIO *cio)
{
s->cio = cio;
s->request_uri = s->env->get("REQUEST_URI");
return 0;
}
-int RGWHandler_REST::read_permissions(RGWOp *op_obj)
+int RGWHandler_ObjStore::read_permissions(RGWOp *op_obj)
{
bool only_bucket;
return do_read_permissions(op_obj, only_bucket);
}
-RGWOp *RGWHandler_REST::get_op()
+RGWOp *RGWHandler_ObjStore::get_op()
{
RGWOp *op;
switch (s->op) {
RGWRESTMgr::RGWRESTMgr()
{
// order is important!
- protocol_handlers.push_back(new RGWHandler_REST_SWIFT);
+ protocol_handlers.push_back(new RGWHandler_ObjStore_SWIFT);
protocol_handlers.push_back(new RGWHandler_SWIFT_Auth);
- protocol_handlers.push_back(new RGWHandler_REST_S3);
+ protocol_handlers.push_back(new RGWHandler_ObjStore_S3);
}
RGWRESTMgr::~RGWRESTMgr()
{
RGWHandler *handler;
- *init_error = RGWHandler_REST::preprocess(s, cio);
+ *init_error = RGWHandler_ObjStore::preprocess(s, cio);
if (*init_error < 0)
return NULL;
return handler;
}
-void RGWHandler_REST::put_op(RGWOp *op)
+void RGWHandler_ObjStore::put_op(RGWOp *op)
{
delete op;
}
class RGWClientIO;
-class RGWGetObj_REST : public RGWGetObj
+class RGWGetObj_ObjStore : public RGWGetObj
{
protected:
bool sent_header;
public:
- RGWGetObj_REST() : sent_header(false) {}
+ RGWGetObj_ObjStore() : sent_header(false) {}
virtual void init(struct req_state *s, RGWHandler *h) {
RGWGetObj::init(s, h);
int get_params();
};
-class RGWListBuckets_REST : public RGWListBuckets {
+class RGWListBuckets_ObjStore : public RGWListBuckets {
public:
- RGWListBuckets_REST() {}
- ~RGWListBuckets_REST() {}
+ RGWListBuckets_ObjStore() {}
+ ~RGWListBuckets_ObjStore() {}
};
-class RGWListBucket_REST : public RGWListBucket {
+class RGWListBucket_ObjStore : public RGWListBucket {
public:
- RGWListBucket_REST() {}
- ~RGWListBucket_REST() {}
+ RGWListBucket_ObjStore() {}
+ ~RGWListBucket_ObjStore() {}
};
-class RGWStatAccount_REST : public RGWStatAccount {
+class RGWStatAccount_ObjStore : public RGWStatAccount {
public:
- RGWStatAccount_REST() {}
- ~RGWStatAccount_REST() {}
+ RGWStatAccount_ObjStore() {}
+ ~RGWStatAccount_ObjStore() {}
};
-class RGWStatBucket_REST : public RGWStatBucket {
+class RGWStatBucket_ObjStore : public RGWStatBucket {
public:
- RGWStatBucket_REST() {}
- ~RGWStatBucket_REST() {}
+ RGWStatBucket_ObjStore() {}
+ ~RGWStatBucket_ObjStore() {}
};
-class RGWCreateBucket_REST : public RGWCreateBucket {
+class RGWCreateBucket_ObjStore : public RGWCreateBucket {
public:
- RGWCreateBucket_REST() {}
- ~RGWCreateBucket_REST() {}
+ RGWCreateBucket_ObjStore() {}
+ ~RGWCreateBucket_ObjStore() {}
};
-class RGWDeleteBucket_REST : public RGWDeleteBucket {
+class RGWDeleteBucket_ObjStore : public RGWDeleteBucket {
public:
- RGWDeleteBucket_REST() {}
- ~RGWDeleteBucket_REST() {}
+ RGWDeleteBucket_ObjStore() {}
+ ~RGWDeleteBucket_ObjStore() {}
};
-class RGWPutObj_REST : public RGWPutObj
+class RGWPutObj_ObjStore : public RGWPutObj
{
public:
- RGWPutObj_REST() {}
- ~RGWPutObj_REST() {}
+ RGWPutObj_ObjStore() {}
+ ~RGWPutObj_ObjStore() {}
virtual int verify_params();
virtual int get_params();
int get_data(bufferlist& bl);
};
-class RGWPutMetadata_REST : public RGWPutMetadata
+class RGWPutMetadata_ObjStore : public RGWPutMetadata
{
public:
- RGWPutMetadata_REST() {}
- ~RGWPutMetadata_REST() {}
+ RGWPutMetadata_ObjStore() {}
+ ~RGWPutMetadata_ObjStore() {}
};
-class RGWDeleteObj_REST : public RGWDeleteObj {
+class RGWDeleteObj_ObjStore : public RGWDeleteObj {
public:
- RGWDeleteObj_REST() {}
- ~RGWDeleteObj_REST() {}
+ RGWDeleteObj_ObjStore() {}
+ ~RGWDeleteObj_ObjStore() {}
};
-class RGWCopyObj_REST : public RGWCopyObj {
+class RGWCopyObj_ObjStore : public RGWCopyObj {
public:
- RGWCopyObj_REST() {}
- ~RGWCopyObj_REST() {}
+ RGWCopyObj_ObjStore() {}
+ ~RGWCopyObj_ObjStore() {}
};
-class RGWGetACLs_REST : public RGWGetACLs {
+class RGWGetACLs_ObjStore : public RGWGetACLs {
public:
- RGWGetACLs_REST() {}
- ~RGWGetACLs_REST() {}
+ RGWGetACLs_ObjStore() {}
+ ~RGWGetACLs_ObjStore() {}
};
-class RGWPutACLs_REST : public RGWPutACLs {
+class RGWPutACLs_ObjStore : public RGWPutACLs {
public:
- RGWPutACLs_REST() {}
- ~RGWPutACLs_REST() {}
+ RGWPutACLs_ObjStore() {}
+ ~RGWPutACLs_ObjStore() {}
int get_params();
};
-class RGWInitMultipart_REST : public RGWInitMultipart {
+class RGWInitMultipart_ObjStore : public RGWInitMultipart {
public:
- RGWInitMultipart_REST() {}
- ~RGWInitMultipart_REST() {}
+ RGWInitMultipart_ObjStore() {}
+ ~RGWInitMultipart_ObjStore() {}
virtual int get_params();
};
-class RGWCompleteMultipart_REST : public RGWCompleteMultipart {
+class RGWCompleteMultipart_ObjStore : public RGWCompleteMultipart {
public:
- RGWCompleteMultipart_REST() {}
- ~RGWCompleteMultipart_REST() {}
+ RGWCompleteMultipart_ObjStore() {}
+ ~RGWCompleteMultipart_ObjStore() {}
int get_params();
};
-class RGWAbortMultipart_REST : public RGWAbortMultipart {
+class RGWAbortMultipart_ObjStore : public RGWAbortMultipart {
public:
- RGWAbortMultipart_REST() {}
- ~RGWAbortMultipart_REST() {}
+ RGWAbortMultipart_ObjStore() {}
+ ~RGWAbortMultipart_ObjStore() {}
};
-class RGWListMultipart_REST : public RGWListMultipart {
+class RGWListMultipart_ObjStore : public RGWListMultipart {
public:
- RGWListMultipart_REST() {}
- ~RGWListMultipart_REST() {}
+ RGWListMultipart_ObjStore() {}
+ ~RGWListMultipart_ObjStore() {}
int get_params();
};
-class RGWListBucketMultiparts_REST : public RGWListBucketMultiparts {
+class RGWListBucketMultiparts_ObjStore : public RGWListBucketMultiparts {
public:
- RGWListBucketMultiparts_REST() {}
- ~RGWListBucketMultiparts_REST() {}
+ RGWListBucketMultiparts_ObjStore() {}
+ ~RGWListBucketMultiparts_ObjStore() {}
int get_params();
};
-class RGWDeleteMultiObj_REST : public RGWDeleteMultiObj {
+class RGWDeleteMultiObj_ObjStore : public RGWDeleteMultiObj {
public:
- RGWDeleteMultiObj_REST() {}
- ~RGWDeleteMultiObj_REST() {}
+ RGWDeleteMultiObj_ObjStore() {}
+ ~RGWDeleteMultiObj_ObjStore() {}
int get_params();
};
-class RGWHandler_REST : public RGWHandler {
+class RGWHandler_ObjStore : public RGWHandler {
protected:
virtual bool is_acl_op() = 0;
virtual bool is_obj_update_op() = 0;
virtual int validate_bucket_name(const string& bucket);
virtual int validate_object_name(const string& object);
public:
- RGWHandler_REST() {}
- virtual ~RGWHandler_REST() {}
+ RGWHandler_ObjStore() {}
+ virtual ~RGWHandler_ObjStore() {}
int read_permissions(RGWOp *op);
RGWOp *get_op();
void put_op(RGWOp *op);
virtual int authorize() = 0;
};
-class RGWHandler_REST_SWIFT;
+class RGWHandler_ObjStore_SWIFT;
class RGWHandler_SWIFT_Auth;
-class RGWHandler_REST_S3;
+class RGWHandler_ObjStore_S3;
class RGWRESTMgr {
vector<RGWHandler *> protocol_handlers;
}
}
-int RGWGetObj_REST_S3::send_response(bufferlist& bl)
+int RGWGetObj_ObjStore_S3::send_response(bufferlist& bl)
{
string content_type_str;
const char *content_type = NULL;
return 0;
}
-void RGWListBuckets_REST_S3::send_response()
+void RGWListBuckets_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
rgw_flush_formatter_and_reset(s, s->formatter);
}
-int RGWListBucket_REST_S3::get_params()
+int RGWListBucket_ObjStore_S3::get_params()
{
prefix = s->args.get("prefix");
marker = s->args.get("marker");
return 0;
}
-void RGWListBucket_REST_S3::send_response()
+void RGWListBucket_ObjStore_S3::send_response()
{
if (ret < 0)
set_req_state_err(s, ret);
s->cio->print("X-RGW-Bytes-Used: %s\n", buf);
}
-void RGWStatBucket_REST_S3::send_response()
+void RGWStatBucket_ObjStore_S3::send_response()
{
if (ret >= 0) {
dump_bucket_metadata(s, bucket);
dump_start(s);
}
-int RGWCreateBucket_REST_S3::get_params()
+int RGWCreateBucket_ObjStore_S3::get_params()
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
int r = s3policy.create_canned(s->user.user_id, s->user.display_name, s->canned_acl);
return 0;
}
-void RGWCreateBucket_REST_S3::send_response()
+void RGWCreateBucket_ObjStore_S3::send_response()
{
if (ret == -ERR_BUCKET_EXISTS)
ret = 0;
end_header(s);
}
-void RGWDeleteBucket_REST_S3::send_response()
+void RGWDeleteBucket_ObjStore_S3::send_response()
{
int r = ret;
if (!r)
end_header(s);
}
-int RGWPutObj_REST_S3::get_params()
+int RGWPutObj_ObjStore_S3::get_params()
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
if (!s->length)
policy = s3policy;
- return RGWPutObj_REST::get_params();
+ return RGWPutObj_ObjStore::get_params();
}
-void RGWPutObj_REST_S3::send_response()
+void RGWPutObj_ObjStore_S3::send_response()
{
if (ret) {
set_req_state_err(s, ret);
end_header(s);
}
-void RGWDeleteObj_REST_S3::send_response()
+void RGWDeleteObj_ObjStore_S3::send_response()
{
int r = ret;
if (r == -ENOENT)
end_header(s);
}
-int RGWCopyObj_REST_S3::init_dest_policy()
+int RGWCopyObj_ObjStore_S3::init_dest_policy()
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
return 0;
}
-int RGWCopyObj_REST_S3::get_params()
+int RGWCopyObj_ObjStore_S3::get_params()
{
if_mod = s->env->get("HTTP_X_AMZ_COPY_IF_MODIFIED_SINCE");
if_unmod = s->env->get("HTTP_X_AMZ_COPY_IF_UNMODIFIED_SINCE");
return 0;
}
-void RGWCopyObj_REST_S3::send_response()
+void RGWCopyObj_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
}
}
-void RGWGetACLs_REST_S3::send_response()
+void RGWGetACLs_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
s->cio->write(acls.c_str(), acls.size());
}
-int RGWPutACLs_REST_S3::get_canned_policy(ACLOwner& owner, stringstream& ss)
+int RGWPutACLs_ObjStore_S3::get_canned_policy(ACLOwner& owner, stringstream& ss)
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
bool r = s3policy.create_canned(owner.get_id(), owner.get_display_name(), s->canned_acl);
return 0;
}
-void RGWPutACLs_REST_S3::send_response()
+void RGWPutACLs_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
dump_start(s);
}
-int RGWInitMultipart_REST_S3::get_params()
+int RGWInitMultipart_ObjStore_S3::get_params()
{
RGWAccessControlPolicy_S3 s3policy(s->cct);
ret = s3policy.create_canned(s->user.user_id, s->user.display_name, s->canned_acl);
policy = s3policy;
- return RGWInitMultipart_REST::get_params();
+ return RGWInitMultipart_ObjStore::get_params();
}
-void RGWInitMultipart_REST_S3::send_response()
+void RGWInitMultipart_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
}
}
-void RGWCompleteMultipart_REST_S3::send_response()
+void RGWCompleteMultipart_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
}
}
-void RGWAbortMultipart_REST_S3::send_response()
+void RGWAbortMultipart_ObjStore_S3::send_response()
{
int r = ret;
if (!r)
end_header(s);
}
-void RGWListMultipart_REST_S3::send_response()
+void RGWListMultipart_ObjStore_S3::send_response()
{
if (ret)
set_req_state_err(s, ret);
}
}
-void RGWListBucketMultiparts_REST_S3::send_response()
+void RGWListBucketMultiparts_ObjStore_S3::send_response()
{
if (ret < 0)
set_req_state_err(s, ret);
rgw_flush_formatter_and_reset(s, s->formatter);
}
-void RGWDeleteMultiObj_REST_S3::send_status()
+void RGWDeleteMultiObj_ObjStore_S3::send_status()
{
if (!status_dumped) {
if (ret < 0)
}
}
-void RGWDeleteMultiObj_REST_S3::begin_response()
+void RGWDeleteMultiObj_ObjStore_S3::begin_response()
{
if (!status_dumped) {
rgw_flush_formatter(s, s->formatter);
}
-void RGWDeleteMultiObj_REST_S3::send_partial_response(pair<string,int>& result)
+void RGWDeleteMultiObj_ObjStore_S3::send_partial_response(pair<string,int>& result)
{
if (!result.first.empty()) {
if (result.second == 0 && !quiet) {
}
}
-void RGWDeleteMultiObj_REST_S3::end_response()
+void RGWDeleteMultiObj_ObjStore_S3::end_response()
{
s->formatter->close_section();
rgw_flush_formatter_and_reset(s, s->formatter);
}
-RGWOp *RGWHandler_REST_S3::get_retrieve_obj_op(bool get_data)
+RGWOp *RGWHandler_ObjStore_S3::get_retrieve_obj_op(bool get_data)
{
if (is_acl_op()) {
- return new RGWGetACLs_REST_S3;
+ return new RGWGetACLs_ObjStore_S3;
}
if (s->object) {
- RGWGetObj_REST_S3 *get_obj_op = new RGWGetObj_REST_S3;
+ RGWGetObj_ObjStore_S3 *get_obj_op = new RGWGetObj_ObjStore_S3;
get_obj_op->set_get_data(get_data);
return get_obj_op;
} else if (!s->bucket_name) {
}
if (s->args.exists("uploads"))
- return new RGWListBucketMultiparts_REST_S3;
+ return new RGWListBucketMultiparts_ObjStore_S3;
if (get_data)
- return new RGWListBucket_REST_S3;
+ return new RGWListBucket_ObjStore_S3;
else
- return new RGWStatBucket_REST_S3;
+ return new RGWStatBucket_ObjStore_S3;
}
-RGWOp *RGWHandler_REST_S3::get_retrieve_op(bool get_data)
+RGWOp *RGWHandler_ObjStore_S3::get_retrieve_op(bool get_data)
{
if (s->bucket_name) {
if (is_acl_op()) {
- return new RGWGetACLs_REST_S3;
+ return new RGWGetACLs_ObjStore_S3;
} else if (s->args.exists("uploadId")) {
- return new RGWListMultipart_REST_S3;
+ return new RGWListMultipart_ObjStore_S3;
}
return get_retrieve_obj_op(get_data);
}
- return new RGWListBuckets_REST_S3;
+ return new RGWListBuckets_ObjStore_S3;
}
-RGWOp *RGWHandler_REST_S3::get_create_op()
+RGWOp *RGWHandler_ObjStore_S3::get_create_op()
{
if (is_acl_op()) {
- return new RGWPutACLs_REST_S3;
+ return new RGWPutACLs_ObjStore_S3;
} else if (s->object) {
if (!s->copy_source)
- return new RGWPutObj_REST_S3;
+ return new RGWPutObj_ObjStore_S3;
else
- return new RGWCopyObj_REST_S3;
+ return new RGWCopyObj_ObjStore_S3;
} else if (s->bucket_name) {
- return new RGWCreateBucket_REST_S3;
+ return new RGWCreateBucket_ObjStore_S3;
}
return NULL;
}
-RGWOp *RGWHandler_REST_S3::get_delete_op()
+RGWOp *RGWHandler_ObjStore_S3::get_delete_op()
{
string upload_id = s->args.get("uploadId");
if (s->object) {
if (upload_id.empty())
- return new RGWDeleteObj_REST_S3;
+ return new RGWDeleteObj_ObjStore_S3;
else
- return new RGWAbortMultipart_REST_S3;
+ return new RGWAbortMultipart_ObjStore_S3;
} else if (s->bucket_name)
- return new RGWDeleteBucket_REST_S3;
+ return new RGWDeleteBucket_ObjStore_S3;
return NULL;
}
-RGWOp *RGWHandler_REST_S3::get_post_op()
+RGWOp *RGWHandler_ObjStore_S3::get_post_op()
{
if (s->object) {
if (s->args.exists("uploadId"))
- return new RGWCompleteMultipart_REST_S3;
+ return new RGWCompleteMultipart_ObjStore_S3;
else
- return new RGWInitMultipart_REST_S3;
+ return new RGWInitMultipart_ObjStore_S3;
}
else if ( s->request_params == "delete" ) {
- return new RGWDeleteMultiObj_REST_S3;
+ return new RGWDeleteMultiObj_ObjStore_S3;
}
return NULL;
}
-int RGWHandler_REST_S3::init_from_header(struct req_state *s)
+int RGWHandler_ObjStore_S3::init_from_header(struct req_state *s)
{
string req;
string first;
return (num_periods == 3);
}
-int RGWHandler_REST_S3::validate_bucket_name(const string& bucket)
+int RGWHandler_ObjStore_S3::validate_bucket_name(const string& bucket)
{
- int ret = RGWHandler_REST::validate_bucket_name(bucket);
+ int ret = RGWHandler_ObjStore::validate_bucket_name(bucket);
if (ret < 0)
return ret;
return 0;
}
-int RGWHandler_REST_S3::init(struct req_state *s, RGWClientIO *cio)
+int RGWHandler_ObjStore_S3::init(struct req_state *s, RGWClientIO *cio)
{
int ret = init_from_header(s);
if (ret < 0)
s->dialect = "s3";
- return RGWHandler_REST::init(s, cio);
+ return RGWHandler_ObjStore::init(s, cio);
}
/*
* verify that a signed request comes from the keyholder
* by checking the signature against our locally-computed version
*/
-int RGWHandler_REST_S3::authorize()
+int RGWHandler_ObjStore_S3::authorize()
{
bool qsr = false;
string auth_id;
void rgw_get_errno_s3(struct rgw_html_errors *e, int err_no);
-class RGWGetObj_REST_S3 : public RGWGetObj_REST
+class RGWGetObj_ObjStore_S3 : public RGWGetObj_ObjStore
{
public:
- RGWGetObj_REST_S3() {}
- ~RGWGetObj_REST_S3() {}
+ RGWGetObj_ObjStore_S3() {}
+ ~RGWGetObj_ObjStore_S3() {}
int send_response(bufferlist& bl);
};
-class RGWListBuckets_REST_S3 : public RGWListBuckets_REST {
+class RGWListBuckets_ObjStore_S3 : public RGWListBuckets_ObjStore {
public:
- RGWListBuckets_REST_S3() {}
- ~RGWListBuckets_REST_S3() {}
+ RGWListBuckets_ObjStore_S3() {}
+ ~RGWListBuckets_ObjStore_S3() {}
int get_params() { return 0; }
void send_response();
};
-class RGWListBucket_REST_S3 : public RGWListBucket_REST {
+class RGWListBucket_ObjStore_S3 : public RGWListBucket_ObjStore {
public:
- RGWListBucket_REST_S3() {
+ RGWListBucket_ObjStore_S3() {
default_max = 1000;
}
- ~RGWListBucket_REST_S3() {}
+ ~RGWListBucket_ObjStore_S3() {}
int get_params();
void send_response();
};
-class RGWStatBucket_REST_S3 : public RGWStatBucket_REST {
+class RGWStatBucket_ObjStore_S3 : public RGWStatBucket_ObjStore {
public:
- RGWStatBucket_REST_S3() {}
- ~RGWStatBucket_REST_S3() {}
+ RGWStatBucket_ObjStore_S3() {}
+ ~RGWStatBucket_ObjStore_S3() {}
void send_response();
};
-class RGWCreateBucket_REST_S3 : public RGWCreateBucket_REST {
+class RGWCreateBucket_ObjStore_S3 : public RGWCreateBucket_ObjStore {
public:
- RGWCreateBucket_REST_S3() {}
- ~RGWCreateBucket_REST_S3() {}
+ RGWCreateBucket_ObjStore_S3() {}
+ ~RGWCreateBucket_ObjStore_S3() {}
int get_params();
void send_response();
};
-class RGWDeleteBucket_REST_S3 : public RGWDeleteBucket_REST {
+class RGWDeleteBucket_ObjStore_S3 : public RGWDeleteBucket_ObjStore {
public:
- RGWDeleteBucket_REST_S3() {}
- ~RGWDeleteBucket_REST_S3() {}
+ RGWDeleteBucket_ObjStore_S3() {}
+ ~RGWDeleteBucket_ObjStore_S3() {}
void send_response();
};
-class RGWPutObj_REST_S3 : public RGWPutObj_REST {
+class RGWPutObj_ObjStore_S3 : public RGWPutObj_ObjStore {
public:
- RGWPutObj_REST_S3() {}
- ~RGWPutObj_REST_S3() {}
+ RGWPutObj_ObjStore_S3() {}
+ ~RGWPutObj_ObjStore_S3() {}
int get_params();
void send_response();
};
-class RGWDeleteObj_REST_S3 : public RGWDeleteObj_REST {
+class RGWDeleteObj_ObjStore_S3 : public RGWDeleteObj_ObjStore {
public:
- RGWDeleteObj_REST_S3() {}
- ~RGWDeleteObj_REST_S3() {}
+ RGWDeleteObj_ObjStore_S3() {}
+ ~RGWDeleteObj_ObjStore_S3() {}
void send_response();
};
-class RGWCopyObj_REST_S3 : public RGWCopyObj_REST {
+class RGWCopyObj_ObjStore_S3 : public RGWCopyObj_ObjStore {
public:
- RGWCopyObj_REST_S3() {}
- ~RGWCopyObj_REST_S3() {}
+ RGWCopyObj_ObjStore_S3() {}
+ ~RGWCopyObj_ObjStore_S3() {}
int init_dest_policy();
int get_params();
void send_response();
};
-class RGWGetACLs_REST_S3 : public RGWGetACLs_REST {
+class RGWGetACLs_ObjStore_S3 : public RGWGetACLs_ObjStore {
public:
- RGWGetACLs_REST_S3() {}
- ~RGWGetACLs_REST_S3() {}
+ RGWGetACLs_ObjStore_S3() {}
+ ~RGWGetACLs_ObjStore_S3() {}
void send_response();
};
-class RGWPutACLs_REST_S3 : public RGWPutACLs_REST {
+class RGWPutACLs_ObjStore_S3 : public RGWPutACLs_ObjStore {
public:
- RGWPutACLs_REST_S3() {}
- ~RGWPutACLs_REST_S3() {}
+ RGWPutACLs_ObjStore_S3() {}
+ ~RGWPutACLs_ObjStore_S3() {}
int get_canned_policy(ACLOwner& owner, stringstream& ss);
void send_response();
};
-class RGWInitMultipart_REST_S3 : public RGWInitMultipart_REST {
+class RGWInitMultipart_ObjStore_S3 : public RGWInitMultipart_ObjStore {
public:
- RGWInitMultipart_REST_S3() {}
- ~RGWInitMultipart_REST_S3() {}
+ RGWInitMultipart_ObjStore_S3() {}
+ ~RGWInitMultipart_ObjStore_S3() {}
int get_params();
void send_response();
};
-class RGWCompleteMultipart_REST_S3 : public RGWCompleteMultipart_REST {
+class RGWCompleteMultipart_ObjStore_S3 : public RGWCompleteMultipart_ObjStore {
public:
- RGWCompleteMultipart_REST_S3() {}
- ~RGWCompleteMultipart_REST_S3() {}
+ RGWCompleteMultipart_ObjStore_S3() {}
+ ~RGWCompleteMultipart_ObjStore_S3() {}
void send_response();
};
-class RGWAbortMultipart_REST_S3 : public RGWAbortMultipart_REST {
+class RGWAbortMultipart_ObjStore_S3 : public RGWAbortMultipart_ObjStore {
public:
- RGWAbortMultipart_REST_S3() {}
- ~RGWAbortMultipart_REST_S3() {}
+ RGWAbortMultipart_ObjStore_S3() {}
+ ~RGWAbortMultipart_ObjStore_S3() {}
void send_response();
};
-class RGWListMultipart_REST_S3 : public RGWListMultipart_REST {
+class RGWListMultipart_ObjStore_S3 : public RGWListMultipart_ObjStore {
public:
- RGWListMultipart_REST_S3() {}
- ~RGWListMultipart_REST_S3() {}
+ RGWListMultipart_ObjStore_S3() {}
+ ~RGWListMultipart_ObjStore_S3() {}
void send_response();
};
-class RGWListBucketMultiparts_REST_S3 : public RGWListBucketMultiparts_REST {
+class RGWListBucketMultiparts_ObjStore_S3 : public RGWListBucketMultiparts_ObjStore {
public:
- RGWListBucketMultiparts_REST_S3() {
+ RGWListBucketMultiparts_ObjStore_S3() {
default_max = 1000;
}
- ~RGWListBucketMultiparts_REST_S3() {}
+ ~RGWListBucketMultiparts_ObjStore_S3() {}
void send_response();
};
-class RGWDeleteMultiObj_REST_S3 : public RGWDeleteMultiObj_REST {
+class RGWDeleteMultiObj_ObjStore_S3 : public RGWDeleteMultiObj_ObjStore {
public:
- RGWDeleteMultiObj_REST_S3() {}
- ~RGWDeleteMultiObj_REST_S3() {}
+ RGWDeleteMultiObj_ObjStore_S3() {}
+ ~RGWDeleteMultiObj_ObjStore_S3() {}
void send_status();
void begin_response();
};
-class RGWHandler_REST_S3 : public RGWHandler_REST {
+class RGWHandler_ObjStore_S3 : public RGWHandler_ObjStore {
protected:
bool is_acl_op() {
return s->args.exists("acl");
int init_from_header(struct req_state *s);
public:
- RGWHandler_REST_S3() : RGWHandler_REST() {}
- virtual ~RGWHandler_REST_S3() {}
+ RGWHandler_ObjStore_S3() : RGWHandler_ObjStore() {}
+ virtual ~RGWHandler_ObjStore_S3() {}
bool filter_request(struct req_state *state) { return true; }
int validate_bucket_name(const string& bucket);
#define dout_subsys ceph_subsys_rgw
-int RGWListBuckets_REST_SWIFT::get_params()
+int RGWListBuckets_ObjStore_SWIFT::get_params()
{
marker = s->args.get("marker");
string limit_str;
return 0;
}
-void RGWListBuckets_REST_SWIFT::send_response()
+void RGWListBuckets_ObjStore_SWIFT::send_response()
{
map<string, RGWBucketEnt>& m = buckets.get_buckets();
map<string, RGWBucketEnt>::iterator iter;
rgw_flush_formatter_and_reset(s, s->formatter);
}
-int RGWListBucket_REST_SWIFT::get_params()
+int RGWListBucket_ObjStore_SWIFT::get_params()
{
prefix = s->args.get("prefix");
marker = s->args.get("marker");
return 0;
}
-void RGWListBucket_REST_SWIFT::send_response()
+void RGWListBucket_ObjStore_SWIFT::send_response()
{
vector<RGWObjEnt>::iterator iter = objs.begin();
map<string, bool>::iterator pref_iter = common_prefixes.begin();
s->cio->print("X-Account-Bytes-Used-Actual: %s\n", buf);
}
-void RGWStatAccount_REST_SWIFT::send_response()
+void RGWStatAccount_ObjStore_SWIFT::send_response()
{
if (ret >= 0) {
ret = STATUS_NO_CONTENT;
dump_start(s);
}
-void RGWStatBucket_REST_SWIFT::send_response()
+void RGWStatBucket_ObjStore_SWIFT::send_response()
{
if (ret >= 0) {
ret = STATUS_NO_CONTENT;
dump_start(s);
}
-int RGWCreateBucket_REST_SWIFT::get_params()
+int RGWCreateBucket_ObjStore_SWIFT::get_params()
{
policy.create_default(s->user.user_id, s->user.display_name);
return 0;
}
-void RGWCreateBucket_REST_SWIFT::send_response()
+void RGWCreateBucket_ObjStore_SWIFT::send_response()
{
if (!ret)
ret = STATUS_CREATED;
rgw_flush_formatter_and_reset(s, s->formatter);
}
-void RGWDeleteBucket_REST_SWIFT::send_response()
+void RGWDeleteBucket_ObjStore_SWIFT::send_response()
{
int r = ret;
if (!r)
rgw_flush_formatter_and_reset(s, s->formatter);
}
-int RGWPutObj_REST_SWIFT::get_params()
+int RGWPutObj_ObjStore_SWIFT::get_params()
{
if (s->has_bad_meta)
return -EINVAL;
obj_manifest = s->env->get("HTTP_X_OBJECT_MANIFEST");
- return RGWPutObj_REST::get_params();
+ return RGWPutObj_ObjStore::get_params();
}
-void RGWPutObj_REST_SWIFT::send_response()
+void RGWPutObj_ObjStore_SWIFT::send_response()
{
if (!ret)
ret = STATUS_CREATED;
rgw_flush_formatter_and_reset(s, s->formatter);
}
-int RGWPutMetadata_REST_SWIFT::get_params()
+int RGWPutMetadata_ObjStore_SWIFT::get_params()
{
if (s->has_bad_meta)
return -EINVAL;
return 0;
}
-void RGWPutMetadata_REST_SWIFT::send_response()
+void RGWPutMetadata_ObjStore_SWIFT::send_response()
{
if (!ret)
ret = STATUS_ACCEPTED;
rgw_flush_formatter_and_reset(s, s->formatter);
}
-void RGWDeleteObj_REST_SWIFT::send_response()
+void RGWDeleteObj_ObjStore_SWIFT::send_response()
{
int r = ret;
if (!r)
rgw_flush_formatter_and_reset(s, s->formatter);
}
-int RGWCopyObj_REST_SWIFT::init_dest_policy()
+int RGWCopyObj_ObjStore_SWIFT::init_dest_policy()
{
dest_policy.create_default(s->user.user_id, s->user.display_name);
return 0;
}
-int RGWCopyObj_REST_SWIFT::get_params()
+int RGWCopyObj_ObjStore_SWIFT::get_params()
{
if_mod = s->env->get("HTTP_IF_MODIFIED_SINCE");
if_unmod = s->env->get("HTTP_IF_UNMODIFIED_SINCE");
return 0;
}
-void RGWCopyObj_REST_SWIFT::send_response()
+void RGWCopyObj_ObjStore_SWIFT::send_response()
{
if (!ret)
ret = STATUS_CREATED;
end_header(s);
}
-int RGWGetObj_REST_SWIFT::send_response(bufferlist& bl)
+int RGWGetObj_ObjStore_SWIFT::send_response(bufferlist& bl)
{
const char *content_type = NULL;
int orig_ret = ret;
return 0;
}
-RGWOp *RGWHandler_REST_SWIFT::get_retrieve_obj_op(bool get_data)
+RGWOp *RGWHandler_ObjStore_SWIFT::get_retrieve_obj_op(bool get_data)
{
if (is_acl_op()) {
- return new RGWGetACLs_REST_SWIFT;
+ return new RGWGetACLs_ObjStore_SWIFT;
}
if (s->object) {
- RGWGetObj_REST_SWIFT *get_obj_op = new RGWGetObj_REST_SWIFT;
+ RGWGetObj_ObjStore_SWIFT *get_obj_op = new RGWGetObj_ObjStore_SWIFT;
get_obj_op->set_get_data(get_data);
return get_obj_op;
} else if (!s->bucket_name) {
}
if (get_data)
- return new RGWListBucket_REST_SWIFT;
+ return new RGWListBucket_ObjStore_SWIFT;
else
- return new RGWStatBucket_REST_SWIFT;
+ return new RGWStatBucket_ObjStore_SWIFT;
}
-RGWOp *RGWHandler_REST_SWIFT::get_retrieve_op(bool get_data)
+RGWOp *RGWHandler_ObjStore_SWIFT::get_retrieve_op(bool get_data)
{
if (s->bucket_name) {
if (is_acl_op()) {
- return new RGWGetACLs_REST_SWIFT;
+ return new RGWGetACLs_ObjStore_SWIFT;
}
return get_retrieve_obj_op(get_data);
}
if (get_data)
- return new RGWListBuckets_REST_SWIFT;
+ return new RGWListBuckets_ObjStore_SWIFT;
else
- return new RGWStatAccount_REST_SWIFT;
+ return new RGWStatAccount_ObjStore_SWIFT;
}
-RGWOp *RGWHandler_REST_SWIFT::get_create_op()
+RGWOp *RGWHandler_ObjStore_SWIFT::get_create_op()
{
if (is_acl_op()) {
- return new RGWPutACLs_REST_SWIFT;
+ return new RGWPutACLs_ObjStore_SWIFT;
} else if (s->object) {
if (!s->copy_source)
- return new RGWPutObj_REST_SWIFT;
+ return new RGWPutObj_ObjStore_SWIFT;
else
- return new RGWCopyObj_REST_SWIFT;
+ return new RGWCopyObj_ObjStore_SWIFT;
} else if (s->bucket_name) {
- return new RGWCreateBucket_REST_SWIFT;
+ return new RGWCreateBucket_ObjStore_SWIFT;
}
return NULL;
}
-RGWOp *RGWHandler_REST_SWIFT::get_delete_op()
+RGWOp *RGWHandler_ObjStore_SWIFT::get_delete_op()
{
if (s->object)
- return new RGWDeleteObj_REST_SWIFT;
+ return new RGWDeleteObj_ObjStore_SWIFT;
else if (s->bucket_name)
- return new RGWDeleteBucket_REST_SWIFT;
+ return new RGWDeleteBucket_ObjStore_SWIFT;
return NULL;
}
-RGWOp *RGWHandler_REST_SWIFT::get_post_op()
+RGWOp *RGWHandler_ObjStore_SWIFT::get_post_op()
{
- return new RGWPutMetadata_REST_SWIFT;
+ return new RGWPutMetadata_ObjStore_SWIFT;
}
-RGWOp *RGWHandler_REST_SWIFT::get_copy_op()
+RGWOp *RGWHandler_ObjStore_SWIFT::get_copy_op()
{
if (s->object)
- return new RGWCopyObj_REST_SWIFT;
+ return new RGWCopyObj_ObjStore_SWIFT;
return NULL;
}
-int RGWHandler_REST_SWIFT::authorize()
+int RGWHandler_ObjStore_SWIFT::authorize()
{
bool authorized = rgw_verify_os_token(s);
if (!authorized)
return 0;
}
-bool RGWHandler_REST_SWIFT::filter_request(struct req_state *s)
+bool RGWHandler_ObjStore_SWIFT::filter_request(struct req_state *s)
{
string& uri = s->decoded_uri;
size_t len = g_conf->rgw_swift_url_prefix.size();
return true;
}
-int RGWHandler_REST_SWIFT::validate_bucket_name(const string& bucket)
+int RGWHandler_ObjStore_SWIFT::validate_bucket_name(const string& bucket)
{
- int ret = RGWHandler_REST::validate_bucket_name(bucket);
+ int ret = RGWHandler_ObjStore::validate_bucket_name(bucket);
if (ret < 0)
return ret;
}
}
-int RGWHandler_REST_SWIFT::init_from_header(struct req_state *s)
+int RGWHandler_ObjStore_SWIFT::init_from_header(struct req_state *s)
{
string req;
string first;
return 0;
}
-int RGWHandler_REST_SWIFT::init(struct req_state *s, RGWClientIO *cio)
+int RGWHandler_ObjStore_SWIFT::init(struct req_state *s, RGWClientIO *cio)
{
int ret = init_from_header(s);
if (ret < 0)
s->dialect = "swift";
- return RGWHandler_REST::init(s, cio);
+ return RGWHandler_ObjStore::init(s, cio);
}
#include "rgw_op.h"
#include "rgw_rest.h"
-class RGWGetObj_REST_SWIFT : public RGWGetObj_REST {
+class RGWGetObj_ObjStore_SWIFT : public RGWGetObj_ObjStore {
public:
- RGWGetObj_REST_SWIFT() {}
- ~RGWGetObj_REST_SWIFT() {}
+ RGWGetObj_ObjStore_SWIFT() {}
+ ~RGWGetObj_ObjStore_SWIFT() {}
int send_response(bufferlist& bl);
};
-class RGWListBuckets_REST_SWIFT : public RGWListBuckets_REST {
+class RGWListBuckets_ObjStore_SWIFT : public RGWListBuckets_ObjStore {
int limit_max;
int limit;
string marker;
public:
- RGWListBuckets_REST_SWIFT() {
+ RGWListBuckets_ObjStore_SWIFT() {
limit_max = 10000;
limit = limit_max;
}
- ~RGWListBuckets_REST_SWIFT() {}
+ ~RGWListBuckets_ObjStore_SWIFT() {}
int get_params();
void send_response();
};
-class RGWListBucket_REST_SWIFT : public RGWListBucket_REST {
+class RGWListBucket_ObjStore_SWIFT : public RGWListBucket_ObjStore {
string path;
public:
- RGWListBucket_REST_SWIFT() {
+ RGWListBucket_ObjStore_SWIFT() {
default_max = 10000;
}
- ~RGWListBucket_REST_SWIFT() {}
+ ~RGWListBucket_ObjStore_SWIFT() {}
int get_params();
void send_response();
};
-class RGWStatAccount_REST_SWIFT : public RGWStatAccount_REST {
+class RGWStatAccount_ObjStore_SWIFT : public RGWStatAccount_ObjStore {
public:
- RGWStatAccount_REST_SWIFT() {
+ RGWStatAccount_ObjStore_SWIFT() {
}
- ~RGWStatAccount_REST_SWIFT() {}
+ ~RGWStatAccount_ObjStore_SWIFT() {}
void send_response();
};
-class RGWStatBucket_REST_SWIFT : public RGWStatBucket_REST {
+class RGWStatBucket_ObjStore_SWIFT : public RGWStatBucket_ObjStore {
public:
- RGWStatBucket_REST_SWIFT() {}
- ~RGWStatBucket_REST_SWIFT() {}
+ RGWStatBucket_ObjStore_SWIFT() {}
+ ~RGWStatBucket_ObjStore_SWIFT() {}
void send_response();
};
-class RGWCreateBucket_REST_SWIFT : public RGWCreateBucket_REST {
+class RGWCreateBucket_ObjStore_SWIFT : public RGWCreateBucket_ObjStore {
public:
- RGWCreateBucket_REST_SWIFT() {}
- ~RGWCreateBucket_REST_SWIFT() {}
+ RGWCreateBucket_ObjStore_SWIFT() {}
+ ~RGWCreateBucket_ObjStore_SWIFT() {}
int get_params();
void send_response();
};
-class RGWDeleteBucket_REST_SWIFT : public RGWDeleteBucket_REST {
+class RGWDeleteBucket_ObjStore_SWIFT : public RGWDeleteBucket_ObjStore {
public:
- RGWDeleteBucket_REST_SWIFT() {}
- ~RGWDeleteBucket_REST_SWIFT() {}
+ RGWDeleteBucket_ObjStore_SWIFT() {}
+ ~RGWDeleteBucket_ObjStore_SWIFT() {}
void send_response();
};
-class RGWPutObj_REST_SWIFT : public RGWPutObj_REST {
+class RGWPutObj_ObjStore_SWIFT : public RGWPutObj_ObjStore {
public:
- RGWPutObj_REST_SWIFT() {}
- ~RGWPutObj_REST_SWIFT() {}
+ RGWPutObj_ObjStore_SWIFT() {}
+ ~RGWPutObj_ObjStore_SWIFT() {}
int get_params();
void send_response();
};
-class RGWPutMetadata_REST_SWIFT : public RGWPutMetadata_REST {
+class RGWPutMetadata_ObjStore_SWIFT : public RGWPutMetadata_ObjStore {
public:
- RGWPutMetadata_REST_SWIFT() {}
- ~RGWPutMetadata_REST_SWIFT() {}
+ RGWPutMetadata_ObjStore_SWIFT() {}
+ ~RGWPutMetadata_ObjStore_SWIFT() {}
int get_params();
void send_response();
};
-class RGWDeleteObj_REST_SWIFT : public RGWDeleteObj_REST {
+class RGWDeleteObj_ObjStore_SWIFT : public RGWDeleteObj_ObjStore {
public:
- RGWDeleteObj_REST_SWIFT() {}
- ~RGWDeleteObj_REST_SWIFT() {}
+ RGWDeleteObj_ObjStore_SWIFT() {}
+ ~RGWDeleteObj_ObjStore_SWIFT() {}
void send_response();
};
-class RGWCopyObj_REST_SWIFT : public RGWCopyObj_REST {
+class RGWCopyObj_ObjStore_SWIFT : public RGWCopyObj_ObjStore {
public:
- RGWCopyObj_REST_SWIFT() {}
- ~RGWCopyObj_REST_SWIFT() {}
+ RGWCopyObj_ObjStore_SWIFT() {}
+ ~RGWCopyObj_ObjStore_SWIFT() {}
int init_dest_policy();
int get_params();
void send_response();
};
-class RGWGetACLs_REST_SWIFT : public RGWGetACLs_REST {
+class RGWGetACLs_ObjStore_SWIFT : public RGWGetACLs_ObjStore {
public:
- RGWGetACLs_REST_SWIFT() {}
- ~RGWGetACLs_REST_SWIFT() {}
+ RGWGetACLs_ObjStore_SWIFT() {}
+ ~RGWGetACLs_ObjStore_SWIFT() {}
void send_response() {}
};
-class RGWPutACLs_REST_SWIFT : public RGWPutACLs_REST {
+class RGWPutACLs_ObjStore_SWIFT : public RGWPutACLs_ObjStore {
public:
- RGWPutACLs_REST_SWIFT() : RGWPutACLs_REST() {}
- virtual ~RGWPutACLs_REST_SWIFT() {}
+ RGWPutACLs_ObjStore_SWIFT() : RGWPutACLs_ObjStore() {}
+ virtual ~RGWPutACLs_ObjStore_SWIFT() {}
void send_response() {}
};
-class RGWHandler_REST_SWIFT : public RGWHandler_REST {
+class RGWHandler_ObjStore_SWIFT : public RGWHandler_ObjStore {
protected:
bool is_acl_op() {
return false; // for now
int init_from_header(struct req_state *s);
public:
- RGWHandler_REST_SWIFT() : RGWHandler_REST() {}
- virtual ~RGWHandler_REST_SWIFT() {}
+ RGWHandler_ObjStore_SWIFT() : RGWHandler_ObjStore() {}
+ virtual ~RGWHandler_ObjStore_SWIFT() {}
bool filter_request(struct req_state *s);
int validate_bucket_name(const string& bucket);
projects / ceph.git / commitdiff