ceph/src/test/osd/TestOSDMap.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 #include "gtest/gtest.h"
   3 #include "osd/OSDMap.h"
   4 #include "osd/OSDMapMapping.h"
   5
   6 #include "global/global_context.h"
   7 #include "global/global_init.h"
   8 #include "common/common_init.h"
   9 #include "common/ceph_argparse.h"
  10
  11 #include <iostream>
  12
  13 using namespace std;
  14
  15 int main(int argc, char **argv) {
  16   std::vector<const char*> args(argv, argv+argc);
  17   env_to_vec(args);
  18   auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_CLIENT,
  19                          CODE_ENVIRONMENT_UTILITY,
  20                          CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
  21   common_init_finish(g_ceph_context);
  22   // make sure we have 3 copies, or some tests won't work
  23   g_ceph_context->_conf->set_val("osd_pool_default_size", "3", false);
  24   // our map is flat, so just try and split across OSDs, not hosts or whatever
  25   g_ceph_context->_conf->set_val("osd_crush_chooseleaf_type", "0", false);
  26   ::testing::InitGoogleTest(&argc, argv);
  27   return RUN_ALL_TESTS();
  28 }
  29
  30 class OSDMapTest : public testing::Test {
  31   const static int num_osds = 6;
  32 public:
  33   OSDMap osdmap;
  34   OSDMapMapping mapping;
  35   const uint64_t my_ec_pool = 1;
  36   const uint64_t my_rep_pool = 2;
  37
  38
  39   OSDMapTest() {}
  40
  41   void set_up_map() {
  42     uuid_d fsid;
  43     osdmap.build_simple(g_ceph_context, 0, fsid, num_osds);
  44     OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
  45     pending_inc.fsid = osdmap.get_fsid();
  46     entity_addr_t sample_addr;
  47     uuid_d sample_uuid;
  48     for (int i = 0; i < num_osds; ++i) {
  49       sample_uuid.generate_random();
  50       sample_addr.nonce = i;
  51       pending_inc.new_state[i] = CEPH_OSD_EXISTS | CEPH_OSD_NEW;
  52       pending_inc.new_up_client[i] = sample_addr;
  53       pending_inc.new_up_cluster[i] = sample_addr;
  54       pending_inc.new_hb_back_up[i] = sample_addr;
  55       pending_inc.new_hb_front_up[i] = sample_addr;
  56       pending_inc.new_weight[i] = CEPH_OSD_IN;
  57       pending_inc.new_uuid[i] = sample_uuid;
  58     }
  59     osdmap.apply_incremental(pending_inc);
  60
  61     // Create an EC ruleset and a pool using it
  62     int r = osdmap.crush->add_simple_rule(
  63       "erasure", "default", "osd", "",
  64       "indep", pg_pool_t::TYPE_ERASURE,
  65       &cerr);
  66
  67     OSDMap::Incremental new_pool_inc(osdmap.get_epoch() + 1);
  68     new_pool_inc.new_pool_max = osdmap.get_pool_max();
  69     new_pool_inc.fsid = osdmap.get_fsid();
  70     pg_pool_t empty;
  71     // make an ec pool
  72     uint64_t pool_id = ++new_pool_inc.new_pool_max;
  73     assert(pool_id == my_ec_pool);
  74     pg_pool_t *p = new_pool_inc.get_new_pool(pool_id, &empty);
  75     p->size = 3;
  76     p->set_pg_num(64);
  77     p->set_pgp_num(64);
  78     p->type = pg_pool_t::TYPE_ERASURE;
  79     p->crush_rule = r;
  80     new_pool_inc.new_pool_names[pool_id] = "ec";
  81     // and a replicated pool
  82     pool_id = ++new_pool_inc.new_pool_max;
  83     assert(pool_id == my_rep_pool);
  84     p = new_pool_inc.get_new_pool(pool_id, &empty);
  85     p->size = 3;
  86     p->set_pg_num(64);
  87     p->set_pgp_num(64);
  88     p->type = pg_pool_t::TYPE_REPLICATED;
  89     p->crush_rule = 0;
  90     p->set_flag(pg_pool_t::FLAG_HASHPSPOOL);
  91     new_pool_inc.new_pool_names[pool_id] = "reppool";
  92     osdmap.apply_incremental(new_pool_inc);
  93   }
  94   unsigned int get_num_osds() { return num_osds; }
  95   void get_crush(CrushWrapper& newcrush) {
  96     bufferlist bl;
  97     osdmap.crush->encode(bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
  98     bufferlist::iterator p = bl.begin();
  99     newcrush.decode(p);
 100   }
 101   int crush_move(const string &name, const vector<string> &argvec) {
 102     map<string,string> loc;
 103     CrushWrapper::parse_loc_map(argvec, &loc);
 104     CrushWrapper newcrush;
 105     get_crush(newcrush);
 106     if (!newcrush.name_exists(name)) {
 107        return -ENOENT;
 108     }
 109     int id = newcrush.get_item_id(name);
 110     int err;
 111     if (!newcrush.check_item_loc(g_ceph_context, id, loc, (int *)NULL)) {
 112       if (id >= 0) {
 113         err = newcrush.create_or_move_item(g_ceph_context, id, 0, name, loc);
 114       } else {
 115         err = newcrush.move_bucket(g_ceph_context, id, loc);
 116       }
 117       if (err >= 0) {
 118         OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 119         pending_inc.crush.clear();
 120         newcrush.encode(pending_inc.crush, CEPH_FEATURES_SUPPORTED_DEFAULT);
 121         osdmap.apply_incremental(pending_inc);
 122         err = 0;
 123       }
 124     } else {
 125       // already there
 126       err = 0;
 127     }
 128     return err;
 129   }
 130   int crush_rule_create_replicated(const string &name,
 131                                    const string &root,
 132                                    const string &type) {
 133     if (osdmap.crush->rule_exists(name)) {
 134       return osdmap.crush->get_rule_id(name);
 135     }
 136     CrushWrapper newcrush;
 137     get_crush(newcrush);
 138     string device_class;
 139     stringstream ss;
 140     int ruleno = newcrush.add_simple_rule(
 141               name, root, type, device_class,
 142               "firstn", pg_pool_t::TYPE_REPLICATED, &ss);
 143     if (ruleno >= 0) {
 144       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 145       pending_inc.crush.clear();
 146       newcrush.encode(pending_inc.crush, CEPH_FEATURES_SUPPORTED_DEFAULT);
 147       osdmap.apply_incremental(pending_inc);
 148     }
 149     return ruleno;
 150   }
 151   void test_mappings(int pool,
 152                      int num,
 153                      vector<int> *any,
 154                      vector<int> *first,
 155                      vector<int> *primary) {
 156     mapping.update(osdmap);
 157     for (int i=0; i<num; ++i) {
 158       vector<int> up, acting;
 159       int up_primary, acting_primary;
 160       pg_t pgid(i, pool);
 161       osdmap.pg_to_up_acting_osds(pgid,
 162                                   &up, &up_primary, &acting, &acting_primary);
 163       for (unsigned j=0; j<acting.size(); ++j)
 164         (*any)[acting[j]]++;
 165       if (!acting.empty())
 166         (*first)[acting[0]]++;
 167       if (acting_primary >= 0)
 168         (*primary)[acting_primary]++;
 169
 170       // compare to precalc mapping
 171       vector<int> up2, acting2;
 172       int up_primary2, acting_primary2;
 173       pgid = osdmap.raw_pg_to_pg(pgid);
 174       mapping.get(pgid, &up2, &up_primary2, &acting2, &acting_primary2);
 175       ASSERT_EQ(up, up2);
 176       ASSERT_EQ(up_primary, up_primary2);
 177       ASSERT_EQ(acting, acting2);
 178       ASSERT_EQ(acting_primary, acting_primary2);
 179     }
 180     cout << "any: " << *any << std::endl;;
 181     cout << "first: " << *first << std::endl;;
 182     cout << "primary: " << *primary << std::endl;;
 183   }
 184 };
 185
 186 TEST_F(OSDMapTest, Create) {
 187   set_up_map();
 188   ASSERT_EQ(get_num_osds(), (unsigned)osdmap.get_max_osd());
 189   ASSERT_EQ(get_num_osds(), osdmap.get_num_in_osds());
 190 }
 191
 192 TEST_F(OSDMapTest, Features) {
 193   // with EC pool
 194   set_up_map();
 195   uint64_t features = osdmap.get_features(CEPH_ENTITY_TYPE_OSD, NULL);
 196   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES);
 197   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES2);
 198   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES3);
 199   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_V2);
 200   ASSERT_TRUE(features & CEPH_FEATURE_OSD_ERASURE_CODES);
 201   ASSERT_TRUE(features & CEPH_FEATURE_OSDHASHPSPOOL);
 202   ASSERT_TRUE(features & CEPH_FEATURE_OSD_PRIMARY_AFFINITY);
 203
 204   // clients have a slightly different view
 205   features = osdmap.get_features(CEPH_ENTITY_TYPE_CLIENT, NULL);
 206   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES);
 207   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES2);
 208   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES3);
 209   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_V2);
 210   ASSERT_FALSE(features & CEPH_FEATURE_OSD_ERASURE_CODES);  // dont' need this
 211   ASSERT_TRUE(features & CEPH_FEATURE_OSDHASHPSPOOL);
 212   ASSERT_TRUE(features & CEPH_FEATURE_OSD_PRIMARY_AFFINITY);
 213
 214   // remove teh EC pool, but leave the rule.  add primary affinity.
 215   {
 216     OSDMap::Incremental new_pool_inc(osdmap.get_epoch() + 1);
 217     new_pool_inc.old_pools.insert(osdmap.lookup_pg_pool_name("ec"));
 218     new_pool_inc.new_primary_affinity[0] = 0x8000;
 219     osdmap.apply_incremental(new_pool_inc);
 220   }
 221
 222   features = osdmap.get_features(CEPH_ENTITY_TYPE_MON, NULL);
 223   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES);
 224   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES2);
 225   ASSERT_TRUE(features & CEPH_FEATURE_CRUSH_TUNABLES3); // shared bit with primary affinity
 226   ASSERT_FALSE(features & CEPH_FEATURE_CRUSH_V2);
 227   ASSERT_FALSE(features & CEPH_FEATURE_OSD_ERASURE_CODES);
 228   ASSERT_TRUE(features & CEPH_FEATURE_OSDHASHPSPOOL);
 229   ASSERT_TRUE(features & CEPH_FEATURE_OSD_PRIMARY_AFFINITY);
 230
 231   // FIXME: test tiering feature bits
 232 }
 233
 234 TEST_F(OSDMapTest, MapPG) {
 235   set_up_map();
 236
 237   std::cerr << " osdmap.pool_max==" << osdmap.get_pool_max() << std::endl;
 238   pg_t rawpg(0, my_rep_pool, -1);
 239   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 240   vector<int> up_osds, acting_osds;
 241   int up_primary, acting_primary;
 242
 243   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 244                               &acting_osds, &acting_primary);
 245
 246   vector<int> old_up_osds, old_acting_osds;
 247   osdmap.pg_to_up_acting_osds(pgid, old_up_osds, old_acting_osds);
 248   ASSERT_EQ(old_up_osds, up_osds);
 249   ASSERT_EQ(old_acting_osds, acting_osds);
 250
 251   ASSERT_EQ(osdmap.get_pg_pool(my_rep_pool)->get_size(), up_osds.size());
 252 }
 253
 254 TEST_F(OSDMapTest, MapFunctionsMatch) {
 255   // TODO: make sure pg_to_up_acting_osds and pg_to_acting_osds match
 256   set_up_map();
 257   pg_t rawpg(0, my_rep_pool, -1);
 258   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 259   vector<int> up_osds, acting_osds;
 260   int up_primary, acting_primary;
 261
 262   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 263                               &acting_osds, &acting_primary);
 264
 265   vector<int> up_osds_two, acting_osds_two;
 266
 267   osdmap.pg_to_up_acting_osds(pgid, up_osds_two, acting_osds_two);
 268
 269   ASSERT_EQ(up_osds, up_osds_two);
 270   ASSERT_EQ(acting_osds, acting_osds_two);
 271
 272   int acting_primary_two;
 273   osdmap.pg_to_acting_osds(pgid, &acting_osds_two, &acting_primary_two);
 274   EXPECT_EQ(acting_osds, acting_osds_two);
 275   EXPECT_EQ(acting_primary, acting_primary_two);
 276   osdmap.pg_to_acting_osds(pgid, acting_osds_two);
 277   EXPECT_EQ(acting_osds, acting_osds_two);
 278 }
 279
 280 /** This test must be removed or modified appropriately when we allow
 281  * other ways to specify a primary. */
 282 TEST_F(OSDMapTest, PrimaryIsFirst) {
 283   set_up_map();
 284
 285   pg_t rawpg(0, my_rep_pool, -1);
 286   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 287   vector<int> up_osds, acting_osds;
 288   int up_primary, acting_primary;
 289
 290   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 291                               &acting_osds, &acting_primary);
 292   EXPECT_EQ(up_osds[0], up_primary);
 293   EXPECT_EQ(acting_osds[0], acting_primary);
 294 }
 295
 296 TEST_F(OSDMapTest, PGTempRespected) {
 297   set_up_map();
 298
 299   pg_t rawpg(0, my_rep_pool, -1);
 300   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 301   vector<int> up_osds, acting_osds;
 302   int up_primary, acting_primary;
 303
 304   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 305                               &acting_osds, &acting_primary);
 306
 307   // copy and swap first and last element in acting_osds
 308   vector<int> new_acting_osds(acting_osds);
 309   int first = new_acting_osds[0];
 310   new_acting_osds[0] = *new_acting_osds.rbegin();
 311   *new_acting_osds.rbegin() = first;
 312
 313   // apply pg_temp to osdmap
 314   OSDMap::Incremental pgtemp_map(osdmap.get_epoch() + 1);
 315   pgtemp_map.new_pg_temp[pgid] = mempool::osdmap::vector<int>(
 316     new_acting_osds.begin(), new_acting_osds.end());
 317   osdmap.apply_incremental(pgtemp_map);
 318
 319   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 320                               &acting_osds, &acting_primary);
 321   EXPECT_EQ(new_acting_osds, acting_osds);
 322 }
 323
 324 TEST_F(OSDMapTest, PrimaryTempRespected) {
 325   set_up_map();
 326
 327   pg_t rawpg(0, my_rep_pool, -1);
 328   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 329   vector<int> up_osds;
 330   vector<int> acting_osds;
 331   int up_primary, acting_primary;
 332
 333   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 334                               &acting_osds, &acting_primary);
 335
 336   // make second OSD primary via incremental
 337   OSDMap::Incremental pgtemp_map(osdmap.get_epoch() + 1);
 338   pgtemp_map.new_primary_temp[pgid] = acting_osds[1];
 339   osdmap.apply_incremental(pgtemp_map);
 340
 341   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 342                               &acting_osds, &acting_primary);
 343   EXPECT_EQ(acting_primary, acting_osds[1]);
 344 }
 345
 346 TEST_F(OSDMapTest, CleanTemps) {
 347   set_up_map();
 348
 349   OSDMap::Incremental pgtemp_map(osdmap.get_epoch() + 1);
 350   OSDMap::Incremental pending_inc(osdmap.get_epoch() + 2);
 351   pg_t pga = osdmap.raw_pg_to_pg(pg_t(0, my_rep_pool));
 352   {
 353     vector<int> up_osds, acting_osds;
 354     int up_primary, acting_primary;
 355     osdmap.pg_to_up_acting_osds(pga, &up_osds, &up_primary,
 356                                 &acting_osds, &acting_primary);
 357     pgtemp_map.new_pg_temp[pga] = mempool::osdmap::vector<int>(
 358       up_osds.begin(), up_osds.end());
 359     pgtemp_map.new_primary_temp[pga] = up_primary;
 360   }
 361   pg_t pgb = osdmap.raw_pg_to_pg(pg_t(1, my_rep_pool));
 362   {
 363     vector<int> up_osds, acting_osds;
 364     int up_primary, acting_primary;
 365     osdmap.pg_to_up_acting_osds(pgb, &up_osds, &up_primary,
 366                                 &acting_osds, &acting_primary);
 367     pending_inc.new_pg_temp[pgb] = mempool::osdmap::vector<int>(
 368       up_osds.begin(), up_osds.end());
 369     pending_inc.new_primary_temp[pgb] = up_primary;
 370   }
 371
 372   osdmap.apply_incremental(pgtemp_map);
 373
 374   OSDMap::clean_temps(g_ceph_context, osdmap, &pending_inc);
 375
 376   EXPECT_TRUE(pending_inc.new_pg_temp.count(pga) &&
 377               pending_inc.new_pg_temp[pga].size() == 0);
 378   EXPECT_EQ(-1, pending_inc.new_primary_temp[pga]);
 379
 380   EXPECT_TRUE(!pending_inc.new_pg_temp.count(pgb) &&
 381               !pending_inc.new_primary_temp.count(pgb));
 382 }
 383
 384 TEST_F(OSDMapTest, KeepsNecessaryTemps) {
 385   set_up_map();
 386
 387   pg_t rawpg(0, my_rep_pool, -1);
 388   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 389   vector<int> up_osds, acting_osds;
 390   int up_primary, acting_primary;
 391
 392   osdmap.pg_to_up_acting_osds(pgid, &up_osds, &up_primary,
 393                               &acting_osds, &acting_primary);
 394
 395   // find unused OSD and stick it in there
 396   OSDMap::Incremental pgtemp_map(osdmap.get_epoch() + 1);
 397   // find an unused osd and put it in place of the first one
 398   int i = 0;
 399   for(; i != (int)get_num_osds(); ++i) {
 400     bool in_use = false;
 401     for (vector<int>::iterator osd_it = up_osds.begin();
 402          osd_it != up_osds.end();
 403          ++osd_it) {
 404       if (i == *osd_it) {
 405         in_use = true;
 406         break;
 407       }
 408     }
 409     if (!in_use) {
 410       up_osds[1] = i;
 411       break;
 412     }
 413   }
 414   if (i == (int)get_num_osds())
 415     FAIL() << "did not find unused OSD for temp mapping";
 416
 417   pgtemp_map.new_pg_temp[pgid] = mempool::osdmap::vector<int>(
 418     up_osds.begin(), up_osds.end());
 419   pgtemp_map.new_primary_temp[pgid] = up_osds[1];
 420   osdmap.apply_incremental(pgtemp_map);
 421
 422   OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 423
 424   OSDMap::clean_temps(g_ceph_context, osdmap, &pending_inc);
 425   EXPECT_FALSE(pending_inc.new_pg_temp.count(pgid));
 426   EXPECT_FALSE(pending_inc.new_primary_temp.count(pgid));
 427 }
 428
 429 TEST_F(OSDMapTest, PrimaryAffinity) {
 430   set_up_map();
 431
 432   int n = get_num_osds();
 433   for (map<int64_t,pg_pool_t>::const_iterator p = osdmap.get_pools().begin();
 434        p != osdmap.get_pools().end();
 435        ++p) {
 436     int pool = p->first;
 437     int expect_primary = 10000 / n;
 438     cout << "pool " << pool << " size " << (int)p->second.size
 439          << " expect_primary " << expect_primary << std::endl;
 440     {
 441       vector<int> any(n, 0);
 442       vector<int> first(n, 0);
 443       vector<int> primary(n, 0);
 444       test_mappings(pool, 10000, &any, &first, &primary);
 445       for (int i=0; i<n; ++i) {
 446         ASSERT_LT(0, any[i]);
 447         ASSERT_LT(0, first[i]);
 448         ASSERT_LT(0, primary[i]);
 449       }
 450     }
 451
 452     osdmap.set_primary_affinity(0, 0);
 453     osdmap.set_primary_affinity(1, 0);
 454     {
 455       vector<int> any(n, 0);
 456       vector<int> first(n, 0);
 457       vector<int> primary(n, 0);
 458       test_mappings(pool, 10000, &any, &first, &primary);
 459       for (int i=0; i<n; ++i) {
 460         ASSERT_LT(0, any[i]);
 461         if (i >= 2) {
 462           ASSERT_LT(0, first[i]);
 463           ASSERT_LT(0, primary[i]);
 464         } else {
 465           if (p->second.is_replicated()) {
 466             ASSERT_EQ(0, first[i]);
 467           }
 468           ASSERT_EQ(0, primary[i]);
 469         }
 470       }
 471     }
 472
 473     osdmap.set_primary_affinity(0, 0x8000);
 474     osdmap.set_primary_affinity(1, 0);
 475     {
 476       vector<int> any(n, 0);
 477       vector<int> first(n, 0);
 478       vector<int> primary(n, 0);
 479       test_mappings(pool, 10000, &any, &first, &primary);
 480       int expect = (10000 / (n-2)) / 2; // half weight
 481       cout << "expect " << expect << std::endl;
 482       for (int i=0; i<n; ++i) {
 483         ASSERT_LT(0, any[i]);
 484         if (i >= 2) {
 485           ASSERT_LT(0, first[i]);
 486           ASSERT_LT(0, primary[i]);
 487         } else if (i == 1) {
 488           if (p->second.is_replicated()) {
 489             ASSERT_EQ(0, first[i]);
 490           }
 491           ASSERT_EQ(0, primary[i]);
 492         } else {
 493           ASSERT_LT(expect *2/3, primary[0]);
 494           ASSERT_GT(expect *4/3, primary[0]);
 495         }
 496       }
 497     }
 498
 499     osdmap.set_primary_affinity(0, 0x10000);
 500     osdmap.set_primary_affinity(1, 0x10000);
 501   }
 502 }
 503
 504 TEST_F(OSDMapTest, parse_osd_id_list) {
 505   set_up_map();
 506   set<int> out;
 507   set<int> all;
 508   osdmap.get_all_osds(all);
 509
 510   ASSERT_EQ(0, osdmap.parse_osd_id_list({"osd.0"}, &out, &cout));
 511   ASSERT_EQ(1, out.size());
 512   ASSERT_EQ(0, *out.begin());
 513
 514   ASSERT_EQ(0, osdmap.parse_osd_id_list({"1"}, &out, &cout));
 515   ASSERT_EQ(1, out.size());
 516   ASSERT_EQ(1, *out.begin());
 517
 518   ASSERT_EQ(0, osdmap.parse_osd_id_list({"osd.0","osd.1"}, &out, &cout));
 519   ASSERT_EQ(2, out.size());
 520   ASSERT_EQ(0, *out.begin());
 521   ASSERT_EQ(1, *out.rbegin());
 522
 523   ASSERT_EQ(0, osdmap.parse_osd_id_list({"osd.0","1"}, &out, &cout));
 524   ASSERT_EQ(2, out.size());
 525   ASSERT_EQ(0, *out.begin());
 526   ASSERT_EQ(1, *out.rbegin());
 527
 528   ASSERT_EQ(0, osdmap.parse_osd_id_list({"*"}, &out, &cout));
 529   ASSERT_EQ(all.size(), out.size());
 530   ASSERT_EQ(all, out);
 531
 532   ASSERT_EQ(0, osdmap.parse_osd_id_list({"all"}, &out, &cout));
 533   ASSERT_EQ(all, out);
 534
 535   ASSERT_EQ(0, osdmap.parse_osd_id_list({"any"}, &out, &cout));
 536   ASSERT_EQ(all, out);
 537
 538   ASSERT_EQ(-EINVAL, osdmap.parse_osd_id_list({"foo"}, &out, &cout));
 539   ASSERT_EQ(-EINVAL, osdmap.parse_osd_id_list({"-12"}, &out, &cout));
 540 }
 541
 542 TEST_F(OSDMapTest, CleanPGUpmaps) {
 543   set_up_map();
 544
 545   // build a crush rule of type host
 546   const int expected_host_num = 3;
 547   int osd_per_host = get_num_osds() / expected_host_num;
 548   ASSERT_GE(2, osd_per_host);
 549   int index = 0;
 550   for (int i = 0; i < (int)get_num_osds(); i++) {
 551     if (i && i % osd_per_host == 0) {
 552       ++index;
 553     }
 554     stringstream osd_name;
 555     stringstream host_name;
 556     vector<string> move_to;
 557     osd_name << "osd." << i;
 558     host_name << "host-" << index;
 559     move_to.push_back("root=default");
 560     string host_loc = "host=" + host_name.str();
 561     move_to.push_back(host_loc);
 562     int r = crush_move(osd_name.str(), move_to);
 563     ASSERT_EQ(0, r);
 564   }
 565   const string upmap_rule = "upmap";
 566   int upmap_rule_no = crush_rule_create_replicated(
 567     upmap_rule, "default", "host");
 568   ASSERT_LT(0, upmap_rule_no);
 569
 570   // create a replicated pool which references the above rule
 571   OSDMap::Incremental new_pool_inc(osdmap.get_epoch() + 1);
 572   new_pool_inc.new_pool_max = osdmap.get_pool_max();
 573   new_pool_inc.fsid = osdmap.get_fsid();
 574   pg_pool_t empty;
 575   uint64_t upmap_pool_id = ++new_pool_inc.new_pool_max;
 576   pg_pool_t *p = new_pool_inc.get_new_pool(upmap_pool_id, &empty);
 577   p->size = 2;
 578   p->set_pg_num(64);
 579   p->set_pgp_num(64);
 580   p->type = pg_pool_t::TYPE_REPLICATED;
 581   p->crush_rule = upmap_rule_no;
 582   p->set_flag(pg_pool_t::FLAG_HASHPSPOOL);
 583   new_pool_inc.new_pool_names[upmap_pool_id] = "upmap_pool";
 584   osdmap.apply_incremental(new_pool_inc);
 585
 586   pg_t rawpg(0, upmap_pool_id);
 587   pg_t pgid = osdmap.raw_pg_to_pg(rawpg);
 588   vector<int> up;
 589   int up_primary;
 590   osdmap.pg_to_raw_up(pgid, &up, &up_primary);
 591   ASSERT_LT(1U, up.size());
 592   {
 593     // validate we won't have two OSDs from a same host
 594     int parent_0 = osdmap.crush->get_parent_of_type(up[0],
 595       osdmap.crush->get_type_id("host"));
 596     int parent_1 = osdmap.crush->get_parent_of_type(up[1],
 597       osdmap.crush->get_type_id("host"));
 598     ASSERT_TRUE(parent_0 != parent_1);
 599   }
 600
 601   {
 602     // TEST pg_upmap
 603     {
 604       // STEP-1: enumerate all children of up[0]'s parent,
 605       // replace up[1] with one of them (other than up[0])
 606       int parent = osdmap.crush->get_parent_of_type(up[0],
 607         osdmap.crush->get_type_id("host"));
 608       set<int> candidates;
 609       osdmap.crush->get_leaves(osdmap.crush->get_item_name(parent), &candidates);
 610       ASSERT_LT(1U, candidates.size());
 611       int replaced_by = -1;
 612       for (auto c: candidates) {
 613         if (c != up[0]) {
 614           replaced_by = c;
 615           break;
 616         }
 617       }
 618       ASSERT_NE(-1, replaced_by);
 619       // generate a new pg_upmap item and apply
 620       vector<int32_t> new_pg_upmap;
 621       new_pg_upmap.push_back(up[0]);
 622       new_pg_upmap.push_back(replaced_by); // up[1] -> replaced_by
 623       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 624       pending_inc.new_pg_upmap[pgid] = mempool::osdmap::vector<int32_t>(
 625         new_pg_upmap.begin(), new_pg_upmap.end());
 626       osdmap.apply_incremental(pending_inc);
 627       {
 628         // validate pg_upmap is there
 629         vector<int> new_up;
 630         int new_up_primary;
 631         osdmap.pg_to_raw_up(pgid, &new_up, &new_up_primary);
 632         ASSERT_TRUE(up.size() == new_up.size());
 633         ASSERT_TRUE(new_up[0] == new_pg_upmap[0]);
 634         ASSERT_TRUE(new_up[1] == new_pg_upmap[1]);
 635         // and we shall have two OSDs from a same host now..
 636         int parent_0 = osdmap.crush->get_parent_of_type(new_up[0],
 637           osdmap.crush->get_type_id("host"));
 638         int parent_1 = osdmap.crush->get_parent_of_type(new_up[1],
 639           osdmap.crush->get_type_id("host"));
 640         ASSERT_TRUE(parent_0 == parent_1);
 641       }
 642     }
 643     {
 644       // STEP-2: apply cure
 645       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 646       osdmap.maybe_remove_pg_upmaps(g_ceph_context, osdmap, &pending_inc);
 647       osdmap.apply_incremental(pending_inc);
 648       {
 649         // validate pg_upmap is gone (reverted)
 650         vector<int> new_up;
 651         int new_up_primary;
 652         osdmap.pg_to_raw_up(pgid, &new_up, &new_up_primary);
 653         ASSERT_TRUE(new_up == up);
 654         ASSERT_TRUE(new_up_primary = up_primary);
 655       }
 656     }
 657   }
 658
 659   {
 660     // TEST pg_upmap_items
 661     // enumerate all used hosts first
 662     set<int> parents;
 663     for (auto u: up) {
 664       int parent = osdmap.crush->get_parent_of_type(u,
 665         osdmap.crush->get_type_id("host"));
 666       ASSERT_GT(0, parent);
 667       parents.insert(parent);
 668     }
 669     int candidate_parent = 0;
 670     set<int> candidate_children;
 671     vector<int> up_after_out;
 672     {
 673       // STEP-1: try mark out up[1] and all other OSDs from the same host
 674       int parent = osdmap.crush->get_parent_of_type(up[1],
 675         osdmap.crush->get_type_id("host"));
 676       set<int> children;
 677       osdmap.crush->get_leaves(osdmap.crush->get_item_name(parent),
 678         &children);
 679       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 680       for (auto c: children) {
 681         pending_inc.new_weight[c] = CEPH_OSD_OUT;
 682       }
 683       OSDMap tmpmap;
 684       tmpmap.deepish_copy_from(osdmap);
 685       tmpmap.apply_incremental(pending_inc);
 686       vector<int> new_up;
 687       int new_up_primary;
 688       tmpmap.pg_to_raw_up(pgid, &new_up, &new_up_primary);
 689       // verify that we'll have OSDs from a different host..
 690       int will_choose = -1;
 691       for (auto o: new_up) {
 692         int parent = tmpmap.crush->get_parent_of_type(o,
 693           osdmap.crush->get_type_id("host"));
 694         if (!parents.count(parent)) {
 695           will_choose = o;
 696           candidate_parent = parent; // record
 697           break;
 698         }
 699       }
 700       ASSERT_LT(-1, will_choose); // it is an OSD!
 701       ASSERT_TRUE(candidate_parent != 0);
 702       osdmap.crush->get_leaves(osdmap.crush->get_item_name(candidate_parent),
 703         &candidate_children);
 704       ASSERT_TRUE(candidate_children.count(will_choose));
 705       candidate_children.erase(will_choose);
 706       ASSERT_TRUE(!candidate_children.empty());
 707       up_after_out = new_up; // needed for verification..
 708     }
 709     {
 710       // STEP-2: generating a new pg_upmap_items entry by
 711       // replacing up[0] with one coming from candidate_children
 712       int victim = up[0];
 713       int replaced_by = *candidate_children.begin();
 714       vector<pair<int32_t,int32_t>> new_pg_upmap_items;
 715       new_pg_upmap_items.push_back(make_pair(victim, replaced_by));
 716       // apply
 717       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 718       pending_inc.new_pg_upmap_items[pgid] =
 719         mempool::osdmap::vector<pair<int32_t,int32_t>>(
 720         new_pg_upmap_items.begin(), new_pg_upmap_items.end());
 721       osdmap.apply_incremental(pending_inc);
 722       {
 723         // validate pg_upmap_items is there
 724         vector<int> new_up;
 725         int new_up_primary;
 726         osdmap.pg_to_raw_up(pgid, &new_up, &new_up_primary);
 727         ASSERT_TRUE(up.size() == new_up.size());
 728         ASSERT_TRUE(std::find(new_up.begin(), new_up.end(), replaced_by) !=
 729           new_up.end());
 730         // and up[1] too
 731         ASSERT_TRUE(std::find(new_up.begin(), new_up.end(), up[1]) !=
 732           new_up.end());
 733       }
 734     }
 735     {
 736       // STEP-3: mark out up[1] and all other OSDs from the same host
 737       int parent = osdmap.crush->get_parent_of_type(up[1],
 738         osdmap.crush->get_type_id("host"));
 739       set<int> children;
 740       osdmap.crush->get_leaves(osdmap.crush->get_item_name(parent),
 741         &children);
 742       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 743       for (auto c: children) {
 744         pending_inc.new_weight[c] = CEPH_OSD_OUT;
 745       }
 746       osdmap.apply_incremental(pending_inc);
 747       {
 748         // validate we have two OSDs from the same host now..
 749         vector<int> new_up;
 750         int new_up_primary;
 751         osdmap.pg_to_raw_up(pgid, &new_up, &new_up_primary);
 752         ASSERT_TRUE(up.size() == new_up.size());
 753         int parent_0 = osdmap.crush->get_parent_of_type(new_up[0],
 754           osdmap.crush->get_type_id("host"));
 755         int parent_1 = osdmap.crush->get_parent_of_type(new_up[1],
 756           osdmap.crush->get_type_id("host"));
 757         ASSERT_TRUE(parent_0 == parent_1);
 758       }
 759     }
 760     {
 761       // STEP-4: apply cure
 762       OSDMap::Incremental pending_inc(osdmap.get_epoch() + 1);
 763       osdmap.maybe_remove_pg_upmaps(g_ceph_context, osdmap, &pending_inc);
 764       osdmap.apply_incremental(pending_inc);
 765       {
 766         // validate pg_upmap_items is gone (reverted)
 767         vector<int> new_up;
 768         int new_up_primary;
 769         osdmap.pg_to_raw_up(pgid, &new_up, &new_up_primary);
 770         ASSERT_TRUE(new_up == up_after_out);
 771       }
 772     }
 773   }
 774 }
 775
 776 TEST(PGTempMap, basic)
 777 {
 778   PGTempMap m;
 779   pg_t a(1,1);
 780   for (auto i=3; i<1000; ++i) {
 781     pg_t x(i, 1);
 782     m.set(x, {static_cast<int>(i)});
 783   }
 784   pg_t b(2,1);
 785   m.set(a, {1, 2});
 786   ASSERT_NE(m.find(a), m.end());
 787   ASSERT_EQ(m.find(a), m.begin());
 788   ASSERT_EQ(m.find(b), m.end());
 789   ASSERT_EQ(998u, m.size());
 790 }
 791