rgw: refactor realm/zongegroup/zone resolving

Don't allow a zone to run under wrong zonegroup. Allow
starting with correct realm/period/zonegroup if only zone is provided,
and a realm exists for that zone.
Refactor svc.zone init and simplify logic complexity.

Signed-off-by: Yehuda Sadeh <yehuda@redhat.com>

diff --git a/src/rgw/rgw_zone.cc b/src/rgw/rgw_zone.cc
index 4e5e3e719c6944b66f67eab32fc74520fb7121b3..1bb4774fd221e4fec391259b19eb37962bf6aa3e 100644 (file)
--- a/src/rgw/rgw_zone.cc
+++ b/src/rgw/rgw_zone.cc
@@ -880,6 +880,35 @@ int RGWRealm::notify_new_period(const DoutPrefixProvider *dpp, const RGWPeriod&
   return notify_zone(dpp, bl, y);
 }
 
+
+int RGWRealm::find_zone(const DoutPrefixProvider *dpp,
+                        const rgw_zone_id& zid,
+                        RGWPeriod *pperiod,
+                        RGWZoneGroup *pzonegroup,
+                        bool *pfound,
+                        optional_yield y) const
+{
+  auto& found = *pfound;
+
+  found = false;
+
+  string period_id;
+  epoch_t epoch = 0;
+
+  RGWPeriod period(period_id, epoch);
+  int r = period.init(dpp, cct, sysobj_svc, get_id(), y, get_name());
+  if (r < 0) {
+    ldpp_dout(dpp, 0) << "WARNING: period init failed: " << cpp_strerror(-r) << " ... skipping" << dendl;
+    return r;
+  }
+
+  found = period.find_zone(dpp, zid, pzonegroup, y);
+  if (found) {
+    *pperiod = period;
+  }
+  return 0;
+}
+
 std::string RGWPeriodConfig::get_oid(const std::string& realm_id)
 {
   if (realm_id.empty()) {
@@ -1005,6 +1034,22 @@ int RGWPeriod::get_zonegroup(RGWZoneGroup& zonegroup,
   return -ENOENT;
 }
 
+bool RGWPeriod::find_zone(const DoutPrefixProvider *dpp,
+                          const rgw_zone_id& zid,
+                          RGWZoneGroup *pzonegroup,
+                          optional_yield y) const
+{
+  RGWZoneGroup zg;
+  RGWZone zone;
+
+  bool found = period_map.find_zone_by_id(zid, &zg, &zone);
+  if (found) {
+    *pzonegroup = zg;
+  }
+
+  return found;
+}
+
 const string& RGWPeriod::get_latest_epoch_oid() const
 {
   if (cct->_conf->rgw_period_latest_epoch_info_oid.empty()) {
@@ -1910,6 +1955,44 @@ uint32_t RGWPeriodMap::get_zone_short_id(const string& zone_id) const
   return i->second;
 }
 
+bool RGWPeriodMap::find_zone_by_id(const rgw_zone_id& zone_id,
+                                   RGWZoneGroup *zonegroup,
+                                   RGWZone *zone) const
+{
+  for (auto& iter : zonegroups) {
+    auto& zg = iter.second;
+
+    auto ziter = zg.zones.find(zone_id);
+    if (ziter != zg.zones.end()) {
+      *zonegroup = zg;
+      *zone = ziter->second;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool RGWPeriodMap::find_zone_by_name(const string& zone_name,
+                                     RGWZoneGroup *zonegroup,
+                                     RGWZone *zone) const
+{
+  for (auto& iter : zonegroups) {
+    auto& zg = iter.second;
+    for (auto& ziter : zg.zones) {
+      auto& z = ziter.second;
+
+      if (z.name == zone_name) {
+        *zonegroup = zg;
+        *zone = z;
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 int RGWZoneGroupMap::read(const DoutPrefixProvider *dpp, CephContext *cct, RGWSI_SysObj *sysobj_svc, optional_yield y)
 {
 

diff --git a/src/rgw/rgw_zone.h b/src/rgw/rgw_zone.h
index 4fabd8e929b576ece0b30b498508b945a746dfa8..453f09b92c8dd46444f3f216bcfc595f5bdd6521 100644 (file)
--- a/src/rgw/rgw_zone.h
+++ b/src/rgw/rgw_zone.h
@@ -863,6 +863,13 @@ struct RGWPeriodMap
   }
 
   uint32_t get_zone_short_id(const std::string& zone_id) const;
+
+  bool find_zone_by_id(const rgw_zone_id& zone_id,
+                       RGWZoneGroup *zonegroup,
+                       RGWZone *zone) const;
+  bool find_zone_by_name(const string& zone_id,
+                       RGWZoneGroup *zonegroup,
+                       RGWZone *zone) const;
 };
 WRITE_CLASS_ENCODER(RGWPeriodMap)
 
@@ -1000,6 +1007,13 @@ public:
   int notify_zone(const DoutPrefixProvider *dpp, bufferlist& bl, optional_yield y);
   /// notify the zone of a new period
   int notify_new_period(const DoutPrefixProvider *dpp, const RGWPeriod& period, optional_yield y);
+
+  int find_zone(const DoutPrefixProvider *dpp,
+                const rgw_zone_id& zid,
+                RGWPeriod *pperiod,
+                RGWZoneGroup *pzonegroup,
+                bool *pfound,
+                optional_yield y) const;
 };
 WRITE_CLASS_ENCODER(RGWRealm)
 
@@ -1151,6 +1165,11 @@ public:
     return false;
   }
 
+  bool find_zone(const DoutPrefixProvider *dpp,
+                const rgw_zone_id& zid,
+                RGWZoneGroup *pzonegroup,
+                optional_yield y) const;
+
   int get_latest_epoch(const DoutPrefixProvider *dpp, epoch_t& epoch, optional_yield y);
   int set_latest_epoch(const DoutPrefixProvider *dpp, optional_yield y,
                       epoch_t epoch, bool exclusive = false,

diff --git a/src/rgw/services/svc_zone.cc b/src/rgw/services/svc_zone.cc
index 31bcbbcdff949d7fc0bec4567238ae4e3bd05bd7..fdaeb6cbeb43b8b4acdae31e9d75fa1dd6582e72 100644 (file)
--- a/src/rgw/services/svc_zone.cc
+++ b/src/rgw/services/svc_zone.cc
@@ -64,6 +64,51 @@ bool RGWSI_Zone::zone_syncs_from(const RGWZone& target_zone, const RGWZone& sour
          sync_modules_svc->get_manager()->supports_data_export(source_zone.tier_type);
 }
 
+int RGWSI_Zone::search_realm_with_zone(const DoutPrefixProvider *dpp,
+                                       const rgw_zone_id& zid,
+                                       RGWRealm *prealm,
+                                       RGWPeriod *pperiod,
+                                       RGWZoneGroup *pzonegroup,
+                                       bool *pfound,
+                                       optional_yield y)
+{
+  auto& found = *pfound;
+
+  found = false;
+
+  list<string> realms;
+  int r = list_realms(dpp, realms);
+  if (r < 0) {
+    ldpp_dout(dpp, 0) << "ERROR: failed to list realms: r=" << r << dendl;
+    return r;
+  }
+
+  for (auto& realm_name : realms) {
+    string realm_id;
+    RGWRealm realm(realm_id, realm_name);
+    r = realm.init(dpp, cct, sysobj_svc, y);
+    if (r < 0) {
+      ldpp_dout(dpp, 0) << "WARNING: can't open realm " << realm_name << ": " << cpp_strerror(-r) << " ... skipping" << dendl;
+      continue;
+    }
+
+    r = realm.find_zone(dpp, zid, pperiod,
+                        pzonegroup, &found, y);
+    if (r < 0) {
+      ldpp_dout(dpp, 20) << __func__ << "(): ERROR: realm.find_zone() returned r=" << r<< dendl;
+      return r;
+    }
+
+    if (found) {
+      *prealm = realm;
+      ldpp_dout(dpp, 20) << __func__ << "(): found realm_id=" << realm_id << " realm_name=" << realm_name << dendl;
+      return 0;
+    }
+  }
+
+  return 0;
+}
+
 int RGWSI_Zone::do_start(optional_yield y, const DoutPrefixProvider *dpp)
 {
   int ret = sysobj_svc->start(y, dpp);
@@ -82,90 +127,174 @@ int RGWSI_Zone::do_start(optional_yield y, const DoutPrefixProvider *dpp)
   if (ret < 0 && ret != -ENOENT) {
     ldpp_dout(dpp, 0) << "failed reading realm info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
     return ret;
-  } else if (ret != -ENOENT) {
-    ldpp_dout(dpp, 20) << "realm  " << realm->get_name() << " " << realm->get_id() << dendl;
-    ret = current_period->init(dpp, cct, sysobj_svc, realm->get_id(), y,
-                              realm->get_name());
-    if (ret < 0 && ret != -ENOENT) {
-      ldpp_dout(dpp, 0) << "failed reading current period info: " << " " << cpp_strerror(-ret) << dendl;
-      return ret;
-    }
-    ldpp_dout(dpp, 20) << "current period " << current_period->get_id() << dendl;  
   }
 
-  ret = replace_region_with_zonegroup(dpp, y);
-  if (ret < 0) {
-    ldpp_dout(dpp, -1) << "failed converting region to zonegroup : ret "<< ret << " " << cpp_strerror(-ret) << dendl;
+  ldpp_dout(dpp, 20) << "realm  " << realm->get_name() << " " << realm->get_id() << dendl;
+  ret = current_period->init(dpp, cct, sysobj_svc, realm->get_id(), y,
+                             realm->get_name());
+  if (ret < 0 && ret != -ENOENT) {
+    ldpp_dout(dpp, 0) << "failed reading current period info: " << " " << cpp_strerror(-ret) << dendl;
     return ret;
   }
 
-  ret = convert_regionmap(dpp, y);
-  if (ret < 0) {
-    ldpp_dout(dpp, -1) << "failed converting regionmap: " << cpp_strerror(-ret) << dendl;
+  ret = zone_params->init(dpp, cct, sysobj_svc, y);
+  bool found_zone = (ret == 0);
+  if (ret < 0 && ret != -ENOENT) {
+    lderr(cct) << "failed reading zone info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
     return ret;
   }
 
-  bool zg_initialized = false;
+  cur_zone_id = rgw_zone_id(zone_params->get_id());
+
+  bool found_period_conf = false;
 
-  if (!current_period->get_id().empty()) {
-    ret = init_zg_from_period(dpp, &zg_initialized, y);
+  /* try to find zone in period config (if we have one) */
+  if (found_zone &&
+      !current_period->get_id().empty()) {
+    found_period_conf = current_period->find_zone(dpp,
+                                    cur_zone_id,
+                                    zonegroup,
+                                    y);
     if (ret < 0) {
+      ldpp_dout(dpp, 0) << "ERROR: current_period->find_zone() returned ret=" << ret << dendl;
       return ret;
     }
+    if (!found_period_conf) {
+      ldpp_dout(dpp, 0) << "period (" << current_period->get_id() << " does not have zone " << cur_zone_id << " configured" << dendl;
+    }
   }
 
-  bool creating_defaults = false;
-  bool using_local = (!zg_initialized);
-  if (using_local) {
-    ldpp_dout(dpp, 10) << " cannot find current period zonegroup using local zonegroup" << dendl;
-    ret = init_zg_from_local(dpp, &creating_defaults, y);
+  RGWRealm search_realm;
+
+  if (found_zone &&
+      !found_period_conf) {
+    ldpp_dout(dpp, 20) << "searching for the correct realm" << dendl;
+    ret = search_realm_with_zone(dpp,
+                                 cur_zone_id,
+                                 realm,
+                                 current_period,
+                                 zonegroup,
+                                 &found_period_conf,
+                                 y);
     if (ret < 0) {
+      ldpp_dout(dpp, 0) << "ERROR: search_realm_conf() failed: ret="<< ret << dendl;
       return ret;
     }
-    // read period_config into current_period
-    auto& period_config = current_period->get_config();
-    ret = period_config.read(dpp, sysobj_svc, zonegroup->realm_id, y);
+  }
+  bool zg_initialized = found_period_conf;
+
+  if (!zg_initialized) {
+    /* couldn't find a proper period config, use local zonegroup */
+    ret = zonegroup->init(dpp, cct, sysobj_svc, y);
+    zg_initialized = (ret == 0);
     if (ret < 0 && ret != -ENOENT) {
-      ldpp_dout(dpp, 0) << "ERROR: failed to read period config: "
-          << cpp_strerror(ret) << dendl;
+      ldpp_dout(dpp, 0) << "failed reading zonegroup info: " << cpp_strerror(-ret) << dendl;
       return ret;
     }
   }
 
-  ldpp_dout(dpp, 10) << "Cannot find current period zone using local zone" << dendl;
-  if (creating_defaults && cct->_conf->rgw_zone.empty()) {
-    ldpp_dout(dpp, 10) << " Using default name "<< default_zone_name << dendl;
-    zone_params->set_name(default_zone_name);
+  auto& zonegroup_param = cct->_conf->rgw_zonegroup;
+  bool init_from_period = found_period_conf;
+  bool explicit_zg = !zonegroup_param.empty();
+
+  if (!zg_initialized &&
+      (!explicit_zg || zonegroup_param == default_zonegroup_name)) {
+    /* we couldn't initialize any zonegroup,
+       falling back to a non-multisite config with default zonegroup */
+    ret = create_default_zg(dpp, y);
+    if (ret < 0) {
+      return ret;
+    }
+    zg_initialized = true;
   }
 
-  ret = zone_params->init(dpp, cct, sysobj_svc, y);
-  if (ret < 0 && ret != -ENOENT) {
-    ldpp_dout(dpp, -1) << "failed reading zone info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
+  if (!zg_initialized) {
+    ldpp_dout(dpp, 0) << "ERROR: could not find zonegroup (" << zonegroup_param << ")" << dendl;
+    return -ENOENT;
+  }
+
+  /* we have zonegroup now */
+
+  if (explicit_zg &&
+      zonegroup->get_name() != zonegroup_param) {
+    ldpp_dout(dpp, 0) << "ERROR: incorrect zonegroup: " << zonegroup_param << " (got: " << zonegroup_param << ", expected: " << zonegroup->get_name() << ")" << dendl;
+    return -EINVAL;
+  }
+
+  auto& zone_param = cct->_conf->rgw_zone;
+  bool explicit_zone = !zone_param.empty();
+
+  if (!found_zone) {
+    if ((!explicit_zone || zone_param == default_zone_name) &&
+        zonegroup->get_name() == default_zonegroup_name) {
+      ret = init_default_zone(dpp, y);
+      if (ret < 0 && ret != -ENOENT) {
+        return ret;
+      }
+      cur_zone_id = zone_params->get_id();
+    } else {
+      ldpp_dout(dpp, 0) << "ERROR: could not find zone (" << zone_param << ")" << dendl;
+      return -ENOENT;
+    }
+  }
+
+  /* we have zone now */
+
+  ret = replace_region_with_zonegroup(dpp, y);
+  if (ret < 0) {
+    ldpp_dout(dpp, -1) << "failed converting region to zonegroup : ret "<< ret << " " << cpp_strerror(-ret) << dendl;
     return ret;
   }
 
-  cur_zone_id = rgw_zone_id(zone_params->get_id());
+  ret = convert_regionmap(dpp, y);
+  if (ret < 0) {
+    ldpp_dout(dpp, -1) << "failed converting regionmap: " << cpp_strerror(-ret) << dendl;
+    return ret;
+  }
 
   auto zone_iter = zonegroup->zones.find(zone_params->get_id());
   if (zone_iter == zonegroup->zones.end()) {
-    if (using_local) {
+    /* shouldn't happen if relying on period config */
+    if (!init_from_period) {
       ldpp_dout(dpp, -1) << "Cannot find zone id=" << zone_params->get_id() << " (name=" << zone_params->get_name() << ")" << dendl;
       return -EINVAL;
     }
     ldpp_dout(dpp, 1) << "Cannot find zone id=" << zone_params->get_id() << " (name=" << zone_params->get_name() << "), switching to local zonegroup configuration" << dendl;
-    ret = init_zg_from_local(dpp, &creating_defaults, y);
-    if (ret < 0) {
-      return ret;
-    }
+    init_from_period = false;
     zone_iter = zonegroup->zones.find(zone_params->get_id());
   }
-  if (zone_iter != zonegroup->zones.end()) {
-    *zone_public_config = zone_iter->second;
-    ldpp_dout(dpp, 20) << "zone " << zone_params->get_name() << " found"  << dendl;
-  } else {
+  if (zone_iter == zonegroup->zones.end()) {
     ldpp_dout(dpp, -1) << "Cannot find zone id=" << zone_params->get_id() << " (name=" << zone_params->get_name() << ")" << dendl;
     return -EINVAL;
   }
+  *zone_public_config = zone_iter->second;
+  ldout(cct, 20) << "zone " << zone_params->get_name() << " found"  << dendl;
+
+  ldpp_dout(dpp, 1) << "Realm:     " << std::left << setw(20) << realm->get_name() << " (" << realm->get_id() << ")" << dendl;
+  ldpp_dout(dpp, 1) << "ZoneGroup: " << std::left << setw(20) << zonegroup->get_name() << " (" << zonegroup->get_id() << ")" << dendl;
+  ldpp_dout(dpp, 1) << "Zone:      " << std::left << setw(20) << zone_params->get_name() << " (" << zone_params->get_id() << ")" << dendl;
+
+  if (init_from_period) {
+    ldpp_dout(dpp, 1) << "using period configuration: " << current_period->get_id() << ":" << current_period->get_epoch() << dendl;
+    ret = init_zg_from_period(dpp, y);
+    if (ret < 0) {
+      return ret;
+    }
+  } else {
+    ldout(cct, 10) << "cannot find current period zonegroup using local zonegroup configuration" << dendl;
+    ret = init_zg_from_local(dpp, y);
+    if (ret < 0) {
+      return ret;
+    }
+    // read period_config into current_period
+    auto& period_config = current_period->get_config();
+    ret = period_config.read(dpp, sysobj_svc, zonegroup->realm_id, y);
+    if (ret < 0 && ret != -ENOENT) {
+      ldout(cct, 0) << "ERROR: failed to read period config: "
+          << cpp_strerror(ret) << dendl;
+      return ret;
+    }
+  }
 
   zone_short_id = current_period->get_map().get_zone_short_id(zone_params->get_id());
 
@@ -615,24 +744,9 @@ static void add_new_connection_to_map(map<string, RGWRESTConn *> &zonegroup_conn
   zonegroup_conn_map[zonegroup.get_id()] = new_connection;
 }
 
-int RGWSI_Zone::init_zg_from_period(const DoutPrefixProvider *dpp, bool *initialized, optional_yield y)
+int RGWSI_Zone::init_zg_from_period(const DoutPrefixProvider *dpp, optional_yield y)
 {
-  *initialized = false;
-
-  if (current_period->get_id().empty()) {
-    return 0;
-  }
-
-  int ret = zonegroup->init(dpp, cct, sysobj_svc, y);
-  ldpp_dout(dpp, 20) << "period zonegroup init ret " << ret << dendl;
-  if (ret == -ENOENT) {
-    return 0;
-  }
-  if (ret < 0) {
-    ldpp_dout(dpp, 0) << "failed reading zonegroup info: " << cpp_strerror(-ret) << dendl;
-    return ret;
-  }
-  ldpp_dout(dpp, 20) << "period zonegroup name " << zonegroup->get_name() << dendl;
+  ldout(cct, 20) << "period zonegroup name " << zonegroup->get_name() << dendl;
 
   map<string, RGWZoneGroup>::const_iterator iter =
     current_period->get_map().zonegroups.find(zonegroup->get_id());
@@ -640,24 +754,11 @@ int RGWSI_Zone::init_zg_from_period(const DoutPrefixProvider *dpp, bool *initial
   if (iter != current_period->get_map().zonegroups.end()) {
     ldpp_dout(dpp, 20) << "using current period zonegroup " << zonegroup->get_name() << dendl;
     *zonegroup = iter->second;
-    ret = zonegroup->init(dpp, cct, sysobj_svc, y, false);
+    int ret = zonegroup->init(dpp, cct, sysobj_svc, y, false);
     if (ret < 0) {
       ldpp_dout(dpp, 0) << "failed init zonegroup: " << " " << cpp_strerror(-ret) << dendl;
       return ret;
     }
-    ret = zone_params->init(dpp, cct, sysobj_svc, y);
-    if (ret < 0 && ret != -ENOENT) {
-      ldpp_dout(dpp, 0) << "failed reading zone params info: " << " " << cpp_strerror(-ret) << dendl;
-      return ret;
-    } if (ret ==-ENOENT && zonegroup->get_name() == default_zonegroup_name) {
-      ldpp_dout(dpp, 10) << " Using default name "<< default_zone_name << dendl;
-      zone_params->set_name(default_zone_name);
-      ret = zone_params->init(dpp, cct, sysobj_svc, y);
-      if (ret < 0 && ret != -ENOENT) {
-       ldpp_dout(dpp, 0) << "failed reading zone params info: " << " " << cpp_strerror(-ret) << dendl;
-       return ret;
-      }
-    }
   }
   for (iter = current_period->get_map().zonegroups.begin();
        iter != current_period->get_map().zonegroups.end(); ++iter){
@@ -675,14 +776,14 @@ int RGWSI_Zone::init_zg_from_period(const DoutPrefixProvider *dpp, bool *initial
          master->second.name << " id:" << master->second.id << " as master" << dendl;
        if (zonegroup->get_id() == zg.get_id()) {
          zonegroup->master_zone = master->second.id;
-         ret = zonegroup->update(dpp, y);
+         int ret = zonegroup->update(dpp, y);
          if (ret < 0) {
            ldpp_dout(dpp, 0) << "error updating zonegroup : " << cpp_strerror(-ret) << dendl;
            return ret;
          }
        } else {
          RGWZoneGroup fixed_zg(zg.get_id(),zg.get_name());
-         ret = fixed_zg.init(dpp, cct, sysobj_svc, y);
+         int ret = fixed_zg.init(dpp, cct, sysobj_svc, y);
          if (ret < 0) {
            ldpp_dout(dpp, 0) << "error initializing zonegroup : " << cpp_strerror(-ret) << dendl;
            return ret;
@@ -708,33 +809,43 @@ int RGWSI_Zone::init_zg_from_period(const DoutPrefixProvider *dpp, bool *initial
     }
   }
 
-  *initialized = true;
+  return 0;
+}
+
+int RGWSI_Zone::create_default_zg(const DoutPrefixProvider *dpp, optional_yield y)
+{
+  ldout(cct, 10) << "Creating default zonegroup " << dendl;
+  int ret = zonegroup->create_default(dpp, y);
+  if (ret < 0) {
+    ldpp_dout(dpp, 0) << "failure in zonegroup create_default: ret "<< ret << " " << cpp_strerror(-ret)
+      << dendl;
+    return ret;
+  }
+  ret = zonegroup->init(dpp, cct, sysobj_svc, y);
+  if (ret < 0) {
+    ldout(cct, 0) << "failure in zonegroup create_default: ret "<< ret << " " << cpp_strerror(-ret)
+      << dendl;
+    return ret;
+  }
 
   return 0;
 }
 
-int RGWSI_Zone::init_zg_from_local(const DoutPrefixProvider *dpp, bool *creating_defaults, optional_yield y)
+int RGWSI_Zone::init_default_zone(const DoutPrefixProvider *dpp, optional_yield y)
 {
-  int ret = zonegroup->init(dpp, cct, sysobj_svc, y);
-  if ( (ret < 0 && ret != -ENOENT) || (ret == -ENOENT && !cct->_conf->rgw_zonegroup.empty())) {
-    ldpp_dout(dpp, 0) << "failed reading zonegroup info: ret "<< ret << " " << cpp_strerror(-ret) << dendl;
+  ldpp_dout(dpp, 10) << " Using default name "<< default_zone_name << dendl;
+  zone_params->set_name(default_zone_name);
+  int ret = zone_params->init(dpp, cct, sysobj_svc, y);
+  if (ret < 0 && ret != -ENOENT) {
+    ldpp_dout(dpp, 0) << "failed reading zone params info: " << " " << cpp_strerror(-ret) << dendl;
     return ret;
-  } else if (ret == -ENOENT) {
-    *creating_defaults = true;
-    ldpp_dout(dpp, 10) << "Creating default zonegroup " << dendl;
-    ret = zonegroup->create_default(dpp, y);
-    if (ret < 0) {
-      ldpp_dout(dpp, 0) << "failure in zonegroup create_default: ret "<< ret << " " << cpp_strerror(-ret)
-        << dendl;
-      return ret;
-    }
-    ret = zonegroup->init(dpp, cct, sysobj_svc, y);
-    if (ret < 0) {
-      ldpp_dout(dpp, 0) << "failure in zonegroup create_default: ret "<< ret << " " << cpp_strerror(-ret)
-        << dendl;
-      return ret;
-    }
   }
+
+  return 0;
+}
+
+int RGWSI_Zone::init_zg_from_local(const DoutPrefixProvider *dpp, optional_yield y)
+{
   ldpp_dout(dpp, 20) << "zonegroup " << zonegroup->get_name() << dendl;
   if (zonegroup->is_master_zonegroup()) {
     // use endpoints from the zonegroup's master zone
@@ -746,7 +857,7 @@ int RGWSI_Zone::init_zg_from_local(const DoutPrefixProvider *dpp, bool *creating
        ldpp_dout(dpp, 0) << "zonegroup " << zonegroup->get_name() << " missing master_zone, setting zone " <<
          master->second.name << " id:" << master->second.id << " as master" << dendl;
        zonegroup->master_zone = master->second.id;
-       ret = zonegroup->update(dpp, y);
+       int ret = zonegroup->update(dpp, y);
        if (ret < 0) {
          ldpp_dout(dpp, 0) << "error initializing zonegroup : " << cpp_strerror(-ret) << dendl;
          return ret;

diff --git a/src/rgw/services/svc_zone.h b/src/rgw/services/svc_zone.h
index 9f503df5e4146d9cd391f919de1f11c8509ba49c..a9e70932bb035b9fc92b3e3b3241d6d848dbe634 100644 (file)
--- a/src/rgw/services/svc_zone.h
+++ b/src/rgw/services/svc_zone.h
@@ -65,11 +65,22 @@ class RGWSI_Zone : public RGWServiceInstance
   void shutdown() override;
 
   int replace_region_with_zonegroup(const DoutPrefixProvider *dpp, optional_yield y);
-  int init_zg_from_period(const DoutPrefixProvider *dpp, bool *initialized, optional_yield y);
-  int init_zg_from_local(const DoutPrefixProvider *dpp, bool *creating_defaults, optional_yield y);
+  int init_zg_from_period(const DoutPrefixProvider *dpp, optional_yield y);
+  int init_zg_from_local(const DoutPrefixProvider *dpp, optional_yield y);
   int convert_regionmap(const DoutPrefixProvider *dpp, optional_yield y);
 
   int update_placement_map(const DoutPrefixProvider *dpp, optional_yield y);
+
+  int create_default_zg(const DoutPrefixProvider *dpp, optional_yield y);
+  int init_default_zone(const DoutPrefixProvider *dpp, optional_yield y);
+
+  int search_realm_with_zone(const DoutPrefixProvider *dpp,
+                             const rgw_zone_id& zid,
+                             RGWRealm *prealm,
+                             RGWPeriod *pperiod,
+                             RGWZoneGroup *pzonegroup,
+                             bool *pfound,
+                             optional_yield y);
 public:
   RGWSI_Zone(CephContext *cct);
   ~RGWSI_Zone();