rgw: consolidate some higher level apis into ctl structure

Similar to svc, just for higher level apis.

Signed-off-by: Yehuda Sadeh <yehuda@redhat.com>

diff --git a/src/rgw/rgw_otp.cc b/src/rgw/rgw_otp.cc
index 8a951d75ed71efd7d4a32055f35c19a35945fc5b..0d2ede4fbb786d1000dce3d3df144ad7c9962704 100644 (file)
--- a/src/rgw/rgw_otp.cc
+++ b/src/rgw/rgw_otp.cc
@@ -201,9 +201,8 @@ RGWMetadataHandler *rgw_otp_get_handler()
   return otp_meta_handler;
 }
 
-void rgw_otp_init(RGWRados *store)
+RGWMetadataHandler *RGWOTPMetaHandlerAllocator::alloc(RGWSI_Zone *zone_svc,
+                                                      RGWSI_MetaBackend *meta_be_svc)
 {
-  otp_meta_handler = new RGWOTPMetadataHandler(store->svc.zone,
-                                               store->svc.meta_be);
-  otp_meta_handler->init(store->svc.meta->get_mgr());
+  return new RGWOTPMetadataHandler(zone_svc, meta_be_svc);
 }

diff --git a/src/rgw/rgw_otp.h b/src/rgw/rgw_otp.h
index 544913430d5e95d62ed8edb613e521f05ee69783..b90d0205c4ac1bfbd1d21954736a9353f145d58c 100644 (file)
--- a/src/rgw/rgw_otp.h
+++ b/src/rgw/rgw_otp.h
@@ -9,7 +9,12 @@ class RGWRados;
 class RGWMetadataHandler;
 
 RGWMetadataHandler *rgw_otp_get_handler(void);
-void rgw_otp_init(RGWRados *store);
+
+class RGWOTPMetaHandlerAllocator {
+public:
+  static RGWMetadataHandler *alloc(RGWSI_Zone *zone_svc, RGWSI_MetaBackend *meta_be_svc);
+};
+
 
 #endif
 

diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc
index bb25c32f1108afa8a24b41d064e45544c8110daf..02e2344e7d354f796acc1ee869269b9efdf2ed2d 100644 (file)
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -1208,13 +1208,13 @@ int RGWRados::init_complete()
 
   if (run_sync_thread) {
     // initialize the log period history
-    meta_mgr->init_oldest_log_period();
+    ctl.meta.mgr->init_oldest_log_period();
   }
 
   async_rados = new RGWAsyncRadosProcessor(this, cct->_conf->rgw_num_async_rados_threads);
   async_rados->start();
 
-  ret = meta_mgr->init(current_period.get_id());
+  ret = ctl.meta.mgr->init(current_period.get_id());
   if (ret < 0) {
     lderr(cct) << "ERROR: failed to initialize metadata log: "
         << cpp_strerror(-ret) << dendl;
@@ -1222,7 +1222,7 @@ int RGWRados::init_complete()
   }
 
   if (svc.zone->is_meta_master()) {
-    auto md_log = meta_mgr->get_log(current_period.get_id());
+    auto md_log = ctl.meta.mgr->get_log(current_period.get_id());
     meta_notifier = new RGWMetaNotifier(this, md_log);
     meta_notifier->start();
   }
@@ -1341,6 +1341,11 @@ int RGWRados::init_svc(bool raw)
   return svc.init(cct, use_cache);
 }
 
+int RGWRados::init_ctl()
+{
+  return ctl.init(svc);
+}
+
 /** 
  * Initialize the RADOS instance and prepare to do other ops
  * Returns 0 on success, -ERR# on failure.
@@ -1359,6 +1364,12 @@ int RGWRados::initialize()
     return ret;
   }
 
+  ret = init_ctl();
+  if (ret < 0) {
+    ldout(cct, 0) << "ERROR: failed to init ctls (ret=" << cpp_strerror(-ret) << ")" << dendl;
+    return ret;
+  }
+
   host_id = svc.zone_utils->gen_host_id();
 
   ret = init_rados();

diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h
index 265a9d1802d0d297653ecaca0033ee6bc63853b2..b5c975ffea7ce5e1162449f172b0c0b110cdff82 100644 (file)
--- a/src/rgw/rgw_rados.h
+++ b/src/rgw/rgw_rados.h
@@ -591,6 +591,7 @@ public:
   }
 
   RGWServices svc;
+  RGWCtl ctl;
 
   /**
    * AmazonS3 errors contain a HostId string, but is an opaque base64 blob; we
@@ -646,6 +647,7 @@ public:
   }
   /** Initialize the RADOS instance and prepare to do other ops */
   int init_svc(bool raw);
