[ceph.git] / ceph / src / rgw / rgw_service.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab ft=cpp

#include "rgw_service.h"

#include "services/svc_finisher.h"
#include "services/svc_bi_rados.h"
#include "services/svc_bilog_rados.h"
#include "services/svc_bucket_sobj.h"
#include "services/svc_bucket_sync_sobj.h"
#include "services/svc_cls.h"
#include "services/svc_config_key_rados.h"
#include "services/svc_mdlog.h"
#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_otp.h"
#include "services/svc_rados.h"
#include "services/svc_zone.h"
#include "services/svc_zone_utils.h"
#include "services/svc_quota.h"
#include "services/svc_sync_modules.h"
#include "services/svc_sys_obj.h"
#include "services/svc_sys_obj_cache.h"
#include "services/svc_sys_obj_core.h"
#include "services/svc_user_rados.h"
#include "services/svc_role_rados.h"

#include "common/errno.h"

#include "rgw_bucket.h"
#include "rgw_datalog.h"
#include "rgw_metadata.h"
#include "rgw_otp.h"
#include "rgw_user.h"
#include "rgw_role.h"

#define dout_subsys ceph_subsys_rgw

using namespace std;

RGWServices_Def::RGWServices_Def() = default;
RGWServices_Def::~RGWServices_Def()
{
  shutdown();
}

int RGWServices_Def::init(CephContext *cct,
			  bool have_cache,
                          bool raw,
			  bool run_sync,
			  optional_yield y,
                          const DoutPrefixProvider *dpp)
{
  finisher = std::make_unique<RGWSI_Finisher>(cct);
  bucket_sobj = std::make_unique<RGWSI_Bucket_SObj>(cct);
  bucket_sync_sobj = std::make_unique<RGWSI_Bucket_Sync_SObj>(cct);
  bi_rados = std::make_unique<RGWSI_BucketIndex_RADOS>(cct);
  bilog_rados = std::make_unique<RGWSI_BILog_RADOS>(cct);
  cls = std::make_unique<RGWSI_Cls>(cct);
  config_key_rados = std::make_unique<RGWSI_ConfigKey_RADOS>(cct);
  datalog_rados = std::make_unique<RGWDataChangesLog>(cct);
  mdlog = std::make_unique<RGWSI_MDLog>(cct, run_sync);
  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);
  otp = std::make_unique<RGWSI_OTP>(cct);
  rados = std::make_unique<RGWSI_RADOS>(cct);
  zone = std::make_unique<RGWSI_Zone>(cct);
  zone_utils = std::make_unique<RGWSI_ZoneUtils>(cct);
  quota = std::make_unique<RGWSI_Quota>(cct);
  sync_modules = std::make_unique<RGWSI_SyncModules>(cct);
  sysobj = std::make_unique<RGWSI_SysObj>(cct);
  sysobj_core = std::make_unique<RGWSI_SysObj_Core>(cct);
  user_rados = std::make_unique<RGWSI_User_RADOS>(cct);
  role_rados = std::make_unique<RGWSI_Role_RADOS>(cct);

  if (have_cache) {
    sysobj_cache = std::make_unique<RGWSI_SysObj_Cache>(dpp, cct);
  }

  vector<RGWSI_MetaBackend *> meta_bes{meta_be_sobj.get(), meta_be_otp.get()};

  finisher->init();
  bi_rados->init(zone.get(), rados.get(), bilog_rados.get(), datalog_rados.get());
  bilog_rados->init(bi_rados.get());
  bucket_sobj->init(zone.get(), sysobj.get(), sysobj_cache.get(),
                    bi_rados.get(), meta.get(), meta_be_sobj.get(),
                    sync_modules.get(), bucket_sync_sobj.get());
  bucket_sync_sobj->init(zone.get(),
                         sysobj.get(),
                         sysobj_cache.get(),
                         bucket_sobj.get());
  cls->init(zone.get(), rados.get());
  config_key_rados->init(rados.get());
  mdlog->init(rados.get(), zone.get(), sysobj.get(), cls.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());
  otp->init(zone.get(), meta.get(), meta_be_otp.get());
  rados->init();
  zone->init(sysobj.get(), rados.get(), sync_modules.get(), bucket_sync_sobj.get());
  zone_utils->init(rados.get(), zone.get());
  quota->init(zone.get());
  sync_modules->init(zone.get());
  sysobj_core->core_init(rados.get(), zone.get());
  if (have_cache) {
    sysobj_cache->init(rados.get(), zone.get(), notify.get());
    sysobj->init(rados.get(), sysobj_cache.get());
  } else {
    sysobj->init(rados.get(), sysobj_core.get());
  }
  user_rados->init(rados.get(), zone.get(), sysobj.get(), sysobj_cache.get(),
                   meta.get(), meta_be_sobj.get(), sync_modules.get());
  role_rados->init(zone.get(), meta.get(), meta_be_sobj.get(), sysobj.get());

  can_shutdown = true;

  int r = finisher->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start finisher service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  if (!raw) {
    r = notify->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start notify service (" << cpp_strerror(-r) << dendl;
      return r;
    }
  }

  r = rados->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start rados service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  if (!raw) {
    r = zone->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start zone service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = datalog_rados->start(dpp, &zone->get_zone(),
			     zone->get_zone_params(),
			     rados->get_rados_handle());
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start datalog_rados service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = mdlog->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start mdlog service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = sync_modules->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start sync modules service (" << cpp_strerror(-r) << dendl;
      return r;
    }
  }

  r = cls->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start cls service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = config_key_rados->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start config_key service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = zone_utils->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start zone_utils service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = quota->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start quota service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = sysobj_core->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj_core service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  if (have_cache) {
    r = sysobj_cache->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj_cache service (" << cpp_strerror(-r) << dendl;
      return r;
    }
  }

  r = sysobj->start(y, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj service (" << cpp_strerror(-r) << dendl;
    return r;
  }

  if (!raw) {
    r = meta_be_sobj->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start meta_be_sobj service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = meta->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start meta service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = bucket_sobj->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start bucket service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = bucket_sync_sobj->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start bucket_sync service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = user_rados->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start user_rados service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = otp->start(y, dpp);
    if (r < 0) {
      ldpp_dout(dpp, 0) << "ERROR: failed to start otp service (" << cpp_strerror(-r) << dendl;
      return r;
    }

    r = role_rados->start(y, dpp);
    if (r < 0) {
      ldout(cct, 0) << "ERROR: failed to start role_rados service (" << cpp_strerror(-r) << dendl;
      return r;
    }

  }

  /* cache or core services will be started by sysobj */

  return  0;
}

