ceph/src/rgw/rgw_lib.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab ft=cpp
   3
   4 #ifndef RGW_LIB_H
   5 #define RGW_LIB_H
   6
   7 #include <mutex>
   8 #include "include/unordered_map.h"
   9 #include "global/global_init.h"
  10 #include "rgw_common.h"
  11 #include "rgw_client_io.h"
  12 #include "rgw_rest.h"
  13 #include "rgw_request.h"
  14 #include "rgw_frontend.h"
  15 #include "rgw_process.h"
  16 #include "rgw_rest_s3.h" // RGW_Auth_S3
  17 #include "rgw_ldap.h"
  18 #include "services/svc_zone_utils.h"
  19 #include "include/ceph_assert.h"
  20
  21 class OpsLogSocket;
  22
  23 namespace rgw {
  24
  25   class RGWLibFrontend;
  26
  27   class RGWLib {
  28     RGWFrontendConfig* fec;
  29     RGWLibFrontend* fe;
  30     OpsLogSocket* olog;
  31     rgw::LDAPHelper* ldh{nullptr};
  32     RGWREST rest; // XXX needed for RGWProcessEnv
  33     rgw::sal::RGWRadosStore* store;
  34     boost::intrusive_ptr<CephContext> cct;
  35
  36   public:
  37     RGWLib() : fec(nullptr), fe(nullptr), olog(nullptr), store(nullptr)
  38       {}
  39     ~RGWLib() {}
  40
  41     rgw::sal::RGWRadosStore* get_store() { return store; }
  42
  43     RGWLibFrontend* get_fe() { return fe; }
  44
  45     rgw::LDAPHelper* get_ldh() { return ldh; }
  46
  47     int init();
  48     int init(vector<const char *>& args);
  49     int stop();
  50   };
  51
  52   extern RGWLib rgwlib;
  53
  54 /* request interface */
  55
  56   class RGWLibIO : public rgw::io::BasicClient,
  57                    public rgw::io::Accounter
  58   {
  59     RGWUserInfo user_info;
  60     RGWEnv env;
  61   public:
  62     RGWLibIO() {
  63       get_env().set("HTTP_HOST", "");
  64     }
  65     explicit RGWLibIO(const RGWUserInfo &_user_info)
  66       : user_info(_user_info) {}
  67
  68     int init_env(CephContext *cct) override {
  69       env.init(cct);
  70       return 0;
  71     }
  72
  73     const RGWUserInfo& get_user() {
  74       return user_info;
  75     }
  76
  77     int set_uid(rgw::sal::RGWRadosStore* store, const rgw_user& uid);
  78
  79     int write_data(const char *buf, int len);
  80     int read_data(char *buf, int len);
  81     int send_status(int status, const char *status_name);
  82     int send_100_continue();
  83     int complete_header();
  84     int send_content_length(uint64_t len);
  85
  86     RGWEnv& get_env() noexcept override {
  87       return env;
  88     }
  89
  90     size_t complete_request() override { /* XXX */
  91       return 0;
  92     };
  93
  94     void set_account(bool) override {
  95       return;
  96     }
  97
  98     uint64_t get_bytes_sent() const override {
  99       return 0;
 100     }
 101
 102     uint64_t get_bytes_received() const override {
 103       return 0;
 104     }
 105
 106   }; /* RGWLibIO */
 107
 108 /* XXX */
 109   class RGWRESTMgr_Lib : public RGWRESTMgr {
 110   public:
 111     RGWRESTMgr_Lib() {}
 112     ~RGWRESTMgr_Lib() override {}
 113   }; /* RGWRESTMgr_Lib */
 114
 115 /* XXX */
 116   class RGWHandler_Lib : public RGWHandler {
 117     friend class RGWRESTMgr_Lib;
 118   public:
 119
 120     int authorize(const DoutPrefixProvider *dpp, optional_yield y) override;
 121
 122     RGWHandler_Lib() {}
 123     ~RGWHandler_Lib() override {}
 124     static int init_from_header(rgw::sal::RGWRadosStore *store,
 125                                 struct req_state *s);
 126   }; /* RGWHandler_Lib */
 127
 128   class RGWLibRequest : public RGWRequest,
 129                         public RGWHandler_Lib {
 130   private:
 131     std::unique_ptr<rgw::sal::RGWUser> tuser; // Don't use this.  It's empty except during init.
 132   public:
 133     CephContext* cct;
 134     boost::optional<RGWSysObjectCtx> sysobj_ctx;
 135
 136     /* unambiguiously return req_state */
 137     inline struct req_state* get_state() { return this->RGWRequest::s; }
 138
 139     RGWLibRequest(CephContext* _cct, std::unique_ptr<rgw::sal::RGWUser> _user)
 140       :  RGWRequest(rgwlib.get_store()->getRados()->get_new_req_id()),
 141          tuser(std::move(_user)), cct(_cct)
 142       {}
 143
 144   int postauth_init(optional_yield) override { return 0; }
 145
 146     /* descendant equivalent of *REST*::init_from_header(...):
 147      * prepare request for execute()--should mean, fixup URI-alikes
 148      * and any other expected stat vars in local req_state, for
 149      * now */
 150     virtual int header_init() = 0;
 151
 152     /* descendant initializer responsible to call RGWOp::init()--which
 153      * descendants are required to inherit */
 154     virtual int op_init() = 0;
 155
 156     using RGWHandler::init;
 157
 158     int init(const RGWEnv& rgw_env, RGWObjectCtx* rados_ctx,
 159              RGWLibIO* io, struct req_state* _s) {
 160
 161       RGWRequest::init_state(_s);
 162       RGWHandler::init(rados_ctx->get_store(), _s, io);
 163
 164       sysobj_ctx.emplace(store->svc()->sysobj);
 165
 166       get_state()->obj_ctx = rados_ctx;
 167       get_state()->sysobj_ctx = &(sysobj_ctx.get());
 168       get_state()->req_id = store->svc()->zone_utils->unique_id(id);
 169       get_state()->trans_id = store->svc()->zone_utils->unique_trans_id(id);
 170       get_state()->bucket_tenant = tuser->get_tenant();
 171       get_state()->set_user(tuser);
 172
 173       ldpp_dout(_s, 2) << "initializing for trans_id = "
 174           << get_state()->trans_id.c_str() << dendl;
 175
 176       int ret = header_init();
 177       if (ret == 0) {
 178         ret = init_from_header(rados_ctx->get_store(), _s);
 179       }
 180       return ret;
 181     }
 182
 183     virtual bool only_bucket() = 0;
 184
 185     int read_permissions(RGWOp *op, optional_yield y) override;
 186
 187   }; /* RGWLibRequest */
 188
 189   class RGWLibContinuedReq : public RGWLibRequest {
 190     RGWLibIO io_ctx;
 191     struct req_state rstate;
 192     RGWObjectCtx rados_ctx;
 193   public:
 194
 195     RGWLibContinuedReq(CephContext* _cct,
 196                        std::unique_ptr<rgw::sal::RGWUser> _user)
 197       :  RGWLibRequest(_cct, std::move(_user)), io_ctx(),
 198          rstate(_cct, &io_ctx.get_env(), id),
 199          rados_ctx(rgwlib.get_store(), &rstate)
 200       {
 201         io_ctx.init(_cct);
 202
 203         RGWRequest::init_state(&rstate);
 204         RGWHandler::init(rados_ctx.get_store(), &rstate, &io_ctx);
 205
 206         sysobj_ctx.emplace(store->svc()->sysobj);
 207
 208         get_state()->cio = &io_ctx;
 209         get_state()->obj_ctx = &rados_ctx;
 210         get_state()->sysobj_ctx = &(sysobj_ctx.get());
 211         get_state()->req_id = store->svc()->zone_utils->unique_id(id);
 212         get_state()->trans_id = store->svc()->zone_utils->unique_trans_id(id);
 213
 214         ldpp_dout(get_state(), 2) << "initializing for trans_id = "
 215             << get_state()->trans_id.c_str() << dendl;
 216       }
 217
 218     inline rgw::sal::RGWRadosStore* get_store() { return store; }
 219     inline RGWLibIO& get_io() { return io_ctx; }
 220     inline RGWObjectCtx& get_octx() { return rados_ctx; }
 221
 222     virtual int execute() final { ceph_abort(); }
 223     virtual int exec_start() = 0;
 224     virtual int exec_continue() = 0;
 225     virtual int exec_finish() = 0;
 226
 227   }; /* RGWLibContinuedReq */
 228
 229 } /* namespace rgw */
 230
 231 #endif /* RGW_LIB_H */