rbd-replay: Use standard image@snap instead of image/snap

Signed-off-by: Adam Crume <adamcrume@gmail.com>

diff --git a/src/rbd_replay/ImageNameMap.cc b/src/rbd_replay/ImageNameMap.cc
index f17c750f4a6ca0aef17e92aba49cf7451a22ea0b..6331e5a58b7c07facb978161ecf62333aca0f2a6 100644 (file)
--- a/src/rbd_replay/ImageNameMap.cc
+++ b/src/rbd_replay/ImageNameMap.cc
@@ -26,10 +26,10 @@ static ImageNameMap::Name bad_mapping_abort(ImageNameMap::Name input, string out
 }
 
 ImageNameMap::ImageNameMap()
-  : m_name("((?:[^/\\\\]|\\\\.)*)/((?:[^/\\\\]|\\\\.)*)"),
-    m_escaped_slash("\\\\/"),
+  : m_name("((?:[^@\\\\]|\\\\.)*)@((?:[^@\\\\]|\\\\.)*)"),
+    m_escaped_at("\\\\@"),
     m_escaped_backslash("\\\\\\\\"),
-    m_slash("/"),
+    m_at("@"),
     m_backslash("\\\\"),
     m_bad_mapping_fallback(bad_mapping_abort) {
 }
@@ -42,21 +42,21 @@ void ImageNameMap::add_mapping(Mapping mapping) {
   m_map.add_mapping(mapping);
 }
 