void RGWServices_Def::shutdown()
{
  if (!can_shutdown) {
    return;
  }

  if (has_shutdown) {
    return;
  }

  sysobj->shutdown();
  sysobj_core->shutdown();
  notify->shutdown();
  if (sysobj_cache) {
    sysobj_cache->shutdown();
  }
  quota->shutdown();
  zone_utils->shutdown();
  zone->shutdown();
  rados->shutdown();

  has_shutdown = true;

}


int RGWServices::do_init(CephContext *_cct, bool have_cache, bool raw, bool run_sync, optional_yield y, const DoutPrefixProvider *dpp)
{
  cct = _cct;

  int r = _svc.init(cct, have_cache, raw, run_sync, y, dpp);
  if (r < 0) {
    return r;
  }

  finisher = _svc.finisher.get();
  bi_rados = _svc.bi_rados.get();
  bi = bi_rados;
  bilog_rados = _svc.bilog_rados.get();
  bucket_sobj = _svc.bucket_sobj.get();
  bucket = bucket_sobj;
  bucket_sync_sobj = _svc.bucket_sync_sobj.get();
  bucket_sync = bucket_sync_sobj;
  cls = _svc.cls.get();
  config_key_rados = _svc.config_key_rados.get();
  config_key = config_key_rados;
  datalog_rados = _svc.datalog_rados.get();
  mdlog = _svc.mdlog.get();
  meta = _svc.meta.get();
  meta_be_sobj = _svc.meta_be_sobj.get();
  meta_be_otp = _svc.meta_be_otp.get();
  notify = _svc.notify.get();
  otp = _svc.otp.get();
  rados = _svc.rados.get();
  zone = _svc.zone.get();
  zone_utils = _svc.zone_utils.get();
  quota = _svc.quota.get();
  sync_modules = _svc.sync_modules.get();
  sysobj = _svc.sysobj.get();
  cache = _svc.sysobj_cache.get();
  core = _svc.sysobj_core.get();
  user = _svc.user_rados.get();
  role = _svc.role_rados.get();

  return 0;
}

