rgw/sal: rename Bucket::remove_bucket() to remove()

cbodley · cbodley · commit 0ead6ff010b1 · 2023-11-07T12:18:18.000-05:00
Signed-off-by: Casey Bodley &lt;cbodley@redhat.com&gt;
diff --git a/src/rgw/driver/daos/rgw_sal_daos.cc b/src/rgw/driver/daos/rgw_sal_daos.cc
@@ -404,19 +404,19 @@ std::unique_ptr<struct ds3_bucket_info> DaosBucket::get_encoded_info(
   return bucket_info;
 }
 
-int DaosBucket::remove_bucket(const DoutPrefixProvider* dpp,
-                              bool delete_children, optional_yield y) {
+int DaosBucket::remove(const DoutPrefixProvider* dpp,
+                       bool delete_children, optional_yield y) {
   ldpp_dout(dpp, 20) << "DEBUG: remove_bucket, delete_children="
                      << delete_children << dendl;
 
   return ds3_bucket_destroy(get_name().c_str(), delete_children, store->ds3,
                             nullptr);
 }
 
-int DaosBucket::remove_bucket_bypass_gc(int concurrent_max,
-                                        bool keep_index_consistent,
-                                        optional_yield y,
-                                        const DoutPrefixProvider* dpp) {
+int DaosBucket::remove_bypass_gc(int concurrent_max,
+                                 bool keep_index_consistent,
+                                 optional_yield y,
+                                 const DoutPrefixProvider* dpp) {
   ldpp_dout(dpp, 20) << "DEBUG: remove_bucket_bypass_gc, concurrent_max="
                     
                      << concurrent_max
diff --git a/src/rgw/driver/daos/rgw_sal_daos.h b/src/rgw/driver/daos/rgw_sal_daos.h
@@ -289,12 +289,12 @@ class DaosBucket : public StoreBucket {
   virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
   virtual int list(const DoutPrefixProvider* dpp, ListParams&, int,
                    ListResults&, optional_yield y) override;
-  virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children,
-                            optional_yield y) override;
-  virtual int remove_bucket_bypass_gc(int concurrent_max,
-                                      bool keep_index_consistent,
-                                      optional_yield y,
-                                      const DoutPrefixProvider* dpp) override;
+  virtual int remove(const DoutPrefixProvider* dpp, bool delete_children,
+                     optional_yield y) override;
+  virtual int remove_bypass_gc(int concurrent_max,
+                               bool keep_index_consistent,
+                               optional_yield y,
+                               const DoutPrefixProvider* dpp) override;
   virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
   virtual int set_acl(const DoutPrefixProvider* dpp,
                       RGWAccessControlPolicy& acl, optional_yield y) override;
diff --git a/src/rgw/driver/motr/rgw_sal_motr.cc b/src/rgw/driver/motr/rgw_sal_motr.cc
@@ -539,7 +539,7 @@ int MotrUser::verify_mfa(const std::string& mfa_str, bool* verified, const DoutP
   return 0;
 }
 
-int MotrBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y)
+int MotrBucket::remove(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y)
 {
   int ret;
 
@@ -669,7 +669,7 @@ int MotrBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_childre
   return ret;
 }
 
-int MotrBucket::remove_bucket_bypass_gc(int concurrent_max, bool
+int MotrBucket::remove_bypass_gc(int concurrent_max, bool
         keep_index_consistent,
         optional_yield y, const
         DoutPrefixProvider *dpp) {
diff --git a/src/rgw/driver/motr/rgw_sal_motr.h b/src/rgw/driver/motr/rgw_sal_motr.h
@@ -352,8 +352,8 @@ class MotrBucket : public StoreBucket {
 
     virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
     virtual int list(const DoutPrefixProvider *dpp, ListParams&, int, ListResults&, optional_yield y) override;
-    virtual int remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y) override;
-    virtual int remove_bucket_bypass_gc(int concurrent_max, bool
+    virtual int remove(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y) override;
+    virtual int remove_bypass_gc(int concurrent_max, bool
         keep_index_consistent,
         optional_yield y, const
         DoutPrefixProvider *dpp) override;
diff --git a/src/rgw/driver/posix/rgw_sal_posix.cc b/src/rgw/driver/posix/rgw_sal_posix.cc
@@ -851,20 +851,20 @@ int POSIXBucket::merge_and_store_attrs(const DoutPrefixProvider* dpp,
   return write_attrs(dpp, y);
 }
 
-int POSIXBucket::remove_bucket(const DoutPrefixProvider* dpp,
-				bool delete_children,
-				optional_yield y)
+int POSIXBucket::remove(const DoutPrefixProvider* dpp,
+			bool delete_children,
+			optional_yield y)
 {
   return delete_directory(parent_fd, get_fname().c_str(),
 			  delete_children, dpp);
 }
 
-int POSIXBucket::remove_bucket_bypass_gc(int concurrent_max,
-					 bool keep_index_consistent,
-					 optional_yield y,
-					 const DoutPrefixProvider *dpp)
+int POSIXBucket::remove_bypass_gc(int concurrent_max,
+				  bool keep_index_consistent,
+				  optional_yield y,
+				  const DoutPrefixProvider *dpp)
 {
-  return remove_bucket(dpp, true, y);
+  return remove(dpp, true, y);
 }
 
 int POSIXBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y)
@@ -1448,7 +1448,7 @@ int POSIXObject::delete_object(const DoutPrefixProvider* dpp,
 
   if (!b->versioned()) {
     if (shadow) {
-      ret = shadow->remove_bucket(dpp, true, y);
+      ret = shadow->remove(dpp, true, y);
       if (ret < 0) {
 	return ret;
       }
@@ -2587,7 +2587,7 @@ int POSIXMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct,
     return ret;
   }
 
-  shadow->remove_bucket(dpp, true, y);
+  shadow->remove(dpp, true, y);
 
   return 0;
 }
diff --git a/src/rgw/driver/posix/rgw_sal_posix.h b/src/rgw/driver/posix/rgw_sal_posix.h
@@ -175,12 +175,12 @@ class POSIXBucket : public StoreBucket {
 		   ListResults&, optional_yield y) override;
   virtual int merge_and_store_attrs(const DoutPrefixProvider* dpp,
 				    Attrs& new_attrs, optional_yield y) override;
-  virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children,
-			    optional_yield y) override;
-  virtual int remove_bucket_bypass_gc(int concurrent_max,
-				      bool keep_index_consistent,
-				      optional_yield y,
-				      const DoutPrefixProvider *dpp) override;
+  virtual int remove(const DoutPrefixProvider* dpp, bool delete_children,
+		     optional_yield y) override;
+  virtual int remove_bypass_gc(int concurrent_max,
+			       bool keep_index_consistent,
+			       optional_yield y,
+			       const DoutPrefixProvider *dpp) override;
   virtual int create(const DoutPrefixProvider* dpp,
 		     const CreateParams& params,
 		     optional_yield y) override;
diff --git a/src/rgw/driver/rados/rgw_bucket.cc b/src/rgw/driver/rados/rgw_bucket.cc
@@ -1253,9 +1253,9 @@ int RGWBucketAdminOp::remove_bucket(rgw::sal::Driver* driver, RGWBucketAdminOpSt
     return ret;
 
   if (bypass_gc)
-    ret = bucket->remove_bucket_bypass_gc(op_state.get_max_aio(), keep_index_consistent, y, dpp);
+    ret = bucket->remove_bypass_gc(op_state.get_max_aio(), keep_index_consistent, y, dpp);
   else
-    ret = bucket->remove_bucket(dpp, op_state.will_delete_children(), y);
+    ret = bucket->remove(dpp, op_state.will_delete_children(), y);
 
   return ret;
 }
diff --git a/src/rgw/driver/rados/rgw_rest_bucket.cc b/src/rgw/driver/rados/rgw_rest_bucket.cc
@@ -243,7 +243,7 @@ void RGWOp_Bucket_Remove::execute(optional_yield y)
     return;
   }
 
-  op_ret = bucket->remove_bucket(s, delete_children, s->yield);
+  op_ret = bucket->remove(s, delete_children, s->yield);
 }
 
 class RGWOp_Set_Bucket_Quota : public RGWRESTOp {
diff --git a/src/rgw/driver/rados/rgw_sal_rados.cc b/src/rgw/driver/rados/rgw_sal_rados.cc
@@ -271,9 +271,9 @@ int RadosUser::verify_mfa(const std::string& mfa_str, bool* verified,
 
 RadosBucket::~RadosBucket() {}
 
-int RadosBucket::remove_bucket(const DoutPrefixProvider* dpp,
-			       bool delete_children,
-			       optional_yield y)
+int RadosBucket::remove(const DoutPrefixProvider* dpp,
+			bool delete_children,
+			optional_yield y)
 {
   int ret;
 
@@ -358,10 +358,10 @@ int RadosBucket::remove_bucket(const DoutPrefixProvider* dpp,
   return ret;
 }
 
-int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool
-					 keep_index_consistent,
-					 optional_yield y, const
-					 DoutPrefixProvider *dpp)
+int RadosBucket::remove_bypass_gc(int concurrent_max, bool
+				  keep_index_consistent,
+				  optional_yield y, const
+				  DoutPrefixProvider *dpp)
 {
   int ret;
   map<RGWObjCategory, RGWStorageStats> stats;
@@ -485,7 +485,7 @@ int RadosBucket::remove_bucket_bypass_gc(int concurrent_max, bool
   // this function can only be run if caller wanted children to be
   // deleted, so we can ignore the check for children as any that
   // remain are detritus from a prior bug
-  ret = remove_bucket(dpp, true, y);
+  ret = remove(dpp, true, y);
   if (ret < 0) {
     ldpp_dout(dpp, -1) << "ERROR: could not remove bucket " << this << dendl;
     return ret;
diff --git a/src/rgw/driver/rados/rgw_sal_rados.h b/src/rgw/driver/rados/rgw_sal_rados.h
@@ -512,11 +512,11 @@ class RadosBucket : public StoreBucket {
     virtual ~RadosBucket();
     virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
     virtual int list(const DoutPrefixProvider* dpp, ListParams&, int, ListResults&, optional_yield y) override;
-    virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children, optional_yield y) override;
-    virtual int remove_bucket_bypass_gc(int concurrent_max, bool
-					keep_index_consistent,
-					optional_yield y, const
-					DoutPrefixProvider *dpp) override;
+    virtual int remove(const DoutPrefixProvider* dpp, bool delete_children, optional_yield y) override;
+    virtual int remove_bypass_gc(int concurrent_max, bool
+				 keep_index_consistent,
+				 optional_yield y, const
+				 DoutPrefixProvider *dpp) override;
     virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
     virtual int set_acl(const DoutPrefixProvider* dpp, RGWAccessControlPolicy& acl, optional_yield y) override;
     int create(const DoutPrefixProvider* dpp, const CreateParams& params,
diff --git a/src/rgw/driver/rados/rgw_user.cc b/src/rgw/driver/rados/rgw_user.cc
@@ -1791,7 +1791,7 @@ int RGWUser::execute_remove(const DoutPrefixProvider *dpp, RGWUserAdminOpState&
         return ret;
       }
 
-      ret = bucket->remove_bucket(dpp, true, y);
+      ret = bucket->remove(dpp, true, y);
       if (ret < 0) {
         set_err_msg(err_msg, "unable to delete user data");
         return ret;
diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
@@ -3730,7 +3730,7 @@ void RGWDeleteBucket::execute(optional_yield y)
       // do nothing; it will already have been logged
   }
 
-  op_ret = s->bucket->remove_bucket(this, false, y);
+  op_ret = s->bucket->remove(this, false, y);
   if (op_ret < 0 && op_ret == -ECANCELED) {
       // lost a race, either with mdlog sync or another delete bucket operation.
       // in either case, we've already called ctl.bucket->unlink_bucket()
@@ -7478,7 +7478,7 @@ bool RGWBulkDelete::Deleter::delete_single(const acct_path_t& path, optional_yie
         goto delop_fail;
       }
     }
-    ret = bucket->remove_bucket(dpp, false, s->yield);
+    ret = bucket->remove(dpp, false, s->yield);
     if (ret < 0) {
       goto delop_fail;
     }
diff --git a/src/rgw/rgw_sal.h b/src/rgw/rgw_sal.h
@@ -636,12 +636,12 @@ class Bucket {
     /** Set the cached attributes on this bucket */
     virtual int set_attrs(Attrs a) = 0;
     /** Remove this bucket from the backing store */
-    virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children, optional_yield y) = 0;
+    virtual int remove(const DoutPrefixProvider* dpp, bool delete_children, optional_yield y) = 0;
     /** Remove this bucket, bypassing garbage collection.  May be removed */
-    virtual int remove_bucket_bypass_gc(int concurrent_max, bool
-					keep_index_consistent,
-					optional_yield y, const
-					DoutPrefixProvider *dpp) = 0;
+    virtual int remove_bypass_gc(int concurrent_max, bool
+				 keep_index_consistent,
+				 optional_yield y, const
+				 DoutPrefixProvider *dpp) = 0;
     /** Get then ACL for this bucket */
     virtual RGWAccessControlPolicy& get_acl(void) = 0;
     /** Set the ACL for this bucket */
diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc
@@ -155,7 +155,7 @@ namespace rgw::sal {
     return 0;
   }
 
-  int DBBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y)
+  int DBBucket::remove(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y)
   {
     int ret;
 
@@ -196,10 +196,10 @@ namespace rgw::sal {
     return ret;
   }
 
-  int DBBucket::remove_bucket_bypass_gc(int concurrent_max, bool
-					keep_index_consistent,
-					optional_yield y, const
-					DoutPrefixProvider *dpp) {
+  int DBBucket::remove_bypass_gc(int concurrent_max, bool
+				 keep_index_consistent,
+				 optional_yield y, const
+				 DoutPrefixProvider *dpp) {
     return 0;
   }
 
diff --git a/src/rgw/rgw_sal_dbstore.h b/src/rgw/rgw_sal_dbstore.h
@@ -155,11 +155,11 @@ class DBNotification : public StoreNotification {
 
       virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
       virtual int list(const DoutPrefixProvider *dpp, ListParams&, int, ListResults&, optional_yield y) override;
-      virtual int remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y) override;
-      virtual int remove_bucket_bypass_gc(int concurrent_max, bool
-					keep_index_consistent,
-					optional_yield y, const
-					DoutPrefixProvider *dpp) override;
+      virtual int remove(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y) override;
+      virtual int remove_bypass_gc(int concurrent_max, bool
+				   keep_index_consistent,
+				   optional_yield y, const
+				   DoutPrefixProvider *dpp) override;
       virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
       virtual int set_acl(const DoutPrefixProvider *dpp, RGWAccessControlPolicy& acl, optional_yield y) override;
       int create(const DoutPrefixProvider* dpp,
diff --git a/src/rgw/rgw_sal_filter.cc b/src/rgw/rgw_sal_filter.cc
@@ -566,19 +566,19 @@ int FilterBucket::list(const DoutPrefixProvider* dpp, ListParams& params, int ma
   return next->list(dpp, params, max, results, y);
 }
 
-int FilterBucket::remove_bucket(const DoutPrefixProvider* dpp,
-				bool delete_children,
-				optional_yield y)
+int FilterBucket::remove(const DoutPrefixProvider* dpp,
+			 bool delete_children,
+			 optional_yield y)
 {
-  return next->remove_bucket(dpp, delete_children, y);
+  return next->remove(dpp, delete_children, y);
 }
 
-int FilterBucket::remove_bucket_bypass_gc(int concurrent_max,
-					  bool keep_index_consistent,
-					  optional_yield y,
-					  const DoutPrefixProvider *dpp)
+int FilterBucket::remove_bypass_gc(int concurrent_max,
+				   bool keep_index_consistent,
+				   optional_yield y,
+				   const DoutPrefixProvider *dpp)
 {
-  return next->remove_bucket_bypass_gc(concurrent_max, keep_index_consistent, y, dpp);
+  return next->remove_bypass_gc(concurrent_max, keep_index_consistent, y, dpp);
 }
 
 int FilterBucket::set_acl(const DoutPrefixProvider* dpp,
diff --git a/src/rgw/rgw_sal_filter.h b/src/rgw/rgw_sal_filter.h
@@ -379,12 +379,12 @@ class FilterBucket : public Bucket {
 		   ListResults&, optional_yield y) override;
   virtual Attrs& get_attrs(void) override { return next->get_attrs(); }
   virtual int set_attrs(Attrs a) override { return next->set_attrs(a); }
-  virtual int remove_bucket(const DoutPrefixProvider* dpp, bool delete_children,
-			    optional_yield y) override;
-  virtual int remove_bucket_bypass_gc(int concurrent_max, bool
-				      keep_index_consistent,
-				      optional_yield y, const
-				      DoutPrefixProvider *dpp) override;
+  virtual int remove(const DoutPrefixProvider* dpp, bool delete_children,
+		     optional_yield y) override;
+  virtual int remove_bypass_gc(int concurrent_max, bool
+			       keep_index_consistent,
+			       optional_yield y, const
+			       DoutPrefixProvider *dpp) override;
   virtual RGWAccessControlPolicy& get_acl(void) override { return next->get_acl(); }
   virtual int set_acl(const DoutPrefixProvider* dpp, RGWAccessControlPolicy& acl,
 		      optional_yield y) override;

Original file line number	Diff line number	Diff line change
`@@ -539,7 +539,7 @@ int MotrUser::verify_mfa(const std::string& mfa_str, bool* verified, const DoutP`
`539`	`539`	`return 0;`
`540`	`540`	`}`
`541`	`541`
`542`		`-int MotrBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y)`
	`542`	`+int MotrBucket::remove(const DoutPrefixProvider *dpp, bool delete_children, optional_yield y)`
`543`	`543`	`{`
`544`	`544`	`int ret;`
`545`	`545`
`@@ -669,7 +669,7 @@ int MotrBucket::remove_bucket(const DoutPrefixProvider *dpp, bool delete_childre`
`669`	`669`	`return ret;`
`670`	`670`	`}`
`671`	`671`
`672`		`-int MotrBucket::remove_bucket_bypass_gc(int concurrent_max, bool`
	`672`	`+int MotrBucket::remove_bypass_gc(int concurrent_max, bool`
`673`	`673`	`keep_index_consistent,`
`674`	`674`	`optional_yield y, const`
`675`	`675`	`DoutPrefixProvider *dpp) {`
Original file line number	Diff line number	Diff line change
`@@ -851,20 +851,20 @@ int POSIXBucket::merge_and_store_attrs(const DoutPrefixProvider* dpp,`
`851`	`851`	`return write_attrs(dpp, y);`
`852`	`852`	`}`
`853`	`853`
`854`		`-int POSIXBucket::remove_bucket(const DoutPrefixProvider* dpp,`
`855`		`- bool delete_children,`
`856`		`- optional_yield y)`
	`854`	`+int POSIXBucket::remove(const DoutPrefixProvider* dpp,`
	`855`	`+ bool delete_children,`
	`856`	`+ optional_yield y)`
`857`	`857`	`{`
`858`	`858`	`return delete_directory(parent_fd, get_fname().c_str(),`
`859`	`859`	`delete_children, dpp);`
`860`	`860`	`}`
`861`	`861`
`862`		`-int POSIXBucket::remove_bucket_bypass_gc(int concurrent_max,`
`863`		`- bool keep_index_consistent,`
`864`		`- optional_yield y,`
`865`		`- const DoutPrefixProvider *dpp)`
	`862`	`+int POSIXBucket::remove_bypass_gc(int concurrent_max,`
	`863`	`+ bool keep_index_consistent,`
	`864`	`+ optional_yield y,`
	`865`	`+ const DoutPrefixProvider *dpp)`
`866`	`866`	`{`
`867`		`- return remove_bucket(dpp, true, y);`
	`867`	`+ return remove(dpp, true, y);`
`868`	`868`	`}`
`869`	`869`
`870`	`870`	`int POSIXBucket::load_bucket(const DoutPrefixProvider* dpp, optional_yield y)`
`@@ -1448,7 +1448,7 @@ int POSIXObject::delete_object(const DoutPrefixProvider* dpp,`
`1448`	`1448`
`1449`	`1449`	`if (!b->versioned()) {`
`1450`	`1450`	`if (shadow) {`
`1451`		`- ret = shadow->remove_bucket(dpp, true, y);`
	`1451`	`+ ret = shadow->remove(dpp, true, y);`
`1452`	`1452`	`if (ret < 0) {`
`1453`	`1453`	`return ret;`
`1454`	`1454`	`}`
`@@ -2587,7 +2587,7 @@ int POSIXMultipartUpload::abort(const DoutPrefixProvider dpp, CephContext cct,`
`2587`	`2587`	`return ret;`
`2588`	`2588`	`}`
`2589`	`2589`
`2590`		`- shadow->remove_bucket(dpp, true, y);`
	`2590`	`+ shadow->remove(dpp, true, y);`
`2591`	`2591`
`2592`	`2592`	`return 0;`
`2593`	`2593`	`}`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ void RGWOp_Bucket_Remove::execute(optional_yield y)`
`243`	`243`	`return;`
`244`	`244`	`}`
`245`	`245`
`246`		`- op_ret = bucket->remove_bucket(s, delete_children, s->yield);`
	`246`	`+ op_ret = bucket->remove(s, delete_children, s->yield);`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`class RGWOp_Set_Bucket_Quota : public RGWRESTOp {`