ceph/src/rgw/rgw_service.cc

   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 #include "rgw_service.h"
   5
   6 #include "services/svc_finisher.h"
   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"
  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"
  18 #include "services/svc_notify.h"
  19 #include "services/svc_otp.h"
  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"
  28 #include "services/svc_user_rados.h"
  29 #include "services/svc_role_rados.h"
  30
  31 #include "common/errno.h"
  32
  33 #include "rgw_bucket.h"
  34 #include "rgw_datalog.h"
  35 #include "rgw_metadata.h"
  36 #include "rgw_otp.h"
  37 #include "rgw_user.h"
  38 #include "rgw_role.h"
  39
  40 #define dout_subsys ceph_subsys_rgw
  41
  42 using namespace std;
  43
  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,
  52                           bool raw,
  53                           bool run_sync,
  54                           optional_yield y,
  55                           const DoutPrefixProvider *dpp)
  56 {
  57   finisher = std::make_unique<RGWSI_Finisher>(cct);
  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);
  64   datalog_rados = std::make_unique<RGWDataChangesLog>(cct);
  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);
  69   notify = std::make_unique<RGWSI_Notify>(cct);
  70   otp = std::make_unique<RGWSI_OTP>(cct);
  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);
  78   user_rados = std::make_unique<RGWSI_User_RADOS>(cct);
  79   role_rados = std::make_unique<RGWSI_Role_RADOS>(cct);
  80
  81   if (have_cache) {
  82     sysobj_cache = std::make_unique<RGWSI_SysObj_Cache>(dpp, cct);
  83   }
  84
  85   vector<RGWSI_MetaBackend *> meta_bes{meta_be_sobj.get(), meta_be_otp.get()};
  86
  87   finisher->init();
  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());
  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());
 103   notify->init(zone.get(), rados.get(), finisher.get());
 104   otp->init(zone.get(), meta.get(), meta_be_otp.get());
 105   rados->init();
 106   zone->init(sysobj.get(), rados.get(), sync_modules.get(), bucket_sync_sobj.get());
 107   zone_utils->init(rados.get(), zone.get());
 108   quota->init(zone.get());
 109   sync_modules->init(zone.get());
 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   }
 117   user_rados->init(rados.get(), zone.get(), sysobj.get(), sysobj_cache.get(),
 118                    meta.get(), meta_be_sobj.get(), sync_modules.get());
 119   role_rados->init(zone.get(), meta.get(), meta_be_sobj.get(), sysobj.get());
 120
 121   can_shutdown = true;
 122
 123   int r = finisher->start(y, dpp);
 124   if (r < 0) {
 125     ldpp_dout(dpp, 0) << "ERROR: failed to start finisher service (" << cpp_strerror(-r) << dendl;
 126     return r;
 127   }
 128
 129   if (!raw) {
 130     r = notify->start(y, dpp);
 131     if (r < 0) {
 132       ldpp_dout(dpp, 0) << "ERROR: failed to start notify service (" << cpp_strerror(-r) << dendl;
 133       return r;
 134     }
 135   }
 136
 137   r = rados->start(y, dpp);
 138   if (r < 0) {
 139     ldpp_dout(dpp, 0) << "ERROR: failed to start rados service (" << cpp_strerror(-r) << dendl;
 140     return r;
 141   }
 142
 143   if (!raw) {
 144     r = zone->start(y, dpp);
 145     if (r < 0) {
 146       ldpp_dout(dpp, 0) << "ERROR: failed to start zone service (" << cpp_strerror(-r) << dendl;
 147       return r;
 148     }
 149
 150     r = datalog_rados->start(dpp, &zone->get_zone(),
 151                              zone->get_zone_params(),
 152                              rados->get_rados_handle());
 153     if (r < 0) {
 154       ldpp_dout(dpp, 0) << "ERROR: failed to start datalog_rados service (" << cpp_strerror(-r) << dendl;
 155       return r;
 156     }
 157
 158     r = mdlog->start(y, dpp);
 159     if (r < 0) {
 160       ldpp_dout(dpp, 0) << "ERROR: failed to start mdlog service (" << cpp_strerror(-r) << dendl;
 161       return r;
 162     }
 163
 164     r = sync_modules->start(y, dpp);
 165     if (r < 0) {
 166       ldpp_dout(dpp, 0) << "ERROR: failed to start sync modules service (" << cpp_strerror(-r) << dendl;
 167       return r;
 168     }
 169   }
 170
 171   r = cls->start(y, dpp);
 172   if (r < 0) {
 173     ldpp_dout(dpp, 0) << "ERROR: failed to start cls service (" << cpp_strerror(-r) << dendl;
 174     return r;
 175   }
 176
 177   r = config_key_rados->start(y, dpp);
 178   if (r < 0) {
 179     ldpp_dout(dpp, 0) << "ERROR: failed to start config_key service (" << cpp_strerror(-r) << dendl;
 180     return r;
 181   }
 182
 183   r = zone_utils->start(y, dpp);
 184   if (r < 0) {
 185     ldpp_dout(dpp, 0) << "ERROR: failed to start zone_utils service (" << cpp_strerror(-r) << dendl;
 186     return r;
 187   }
 188
 189   r = quota->start(y, dpp);
 190   if (r < 0) {
 191     ldpp_dout(dpp, 0) << "ERROR: failed to start quota service (" << cpp_strerror(-r) << dendl;
 192     return r;
 193   }
 194
 195   r = sysobj_core->start(y, dpp);
 196   if (r < 0) {
 197     ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj_core service (" << cpp_strerror(-r) << dendl;
 198     return r;
 199   }
 200
 201   if (have_cache) {
 202     r = sysobj_cache->start(y, dpp);
 203     if (r < 0) {
 204       ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj_cache service (" << cpp_strerror(-r) << dendl;
 205       return r;
 206     }
 207   }
 208
 209   r = sysobj->start(y, dpp);
 210   if (r < 0) {
 211     ldpp_dout(dpp, 0) << "ERROR: failed to start sysobj service (" << cpp_strerror(-r) << dendl;
 212     return r;
 213   }
 214
 215   if (!raw) {
 216     r = meta_be_sobj->start(y, dpp);
 217     if (r < 0) {
 218       ldpp_dout(dpp, 0) << "ERROR: failed to start meta_be_sobj service (" << cpp_strerror(-r) << dendl;
 219       return r;
 220     }
 221
 222     r = meta->start(y, dpp);
 223     if (r < 0) {
 224       ldpp_dout(dpp, 0) << "ERROR: failed to start meta service (" << cpp_strerror(-r) << dendl;
 225       return r;
 226     }
 227
 228     r = bucket_sobj->start(y, dpp);
 229     if (r < 0) {
 230       ldpp_dout(dpp, 0) << "ERROR: failed to start bucket service (" << cpp_strerror(-r) << dendl;
 231       return r;
 232     }
 233
 234     r = bucket_sync_sobj->start(y, dpp);
 235     if (r < 0) {
 236       ldpp_dout(dpp, 0) << "ERROR: failed to start bucket_sync service (" << cpp_strerror(-r) << dendl;
 237       return r;
 238     }
 239
 240     r = user_rados->start(y, dpp);
 241     if (r < 0) {
 242       ldpp_dout(dpp, 0) << "ERROR: failed to start user_rados service (" << cpp_strerror(-r) << dendl;
 243       return r;
 244     }
 245
 246     r = otp->start(y, dpp);
 247     if (r < 0) {
 248       ldpp_dout(dpp, 0) << "ERROR: failed to start otp service (" << cpp_strerror(-r) << dendl;
 249       return r;
 250     }
 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
 258   }
 259
 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
 291 int RGWServices::do_init(CephContext *_cct, bool have_cache, bool raw, bool run_sync, optional_yield y, const DoutPrefixProvider *dpp)
 292 {
 293   cct = _cct;
 294
 295   int r = _svc.init(cct, have_cache, raw, run_sync, y, dpp);
 296   if (r < 0) {
 297     return r;
 298   }
 299
 300   finisher = _svc.finisher.get();
 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();
 316   notify = _svc.notify.get();
 317   otp = _svc.otp.get();
 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();
 326   user = _svc.user_rados.get();
 327   role = _svc.role_rados.get();
 328
 329   return 0;
 330 }
 331
 332 RGWServiceInstance::~RGWServiceInstance() {}
 333
 334 int RGWServiceInstance::start(optional_yield y, const DoutPrefixProvider *dpp)
 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
 343   int r = do_start(y, dpp);
 344   if (r < 0) {
 345     return r;
 346   }
 347
 348   start_state = StateStarted;
 349
 350   return 0;
 351 }
 352
 353 RGWCtlDef::RGWCtlDef() {}
 354 RGWCtlDef::~RGWCtlDef() {}
 355 RGWCtlDef::_meta::_meta() {}
 356 RGWCtlDef::_meta::~_meta() {}
 357
 358
 359 int RGWCtlDef::init(RGWServices& svc, rgw::sal::Store* store, const DoutPrefixProvider *dpp)
 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());
 375   meta.role = std::make_unique<rgw::sal::RGWRoleMetadataHandler>(store, svc.role);
 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,
 397                svc.datalog_rados,
 398                dpp);
 399
 400   otp->init((RGWOTPMetadataHandler *)meta.otp.get());
 401
 402   return 0;
 403 }
 404
 405 int RGWCtl::init(RGWServices *_svc, rgw::sal::Store* store, const DoutPrefixProvider *dpp)
 406 {
 407   svc = _svc;
 408   cct = svc->cct;
 409
 410   int r = _ctl.init(*svc, store, dpp);
 411   if (r < 0) {
 412     ldpp_dout(dpp, 0) << "ERROR: failed to start init ctls (" << cpp_strerror(-r) << dendl;
 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();
 421   meta.role = _ctl.meta.role.get();
 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
 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   }
 456   return 0;
 457 }
 458