-string ImageNameMap::unescape_slash(string s) const {
-  s = boost::regex_replace(s, m_escaped_slash, "/");
+string ImageNameMap::unescape_at(string s) const {
+  s = boost::regex_replace(s, m_escaped_at, "@");
   return  boost::regex_replace(s, m_escaped_backslash, "\\\\");
 }
 
-string ImageNameMap::escape_slash(string s) const {
+string ImageNameMap::escape_at(string s) const {
   string result = boost::regex_replace(s, m_backslash, "\\\\");
-  return boost::regex_replace(result, m_slash, "\\\\/");
+  return boost::regex_replace(result, m_at, "\\\\@");
 }
 
 bool ImageNameMap::parse_name(string name_string, Name *name) const {
   boost::smatch what;
   if (boost::regex_match(name_string, what, m_name)) {
-    string image(unescape_slash(what[1]));
-    string snap(unescape_slash(what[2]));
+    string image(unescape_at(what[1]));
+    string snap(unescape_at(what[2]));
     *name = Name(image, snap);
     return true;
   } else {
@@ -65,7 +65,7 @@ bool ImageNameMap::parse_name(string name_string, Name *name) const {
 }
 
 string ImageNameMap::format_name(ImageNameMap::Name name) const {
-  return escape_slash(name.first) + "/" + escape_slash(name.second);
+  return escape_at(name.first) + "@" + escape_at(name.second);
 }
 
 ImageNameMap::Name ImageNameMap::map(ImageNameMap::Name name) const {

diff --git a/src/rbd_replay/ImageNameMap.hpp b/src/rbd_replay/ImageNameMap.hpp
index 5e9fa8cc93c75e1b5ac4131d8e1c3fd8eb9eea00..36570481eaec82ff6912823891af20d530daa187 100644 (file)
--- a/src/rbd_replay/ImageNameMap.hpp
+++ b/src/rbd_replay/ImageNameMap.hpp
@@ -47,22 +47,22 @@ public:
   void set_bad_mapping_fallback(BadMappingFallback bad_mapping_fallback);
 
 private:
-  std::string escape_slash(std::string s) const;
+  std::string escape_at(std::string s) const;
 
-  std::string unescape_slash(std::string s) const;
+  std::string unescape_at(std::string s) const;
 
   NameMap m_map;
 
-  // Split "a/b" into "a" and "b", allowing for escaped slashes
+  // Split "a@b" into "a" and "b", allowing for escaped at sign
   boost::regex m_name;
 
-  // We don't have to worry about an even number of backslahes followed by a slash,
-  // because that slash would have already been matched and removed.
-  boost::regex m_escaped_slash;
+  // We don't have to worry about an even number of backslahes followed by an at sign,
+  // because that at sign would have already been matched and removed.
+  boost::regex m_escaped_at;
 
   boost::regex m_escaped_backslash;
 
-  boost::regex m_slash;
+  boost::regex m_at;
 
   boost::regex m_backslash;
 

diff --git a/src/rbd_replay/rbd-replay.cc b/src/rbd_replay/rbd-replay.cc
index a90317e0e694c7696a9ec34a21b644eae758a512..b1e3cb586da3e86ea73fd70d5b8140db15f2cae2 100644 (file)
--- a/src/rbd_replay/rbd-replay.cc
+++ b/src/rbd_replay/rbd-replay.cc
@@ -44,9 +44,9 @@ static void usage(const char* program) {
   cout << "                                  image names in the replay cluster." << std::endl;
   cout << std::endl;
   cout << "Image mapping rules:" << std::endl;
-  cout << "A rule of image1/snap1=image2/snap2 would map snap1 of image1 to snap2 of" << std::endl;
-  cout << "image2. Regular expressions are used, so image/snap_(.*)=image_$1/ would map" << std::endl;
-  cout << "image/snap_1 to image_1/. (Note that an un-snapshotted image has the empty" << std::endl;
+  cout << "A rule of image1@snap1=image2@snap2 would map snap1 of image1 to snap2 of" << std::endl;
+  cout << "image2. Regular expressions are used, so image@snap_(.*)=image_$1@ would map" << std::endl;
+  cout << "image@snap_1 to image_1@. (Note that an un-snapshotted image has the empty" << std::endl;
   cout << "string for the snapshot name.)" << std::endl;
 }
 

diff --git a/src/test/test_rbd_replay.cc b/src/test/test_rbd_replay.cc
index fee950037b3108401a1bc9aa46afc760a551f508..66b476f5528cd37322242e1b626e1d4e744be9fb 100644 (file)
--- a/src/test/test_rbd_replay.cc
+++ b/src/test/test_rbd_replay.cc
@@ -69,18 +69,18 @@ TEST(RBDReplay, ImageNameMap) {
   typedef ImageNameMap::Name Name;
   ImageNameMap m;
   m.set_bad_mapping_fallback(bad_mapping);
-  add_mapping(&m, "x/y=y/x");
-  add_mapping(&m, "a\\=b/c=h/i");
-  add_mapping(&m, "a/b\\=c=j/k");
-  add_mapping(&m, "a\\\\/b/c=d/e");
-  add_mapping(&m, "a/b\\\\/c=f/g");
-  add_mapping(&m, "image/snap_(.*)=image_$1/");
-  add_mapping(&m, "bad/=///");
+  add_mapping(&m, "x@y=y@x");
+  add_mapping(&m, "a\\=b@c=h@i");
+  add_mapping(&m, "a@b\\=c=j@k");
+  add_mapping(&m, "a\\\\@b@c=d@e");
+  add_mapping(&m, "a@b\\\\@c=f@g");
+  add_mapping(&m, "image@snap_(.*)=image_$1@");
+  add_mapping(&m, "bad@=@@@");
   EXPECT_EQ(Name("y", "x"), m.map(Name("x", "y")));
   EXPECT_EQ(Name("h", "i"), m.map(Name("a=b", "c")));
   EXPECT_EQ(Name("j", "k"), m.map(Name("a", "b=c")));
-  EXPECT_EQ(Name("d", "e"), m.map(Name("a/b", "c")));
-  EXPECT_EQ(Name("f", "g"), m.map(Name("a", "b/c")));
+  EXPECT_EQ(Name("d", "e"), m.map(Name("a@b", "c")));
+  EXPECT_EQ(Name("f", "g"), m.map(Name("a", "b@c")));
   EXPECT_EQ(Name("image_1", ""), m.map(Name("image", "snap_1")));
   EXPECT_EQ(Name("xxx", "xxx"), m.map(Name("bad", "")));
 }