+  int init_ctl();
   int init_rados();
   int init_complete();
   int initialize();

diff --git a/src/rgw/rgw_service.cc b/src/rgw/rgw_service.cc
index fcb9cc8ecc8e40cbef0d8a49e3df33b9b1f07eb7..74c4343982f3cc9a68560d5cde7563bbadd2c00c 100644 (file)
--- a/src/rgw/rgw_service.cc
+++ b/src/rgw/rgw_service.cc
@@ -10,6 +10,7 @@
 #include "services/svc_meta.h"
 #include "services/svc_meta_be.h"
 #include "services/svc_meta_be_sobj.h"
+#include "services/svc_meta_be_otp.h"
 #include "services/svc_notify.h"
 #include "services/svc_rados.h"
 #include "services/svc_zone.h"
@@ -23,6 +24,11 @@
 
 #include "common/errno.h"
 
+#include "rgw_metadata.h"
+#include "rgw_user.h"
+#include "rgw_bucket.h"
+#include "rgw_otp.h"
+
 #define dout_subsys ceph_subsys_rgw
 
 
@@ -42,6 +48,7 @@ int RGWServices_Def::init(CephContext *cct,
   mdlog = std::make_unique<RGWSI_MDLog>(cct);
   meta = std::make_unique<RGWSI_Meta>(cct);
   meta_be_sobj = std::make_unique<RGWSI_MetaBackend_SObj>(cct);
+  meta_be_otp = std::make_unique<RGWSI_MetaBackend_OTP>(cct);
   notify = std::make_unique<RGWSI_Notify>(cct);
   rados = std::make_unique<RGWSI_RADOS>(cct);
   zone = std::make_unique<RGWSI_Zone>(cct);
@@ -56,7 +63,7 @@ int RGWServices_Def::init(CephContext *cct,
     sysobj_cache = std::make_unique<RGWSI_SysObj_Cache>(cct);
   }
 
-  vector<RGWSI_MetaBackend *> meta_bes{meta_be_sobj.get()};
+  vector<RGWSI_MetaBackend *> meta_bes{meta_be_sobj.get(), meta_be_otp.get()};
 
   finisher->init();
   bucket->init(zone.get(), sysobj.get(), sysobj_cache.get(), meta.get(), sync_modules.get());
@@ -64,6 +71,7 @@ int RGWServices_Def::init(CephContext *cct,
   mdlog->init(zone.get(), sysobj.get());
   meta->init(sysobj.get(), mdlog.get(), meta_bes);
   meta_be_sobj->init(sysobj.get(), mdlog.get());
+  meta_be_otp->init(sysobj.get(), mdlog.get(), cls.get());
   notify->init(zone.get(), rados.get(), finisher.get());
   rados->init();
   zone->init(sysobj.get(), rados.get(), sync_modules.get());
@@ -215,8 +223,10 @@ void RGWServices_Def::shutdown()
 }
 
 
-int RGWServices::do_init(CephContext *cct, bool have_cache, bool raw)
+int RGWServices::do_init(CephContext *_cct, bool have_cache, bool raw)
 {
+  cct = _cct;
+
   int r = _svc.init(cct, have_cache, raw);
   if (r < 0) {
     return r;
@@ -227,7 +237,8 @@ int RGWServices::do_init(CephContext *cct, bool have_cache, bool raw)
   cls = _svc.cls.get();
   mdlog = _svc.mdlog.get();
   meta = _svc.meta.get();
-  meta_be = _svc.meta_be_sobj.get();
+  meta_be_sobj = _svc.meta_be_sobj.get();
+  meta_be_otp = _svc.meta_be_otp.get();
   notify = _svc.notify.get();
   rados = _svc.rados.get();
   zone = _svc.zone.get();
@@ -237,6 +248,7 @@ int RGWServices::do_init(CephContext *cct, bool have_cache, bool raw)
   sysobj = _svc.sysobj.get();
   cache = _svc.sysobj_cache.get();
   core = _svc.sysobj_core.get();
+  user = _svc.user.get();
 
   return 0;
 }
@@ -259,3 +271,74 @@ int RGWServiceInstance::start()
 
   return 0;
 }
+
+RGWCtlDef::RGWCtlDef() {}
+RGWCtlDef::~RGWCtlDef() {}
+RGWCtlDef::_meta::_meta() {}
+RGWCtlDef::_meta::~_meta() {}
+
+
+int RGWCtlDef::init(RGWServices& svc)
+{
+  meta.mgr.reset(new RGWMetadataManager(svc.meta));
+
+  meta.user.reset(RGWUserMetaHandlerAllocator::alloc(svc.user));
+
+  auto sync_module = svc.sync_modules->get_sync_module();
+  if (sync_module) {
+    meta.bucket.reset(sync_module->alloc_bucket_meta_handler());
+    meta.bucket_instance.reset(sync_module->alloc_bucket_instance_meta_handler());
+  } else {
+    meta.bucket.reset(RGWBucketMetaHandlerAllocator::alloc());
+    meta.bucket_instance.reset(RGWBucketInstanceMetaHandlerAllocator::alloc());
+  }
+
+  meta.otp.reset(RGWOTPMetaHandlerAllocator::alloc(svc.zone, svc.meta_be_otp));
+
+  user.reset(new RGWUserCtl(svc.zone, svc.user, (RGWUserMetadataHandler *)meta.user.get()));
+
+  return 0;
+}
+
+int RGWCtl::init(RGWServices& svc)
+{
+  int r = _ctl.init(svc);
+  if (r < 0) {
+    ldout(svc.cct, 0) << "ERROR: failed to start init ctls (" << cpp_strerror(-r) << dendl;
+    return r;
+  }
+
+  meta.mgr = _ctl.meta.mgr.get();
+  meta.user = _ctl.meta.user.get();
+  meta.bucket = _ctl.meta.bucket.get();
+  meta.bucket_instance = _ctl.meta.bucket_instance.get();
+
+  user = _ctl.user.get();
+
+  r = meta.user->init(meta.mgr);
+  if (r < 0) {
+    ldout(svc.cct, 0) << "ERROR: failed to start init meta.user ctl (" << cpp_strerror(-r) << dendl;
+    return r;
+  }
+
+  r = meta.bucket->init(meta.mgr);
+  if (r < 0) {
+    ldout(svc.cct, 0) << "ERROR: failed to start init meta.bucket ctl (" << cpp_strerror(-r) << dendl;
+    return r;
+  }
+
+  r = meta.bucket_instance->init(meta.mgr);
+  if (r < 0) {
+    ldout(svc.cct, 0) << "ERROR: failed to start init meta.bucket_instance ctl (" << cpp_strerror(-r) << dendl;
+    return r;
+  }
+
+  r = meta.otp->init(meta.mgr);
+  if (r < 0) {
+    ldout(svc.cct, 0) << "ERROR: failed to start init otp ctl (" << cpp_strerror(-r) << dendl;
+    return r;
+  }
+
+  return 0;
+}
+

diff --git a/src/rgw/rgw_service.h b/src/rgw/rgw_service.h
index b06c76098019516d2b1496bb6029eb8dce219b4b..ba355e57e55fae7211ac1fcd62ed956855705b6f 100644 (file)
--- a/src/rgw/rgw_service.h
+++ b/src/rgw/rgw_service.h
@@ -51,6 +51,7 @@ class RGWSI_MDLog;
 class RGWSI_Meta;
 class RGWSI_MetaBackend;
 class RGWSI_MetaBackend_SObj;
+class RGWSI_MetaBackend_OTP;
 class RGWSI_Notify;
 class RGWSI_RADOS;
 class RGWSI_Zone;
@@ -73,6 +74,7 @@ struct RGWServices_Def
   std::unique_ptr<RGWSI_MDLog> mdlog;
   std::unique_ptr<RGWSI_Meta> meta;
   std::unique_ptr<RGWSI_MetaBackend_SObj> meta_be_sobj;
+  std::unique_ptr<RGWSI_MetaBackend_OTP> meta_be_otp;
   std::unique_ptr<RGWSI_Notify> notify;
   std::unique_ptr<RGWSI_RADOS> rados;
   std::unique_ptr<RGWSI_Zone> zone;
@@ -96,12 +98,15 @@ struct RGWServices
 {
   RGWServices_Def _svc;
 
+  CephContext *cct;
+
   RGWSI_Finisher *finisher{nullptr};
   RGWSI_Bucket *bucket{nullptr};
   RGWSI_Cls *cls{nullptr};
   RGWSI_MDLog *mdlog{nullptr};
   RGWSI_Meta *meta{nullptr};
-  RGWSI_MetaBackend *meta_be{nullptr};
+  RGWSI_MetaBackend *meta_be_sobj{nullptr};
+  RGWSI_MetaBackend *meta_be_otp{nullptr};
   RGWSI_Notify *notify{nullptr};
   RGWSI_RADOS *rados{nullptr};
   RGWSI_Zone *zone{nullptr};
@@ -111,6 +116,7 @@ struct RGWServices
   RGWSI_SysObj *sysobj{nullptr};
   RGWSI_SysObj_Cache *cache{nullptr};
   RGWSI_SysObj_Core *core{nullptr};
+  RGWSI_User *user{nullptr};
 
   int do_init(CephContext *cct, bool have_cache, bool raw_storage);
 
@@ -126,5 +132,45 @@ struct RGWServices
   }
 };
 
