cls/rgw: remove unused CLSRGWConcurrentIO and subclasses

Signed-off-by: Casey Bodley <[email protected]>

Author: cbodley

src/cls/rgw/cls_rgw_client.cc

@@ -21,67 +21,6 @@ using namespace librados;
 const string BucketIndexShardsManager::KEY_VALUE_SEPARATOR = "#";
 const string BucketIndexShardsManager::SHARDS_SEPARATOR = ",";
 
-
-int CLSRGWConcurrentIO::operator()() {
-  int ret = 0;
-  iter = objs_container.begin();
-  for (; iter != objs_container.end() && max_aio-- > 0; ++iter) {
-    ret = issue_op(iter->first, iter->second);
-    if (ret < 0)
-      break;
-  }
-
-  int num_completions = 0, r = 0;
-  std::map<int, std::string> completed_objs;
-  std::map<int, std::string> retry_objs;
-  while (manager.wait_for_completions(valid_ret_code(), &num_completions, &r,
-				      need_multiple_rounds() ? &completed_objs : nullptr,
-				      !need_multiple_rounds() ? &retry_objs : nullptr)) {
-    if (r >= 0 && ret >= 0) {
-      for (; num_completions && iter != objs_container.end(); --num_completions, ++iter) {
-	int issue_ret = issue_op(iter->first, iter->second);
-	if (issue_ret < 0) {
-	  ret = issue_ret;
-	  break;
-	}
-      }
-    } else if (ret >= 0) {
-      ret = r;
-    }
-
-    // if we're at the end with this round, see if another round is needed
-    if (iter == objs_container.end()) {
-      if (need_multiple_rounds() && !completed_objs.empty()) {
-	// For those objects which need another round, use them to reset
-	// the container
-	reset_container(completed_objs);
-	iter = objs_container.begin();
-      } else if (! need_multiple_rounds() && !retry_objs.empty()) {
-	reset_container(retry_objs);
-	iter = objs_container.begin();
-      }
-
-      // re-issue ops if container was reset above (i.e., iter !=
-      // objs_container.end()); if it was not reset above (i.e., iter
-      // == objs_container.end()) the loop will exit immediately
-      // without iterating
-      for (; num_completions && iter != objs_container.end(); --num_completions, ++iter) {
-	int issue_ret = issue_op(iter->first, iter->second);
-	if (issue_ret < 0) {
-	  ret = issue_ret;
-	  break;
-	}
-      }
-    }
-  }
-
-  if (ret < 0) {
-    cleanup();
-  }
-  return ret;
-} // CLSRGWConcurrentIO::operator()()
-
-
 /**
  * This class represents the bucket index object operation callback context.
  */
@@ -192,44 +131,12 @@ void cls_rgw_bucket_init_index(ObjectWriteOperation& o)
   o.exec(RGW_CLASS, RGW_BUCKET_INIT_INDEX, in);
 }
 