RGWServiceInstance::~RGWServiceInstance() {}

int RGWServiceInstance::start(optional_yield y, const DoutPrefixProvider *dpp)
{
  if (start_state != StateInit) {
    return 0;
  }

  start_state = StateStarting;; /* setting started prior to do_start() on purpose so that circular
                                   references can call start() on each other */

  int r = do_start(y, dpp);
  if (r < 0) {
    return r;
  }

  start_state = StateStarted;

  return 0;
}

RGWCtlDef::RGWCtlDef() {}
RGWCtlDef::~RGWCtlDef() {}
RGWCtlDef::_meta::_meta() {}
RGWCtlDef::_meta::~_meta() {}


int RGWCtlDef::init(RGWServices& svc, rgw::sal::Store* store, const DoutPrefixProvider *dpp)
{
  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());
  meta.role = std::make_unique<rgw::sal::RGWRoleMetadataHandler>(store, svc.role);

  user.reset(new RGWUserCtl(svc.zone, svc.user, (RGWUserMetadataHandler *)meta.user.get()));
  bucket.reset(new RGWBucketCtl(svc.zone,
                                svc.bucket,
                                svc.bucket_sync,
                                svc.bi));
  otp.reset(new RGWOTPCtl(svc.zone, svc.otp));

  RGWBucketMetadataHandlerBase *bucket_meta_handler = static_cast<RGWBucketMetadataHandlerBase *>(meta.bucket.get());
  RGWBucketInstanceMetadataHandlerBase *bi_meta_handler = static_cast<RGWBucketInstanceMetadataHandlerBase *>(meta.bucket_instance.get());

  bucket_meta_handler->init(svc.bucket, bucket.get());
  bi_meta_handler->init(svc.zone, svc.bucket, svc.bi);

  RGWOTPMetadataHandlerBase *otp_handler = static_cast<RGWOTPMetadataHandlerBase *>(meta.otp.get());
  otp_handler->init(svc.zone, svc.meta_be_otp, svc.otp);

  user->init(bucket.get());
  bucket->init(user.get(),
               (RGWBucketMetadataHandler *)bucket_meta_handler,
               (RGWBucketInstanceMetadataHandler *)bi_meta_handler,
	       svc.datalog_rados,
               dpp);

  otp->init((RGWOTPMetadataHandler *)meta.otp.get());

  return 0;
}

