test_idempotent_sequence: diff two stores.

Signed-off-by: Joao Eduardo Luis <jecluis@gmail.com>

diff --git a/src/test/filestore_test/test_idempotent_sequence.cc b/src/test/filestore_test/test_idempotent_sequence.cc
index 9a8dcd765355303cfb280edd8a08cb5d007538bd..143eaf14ce66105d8b598325d5d661bb40ebc5a6 100644 (file)
--- a/src/test/filestore_test/test_idempotent_sequence.cc
+++ b/src/test/filestore_test/test_idempotent_sequence.cc
@@ -74,6 +74,193 @@ bool is_seed_set = false;
 int verify_at = 0;
 std::string status_file;
 
+bool diff_attrs(std::map<std::string,bufferptr>& verify,
+    std::map<std::string,bufferptr>& store)
+{
+  std::map<std::string, bufferptr>::iterator v_it = verify.begin();
+  std::map<std::string, bufferptr>::iterator s_it = store.begin();
+  for (; v_it != verify.end(); ++v_it, ++s_it) {
+    if (v_it->first != s_it->first) {
+      dout(0) << "diff_attrs name mismatch (verify: " << v_it->first
+          << ", store: " << s_it->first << ")" << dendl;
+      return false;
+    }
+
+    if (!v_it->second.cmp(s_it->second)) {
+      dout(0) << "diff_attrs contents mismatch on attr " << v_it->first << dendl;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool diff_objects_stat(struct stat& a, struct stat& b)
+{
+  if (a.st_uid != b.st_uid) {
+    dout(0) << "diff_objects_stat uid mismatch ("
+        << a.st_uid << " != " << b.st_uid << ")" << dendl;
+    return false;
+  }
+
+  if (a.st_gid != b.st_gid) {
+    dout(0) << "diff_objects_stat gid mismatch ("
+        << a.st_gid << " != " << b.st_gid << ")" << dendl;
+    return false;
+  }
+
+  if (a.st_mode != b.st_mode) {
+    dout(0) << "diff_objects_stat mode mismatch ("
+        << a.st_mode << " != " << b.st_mode << ")" << dendl;
+    return false;
+  }
+
+  if (a.st_nlink != b.st_nlink) {
+    dout(0) << "diff_objects_stat nlink mismatch ("
+        << a.st_nlink << " != " << b.st_nlink << ")" << dendl;
+    return false;
+  }
+
+  if (a.st_size != b.st_size) {
+    dout(0) << "diff_objects_stat size mismatch ("
+        << a.st_size << " != " << b.st_size << ")" << dendl;
+    return false;
+  }
+  return true;
+}
+
+bool diff_objects(FileStore *store, FileStore *verify, coll_t coll)
+{
+  int err;
+  std::vector<hobject_t> verify_objects, store_objects;
+  err = verify->collection_list(coll, verify_objects);
+  if (err < 0) {
+    dout(0) << "diff_objects list on verify coll " << coll.to_str()
+        << " returns " << err << dendl;
+    return false;
+  }
+  err = store->collection_list(coll, store_objects);
+  if (err < 0) {
+    dout(0) << "diff_objects list on store coll " << coll.to_str()
+              << " returns " << err << dendl;
+    return false;
+  }
+
+  if (verify_objects.size() != store_objects.size()) {
+    dout(0) << "diff_objects size mismatch (verify: " << verify_objects.size()
+        << ", store: " << store_objects.size() << ")" << dendl;
+    return false;
+  }
+
+  std::vector<hobject_t>::iterator v_it = verify_objects.begin();
+  std::vector<hobject_t>::iterator s_it = verify_objects.begin();
+  for (; v_it != verify_objects.end(); ++v_it, ++s_it) {
+    hobject_t v_obj = *v_it, s_obj = *s_it;
+    if (v_obj.oid.name != s_obj.oid.name) {
+      dout(0) << "diff_objects name mismatch (verify: "<< v_obj.oid.name
+          << ", store: " << s_obj.oid.name << ")" << dendl;
+      return false;
+    }
+
+    struct stat v_stat, s_stat;
+    err = verify->stat(coll, v_obj, &v_stat);
+    if (err < 0) {
+      dout(0) << "diff_objects error stating " << v_obj.oid.name << dendl;
+      return false;
+    }
+    err = store->stat(coll, s_obj, &s_stat);
+    if (err < 0) {
+      dout(0) << "diff_objects error stating " << s_obj.oid.name << dendl;
+      return false;
+    }
+
+    if (diff_objects_stat(v_stat, s_stat)) {
+      dout(0) << "diff_objects stat mismatch" << dendl;
+      return false;
+    }
+
+    bufferlist s_bl, v_bl;
+    verify->read(coll, v_obj, 0, v_stat.st_size, v_bl);
+    store->read(coll, s_obj, 0, s_stat.st_size, s_bl);
+
+    if (!s_bl.contents_equal(v_bl)) {
+      dout(0) << "diff_objects content mismatch" << dendl;
+      return false;
+    }
+
+    std::map<std::string, bufferptr> s_attrs_map, v_attrs_map;
+    err = store->getattrs(coll, s_obj, s_attrs_map);
+    if (err < 0) {
+      dout(0) << "diff_objects getattrs on store object " << s_obj.oid.name
+                      << "returns " << err << dendl;
+      return false;
+    }
+    err = verify->getattrs(coll, v_obj, v_attrs_map);
+    if (err < 0) {
+      dout(0) << "diff_objects getattrs on verify object " << v_obj.oid.name
+          << "returns " << err << dendl;
+      return false;
+    }
+
+    if (!diff_attrs(v_attrs_map, s_attrs_map)) {
+      dout(0) << "diff_objects attrs mismatch" << dendl;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool diff_coll_attrs(FileStore *store, FileStore *verify, coll_t coll)
+{
+  int err;
+  std::map<std::string, bufferptr> verify_coll_attrs, store_coll_attrs;
+  err = verify->collection_getattrs(coll, verify_coll_attrs);
+  if (err < 0) {
+    dout(0) << "diff_attrs getattrs on verify coll " << coll.to_str()
+        << "returns " << err << dendl;
+    return false;
+  }
+  err = store->collection_getattrs(coll, store_coll_attrs);
+  if (err < 0) {
+    dout(0) << "diff_attrs getattrs on store coll " << coll.to_str()
+              << "returns " << err << dendl;
+    return false;
+  }
+
+  if (verify_coll_attrs.size() != store_coll_attrs.size()) {
+    dout(0) << "diff_attrs size mismatch (verify: " << verify_coll_attrs.size()
+        << ", store: " << store_coll_attrs.size() << ")" << dendl;
+    return false;
+  }
+
+  return diff_attrs(verify_coll_attrs, store_coll_attrs);
+}
+
+bool diff(FileStore *store, FileStore *verify)
+{
+  bool ret = true;
+  std::vector<coll_t> store_coll_list, verify_coll_list;;
+  verify->list_collections(verify_coll_list);
+
+  std::vector<coll_t>::iterator it = verify_coll_list.begin();
+  for (; it != verify_coll_list.end(); ++it) {
+    coll_t verify_coll = *it;
+    if (!store->collection_exists(verify_coll)) {
+      dout(0) << "diff collection " << verify_coll.to_str() << " DNE" << dendl;
+      return false;
+    }
+
+    ret = diff_coll_attrs(store, verify, verify_coll);
+    if (!ret)
+      break;
+
+    ret = diff_objects(store, verify, verify_coll);
+    if (!ret)
+      break;
+  }
+  return ret;
+}
+
 void run_diff(std::string& store_path, std::string& store_journal_path,
     std::string& verify_store_path, std::string& verify_store_journal_path)
 {
@@ -82,9 +269,8 @@ void run_diff(std::string& store_path, std::string& store_journal_path,
 
   FileStore *store = new FileStore(store_path, store_journal_path, "store");
   FileStore *verify_store = new FileStore(verify_store_path,
-      verify_store_journal_path, "verify_store");
+      verify_store_journal_path, "ablaer");
 
-  ::mkdir(verify_store_path.c_str(), 0755);
   int err;
   err = verify_store->mkfs();
   ceph_assert(err == 0);
@@ -93,9 +279,11 @@ void run_diff(std::string& store_path, std::string& store_journal_path,
   err = store->mount();
   ceph_assert(err == 0);
 
-  VerifyFileStore verify(store, verify_store, status_file);
-  verify.init(num_colls, num_objs);
-  verify.generate(seed, verify_at);
+  if (diff(store, verify_store)) {
+    dout(0) << "diff looks okay!" << dendl;
+  } else {
+    dout(0) << "diff found an error." << dendl;
+  }
 
   store->umount();
   verify_store->umount();
@@ -140,7 +328,7 @@ void run_sequence_to(int val, std::string& filestore_path,
     cerr << filestore_path << " already exists" << std::endl;
     return;
   }
-
+  
   err = store->mkfs();
   ceph_assert(err == 0);
 
@@ -168,6 +356,7 @@ void run_command(std::string& command, std::vector<std::string>& args)
     /* expect 4 arguments: (filestore path + journal path)*2 */
     if (args.size() == 4) {
       run_diff(args[0], args[1], args[2], args[3]);
+      return;
     }
   } else if (command == "get-last-op") {
     /* expect 2 arguments: a filestore path + journal */