ceph/src/rgw/driver/rados/rgw_bucket.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 #pragma once
   5
   6 #include <string>
   7 #include <memory>
   8 #include <variant>
   9
  10 #include <boost/container/flat_map.hpp>
  11 #include <boost/container/flat_set.hpp>
  12
  13 #include "include/types.h"
  14 #include "rgw_common.h"
  15 #include "rgw_tools.h"
  16 #include "rgw_metadata.h"
  17 #include "rgw/rgw_bucket.h"
  18
  19 #include "rgw_string.h"
  20 #include "rgw_sal.h"
  21
  22 #include "common/Formatter.h"
  23 #include "common/lru_map.h"
  24 #include "common/ceph_time.h"
  25
  26 #include "rgw_formats.h"
  27
  28 #include "services/svc_bucket_types.h"
  29 #include "services/svc_bucket_sync.h"
  30
  31 // define as static when RGWBucket implementation completes
  32 extern void rgw_get_buckets_obj(const rgw_user& user_id, std::string& buckets_obj_id);
  33
  34 class RGWSI_Meta;
  35 class RGWBucketMetadataHandler;
  36 class RGWBucketInstanceMetadataHandler;
  37 class RGWUserCtl;
  38 class RGWBucketCtl;
  39 class RGWZone;
  40 struct RGWZoneParams;
  41
  42 // this is used as a filter to RGWRados::cls_bucket_list_ordered; it
  43 // conforms to the type RGWBucketListNameFilter
  44 extern bool rgw_bucket_object_check_filter(const std::string& oid);
  45
  46 void init_default_bucket_layout(CephContext *cct, rgw::BucketLayout& layout,
  47                                 const RGWZone& zone,
  48                                 std::optional<uint32_t> shards,
  49                                 std::optional<rgw::BucketIndexType> type);
  50
  51 struct RGWBucketCompleteInfo {
  52   RGWBucketInfo info;
  53   std::map<std::string, bufferlist> attrs;
  54
  55   void dump(Formatter *f) const;
  56   void decode_json(JSONObj *obj);
  57 };
  58
  59 class RGWBucketEntryMetadataObject : public RGWMetadataObject {
  60   RGWBucketEntryPoint ep;
  61   std::map<std::string, bufferlist> attrs;
  62 public:
  63   RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, const obj_version& v, real_time m) : ep(_ep) {
  64     objv = v;
  65     mtime = m;
  66     set_pattrs (&attrs);
  67   }
  68   RGWBucketEntryMetadataObject(RGWBucketEntryPoint& _ep, const obj_version& v, real_time m, std::map<std::string, bufferlist>&& _attrs) :
  69     ep(_ep), attrs(std::move(_attrs)) {
  70     objv = v;
  71     mtime = m;
  72     set_pattrs (&attrs);
  73   }
  74
  75   void dump(Formatter *f) const override {
  76     ep.dump(f);
  77   }
  78
  79   RGWBucketEntryPoint& get_ep() {
  80     return ep;
  81   }
  82
  83   std::map<std::string, bufferlist>& get_attrs() {
  84     return attrs;
  85   }
  86 };
  87
  88 class RGWBucketInstanceMetadataObject : public RGWMetadataObject {
  89   RGWBucketCompleteInfo info;
  90 public:
  91   RGWBucketInstanceMetadataObject() {}
  92   RGWBucketInstanceMetadataObject(RGWBucketCompleteInfo& i, const obj_version& v, real_time m) : info(i) {
  93     objv = v;
  94     mtime = m;
  95   }
  96
  97   void dump(Formatter *f) const override {
  98     info.dump(f);
  99   }
 100
 101   void decode_json(JSONObj *obj) {
 102     info.decode_json(obj);
 103   }
 104
 105   RGWBucketCompleteInfo& get_bci() {
 106     return info;
 107   }
 108   RGWBucketInfo& get_bucket_info() {
 109     return info.info;
 110   }
 111 };
 112
 113 /**
 114  * store a list of the user's buckets, with associated functinos.
 115  */
 116 class RGWUserBuckets {
 117   std::map<std::string, RGWBucketEnt> buckets;
 118
 119 public:
 120   RGWUserBuckets() = default;
 121   RGWUserBuckets(RGWUserBuckets&&) = default;
 122
 123   RGWUserBuckets& operator=(const RGWUserBuckets&) = default;
 124
 125   void encode(bufferlist& bl) const {
 126     using ceph::encode;
 127     encode(buckets, bl);
 128   }
 129   void decode(bufferlist::const_iterator& bl) {
 130     using ceph::decode;
 131     decode(buckets, bl);
 132   }
 133   /**
 134    * Check if the user owns a bucket by the given name.
 135    */
 136   bool owns(std::string& name) {
 137     std::map<std::string, RGWBucketEnt>::iterator iter;
 138     iter = buckets.find(name);
 139     return (iter != buckets.end());
 140   }
 141
 142   /**
 143    * Add a (created) bucket to the user's bucket list.
 144    */
 145   void add(const RGWBucketEnt& bucket) {
 146     buckets[bucket.bucket.name] = bucket;
 147   }
 148
 149   /**
 150    * Remove a bucket from the user's list by name.
 151    */
 152   void remove(const std::string& name) {
 153     std::map<std::string, RGWBucketEnt>::iterator iter;
 154     iter = buckets.find(name);
 155     if (iter != buckets.end()) {
 156       buckets.erase(iter);
 157     }
 158   }
 159
 160   /**
 161    * Get the user's buckets as a map.
 162    */
 163   std::map<std::string, RGWBucketEnt>& get_buckets() { return buckets; }
 164
 165   /**
 166    * Cleanup data structure
 167    */
 168   void clear() { buckets.clear(); }
 169
 170   size_t count() { return buckets.size(); }
 171 };
 172 WRITE_CLASS_ENCODER(RGWUserBuckets)
 173
 174 class RGWBucketMetadataHandlerBase : public RGWMetadataHandler_GenericMetaBE {
 175 public:
 176   virtual ~RGWBucketMetadataHandlerBase() {}
 177   virtual void init(RGWSI_Bucket *bucket_svc,
 178                     RGWBucketCtl *bucket_ctl) = 0;
 179
 180 };
 181
 182 class RGWBucketInstanceMetadataHandlerBase : public RGWMetadataHandler_GenericMetaBE {
 183 public:
 184   virtual ~RGWBucketInstanceMetadataHandlerBase() {}
 185   virtual void init(RGWSI_Zone *zone_svc,
 186                     RGWSI_Bucket *bucket_svc,
 187                     RGWSI_BucketIndex *bi_svc) = 0;
 188 };
 189
 190 class RGWBucketMetaHandlerAllocator {
 191 public:
 192   static RGWBucketMetadataHandlerBase *alloc();
 193 };
 194
 195 class RGWBucketInstanceMetaHandlerAllocator {
 196 public:
 197   static RGWBucketInstanceMetadataHandlerBase *alloc(rgw::sal::Driver* driver);
 198 };
 199
 200 class RGWArchiveBucketMetaHandlerAllocator {
 201 public:
 202   static RGWBucketMetadataHandlerBase *alloc();
 203 };
 204
 205 class RGWArchiveBucketInstanceMetaHandlerAllocator {
 206 public:
 207   static RGWBucketInstanceMetadataHandlerBase *alloc(rgw::sal::Driver* driver);
 208 };
 209
 210 extern int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Driver* driver, rgw::sal::Bucket* bucket, rgw_obj_key& key);
 211
 212 extern int rgw_object_get_attr(rgw::sal::Driver* driver, rgw::sal::Object* obj,
 213                                const char* attr_name, bufferlist& out_bl,
 214                                optional_yield y);
 215
 216 extern void check_bad_user_bucket_mapping(rgw::sal::Driver* driver, rgw::sal::User& user, bool fix, optional_yield y, const DoutPrefixProvider *dpp);
 217
 218 struct RGWBucketAdminOpState {
 219   rgw_user uid;
 220   std::string display_name;
 221   std::string bucket_name;
 222   std::string bucket_id;
 223   std::string object_name;
 224   std::string new_bucket_name;
 225
 226   bool list_buckets;
 227   bool stat_buckets;
 228   bool check_objects;
 229   bool fix_index;
 230   bool delete_child_objects;
 231   bool bucket_stored;
 232   bool sync_bucket;
 233   int max_aio = 0;
 234
 235   std::unique_ptr<rgw::sal::Bucket>  bucket;
 236
 237   RGWQuotaInfo quota;
 238   RGWRateLimitInfo ratelimit_info;
 239
 240   void set_fetch_stats(bool value) { stat_buckets = value; }
 241   void set_check_objects(bool value) { check_objects = value; }
 242   void set_fix_index(bool value) { fix_index = value; }
 243   void set_delete_children(bool value) { delete_child_objects = value; }
 244
 245   void set_max_aio(int value) { max_aio = value; }
 246
 247   void set_user_id(const rgw_user& user_id) {
 248     if (!user_id.empty())
 249       uid = user_id;
 250   }
 251   void set_tenant(const std::string& tenant_str) {
 252     uid.tenant = tenant_str;
 253   }
 254   void set_bucket_name(const std::string& bucket_str) {
 255     bucket_name = bucket_str;
 256   }
 257   void set_object(std::string& object_str) {
 258     object_name = object_str;
 259   }
 260   void set_new_bucket_name(std::string& new_bucket_str) {
 261     new_bucket_name = new_bucket_str;
 262   }
 263   void set_quota(RGWQuotaInfo& value) {
 264     quota = value;
 265   }
 266   void set_bucket_ratelimit(RGWRateLimitInfo& value) {
 267     ratelimit_info = value;
 268   }
 269
 270
 271   void set_sync_bucket(bool value) { sync_bucket = value; }
 272
 273   rgw_user& get_user_id() { return uid; }
 274   std::string& get_user_display_name() { return display_name; }
 275   std::string& get_bucket_name() { return bucket_name; }
 276   std::string& get_object_name() { return object_name; }
 277   std::string& get_tenant() { return uid.tenant; }
 278
 279   rgw::sal::Bucket* get_bucket() { return bucket.get(); }
 280   void set_bucket(std::unique_ptr<rgw::sal::Bucket> _bucket) {
 281     bucket = std::move(_bucket);
 282     bucket_stored = true;
 283   }
 284
 285   void set_bucket_id(const std::string& bi) {
 286     bucket_id = bi;
 287   }
 288   const std::string& get_bucket_id() { return bucket_id; }
 289
 290   bool will_fetch_stats() { return stat_buckets; }
 291   bool will_fix_index() { return fix_index; }
 292   bool will_delete_children() { return delete_child_objects; }
 293   bool will_check_objects() { return check_objects; }
 294   bool is_user_op() { return !uid.empty(); }
 295   bool is_system_op() { return uid.empty(); }
 296   bool has_bucket_stored() { return bucket_stored; }
 297   int get_max_aio() { return max_aio; }
 298   bool will_sync_bucket() { return sync_bucket; }
 299
 300   RGWBucketAdminOpState() : list_buckets(false), stat_buckets(false), check_objects(false),
 301                             fix_index(false), delete_child_objects(false),
 302                             bucket_stored(false), sync_bucket(true)  {}
 303 };
 304
 305
 306 /*
 307  * A simple wrapper class for administrative bucket operations
 308  */
 309 class RGWBucket {
 310   RGWUserBuckets buckets;
 311   rgw::sal::Driver* driver;
 312   RGWAccessHandle handle;
 313
 314   std::unique_ptr<rgw::sal::Bucket> bucket;
 315   std::unique_ptr<rgw::sal::User> user;
 316
 317   bool failure;
 318
 319   RGWObjVersionTracker ep_objv; // entrypoint object version
 320
 321 public:
 322   RGWBucket() : driver(NULL), handle(NULL), failure(false) {}
 323   int init(rgw::sal::Driver* storage, RGWBucketAdminOpState& op_state, optional_yield y,
 324              const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 325
 326   int check_bad_index_multipart(RGWBucketAdminOpState& op_state,
 327               RGWFormatterFlusher& flusher,
 328               const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 329
 330   int check_object_index(const DoutPrefixProvider *dpp,
 331                          RGWBucketAdminOpState& op_state,
 332                          RGWFormatterFlusher& flusher,
 333                          optional_yield y,
 334                          std::string *err_msg = NULL);
 335
 336   int check_index(const DoutPrefixProvider *dpp,
 337           RGWBucketAdminOpState& op_state,
 338           std::map<RGWObjCategory, RGWStorageStats>& existing_stats,
 339           std::map<RGWObjCategory, RGWStorageStats>& calculated_stats,
 340           std::string *err_msg = NULL);
 341
 342   int chown(RGWBucketAdminOpState& op_state, const std::string& marker,
 343             optional_yield y, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 344   int set_quota(RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 345
 346   int remove_object(const DoutPrefixProvider *dpp, RGWBucketAdminOpState& op_state, std::string *err_msg = NULL);
 347   int policy_bl_to_stream(bufferlist& bl, std::ostream& o);
 348   int get_policy(RGWBucketAdminOpState& op_state, RGWAccessControlPolicy& policy, optional_yield y, const DoutPrefixProvider *dpp);
 349   int sync(RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 350
 351   void clear_failure() { failure = false; }
 352
 353   const RGWBucketInfo& get_bucket_info() const { return bucket->get_info(); }
 354 };
 355
 356 class RGWBucketAdminOp {
 357 public:
 358   static int get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 359                   RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
 360   static int get_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 361                   RGWAccessControlPolicy& policy, const DoutPrefixProvider *dpp);
 362   static int dump_s3_policy(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 363                   std::ostream& os, const DoutPrefixProvider *dpp);
 364
 365   static int unlink(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
 366   static int link(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 367   static int chown(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const std::string& marker, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 368
 369   static int check_index(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 370                   RGWFormatterFlusher& flusher, optional_yield y, const DoutPrefixProvider *dpp);
 371
 372   static int remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, optional_yield y,
 373                            const DoutPrefixProvider *dpp, bool bypass_gc = false, bool keep_index_consistent = true);
 374   static int remove_object(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
 375   static int info(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, RGWFormatterFlusher& flusher, optional_yield y, const DoutPrefixProvider *dpp);
 376   static int limit_check(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 377                          const std::list<std::string>& user_ids,
 378                          RGWFormatterFlusher& flusher, optional_yield y,
 379                          const DoutPrefixProvider *dpp,
 380                          bool warnings_only = false);
 381   static int set_quota(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp);
 382
 383   static int list_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 384                                   RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
 385
 386   static int clear_stale_instances(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 387                                    RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
 388   static int fix_lc_shards(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 389                            RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp);
 390   static int fix_obj_expiry(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state,
 391                             RGWFormatterFlusher& flusher, const DoutPrefixProvider *dpp, bool dry_run = false);
 392
 393   static int sync_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpState& op_state, const DoutPrefixProvider *dpp, std::string *err_msg = NULL);
 394 };
 395
 396 struct rgw_ep_info {
 397   RGWBucketEntryPoint &ep;
 398   std::map<std::string, buffer::list>& attrs;
 399   RGWObjVersionTracker ep_objv;
 400   rgw_ep_info(RGWBucketEntryPoint &ep, std::map<std::string, bufferlist>& attrs)
 401     : ep(ep), attrs(attrs) {}
 402 };
 403
 404 class RGWBucketCtl {
 405   CephContext *cct;
 406
 407   struct Svc {
 408     RGWSI_Zone *zone{nullptr};
 409     RGWSI_Bucket *bucket{nullptr};
 410     RGWSI_Bucket_Sync *bucket_sync{nullptr};
 411     RGWSI_BucketIndex *bi{nullptr};
 412     RGWSI_User* user = nullptr;
 413   } svc;
 414
 415   struct Ctl {
 416     RGWUserCtl *user{nullptr};
 417   } ctl;
 418
 419   RGWBucketMetadataHandler *bm_handler;
 420   RGWBucketInstanceMetadataHandler *bmi_handler;
 421
 422   RGWSI_Bucket_BE_Handler bucket_be_handler; /* bucket backend handler */
 423   RGWSI_BucketInstance_BE_Handler bi_be_handler; /* bucket instance backend handler */
 424
 425   int call(std::function<int(RGWSI_Bucket_X_Ctx& ctx)> f);
 426
 427 public:
 428   RGWBucketCtl(RGWSI_Zone *zone_svc,
 429                RGWSI_Bucket *bucket_svc,
 430                RGWSI_Bucket_Sync *bucket_sync_svc,
 431                RGWSI_BucketIndex *bi_svc,
 432                RGWSI_User* user_svc);
 433
 434   void init(RGWUserCtl *user_ctl,
 435             RGWBucketMetadataHandler *_bm_handler,
 436             RGWBucketInstanceMetadataHandler *_bmi_handler,
 437             RGWDataChangesLog *datalog,
 438             const DoutPrefixProvider *dpp);
 439
 440   struct Bucket {
 441     struct GetParams {
 442       RGWObjVersionTracker *objv_tracker{nullptr};
 443       real_time *mtime{nullptr};
 444       std::map<std::string, bufferlist> *attrs{nullptr};
 445       rgw_cache_entry_info *cache_info{nullptr};
 446       boost::optional<obj_version> refresh_version;
 447       std::optional<RGWSI_MetaBackend_CtxParams> bectx_params;
 448
 449       GetParams() {}
 450
 451       GetParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
 452         objv_tracker = _objv_tracker;
 453         return *this;
 454       }
 455
 456       GetParams& set_mtime(ceph::real_time *_mtime) {
 457         mtime = _mtime;
 458         return *this;
 459       }
 460
 461       GetParams& set_attrs(std::map<std::string, bufferlist> *_attrs) {
 462         attrs = _attrs;
 463         return *this;
 464       }
 465
 466       GetParams& set_cache_info(rgw_cache_entry_info *_cache_info) {
 467         cache_info = _cache_info;
 468         return *this;
 469       }
 470
 471       GetParams& set_refresh_version(const obj_version& _refresh_version) {
 472         refresh_version = _refresh_version;
 473         return *this;
 474       }
 475
 476       GetParams& set_bectx_params(std::optional<RGWSI_MetaBackend_CtxParams> _bectx_params) {
 477         bectx_params = _bectx_params;
 478         return *this;
 479       }
 480     };
 481
 482     struct PutParams {
 483       RGWObjVersionTracker *objv_tracker{nullptr};
 484       ceph::real_time mtime;
 485       bool exclusive{false};
 486       std::map<std::string, bufferlist> *attrs{nullptr};
 487
 488       PutParams() {}
 489
 490       PutParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
 491         objv_tracker = _objv_tracker;
 492         return *this;
 493       }
 494
 495       PutParams& set_mtime(const ceph::real_time& _mtime) {
 496         mtime = _mtime;
 497         return *this;
 498       }
 499
 500       PutParams& set_exclusive(bool _exclusive) {
 501         exclusive = _exclusive;
 502         return *this;
 503       }
 504
 505       PutParams& set_attrs(std::map<std::string, bufferlist> *_attrs) {
 506         attrs = _attrs;
 507         return *this;
 508       }
 509     };
 510
 511     struct RemoveParams {
 512       RGWObjVersionTracker *objv_tracker{nullptr};
 513
 514       RemoveParams() {}
 515
 516       RemoveParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
 517         objv_tracker = _objv_tracker;
 518         return *this;
 519       }
 520     };
 521   };
 522
 523   struct BucketInstance {
 524     struct GetParams {
 525       real_time *mtime{nullptr};
 526       std::map<std::string, bufferlist> *attrs{nullptr};
 527       rgw_cache_entry_info *cache_info{nullptr};
 528       boost::optional<obj_version> refresh_version;
 529       RGWObjVersionTracker *objv_tracker{nullptr};
 530       std::optional<RGWSI_MetaBackend_CtxParams> bectx_params;
 531
 532       GetParams() {}
 533
 534       GetParams& set_mtime(ceph::real_time *_mtime) {
 535         mtime = _mtime;
 536         return *this;
 537       }
 538
 539       GetParams& set_attrs(std::map<std::string, bufferlist> *_attrs) {
 540         attrs = _attrs;
 541         return *this;
 542       }
 543
 544       GetParams& set_cache_info(rgw_cache_entry_info *_cache_info) {
 545         cache_info = _cache_info;
 546         return *this;
 547       }
 548
 549       GetParams& set_refresh_version(const obj_version& _refresh_version) {
 550         refresh_version = _refresh_version;
 551         return *this;
 552       }
 553
 554       GetParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
 555         objv_tracker = _objv_tracker;
 556         return *this;
 557       }
 558
 559       GetParams& set_bectx_params(std::optional<RGWSI_MetaBackend_CtxParams> _bectx_params) {
 560         bectx_params = _bectx_params;
 561         return *this;
 562       }
 563     };
 564
 565     struct PutParams {
 566       std::optional<RGWBucketInfo *> orig_info; /* nullopt: orig_info was not fetched,
 567                                                    nullptr: orig_info was not found (new bucket instance */
 568       ceph::real_time mtime;
 569       bool exclusive{false};
 570       std::map<std::string, bufferlist> *attrs{nullptr};
 571       RGWObjVersionTracker *objv_tracker{nullptr};
 572
 573       PutParams() {}
 574
 575       PutParams& set_orig_info(RGWBucketInfo *pinfo) {
 576         orig_info = pinfo;
 577         return *this;
 578       }
 579
 580       PutParams& set_mtime(const ceph::real_time& _mtime) {
 581         mtime = _mtime;
 582         return *this;
 583       }
 584
 585       PutParams& set_exclusive(bool _exclusive) {
 586         exclusive = _exclusive;
 587         return *this;
 588       }
 589
 590       PutParams& set_attrs(std::map<std::string, bufferlist> *_attrs) {
 591         attrs = _attrs;
 592         return *this;
 593       }
 594
 595       PutParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
 596         objv_tracker = _objv_tracker;
 597         return *this;
 598       }
 599     };
 600
 601     struct RemoveParams {
 602       RGWObjVersionTracker *objv_tracker{nullptr};
 603
 604       RemoveParams() {}
 605
 606       RemoveParams& set_objv_tracker(RGWObjVersionTracker *_objv_tracker) {
 607         objv_tracker = _objv_tracker;
 608         return *this;
 609       }
 610     };
 611   };
 612
 613   /* bucket entrypoint */
 614   int read_bucket_entrypoint_info(const rgw_bucket& bucket,
 615                                   RGWBucketEntryPoint *info,
 616                                   optional_yield y,
 617                                   const DoutPrefixProvider *dpp,
 618                                   const Bucket::GetParams& params = {});
 619   int store_bucket_entrypoint_info(const rgw_bucket& bucket,
 620                                    RGWBucketEntryPoint& info,
 621                                    optional_yield y,
 622                                    const DoutPrefixProvider *dpp,
 623                                    const Bucket::PutParams& params = {});
 624   int remove_bucket_entrypoint_info(const rgw_bucket& bucket,
 625                                     optional_yield y,
 626                                     const DoutPrefixProvider *dpp,
 627                                     const Bucket::RemoveParams& params = {});
 628
 629   /* bucket instance */
 630   int read_bucket_instance_info(const rgw_bucket& bucket,
 631                                   RGWBucketInfo *info,
 632                                   optional_yield y,
 633                                   const DoutPrefixProvider *dpp,
 634                                   const BucketInstance::GetParams& params = {});
 635   int store_bucket_instance_info(const rgw_bucket& bucket,
 636                                  RGWBucketInfo& info,
 637                                  optional_yield y,
 638                                  const DoutPrefixProvider *dpp,
 639                                  const BucketInstance::PutParams& params = {});
 640   int remove_bucket_instance_info(const rgw_bucket& bucket,
 641                                   RGWBucketInfo& info,
 642                                   optional_yield y,
 643                                   const DoutPrefixProvider *dpp,
 644                                   const BucketInstance::RemoveParams& params = {});
 645
 646   /*
 647    * bucket_id may or may not be provided
 648    *
 649    * ep_objv_tracker might not be populated even if provided. Will only be set if entrypoint is read
 650    * (that is: if bucket_id is empty).
 651    */
 652   int read_bucket_info(const rgw_bucket& bucket,
 653                        RGWBucketInfo *info,
 654                        optional_yield y,
 655                        const DoutPrefixProvider *dpp,
 656                        const BucketInstance::GetParams& params = {},
 657                        RGWObjVersionTracker *ep_objv_tracker = nullptr);
 658
 659
 660   int set_bucket_instance_attrs(RGWBucketInfo& bucket_info,
 661                                 std::map<std::string, bufferlist>& attrs,
 662                                 RGWObjVersionTracker *objv_tracker,
 663                                 optional_yield y,
 664                                 const DoutPrefixProvider *dpp);
 665
 666   /* user/bucket */
 667   int link_bucket(const rgw_user& user_id,
 668                   const rgw_bucket& bucket,
 669                   ceph::real_time creation_time,
 670                   optional_yield y,
 671                   const DoutPrefixProvider *dpp,
 672                   bool update_entrypoint = true,
 673                   rgw_ep_info *pinfo = nullptr);
 674
 675   int unlink_bucket(const rgw_user& user_id,
 676                     const rgw_bucket& bucket,
 677                     optional_yield y,
 678                     const DoutPrefixProvider *dpp,
 679                     bool update_entrypoint = true);
 680
 681   int read_buckets_stats(std::map<std::string, RGWBucketEnt>& m,
 682                          optional_yield y,
 683                          const DoutPrefixProvider *dpp);
 684
 685   int read_bucket_stats(const rgw_bucket& bucket,
 686                         RGWBucketEnt *result,
 687                         optional_yield y,
 688                         const DoutPrefixProvider *dpp);
 689
 690   /* quota related */
 691   int sync_user_stats(const DoutPrefixProvider *dpp,
 692                       const rgw_user& user_id, const RGWBucketInfo& bucket_info,
 693                       optional_yield y,
 694                       RGWBucketEnt* pent);
 695
 696   /* bucket sync */
 697   int get_sync_policy_handler(std::optional<rgw_zone_id> zone,
 698                               std::optional<rgw_bucket> bucket,
 699                               RGWBucketSyncPolicyHandlerRef *phandler,
 700                               optional_yield y,
 701                               const DoutPrefixProvider *dpp);
 702   int bucket_exports_data(const rgw_bucket& bucket,
 703                           optional_yield y,
 704                           const DoutPrefixProvider *dpp);
 705   int bucket_imports_data(const rgw_bucket& bucket,
 706                           optional_yield y,
 707                           const DoutPrefixProvider *dpp);
 708
 709 private:
 710   int convert_old_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
 711                               const rgw_bucket& bucket,
 712                               optional_yield y,
 713                               const DoutPrefixProvider *dpp);
 714
 715   int do_store_bucket_instance_info(RGWSI_Bucket_BI_Ctx& ctx,
 716                                     const rgw_bucket& bucket,
 717                                     RGWBucketInfo& info,
 718                                     optional_yield y,
 719                                     const DoutPrefixProvider *dpp,
 720                                     const BucketInstance::PutParams& params);
 721
 722   int do_store_linked_bucket_info(RGWSI_Bucket_X_Ctx& ctx,
 723                                   RGWBucketInfo& info,
 724                                   RGWBucketInfo *orig_info,
 725                                   bool exclusive, real_time mtime,
 726                                   obj_version *pep_objv,
 727                                   std::map<std::string, bufferlist> *pattrs,
 728                                   bool create_entry_point,
 729                                   optional_yield,
 730                                   const DoutPrefixProvider *dpp);
 731
 732   int do_link_bucket(RGWSI_Bucket_EP_Ctx& ctx,
 733                      const rgw_user& user,
 734                      const rgw_bucket& bucket,
 735                      ceph::real_time creation_time,
 736                      bool update_entrypoint,
 737                      rgw_ep_info *pinfo,
 738                      optional_yield y,
 739                      const DoutPrefixProvider *dpp);
 740
 741   int do_unlink_bucket(RGWSI_Bucket_EP_Ctx& ctx,
 742                        const rgw_user& user_id,
 743                        const rgw_bucket& bucket,
 744                        bool update_entrypoint,
 745                        optional_yield y,
 746                        const DoutPrefixProvider *dpp);
 747
 748 };
 749
 750 bool rgw_find_bucket_by_id(const DoutPrefixProvider *dpp, CephContext *cct, rgw::sal::Driver* driver, const std::string& marker,
 751                            const std::string& bucket_id, rgw_bucket* bucket_out);