int RGWCtl::init(RGWServices *_svc, rgw::sal::Store* store, const DoutPrefixProvider *dpp)
{
  svc = _svc;
  cct = svc->cct;

  int r = _ctl.init(*svc, store, dpp);
  if (r < 0) {
    ldpp_dout(dpp, 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();
  meta.otp = _ctl.meta.otp.get();
  meta.role = _ctl.meta.role.get();

  user = _ctl.user.get();
  bucket = _ctl.bucket.get();
  otp = _ctl.otp.get();

  r = meta.user->attach(meta.mgr);
  if (r < 0) {
    ldout(cct, 0) << "ERROR: failed to start init meta.user ctl (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = meta.bucket->attach(meta.mgr);
  if (r < 0) {
    ldout(cct, 0) << "ERROR: failed to start init meta.bucket ctl (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = meta.bucket_instance->attach(meta.mgr);
  if (r < 0) {
    ldout(cct, 0) << "ERROR: failed to start init meta.bucket_instance ctl (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = meta.otp->attach(meta.mgr);
  if (r < 0) {
    ldout(cct, 0) << "ERROR: failed to start init otp ctl (" << cpp_strerror(-r) << dendl;
    return r;
  }

  r = meta.role->attach(meta.mgr);
  if (r < 0) {
    ldout(cct, 0) << "ERROR: failed to start init otp ctl (" << cpp_strerror(-r) << dendl;
    return r;
  }
  return 0;
}
Commit	Line	Data
11fdf7f2	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
9f95a23c	2	// vim: ts=8 sw=2 smarttab ft=cpp
11fdf7f2 TL	3
	4	#include "rgw_service.h"
	5
	6	#include "services/svc_finisher.h"
9f95a23c TL	7	#include "services/svc_bi_rados.h"
	8	#include "services/svc_bilog_rados.h"
	9	#include "services/svc_bucket_sobj.h"
	10	#include "services/svc_bucket_sync_sobj.h"
	11	#include "services/svc_cls.h"
	12	#include "services/svc_config_key_rados.h"
9f95a23c TL	13	#include "services/svc_mdlog.h"
	14	#include "services/svc_meta.h"
	15	#include "services/svc_meta_be.h"
	16	#include "services/svc_meta_be_sobj.h"
	17	#include "services/svc_meta_be_otp.h"
11fdf7f2	18	#include "services/svc_notify.h"
9f95a23c	19	#include "services/svc_otp.h"
11fdf7f2 TL	20	#include "services/svc_rados.h"
	21	#include "services/svc_zone.h"
	22	#include "services/svc_zone_utils.h"
	23	#include "services/svc_quota.h"
	24	#include "services/svc_sync_modules.h"
	25	#include "services/svc_sys_obj.h"
	26	#include "services/svc_sys_obj_cache.h"
	27	#include "services/svc_sys_obj_core.h"
9f95a23c	28	#include "services/svc_user_rados.h"
39ae355f	29	#include "services/svc_role_rados.h"
11fdf7f2 TL	30
	31	#include "common/errno.h"
	32
9f95a23c	33	#include "rgw_bucket.h"
f67539c2 TL	34	#include "rgw_datalog.h"
f67539c2 TL	35	#include "rgw_metadata.h"
9f95a23c	36	#include "rgw_otp.h"
f67539c2	37	#include "rgw_user.h"
39ae355f	38	#include "rgw_role.h"
9f95a23c	39
11fdf7f2 TL	40	#define dout_subsys ceph_subsys_rgw
11fdf7f2 TL	41
20effc67 TL	42	using namespace std;
20effc67 TL	43
11fdf7f2 TL	44	RGWServices_Def::RGWServices_Def() = default;
	45	RGWServices_Def::~RGWServices_Def()
	46	{
	47	shutdown();
	48	}
	49
	50	int RGWServices_Def::init(CephContext *cct,
	51	bool have_cache,
9f95a23c	52	bool raw,
f67539c2	53	bool run_sync,
b3b6e05e TL	54	optional_yield y,
b3b6e05e TL	55	const DoutPrefixProvider *dpp)
11fdf7f2 TL	56	{
11fdf7f2 TL	57	finisher = std::make_unique<RGWSI_Finisher>(cct);
9f95a23c TL	58	bucket_sobj = std::make_unique<RGWSI_Bucket_SObj>(cct);
	59	bucket_sync_sobj = std::make_unique<RGWSI_Bucket_Sync_SObj>(cct);
	60	bi_rados = std::make_unique<RGWSI_BucketIndex_RADOS>(cct);
	61	bilog_rados = std::make_unique<RGWSI_BILog_RADOS>(cct);
	62	cls = std::make_unique<RGWSI_Cls>(cct);
	63	config_key_rados = std::make_unique<RGWSI_ConfigKey_RADOS>(cct);
f67539c2	64	datalog_rados = std::make_unique<RGWDataChangesLog>(cct);
9f95a23c TL	65	mdlog = std::make_unique<RGWSI_MDLog>(cct, run_sync);
	66	meta = std::make_unique<RGWSI_Meta>(cct);
	67	meta_be_sobj = std::make_unique<RGWSI_MetaBackend_SObj>(cct);
	68	meta_be_otp = std::make_unique<RGWSI_MetaBackend_OTP>(cct);
11fdf7f2	69	notify = std::make_unique<RGWSI_Notify>(cct);
9f95a23c	70	otp = std::make_unique<RGWSI_OTP>(cct);
11fdf7f2 TL	71	rados = std::make_unique<RGWSI_RADOS>(cct);
	72	zone = std::make_unique<RGWSI_Zone>(cct);
	73	zone_utils = std::make_unique<RGWSI_ZoneUtils>(cct);
	74	quota = std::make_unique<RGWSI_Quota>(cct);
	75	sync_modules = std::make_unique<RGWSI_SyncModules>(cct);
	76	sysobj = std::make_unique<RGWSI_SysObj>(cct);
	77	sysobj_core = std::make_unique<RGWSI_SysObj_Core>(cct);
9f95a23c	78	user_rados = std::make_unique<RGWSI_User_RADOS>(cct);
39ae355f	79	role_rados = std::make_unique<RGWSI_Role_RADOS>(cct);
11fdf7f2 TL	80
11fdf7f2 TL	81	if (have_cache) {
b3b6e05e	82	sysobj_cache = std::make_unique<RGWSI_SysObj_Cache>(dpp, cct);
11fdf7f2	83	}
9f95a23c TL	84
	85	vector<RGWSI_MetaBackend *> meta_bes{meta_be_sobj.get(), meta_be_otp.get()};
	86
11fdf7f2	87	finisher->init();
9f95a23c TL	88	bi_rados->init(zone.get(), rados.get(), bilog_rados.get(), datalog_rados.get());
	89	bilog_rados->init(bi_rados.get());
	90	bucket_sobj->init(zone.get(), sysobj.get(), sysobj_cache.get(),
	91	bi_rados.get(), meta.get(), meta_be_sobj.get(),
	92	sync_modules.get(), bucket_sync_sobj.get());
	93	bucket_sync_sobj->init(zone.get(),
	94	sysobj.get(),
	95	sysobj_cache.get(),
	96	bucket_sobj.get());
	97	cls->init(zone.get(), rados.get());
	98	config_key_rados->init(rados.get());
9f95a23c TL	99	mdlog->init(rados.get(), zone.get(), sysobj.get(), cls.get());
	100	meta->init(sysobj.get(), mdlog.get(), meta_bes);
	101	meta_be_sobj->init(sysobj.get(), mdlog.get());
	102	meta_be_otp->init(sysobj.get(), mdlog.get(), cls.get());
11fdf7f2	103	notify->init(zone.get(), rados.get(), finisher.get());
9f95a23c	104	otp->init(zone.get(), meta.get(), meta_be_otp.get());
11fdf7f2	105	rados->init();
9f95a23c	106	zone->init(sysobj.get(), rados.get(), sync_modules.get(), bucket_sync_sobj.get());
11fdf7f2 TL	107	zone_utils->init(rados.get(), zone.get());
11fdf7f2 TL	108	quota->init(zone.get());
9f95a23c	109	sync_modules->init(zone.get());
11fdf7f2 TL	110	sysobj_core->core_init(rados.get(), zone.get());
	111	if (have_cache) {
	112	sysobj_cache->init(rados.get(), zone.get(), notify.get());
	113	sysobj->init(rados.get(), sysobj_cache.get());
	114	} else {
	115	sysobj->init(rados.get(), sysobj_core.get());
	116	}
9f95a23c TL	117	user_rados->init(rados.get(), zone.get(), sysobj.get(), sysobj_cache.get(),
9f95a23c TL	118	meta.get(), meta_be_sobj.get(), sync_modules.get());
39ae355f	119	role_rados->init(zone.get(), meta.get(), meta_be_sobj.get(), sysobj.get());
11fdf7f2 TL	120
	121	can_shutdown = true;
	122
b3b6e05e	123	int r = finisher->start(y, dpp);
11fdf7f2	124	if (r < 0) {
b3b6e05e	125	ldpp_dout(dpp, 0) << "ERROR: failed to start finisher service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	126	return r;
	127	}
	128
	129	if (!raw) {
b3b6e05e	130	r = notify->start(y, dpp);
11fdf7f2	131	if (r < 0) {
b3b6e05e	132	ldpp_dout(dpp, 0) << "ERROR: failed to start notify service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	133	return r;
	134	}
	135	}
	136
b3b6e05e	137	r = rados->start(y, dpp);
11fdf7f2	138	if (r < 0) {
b3b6e05e	139	ldpp_dout(dpp, 0) << "ERROR: failed to start rados service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	140	return r;
	141	}
	142
	143	if (!raw) {
b3b6e05e	144	r = zone->start(y, dpp);
11fdf7f2	145	if (r < 0) {
b3b6e05e	146	ldpp_dout(dpp, 0) << "ERROR: failed to start zone service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	147	return r;
11fdf7f2 TL	148	}
9f95a23c	149
b3b6e05e	150	r = datalog_rados->start(dpp, &zone->get_zone(),
f67539c2 TL	151	zone->get_zone_params(),
	152	rados->get_rados_handle());
	153	if (r < 0) {
20effc67	154	ldpp_dout(dpp, 0) << "ERROR: failed to start datalog_rados service (" << cpp_strerror(-r) << dendl;
f67539c2 TL	155	return r;
	156	}
	157
b3b6e05e	158	r = mdlog->start(y, dpp);
9f95a23c	159	if (r < 0) {
b3b6e05e	160	ldpp_dout(dpp, 0) << "ERROR: failed to start mdlog service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	161	return r;
	162	}
	163
b3b6e05e	164	r = sync_modules->start(y, dpp);
9f95a23c	165	if (r < 0) {
b3b6e05e	166	ldpp_dout(dpp, 0) << "ERROR: failed to start sync modules service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	167	return r;
	168	}
	169	}
	170
b3b6e05e	171	r = cls->start(y, dpp);
9f95a23c	172	if (r < 0) {
b3b6e05e	173	ldpp_dout(dpp, 0) << "ERROR: failed to start cls service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	174	return r;
	175	}
	176
b3b6e05e	177	r = config_key_rados->start(y, dpp);
9f95a23c	178	if (r < 0) {
b3b6e05e	179	ldpp_dout(dpp, 0) << "ERROR: failed to start config_key service (" << cpp_strerror(-r) << dendl;
9f95a23c	180	return r;
11fdf7f2 TL	181	}
11fdf7f2 TL	182
b3b6e05e	183	r = zone_utils->start(y, dpp);
11fdf7f2	184	if (r < 0) {
b3b6e05e	185	ldpp_dout(dpp, 0) << "ERROR: failed to start zone_utils service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	186	return r;
	187	}
	188
b3b6e05e	189	r = quota->start(y, dpp);
11fdf7f2	190	if (r < 0) {
b3b6e05e	191	ldpp_dout(dpp, 0) << "ERROR: failed to start quota service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	192	return r;
	193	}
	194
b3b6e05e	195	r = sysobj_core->start(y, dpp);
11fdf7f2	196	if (r < 0) {
b3b6e05e	197	ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj_core service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	198	return r;
	199	}
	200
	201	if (have_cache) {
b3b6e05e	202	r = sysobj_cache->start(y, dpp);
11fdf7f2	203	if (r < 0) {
b3b6e05e	204	ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj_cache service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	205	return r;
	206	}
	207	}
	208
b3b6e05e	209	r = sysobj->start(y, dpp);
11fdf7f2	210	if (r < 0) {
b3b6e05e	211	ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj service (" << cpp_strerror(-r) << dendl;
11fdf7f2 TL	212	return r;
	213	}
	214
9f95a23c	215	if (!raw) {
b3b6e05e	216	r = meta_be_sobj->start(y, dpp);
9f95a23c	217	if (r < 0) {
b3b6e05e	218	ldpp_dout(dpp, 0) << "ERROR: failed to start meta_be_sobj service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	219	return r;
	220	}
	221
b3b6e05e	222	r = meta->start(y, dpp);
9f95a23c	223	if (r < 0) {
b3b6e05e	224	ldpp_dout(dpp, 0) << "ERROR: failed to start meta service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	225	return r;
	226	}
	227
b3b6e05e	228	r = bucket_sobj->start(y, dpp);
9f95a23c	229	if (r < 0) {
b3b6e05e	230	ldpp_dout(dpp, 0) << "ERROR: failed to start bucket service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	231	return r;
	232	}
	233
b3b6e05e	234	r = bucket_sync_sobj->start(y, dpp);
9f95a23c	235	if (r < 0) {
b3b6e05e	236	ldpp_dout(dpp, 0) << "ERROR: failed to start bucket_sync service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	237	return r;
	238	}
	239
b3b6e05e	240	r = user_rados->start(y, dpp);
9f95a23c	241	if (r < 0) {
b3b6e05e	242	ldpp_dout(dpp, 0) << "ERROR: failed to start user_rados service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	243	return r;
	244	}
	245
b3b6e05e	246	r = otp->start(y, dpp);
9f95a23c	247	if (r < 0) {
b3b6e05e	248	ldpp_dout(dpp, 0) << "ERROR: failed to start otp service (" << cpp_strerror(-r) << dendl;
9f95a23c TL	249	return r;
9f95a23c TL	250	}
39ae355f TL	251
	252	r = role_rados->start(y, dpp);
	253	if (r < 0) {
	254	ldout(cct, 0) << "ERROR: failed to start role_rados service (" << cpp_strerror(-r) << dendl;
	255	return r;
	256	}
	257
9f95a23c TL	258	}
9f95a23c TL	259
11fdf7f2 TL	260	/* cache or core services will be started by sysobj */
	261
	262	return 0;
	263	}
	264
	265	void RGWServices_Def::shutdown()
	266	{
	267	if (!can_shutdown) {
	268	return;
	269	}
	270
	271	if (has_shutdown) {
	272	return;
	273	}
	274
	275	sysobj->shutdown();
	276	sysobj_core->shutdown();
	277	notify->shutdown();
	278	if (sysobj_cache) {
	279	sysobj_cache->shutdown();
	280	}
	281	quota->shutdown();
	282	zone_utils->shutdown();
	283	zone->shutdown();
	284	rados->shutdown();
	285
	286	has_shutdown = true;
	287
	288	}
	289
	290
b3b6e05e	291	int RGWServices::do_init(CephContext _cct, bool have_cache, bool raw, bool run_sync, optional_yield y, const DoutPrefixProvider dpp)
11fdf7f2	292	{
9f95a23c TL	293	cct = _cct;
9f95a23c TL	294
b3b6e05e	295	int r = _svc.init(cct, have_cache, raw, run_sync, y, dpp);
11fdf7f2 TL	296	if (r < 0) {
	297	return r;
	298	}
	299
	300	finisher = _svc.finisher.get();
9f95a23c TL	301	bi_rados = _svc.bi_rados.get();
	302	bi = bi_rados;
	303	bilog_rados = _svc.bilog_rados.get();
	304	bucket_sobj = _svc.bucket_sobj.get();
	305	bucket = bucket_sobj;
	306	bucket_sync_sobj = _svc.bucket_sync_sobj.get();
	307	bucket_sync = bucket_sync_sobj;
	308	cls = _svc.cls.get();
	309	config_key_rados = _svc.config_key_rados.get();
	310	config_key = config_key_rados;
	311	datalog_rados = _svc.datalog_rados.get();
	312	mdlog = _svc.mdlog.get();
	313	meta = _svc.meta.get();
	314	meta_be_sobj = _svc.meta_be_sobj.get();
	315	meta_be_otp = _svc.meta_be_otp.get();
11fdf7f2	316	notify = _svc.notify.get();
9f95a23c	317	otp = _svc.otp.get();
11fdf7f2 TL	318	rados = _svc.rados.get();
	319	zone = _svc.zone.get();
	320	zone_utils = _svc.zone_utils.get();
	321	quota = _svc.quota.get();
	322	sync_modules = _svc.sync_modules.get();
	323	sysobj = _svc.sysobj.get();
	324	cache = _svc.sysobj_cache.get();
	325	core = _svc.sysobj_core.get();
9f95a23c	326	user = _svc.user_rados.get();
39ae355f	327	role = _svc.role_rados.get();
11fdf7f2 TL	328
	329	return 0;
	330	}
	331
20effc67 TL	332	RGWServiceInstance::~RGWServiceInstance() {}
20effc67 TL	333
b3b6e05e	334	int RGWServiceInstance::start(optional_yield y, const DoutPrefixProvider *dpp)
11fdf7f2 TL	335	{
	336	if (start_state != StateInit) {
	337	return 0;
	338	}
	339
	340	start_state = StateStarting;; /* setting started prior to do_start() on purpose so that circular
	341	references can call start() on each other */
	342
b3b6e05e	343	int r = do_start(y, dpp);
11fdf7f2 TL	344	if (r < 0) {
	345	return r;
	346	}
	347
	348	start_state = StateStarted;
	349
	350	return 0;
	351	}
9f95a23c TL	352
	353	RGWCtlDef::RGWCtlDef() {}
	354	RGWCtlDef::~RGWCtlDef() {}
	355	RGWCtlDef::_meta::_meta() {}
	356	RGWCtlDef::_meta::~_meta() {}
	357
	358
39ae355f	359	int RGWCtlDef::init(RGWServices& svc, rgw::sal::Store* store, const DoutPrefixProvider *dpp)
9f95a23c TL	360	{
	361	meta.mgr.reset(new RGWMetadataManager(svc.meta));
	362
	363	meta.user.reset(RGWUserMetaHandlerAllocator::alloc(svc.user));
	364
	365	auto sync_module = svc.sync_modules->get_sync_module();
	366	if (sync_module) {
	367	meta.bucket.reset(sync_module->alloc_bucket_meta_handler());
	368	meta.bucket_instance.reset(sync_module->alloc_bucket_instance_meta_handler());
	369	} else {
	370	meta.bucket.reset(RGWBucketMetaHandlerAllocator::alloc());
	371	meta.bucket_instance.reset(RGWBucketInstanceMetaHandlerAllocator::alloc());
	372	}
	373
	374	meta.otp.reset(RGWOTPMetaHandlerAllocator::alloc());
39ae355f	375	meta.role = std::make_unique<rgw::sal::RGWRoleMetadataHandler>(store, svc.role);
9f95a23c TL	376
	377	user.reset(new RGWUserCtl(svc.zone, svc.user, (RGWUserMetadataHandler *)meta.user.get()));
	378	bucket.reset(new RGWBucketCtl(svc.zone,
	379	svc.bucket,
	380	svc.bucket_sync,
	381	svc.bi));
	382	otp.reset(new RGWOTPCtl(svc.zone, svc.otp));
	383
	384	RGWBucketMetadataHandlerBase bucket_meta_handler = static_cast<RGWBucketMetadataHandlerBase >(meta.bucket.get());
	385	RGWBucketInstanceMetadataHandlerBase bi_meta_handler = static_cast<RGWBucketInstanceMetadataHandlerBase >(meta.bucket_instance.get());
	386
	387	bucket_meta_handler->init(svc.bucket, bucket.get());
	388	bi_meta_handler->init(svc.zone, svc.bucket, svc.bi);
	389
	390	RGWOTPMetadataHandlerBase otp_handler = static_cast<RGWOTPMetadataHandlerBase >(meta.otp.get());
	391	otp_handler->init(svc.zone, svc.meta_be_otp, svc.otp);
	392
	393	user->init(bucket.get());
	394	bucket->init(user.get(),
	395	(RGWBucketMetadataHandler *)bucket_meta_handler,
	396	(RGWBucketInstanceMetadataHandler *)bi_meta_handler,
b3b6e05e TL	397	svc.datalog_rados,
b3b6e05e TL	398	dpp);
9f95a23c TL	399
	400	otp->init((RGWOTPMetadataHandler *)meta.otp.get());
	401
	402	return 0;
	403	}
	404
39ae355f	405	int RGWCtl::init(RGWServices _svc, rgw::sal::Store store, const DoutPrefixProvider *dpp)
9f95a23c TL	406	{
	407	svc = _svc;
	408	cct = svc->cct;
	409
39ae355f	410	int r = _ctl.init(*svc, store, dpp);
9f95a23c	411	if (r < 0) {
b3b6e05e	412	ldpp_dout(dpp, 0) << "ERROR: failed to start init ctls (" << cpp_strerror(-r) << dendl;
9f95a23c TL	413	return r;
	414	}
	415
	416	meta.mgr = _ctl.meta.mgr.get();
	417	meta.user = _ctl.meta.user.get();
	418	meta.bucket = _ctl.meta.bucket.get();
	419	meta.bucket_instance = _ctl.meta.bucket_instance.get();
	420	meta.otp = _ctl.meta.otp.get();
39ae355f	421	meta.role = _ctl.meta.role.get();
9f95a23c TL	422
	423	user = _ctl.user.get();
	424	bucket = _ctl.bucket.get();
	425	otp = _ctl.otp.get();
	426
	427	r = meta.user->attach(meta.mgr);
	428	if (r < 0) {
	429	ldout(cct, 0) << "ERROR: failed to start init meta.user ctl (" << cpp_strerror(-r) << dendl;
	430	return r;
	431	}
	432
	433	r = meta.bucket->attach(meta.mgr);
	434	if (r < 0) {
	435	ldout(cct, 0) << "ERROR: failed to start init meta.bucket ctl (" << cpp_strerror(-r) << dendl;
	436	return r;
	437	}
	438
	439	r = meta.bucket_instance->attach(meta.mgr);
	440	if (r < 0) {
	441	ldout(cct, 0) << "ERROR: failed to start init meta.bucket_instance ctl (" << cpp_strerror(-r) << dendl;
	442	return r;
	443	}
	444
	445	r = meta.otp->attach(meta.mgr);
	446	if (r < 0) {
	447	ldout(cct, 0) << "ERROR: failed to start init otp ctl (" << cpp_strerror(-r) << dendl;
	448	return r;
	449	}
	450
39ae355f TL	451	r = meta.role->attach(meta.mgr);
	452	if (r < 0) {
	453	ldout(cct, 0) << "ERROR: failed to start init otp ctl (" << cpp_strerror(-r) << dendl;
	454	return r;
	455	}
9f95a23c TL	456	return 0;
	457	}
	458