-static bool issue_bucket_index_init_op(librados::IoCtx& io_ctx,
-				       const int shard_id,
-				       const string& oid,
-				       BucketIndexAioManager *manager) {
-  bufferlist in;
-  librados::ObjectWriteOperation op;
-  op.create(true);
-  cls_rgw_bucket_init_index(op);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
 void cls_rgw_bucket_init_index2(ObjectWriteOperation& o)
 {
   bufferlist in;
   o.exec(RGW_CLASS, RGW_BUCKET_INIT_INDEX2, in);
 }
 
-static bool issue_bucket_index_init_op2(librados::IoCtx& io_ctx,
-				       const int shard_id,
-				       const string& oid,
-				       BucketIndexAioManager *manager) {
-  bufferlist in;
-  librados::ObjectWriteOperation op;
-  op.create(true);
-  cls_rgw_bucket_init_index2(op);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-static bool issue_bucket_index_clean_op(librados::IoCtx& io_ctx,
-					const int shard_id,
-					const string& oid,
-					BucketIndexAioManager *manager) {
-  bufferlist in;
-  librados::ObjectWriteOperation op;
-  op.remove();
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
 void cls_rgw_bucket_set_tag_timeout(librados::ObjectWriteOperation& op,
                                     uint64_t timeout)
 {
@@ -239,52 +146,6 @@ void cls_rgw_bucket_set_tag_timeout(librados::ObjectWriteOperation& op,
   op.exec(RGW_CLASS, RGW_BUCKET_SET_TAG_TIMEOUT, in);
 }
 
-static bool issue_bucket_set_tag_timeout_op(librados::IoCtx& io_ctx,
-					    const int shard_id,
-					    const string& oid,
-					    uint64_t timeout,
-					    BucketIndexAioManager *manager) {
-  ObjectWriteOperation op;
-  cls_rgw_bucket_set_tag_timeout(op, timeout);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBucketIndexInit::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bucket_index_init_op(io_ctx, shard_id, oid, &manager);
-}
-
-int CLSRGWIssueBucketIndexInit2::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bucket_index_init_op2(io_ctx, shard_id, oid, &manager);
-}
-
-void CLSRGWIssueBucketIndexInit::cleanup()
-{
-  // Do best effort removal
-  for (auto citer = objs_container.begin(); citer != iter; ++citer) {
-    io_ctx.remove(citer->second);
-  }
-}
-
-void CLSRGWIssueBucketIndexInit2::cleanup()
-{
-  // Do best effort removal
-  for (auto citer = objs_container.begin(); citer != iter; ++citer) {
-    io_ctx.remove(citer->second);
-  }
-}
-
-int CLSRGWIssueBucketIndexClean::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bucket_index_clean_op(io_ctx, shard_id, oid, &manager);
-}
-
-int CLSRGWIssueSetTagTimeout::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bucket_set_tag_timeout_op(io_ctx, shard_id, oid, tag_timeout, &manager);
-}
-
 void cls_rgw_bucket_update_stats(librados::ObjectWriteOperation& o,
 				 bool absolute,
                                  const map<RGWObjCategory, rgw_bucket_category_stats>& stats,
@@ -363,54 +224,6 @@ void cls_rgw_bucket_list_op(librados::ObjectReadOperation& op,
 	  new ClsBucketIndexOpCtx<rgw_cls_list_ret>(result, NULL));
 }
 
-static bool issue_bucket_list_op(librados::IoCtx& io_ctx,
-				 const int shard_id,
-				 const std::string& oid,
-				 const cls_rgw_obj_key& start_obj,
-				 const std::string& filter_prefix,
-				 const std::string& delimiter,
-				 uint32_t num_entries,
-				 bool list_versions,
-				 BucketIndexAioManager *manager,
-				 rgw_cls_list_ret *pdata)
-{
-  librados::ObjectReadOperation op;
-  cls_rgw_bucket_list_op(op,
-			 start_obj, filter_prefix, delimiter,
-                         num_entries, list_versions, pdata);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBucketList::issue_op(const int shard_id, const string& oid)
-{
-  // set the marker depending on whether we've already queried this
-  // shard and gotten a RGWBIAdvanceAndRetryError (defined
-  // constant) return value; if we have use the marker in the return
-  // to advance the search, otherwise use the marker passed in by the
-  // caller
-  cls_rgw_obj_key marker;
-  auto iter = result.find(shard_id);
-  if (iter != result.end()) {
-    marker = iter->second.marker;
-  } else {
-    marker = start_obj;
-  }
-
-  return issue_bucket_list_op(io_ctx, shard_id, oid,
-			      marker, filter_prefix, delimiter,
-			      num_entries, list_versions, &manager,
-			      &result[shard_id]);
-}
-
-
-void CLSRGWIssueBucketList::reset_container(std::map<int, std::string>& objs)
-{
-  objs_container.swap(objs);
-  iter = objs_container.begin();
-  objs.clear();
-}
-
-
 void cls_rgw_remove_obj(librados::ObjectWriteOperation& o, list<string>& keep_attr_prefixes)
 {
   bufferlist in;
@@ -687,21 +500,6 @@ void cls_rgw_bilog_list(librados::ObjectReadOperation& op,
   op.exec(RGW_CLASS, RGW_BI_LOG_LIST, in, new ClsBucketIndexOpCtx<cls_rgw_bi_log_list_ret>(pdata, ret));
 }
 
-static bool issue_bi_log_list_op(librados::IoCtx& io_ctx, const string& oid, const int shard_id,
-                                 BucketIndexShardsManager& marker_mgr, uint32_t max,
-                                 BucketIndexAioManager *manager,
-                                 cls_rgw_bi_log_list_ret *pdata)
-{
-  librados::ObjectReadOperation op;
-  cls_rgw_bilog_list(op, marker_mgr.get(shard_id, ""), max, pdata, nullptr);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBILogList::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bi_log_list_op(io_ctx, oid, shard_id, marker_mgr, max, &manager, &result[shard_id]);
-}
-
 void cls_rgw_bilog_trim(librados::ObjectWriteOperation& op,
                         const std::string& start_marker,
                         const std::string& end_marker)
@@ -715,39 +513,12 @@ void cls_rgw_bilog_trim(librados::ObjectWriteOperation& op,
   op.exec(RGW_CLASS, RGW_BI_LOG_TRIM, in);
 }
 
-static bool issue_bi_log_trim(librados::IoCtx& io_ctx, const string& oid, const int shard_id,
-                              BucketIndexShardsManager& start_marker_mgr,
-                              BucketIndexShardsManager& end_marker_mgr, BucketIndexAioManager *manager) {
-  cls_rgw_bi_log_trim_op call;
-  librados::ObjectWriteOperation op;
-  cls_rgw_bilog_trim(op, start_marker_mgr.get(shard_id, ""),
-                     end_marker_mgr.get(shard_id, ""));
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBILogTrim::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bi_log_trim(io_ctx, oid, shard_id, start_marker_mgr, end_marker_mgr, &manager);
-}
-
 void cls_rgw_bucket_reshard_log_trim(librados::ObjectWriteOperation& op)
 {
   bufferlist in;
   op.exec(RGW_CLASS, RGW_RESHARD_LOG_TRIM, in);
 }
 
-static bool issue_reshard_log_trim(librados::IoCtx& io_ctx, const string& oid, int shard_id,
-                                   BucketIndexAioManager *manager) {
-  ObjectWriteOperation op;
-  cls_rgw_bucket_reshard_log_trim(op);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueReshardLogTrim::issue_op(int shard_id, const string& oid)
-{
-  return issue_reshard_log_trim(io_ctx, oid, shard_id, &manager);
-}
-
 void cls_rgw_bucket_check_index(librados::ObjectReadOperation& op,
                                 bufferlist& out)
 {
@@ -762,38 +533,12 @@ void cls_rgw_bucket_check_index_decode(const bufferlist& out,
   decode(result, p);
 }
 
-static bool issue_bucket_check_index_op(IoCtx& io_ctx, const int shard_id, const string& oid, BucketIndexAioManager *manager,
-    rgw_cls_check_index_ret *pdata) {
-  bufferlist in;
-  librados::ObjectReadOperation op;
-  op.exec(RGW_CLASS, RGW_BUCKET_CHECK_INDEX, in, new ClsBucketIndexOpCtx<rgw_cls_check_index_ret>(
-        pdata, NULL));
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBucketCheck::issue_op(int shard_id, const string& oid)
-{
-  return issue_bucket_check_index_op(io_ctx, shard_id, oid, &manager, &result[shard_id]);
-}
-
 void cls_rgw_bucket_rebuild_index(librados::ObjectWriteOperation& op)
 {
   bufferlist in;
   op.exec(RGW_CLASS, RGW_BUCKET_REBUILD_INDEX, in);
 }
 
-static bool issue_bucket_rebuild_index_op(IoCtx& io_ctx, const int shard_id, const string& oid,
-    BucketIndexAioManager *manager) {
-  librados::ObjectWriteOperation op;
-  cls_rgw_bucket_rebuild_index(op);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBucketRebuild::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bucket_rebuild_index_op(io_ctx, shard_id, oid, &manager);
-}
-
 void cls_rgw_encode_suggestion(char op, rgw_bucket_dir_entry& dirent, bufferlist& updates)
 {
   updates.append(op);
@@ -805,52 +550,18 @@ void cls_rgw_suggest_changes(ObjectWriteOperation& o, bufferlist& updates)
   o.exec(RGW_CLASS, RGW_DIR_SUGGEST_CHANGES, updates);
 }
 
-int CLSRGWIssueGetDirHeader::issue_op(const int shard_id, const string& oid)
-{
-  cls_rgw_obj_key empty_key;
-  string empty_prefix;
-  string empty_delimiter;
-  return issue_bucket_list_op(io_ctx, shard_id, oid,
-			      empty_key, empty_prefix, empty_delimiter,
-			      0, false, &manager, &result[shard_id]);
-}
-
 void cls_rgw_bilog_start(ObjectWriteOperation& op)
 {
   bufferlist in;
   op.exec(RGW_CLASS, RGW_BI_LOG_RESYNC, in);
 }
 
-static bool issue_resync_bi_log(librados::IoCtx& io_ctx, const int shard_id, const string& oid, BucketIndexAioManager *manager)
-{
-  librados::ObjectWriteOperation op;
-  cls_rgw_bilog_start(op);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueResyncBucketBILog::issue_op(const int shard_id, const string& oid)
-{
-  return issue_resync_bi_log(io_ctx, shard_id, oid, &manager);
-}
-
 void cls_rgw_bilog_stop(ObjectWriteOperation& op)
 {
   bufferlist in;
   op.exec(RGW_CLASS, RGW_BI_LOG_STOP, in);
 }
 
-static bool issue_bi_log_stop(librados::IoCtx& io_ctx, const int shard_id, const string& oid, BucketIndexAioManager *manager)
-{
-  librados::ObjectWriteOperation op;
-  cls_rgw_bilog_stop(op);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueBucketBILogStop::issue_op(const int shard_id, const string& oid)
-{
-  return issue_bi_log_stop(io_ctx, shard_id, oid, &manager);
-}
-
 class GetDirHeaderCompletion : public ObjectOperationCompletion {
   boost::intrusive_ptr<RGWGetDirHeader_CB> cb;
 public:
@@ -1300,18 +1011,3 @@ void cls_rgw_set_bucket_resharding(librados::ObjectWriteOperation& op,
   op.assert_exists(); // the shard must exist; if not fail rather than recreate
   op.exec(RGW_CLASS, RGW_SET_BUCKET_RESHARDING, in);
 }
-
-static bool issue_set_bucket_resharding(librados::IoCtx& io_ctx,
-					const int shard_id, const string& oid,
-                                        const cls_rgw_bucket_instance_entry& entry,
-                                        BucketIndexAioManager *manager) {
-  librados::ObjectWriteOperation op;
-  cls_rgw_set_bucket_resharding(op, entry.reshard_status);
-  return manager->aio_operate(io_ctx, shard_id, oid, &op);
-}
-
-int CLSRGWIssueSetBucketResharding::issue_op(const int shard_id, const string& oid)
-{
-  return issue_set_bucket_resharding(io_ctx, shard_id, oid, entry, &manager);
-}
-