mon/OSDMonitor: rename functions and variables, ruleset -> rule

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/qa/workunits/rest/test_mgr_rest_api.py b/qa/workunits/rest/test_mgr_rest_api.py
index 3dcb1d67741b62870eb45ee453d1011ca49752b7..913438f4c86f6f094c4fdfe58e1d85b088fc7298 100755 (executable)
--- a/qa/workunits/rest/test_mgr_rest_api.py
+++ b/qa/workunits/rest/test_mgr_rest_api.py
@@ -50,7 +50,6 @@ screenplay = [
     ('get',    '/', {}),
     ('get',    '/config/cluster', {}),
     ('get',    '/crush/rule', {}),
-    ('get',    '/crush/ruleset', {}),
     ('get',    '/doc', {}),
     ('get',    '/mon', {}),
     ('get',    '/mon/' + firstmon, {}),

diff --git a/src/mon/OSDMonitor.cc b/src/mon/OSDMonitor.cc
index 4df1ad3a7a76fc1d9608d9c6d6af952beebf92ac..9ae937fc0f57f2da4d0ce5ca35ec8fa742246851 100644 (file)
--- a/src/mon/OSDMonitor.cc
+++ b/src/mon/OSDMonitor.cc
@@ -5096,14 +5096,14 @@ int OSDMonitor::prepare_new_pool(MonOpRequestRef op)
     return -EPERM;
   string erasure_code_profile;
   stringstream ss;
-  string ruleset_name;
+  string rule_name;
   if (m->auid)
-    return prepare_new_pool(m->name, m->auid, m->crush_rule, ruleset_name,
+    return prepare_new_pool(m->name, m->auid, m->crush_rule, rule_name,
                            0, 0,
                             erasure_code_profile,
                            pg_pool_t::TYPE_REPLICATED, 0, FAST_READ_OFF, &ss);
   else
-    return prepare_new_pool(m->name, session->auid, m->crush_rule, ruleset_name,
+    return prepare_new_pool(m->name, session->auid, m->crush_rule, rule_name,
                            0, 0,
                             erasure_code_profile,
                            pg_pool_t::TYPE_REPLICATED, 0, FAST_READ_OFF, &ss);
@@ -5211,14 +5211,14 @@ int OSDMonitor::normalize_profile(const string& profilename,
   return 0;
 }
 
-int OSDMonitor::crush_ruleset_create_erasure(const string &name,
+int OSDMonitor::crush_rule_create_erasure(const string &name,
                                             const string &profile,
-                                            int *ruleset,
+                                            int *rule,
                                             ostream *ss)
 {
   int ruleid = osdmap.crush->get_rule_id(name);
   if (ruleid != -ENOENT) {
-    *ruleset = osdmap.crush->get_rule_mask_ruleset(ruleid);
+    *rule = osdmap.crush->get_rule_mask_ruleset(ruleid);
     return -EEXIST;
   }
 
@@ -5227,7 +5227,7 @@ int OSDMonitor::crush_ruleset_create_erasure(const string &name,
 
   ruleid = newcrush.get_rule_id(name);
   if (ruleid != -ENOENT) {
-    *ruleset = newcrush.get_rule_mask_ruleset(ruleid);
+    *rule = newcrush.get_rule_mask_ruleset(ruleid);
     return -EALREADY;
   } else {
     ErasureCodeInterfaceRef erasure_code;
@@ -5241,7 +5241,7 @@ int OSDMonitor::crush_ruleset_create_erasure(const string &name,
     erasure_code.reset();
     if (err < 0)
       return err;
-    *ruleset = err;
+    *rule = err;
     pending_inc.crush.clear();
     newcrush.encode(pending_inc.crush, mon->get_quorum_con_features());
     return 0;
@@ -5471,40 +5471,40 @@ int OSDMonitor::prepare_pool_stripe_width(const unsigned pool_type,
   return err;
 }
 
-int OSDMonitor::prepare_pool_crush_ruleset(const unsigned pool_type,
+int OSDMonitor::prepare_pool_crush_rule(const unsigned pool_type,
                                           const string &erasure_code_profile,
-                                          const string &ruleset_name,
-                                          int *crush_ruleset,
+                                          const string &rule_name,
+                                          int *crush_rule,
                                           ostream *ss)
 {
 
-  if (*crush_ruleset < 0) {
+  if (*crush_rule < 0) {
     switch (pool_type) {
     case pg_pool_t::TYPE_REPLICATED:
       {
-       if (ruleset_name == "") {
-         //Use default ruleset
-         *crush_ruleset = osdmap.crush->get_osd_pool_default_crush_replicated_ruleset(g_ceph_context);
-         if (*crush_ruleset < 0) {
-           // Errors may happen e.g. if no valid ruleset is available
+       if (rule_name == "") {
+         //Use default rule
+         *crush_rule = osdmap.crush->get_osd_pool_default_crush_replicated_ruleset(g_ceph_context);
+         if (*crush_rule < 0) {
+           // Errors may happen e.g. if no valid rule is available
            *ss << "No suitable CRUSH rule exists, check "
                 << "'osd pool default crush *' config options";
            return -ENOENT;
          }
        } else {
-         return get_crush_ruleset(ruleset_name, crush_ruleset, ss);
+         return get_crush_rule(rule_name, crush_rule, ss);
        }
       }
       break;
     case pg_pool_t::TYPE_ERASURE:
       {
-       int err = crush_ruleset_create_erasure(ruleset_name,
+       int err = crush_rule_create_erasure(rule_name,
                                               erasure_code_profile,
-                                              crush_ruleset, ss);
+                                              crush_rule, ss);
        switch (err) {
        case -EALREADY:
-         dout(20) << "prepare_pool_crush_ruleset: rule "
-                  << ruleset_name << " try again" << dendl;
+         dout(20) << "prepare_pool_crush_rule: rule "
+                  << rule_name << " try again" << dendl;
          // fall through
        case 0:
          // need to wait for the crush rule to be proposed before proceeding
@@ -5518,14 +5518,14 @@ int OSDMonitor::prepare_pool_crush_ruleset(const unsigned pool_type,
       }
       break;
     default:
-      *ss << "prepare_pool_crush_ruleset: " << pool_type
+      *ss << "prepare_pool_crush_rule: " << pool_type
         << " is not a known pool type";
       return -EINVAL;
       break;
     }
   } else {
-    if (!osdmap.crush->ruleset_exists(*crush_ruleset)) {
-      *ss << "CRUSH rule " << *crush_ruleset << " not found";
+    if (!osdmap.crush->ruleset_exists(*crush_rule)) {
+      *ss << "CRUSH rule " << *crush_rule << " not found";
       return -ENOENT;
     }
   }
@@ -5533,28 +5533,28 @@ int OSDMonitor::prepare_pool_crush_ruleset(const unsigned pool_type,
   return 0;
 }
 
-int OSDMonitor::get_crush_ruleset(const string &ruleset_name,
-                                 int *crush_ruleset,
+int OSDMonitor::get_crush_rule(const string &rule_name,
+                                 int *crush_rule,
                                  ostream *ss)
 {
   int ret;
-  ret = osdmap.crush->get_rule_id(ruleset_name);
+  ret = osdmap.crush->get_rule_id(rule_name);
   if (ret != -ENOENT) {
     // found it, use it
-    *crush_ruleset = ret;
+    *crush_rule = ret;
   } else {
     CrushWrapper newcrush;
     _get_pending_crush(newcrush);
 
-    ret = newcrush.get_rule_id(ruleset_name);
+    ret = newcrush.get_rule_id(rule_name);
     if (ret != -ENOENT) {
       // found it, wait for it to be proposed
-      dout(20) << __func__ << ": rule " << ruleset_name
+      dout(20) << __func__ << ": rule " << rule_name
               << " try again" << dendl;
       return -EAGAIN;
     } else {
       //Cannot find it , return error
-      *ss << "specified rule " << ruleset_name << " doesn't exist";
+      *ss << "specified rule " << rule_name << " doesn't exist";
       return ret;
     }
   }
@@ -5564,8 +5564,8 @@ int OSDMonitor::get_crush_ruleset(const string &ruleset_name,
 /**
  * @param name The name of the new pool
  * @param auid The auid of the pool owner. Can be -1
- * @param crush_ruleset The crush rule to use. If <0, will use the system default
- * @param crush_ruleset_name The crush rule to use, if crush_rulset <0
+ * @param crush_rule The crush rule to use. If <0, will use the system default
+ * @param crush_rule_name The crush rule to use, if crush_rulset <0
  * @param pg_num The pg_num to use. If set to 0, will use the system default
  * @param pgp_num The pgp_num to use. If set to 0, will use the system default
  * @param erasure_code_profile The profile name in OSDMap to be used for erasure code
@@ -5577,8 +5577,8 @@ int OSDMonitor::get_crush_ruleset(const string &ruleset_name,
  * @return 0 on success, negative errno on failure.
  */
 int OSDMonitor::prepare_new_pool(string& name, uint64_t auid,
-                                int crush_ruleset,
-                                const string &crush_ruleset_name,
+                                int crush_rule,
+                                const string &crush_rule_name,
                                  unsigned pg_num, unsigned pgp_num,
                                 const string &erasure_code_profile,
                                  const unsigned pool_type,
@@ -5608,10 +5608,10 @@ int OSDMonitor::prepare_new_pool(string& name, uint64_t auid,
     return -EINVAL;
   }
   int r;
-  r = prepare_pool_crush_ruleset(pool_type, erasure_code_profile,
-                                crush_ruleset_name, &crush_ruleset, ss);
+  r = prepare_pool_crush_rule(pool_type, erasure_code_profile,
+                                crush_rule_name, &crush_rule, ss);
   if (r) {
-    dout(10) << " prepare_pool_crush_ruleset returns " << r << dendl;
+    dout(10) << " prepare_pool_crush_rule returns " << r << dendl;
     return r;
   }
   CrushWrapper newcrush;
@@ -5625,7 +5625,7 @@ int OSDMonitor::prepare_new_pool(string& name, uint64_t auid,
     r = tester.test_with_crushtool(g_conf->crushtool.c_str(),
                                 osdmap.get_max_osd(),
                                 g_conf->mon_lease,
-                                crush_ruleset);
+                                crush_rule);
   }
   if (r) {
     dout(10) << " tester.test_with_crushtool returns " << r
@@ -5640,7 +5640,7 @@ int OSDMonitor::prepare_new_pool(string& name, uint64_t auid,
     return r;
   }
 
-  if (!osdmap.crush->check_crush_rule(crush_ruleset, pool_type, size, *ss)) {
+  if (!osdmap.crush->check_crush_rule(crush_rule, pool_type, size, *ss)) {
     return -EINVAL;
   }
 
@@ -5700,7 +5700,7 @@ int OSDMonitor::prepare_new_pool(string& name, uint64_t auid,
 
   pi->size = size;
   pi->min_size = min_size;
-  pi->crush_rule = crush_ruleset;
+  pi->crush_rule = crush_rule;
   pi->expected_num_objects = expected_num_objects;
   pi->object_hash = CEPH_STR_HASH_RJENKINS;
   pi->set_pg_num(pg_num);
@@ -7717,8 +7717,8 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
       mode = "firstn";
 
     if (osdmap.crush->rule_exists(name)) {
-      // The name is uniquely associated to a ruleid and the ruleset it contains
-      // From the user point of view, the ruleset is more meaningfull.
+      // The name is uniquely associated to a ruleid and the rule it contains
+      // From the user point of view, the rule is more meaningfull.
       ss << "rule " << name << " already exists";
       err = 0;
       goto reply;
@@ -7728,8 +7728,8 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
     _get_pending_crush(newcrush);
 
     if (newcrush.rule_exists(name)) {
-      // The name is uniquely associated to a ruleid and the ruleset it contains
-      // From the user point of view, the ruleset is more meaningfull.
+      // The name is uniquely associated to a ruleid and the rule it contains
+      // From the user point of view, the rule is more meaningfull.
       ss << "rule " << name << " already exists";
       err = 0;
     } else {
@@ -7891,8 +7891,8 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
       }
     }
 
-    int ruleset;
-    err = crush_ruleset_create_erasure(name, profile, &ruleset, &ss);
+    int rule;
+    err = crush_rule_create_erasure(name, profile, &rule, &ss);
     if (err < 0) {
       switch(err) {
       case -EEXIST: // return immediately
@@ -7909,7 +7909,7 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
        break;
       }
     } else {
-      ss << "created rule " << name << " at " << ruleset;
+      ss << "created rule " << name << " at " << rule;
     }
 
     getline(ss, rs);
@@ -7942,7 +7942,7 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
       // complexity now.
       int ruleset = newcrush.get_rule_mask_ruleset(ruleno);
       if (osdmap.crush_ruleset_in_use(ruleset)) {
-       ss << "crush rule " << name << " " << ruleset << " is in use";
+       ss << "crush ruleset " << name << " " << ruleset << " is in use";
        err = -EBUSY;
        goto reply;
       }
@@ -9498,9 +9498,9 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
       goto reply;
     }
 
-    bool implicit_ruleset_creation = false;
-    string ruleset_name;
-    cmd_getval(g_ceph_context, cmdmap, "rule", ruleset_name);
+    bool implicit_rule_creation = false;
+    string rule_name;
+    cmd_getval(g_ceph_context, cmdmap, "rule", rule_name);
     string erasure_code_profile;
     cmd_getval(g_ceph_context, cmdmap, "erasure_code_profile", erasure_code_profile);
 
@@ -9526,24 +9526,24 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
          goto wait;
        }
       }
-      if (ruleset_name == "") {
-       implicit_ruleset_creation = true;
+      if (rule_name == "") {
+       implicit_rule_creation = true;
        if (erasure_code_profile == "default") {
-         ruleset_name = "erasure-code";
+         rule_name = "erasure-code";
        } else {
          dout(1) << "implicitly use rule named after the pool: "
                << poolstr << dendl;
-         ruleset_name = poolstr;
+         rule_name = poolstr;
        }
       }
     } else {
-      //NOTE:for replicated pool,cmd_map will put ruleset_name to erasure_code_profile field
-      ruleset_name = erasure_code_profile;
+      //NOTE:for replicated pool,cmd_map will put rule_name to erasure_code_profile field
+      rule_name = erasure_code_profile;
     }
 
-    if (!implicit_ruleset_creation && ruleset_name != "") {
-      int ruleset;
-      err = get_crush_ruleset(ruleset_name, &ruleset, &ss);
+    if (!implicit_rule_creation && rule_name != "") {
+      int rule;
+      err = get_crush_rule(rule_name, &rule, &ss);
       if (err == -EAGAIN) {
        wait_for_finished_proposal(op, new C_RetryMessage(this, op));
        return true;
@@ -9570,7 +9570,7 @@ bool OSDMonitor::prepare_command_impl(MonOpRequestRef op,
     
     err = prepare_new_pool(poolstr, 0, // auid=0 for admin created pool
                           -1, // default crush rule
-                          ruleset_name,
+                          rule_name,
                           pg_num, pgp_num,
                           erasure_code_profile, pool_type,
                            (uint64_t)expected_num_objects,

diff --git a/src/mon/OSDMonitor.h b/src/mon/OSDMonitor.h
index fb53ee99ffc58c3a20584ce0e4248f2f8f6c4047..3f258815a1242efc3bdc0b25cf286c60762c4512 100644 (file)
--- a/src/mon/OSDMonitor.h
+++ b/src/mon/OSDMonitor.h
@@ -316,20 +316,20 @@ private:
                        ErasureCodeProfile &profile,
                        bool force,
                        ostream *ss);
-  int crush_ruleset_create_erasure(const string &name,
-                                  const string &profile,
-                                  int *ruleset,
-                                  ostream *ss);
-  int get_crush_ruleset(const string &ruleset_name,
-                       int *crush_ruleset,
+  int crush_rule_create_erasure(const string &name,
+                               const string &profile,
+                               int *rule,
+                               ostream *ss);
+  int get_crush_rule(const string &rule_name,
+                       int *crush_rule,
                        ostream *ss);
   int get_erasure_code(const string &erasure_code_profile,
                       ErasureCodeInterfaceRef *erasure_code,
                       ostream *ss) const;
-  int prepare_pool_crush_ruleset(const unsigned pool_type,
+  int prepare_pool_crush_rule(const unsigned pool_type,
                                 const string &erasure_code_profile,
-                                const string &ruleset_name,
-                                int *crush_ruleset,
+                                const string &rule_name,
+                                int *crush_rule,
                                 ostream *ss);
   bool erasure_code_profile_in_use(
     const mempool::osdmap::map<int64_t, pg_pool_t> &pools,
@@ -347,8 +347,8 @@ private:
                                unsigned *stripe_width,
                                ostream *ss);
   int prepare_new_pool(string& name, uint64_t auid,
-                      int crush_ruleset,
-                      const string &crush_ruleset_name,
+                      int crush_rule,
+                      const string &crush_rule_name,
                        unsigned pg_num, unsigned pgp_num,
                       const string &erasure_code_profile,
                        const unsigned pool_type,