+class RGWMetadataManager;
+class RGWMetadataHandler;
+class RGWUserCtl;
+
+struct RGWCtlDef {
+  struct _meta {
+    std::unique_ptr<RGWMetadataManager> mgr;
+    std::unique_ptr<RGWMetadataHandler> bucket;
+    std::unique_ptr<RGWMetadataHandler> bucket_instance;
+    std::unique_ptr<RGWMetadataHandler> user;
+    std::unique_ptr<RGWMetadataHandler> otp;
+
+    _meta();
+    ~_meta();
+  } meta;
+
+  std::unique_ptr<RGWUserCtl> user;
+
+  RGWCtlDef();
+  ~RGWCtlDef();
+
+  int init(RGWServices& svc);
+};
+
+struct RGWCtl {
+  RGWCtlDef _ctl;
+
+  struct _meta {
+    RGWMetadataManager *mgr{nullptr};
+
+    RGWMetadataHandler *bucket{nullptr};
+    RGWMetadataHandler *bucket_instance{nullptr};
+    RGWMetadataHandler *user{nullptr};
+    RGWMetadataHandler *otp{nullptr};
+  } meta;
+
+  RGWUserCtl *user{nullptr};
+
+  int init(RGWServices& svc);
+};
 
 #endif

diff --git a/src/rgw/services/svc_bucket.cc b/src/rgw/services/svc_bucket.cc
index c6efc898fd68c7d2e722e8044277265d119e6034..db1d8d7c7a6dc6fa0f8a565dfc41895e6aaaabdc 100644 (file)
--- a/src/rgw/services/svc_bucket.cc
+++ b/src/rgw/services/svc_bucket.cc
@@ -46,26 +46,6 @@ int RGWSI_Bucket::do_start()
 {
   binfo_cache.reset(new RGWChainedCacheImpl<bucket_info_cache_entry>);
   binfo_cache->init(svc.cache);
-
-  auto mm = svc.meta->get_mgr();
-  auto sync_module = svc.sync_modules->get_sync_module();
-  if (sync_module) {
-    bucket_meta_handler = sync_module->alloc_bucket_meta_handler();
-    bucket_instance_meta_handler = sync_module->alloc_bucket_instance_meta_handler();
-  } else {
-    bucket_meta_handler = RGWBucketMetaHandlerAllocator::alloc();
-    bucket_instance_meta_handler = RGWBucketInstanceMetaHandlerAllocator::alloc();
-  }
-
-  int r = bucket_meta_handler->init(mm);
-  if (r < 0) {
-    return r;
-  }
-
-  r = bucket_instance_meta_handler->init(mm);
-  if (r < 0) {
-    return r;
-  }
   return 0;
 }
 

diff --git a/src/rgw/services/svc_user.cc b/src/rgw/services/svc_user.cc
index 8d4b0e58b724ef16210c0d5e1cbbfe5a359a79cd..733ea63b8d8800cdb2b82e17b0d3712b9518eeb7 100644 (file)
--- a/src/rgw/services/svc_user.cc
+++ b/src/rgw/services/svc_user.cc
@@ -37,15 +37,6 @@ int RGWSI_User::do_start()
 {
   uinfo_cache.reset(new RGWChainedCacheImpl<user_info_cache_entry>);
   uinfo_cache->init(svc.cache);
-
-  auto mm = svc.meta->get_mgr();
-  user_meta_handler = RGWUserMetaHandlerAllocator::alloc(this);
-
-  int r = user_meta_handler->init(mm);
-  if (r < 0) {
-    return r;
-  }
-
   return 0;
 }