[ceph.git] / ceph / src / tools / rbd / action / ImageMeta.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#include "tools/rbd/ArgumentTypes.h"
#include "tools/rbd/Shell.h"
#include "tools/rbd/Utils.h"
#include "common/errno.h"
#include "common/Formatter.h"
#include "common/TextTable.h"
#include <iostream>
#include <boost/program_options.hpp>

namespace rbd {
namespace action {
namespace image_meta {

namespace at = argument_types;
namespace po = boost::program_options;

namespace {

void add_key_option(po::options_description *positional) {
  positional->add_options()
    ("key", "image meta key");
}

int get_key(const po::variables_map &vm, size_t *arg_index,
            std::string *key) {
  *key = utils::get_positional_argument(vm, *arg_index);
  if (key->empty()) {
    std::cerr << "rbd: metadata key was not specified" << std::endl;
    return -EINVAL;
  } else {
    ++(*arg_index);
  }
  return 0;
}

const uint32_t MAX_KEYS = 64;

} // anonymous namespace

static int do_metadata_list(librbd::Image& image, Formatter *f)
{
  int r;
  TextTable tbl;

  size_t count = 0;
  std::string last_key;
  bool more_results = true;
  while (more_results) {
    std::map<std::string, bufferlist> pairs;
    r = image.metadata_list(last_key, MAX_KEYS, &pairs);
    if (r < 0) {
      std::cerr << "failed to list metadata of image : " << cpp_strerror(r)
                << std::endl;
      return r;
    }

    more_results = (pairs.size() == MAX_KEYS);
    if (!pairs.empty()) {
      if (count == 0) {
        if (f) {
          f->open_object_section("metadatas");
        } else {
          tbl.define_column("Key", TextTable::LEFT, TextTable::LEFT);
          tbl.define_column("Value", TextTable::LEFT, TextTable::LEFT);
        }
      }

      last_key = pairs.rbegin()->first;
      count += pairs.size();

      for (auto kv : pairs) {
        std::string val(kv.second.c_str(), kv.second.length());
        if (f) {
          f->dump_string(kv.first.c_str(), val.c_str());
        } else {
          tbl << kv.first << val << TextTable::endrow;
        }
      }
    }
  }

  if (f == nullptr) {
    bool single = (count == 1);
    std::cout << "There " << (single ? "is" : "are") << " " << count << " "
              << (single ? "metadatum" : "metadata") << " on this image"
              << (count == 0 ? "." : ":") << std::endl;
  }

  if (count > 0) {
    if (f) {
      f->close_section();
      f->flush(std::cout);
    } else {
      std::cout << std::endl << tbl;
    }
  }
  return 0;
}

static int do_metadata_set(librbd::Image& image, std::string &key,
                          std::string &value)
{
  int r = image.metadata_set(key, value);
  if (r < 0) {
    std::cerr << "failed to set metadata " << key << " of image : "
              << cpp_strerror(r) << std::endl;
  }
  return r;
}

static int do_metadata_remove(librbd::Image& image, std::string &key)
{
  int r = image.metadata_remove(key);
  if (r == -ENOENT) {
      std::cerr << "rbd: no existing metadata key " << key << " of image : "
                << cpp_strerror(r) << std::endl;
  } else if(r < 0) {
      std::cerr << "failed to remove metadata " << key << " of image : "
                << cpp_strerror(r) << std::endl;
  }
  return r;
}

static int do_metadata_get(librbd::Image& image, std::string &key)
{
  std::string s;
  int r = image.metadata_get(key, &s);
  if (r < 0) {
    std::cerr << "failed to get metadata " << key << " of image : "
              << cpp_strerror(r) << std::endl;
    return r;
  }
  std::cout << s << std::endl;
  return r;
}

void get_list_arguments(po::options_description *positional,
                        po::options_description *options) {
  at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
  at::add_format_options(options);
}

int execute_list(const po::variables_map &vm,
                 const std::vector<std::string> &ceph_global_init_args) {
  size_t arg_index = 0;
  std::string pool_name;
  std::string namespace_name;
  std::string image_name;
  std::string snap_name;
  int r = utils::get_pool_image_snapshot_names(
    vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
    &image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
    utils::SPEC_VALIDATION_NONE);
  if (r < 0) {
    return r;
  }

  at::Format::Formatter formatter;
  r = utils::get_formatter(vm, &formatter);
  if (r < 0) {
    return r;
  }

  librados::Rados rados;
  librados::IoCtx io_ctx;
  librbd::Image image;
  r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
                                 false, &rados, &io_ctx, &image);
  if (r < 0) {
    return r;
  }

  r = do_metadata_list(image, formatter.get());
  if (r < 0) {
    std::cerr << "rbd: listing metadata failed: " << cpp_strerror(r)
              << std::endl;
    return r;
  }
  return 0;
}

void get_get_arguments(po::options_description *positional,
                       po::options_description *options) {
  at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
  add_key_option(positional);
}

int execute_get(const po::variables_map &vm,
                const std::vector<std::string> &ceph_global_init_args) {
  size_t arg_index = 0;
  std::string pool_name;
  std::string namespace_name;
  std::string image_name;
  std::string snap_name;
  int r = utils::get_pool_image_snapshot_names(
    vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
    &image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
    utils::SPEC_VALIDATION_NONE);
  if (r < 0) {
    return r;
  }

  std::string key;
  r = get_key(vm, &arg_index, &key);
  if (r < 0) {
    return r;
  }

  librados::Rados rados;
  librados::IoCtx io_ctx;
  librbd::Image image;
  r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
                                 false, &rados, &io_ctx, &image);
  if (r < 0) {
    return r;
  }

  r = do_metadata_get(image, key);
  if (r < 0) {
    std::cerr << "rbd: getting metadata failed: " << cpp_strerror(r)
              << std::endl;
    return r;
  }
  return 0;
}

void get_set_arguments(po::options_description *positional,
                       po::options_description *options) {
  at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
  add_key_option(positional);
  positional->add_options()
    ("value", "image meta value");
}

int execute_set(const po::variables_map &vm,
                const std::vector<std::string> &ceph_global_init_args) {
  size_t arg_index = 0;
  std::string pool_name;
  std::string namespace_name;
  std::string image_name;
  std::string snap_name;
  int r = utils::get_pool_image_snapshot_names(
    vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
    &image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
    utils::SPEC_VALIDATION_NONE);
  if (r < 0) {
    return r;
  }

  std::string key;
  r = get_key(vm, &arg_index, &key);
  if (r < 0) {
    return r;
  }

  std::string value = utils::get_positional_argument(vm, arg_index);
  if (value.empty()) {
    std::cerr << "rbd: metadata value was not specified" << std::endl;
    return -EINVAL;
  }

  librados::Rados rados;
  librados::IoCtx io_ctx;
  librbd::Image image;
  r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
                                 false, &rados, &io_ctx, &image);
  if (r < 0) {
    return r;
  }

  r = do_metadata_set(image, key, value);
  if (r < 0) {
    std::cerr << "rbd: setting metadata failed: " << cpp_strerror(r)
              << std::endl;
    return r;
  }
  return 0;
}

void get_remove_arguments(po::options_description *positional,
                          po::options_description *options) {
  at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
  add_key_option(positional);
}

int execute_remove(const po::variables_map &vm,
                   const std::vector<std::string> &ceph_global_init_args) {
  size_t arg_index = 0;
  std::string pool_name;
  std::string namespace_name;
  std::string image_name;
  std::string snap_name;
  int r = utils::get_pool_image_snapshot_names(
    vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
    &image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
    utils::SPEC_VALIDATION_NONE);
  if (r < 0) {
    return r;
  }

  std::string key;
  r = get_key(vm, &arg_index, &key);
  if (r < 0) {
    return r;
  }

  librados::Rados rados;
  librados::IoCtx io_ctx;
  librbd::Image image;
  r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
                                 false, &rados, &io_ctx, &image);
  if (r < 0) {
    return r;
  }

  r = do_metadata_remove(image, key);
  if (r < 0) {
    std::cerr << "rbd: removing metadata failed: " << cpp_strerror(r)
              << std::endl;
    return r;
  }
  return 0;
}

Shell::Action action_list(
  {"image-meta", "list"}, {"image-meta", "ls"}, "Image metadata list keys with values.", "",
  &get_list_arguments, &execute_list);
Shell::Action action_get(
  {"image-meta", "get"}, {},
  "Image metadata get the value associated with the key.", "",
  &get_get_arguments, &execute_get);
Shell::Action action_set(
  {"image-meta", "set"}, {}, "Image metadata set key with value.", "",
  &get_set_arguments, &execute_set);
Shell::Action action_remove(
  {"image-meta", "remove"}, {"image-meta", "rm"},
  "Image metadata remove the key and value associated.", "",
  &get_remove_arguments, &execute_remove);

} // namespace image_meta
} // namespace action
} // namespace rbd
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3
	4	#include "tools/rbd/ArgumentTypes.h"
	5	#include "tools/rbd/Shell.h"
	6	#include "tools/rbd/Utils.h"
	7	#include "common/errno.h"
	8	#include "common/Formatter.h"
	9	#include "common/TextTable.h"
	10	#include <iostream>
	11	#include <boost/program_options.hpp>
	12
	13	namespace rbd {
	14	namespace action {
	15	namespace image_meta {
	16
	17	namespace at = argument_types;
	18	namespace po = boost::program_options;
	19
	20	namespace {
	21
	22	void add_key_option(po::options_description *positional) {
	23	positional->add_options()
	24	("key", "image meta key");
	25	}
	26
11fdf7f2 TL	27	int get_key(const po::variables_map &vm, size_t *arg_index,
	28	std::string *key) {
	29	key = utils::get_positional_argument(vm, arg_index);
7c673cae FG	30	if (key->empty()) {
	31	std::cerr << "rbd: metadata key was not specified" << std::endl;
	32	return -EINVAL;
11fdf7f2 TL	33	} else {
11fdf7f2 TL	34	++(*arg_index);
7c673cae FG	35	}
	36	return 0;
	37	}
	38
181888fb FG	39	const uint32_t MAX_KEYS = 64;
181888fb FG	40
7c673cae FG	41	} // anonymous namespace
	42
	43	static int do_metadata_list(librbd::Image& image, Formatter *f)
	44	{
7c673cae FG	45	int r;
	46	TextTable tbl;
	47
181888fb FG	48	size_t count = 0;
	49	std::string last_key;
	50	bool more_results = true;
	51	while (more_results) {
	52	std::map<std::string, bufferlist> pairs;
	53	r = image.metadata_list(last_key, MAX_KEYS, &pairs);
	54	if (r < 0) {
	55	std::cerr << "failed to list metadata of image : " << cpp_strerror(r)
	56	<< std::endl;
	57	return r;
	58	}
7c673cae	59
181888fb FG	60	more_results = (pairs.size() == MAX_KEYS);
	61	if (!pairs.empty()) {
	62	if (count == 0) {
	63	if (f) {
	64	f->open_object_section("metadatas");
	65	} else {
	66	tbl.define_column("Key", TextTable::LEFT, TextTable::LEFT);
	67	tbl.define_column("Value", TextTable::LEFT, TextTable::LEFT);
	68	}
	69	}
7c673cae	70
181888fb FG	71	last_key = pairs.rbegin()->first;
181888fb FG	72	count += pairs.size();
7c673cae	73
181888fb FG	74	for (auto kv : pairs) {
	75	std::string val(kv.second.c_str(), kv.second.length());
	76	if (f) {
	77	f->dump_string(kv.first.c_str(), val.c_str());
	78	} else {
	79	tbl << kv.first << val << TextTable::endrow;
	80	}
7c673cae FG	81	}
7c673cae FG	82	}
7c673cae FG	83	}
7c673cae FG	84
181888fb FG	85	if (f == nullptr) {
	86	bool single = (count == 1);
	87	std::cout << "There " << (single ? "is" : "are") << " " << count << " "
	88	<< (single ? "metadatum" : "metadata") << " on this image"
	89	<< (count == 0 ? "." : ":") << std::endl;
	90	}
	91
	92	if (count > 0) {
	93	if (f) {
	94	f->close_section();
	95	f->flush(std::cout);
	96	} else {
	97	std::cout << std::endl << tbl;
	98	}
7c673cae FG	99	}
	100	return 0;
	101	}
	102
11fdf7f2 TL	103	static int do_metadata_set(librbd::Image& image, std::string &key,
11fdf7f2 TL	104	std::string &value)
7c673cae FG	105	{
	106	int r = image.metadata_set(key, value);
	107	if (r < 0) {
	108	std::cerr << "failed to set metadata " << key << " of image : "
	109	<< cpp_strerror(r) << std::endl;
	110	}
	111	return r;
	112	}
	113
11fdf7f2	114	static int do_metadata_remove(librbd::Image& image, std::string &key)
7c673cae FG	115	{
7c673cae FG	116	int r = image.metadata_remove(key);
d2e6a577 FG	117	if (r == -ENOENT) {
	118	std::cerr << "rbd: no existing metadata key " << key << " of image : "
	119	<< cpp_strerror(r) << std::endl;
	120	} else if(r < 0) {
	121	std::cerr << "failed to remove metadata " << key << " of image : "
	122	<< cpp_strerror(r) << std::endl;
7c673cae FG	123	}
	124	return r;
	125	}
	126
11fdf7f2	127	static int do_metadata_get(librbd::Image& image, std::string &key)
7c673cae FG	128	{
	129	std::string s;
	130	int r = image.metadata_get(key, &s);
	131	if (r < 0) {
	132	std::cerr << "failed to get metadata " << key << " of image : "
	133	<< cpp_strerror(r) << std::endl;
	134	return r;
	135	}
	136	std::cout << s << std::endl;
	137	return r;
	138	}
	139
	140	void get_list_arguments(po::options_description *positional,
	141	po::options_description *options) {
	142	at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
	143	at::add_format_options(options);
	144	}
	145
11fdf7f2 TL	146	int execute_list(const po::variables_map &vm,
11fdf7f2 TL	147	const std::vector<std::string> &ceph_global_init_args) {
7c673cae FG	148	size_t arg_index = 0;
7c673cae FG	149	std::string pool_name;
11fdf7f2	150	std::string namespace_name;
7c673cae FG	151	std::string image_name;
	152	std::string snap_name;
	153	int r = utils::get_pool_image_snapshot_names(
11fdf7f2 TL	154	vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
	155	&image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
	156	utils::SPEC_VALIDATION_NONE);
7c673cae FG	157	if (r < 0) {
	158	return r;
	159	}
	160
	161	at::Format::Formatter formatter;
	162	r = utils::get_formatter(vm, &formatter);
	163	if (r < 0) {
	164	return r;
	165	}
	166
	167	librados::Rados rados;
	168	librados::IoCtx io_ctx;
	169	librbd::Image image;
11fdf7f2 TL	170	r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
11fdf7f2 TL	171	false, &rados, &io_ctx, &image);
7c673cae FG	172	if (r < 0) {
	173	return r;
	174	}
	175
	176	r = do_metadata_list(image, formatter.get());
	177	if (r < 0) {
	178	std::cerr << "rbd: listing metadata failed: " << cpp_strerror(r)
	179	<< std::endl;
	180	return r;
	181	}
	182	return 0;
	183	}
	184
	185	void get_get_arguments(po::options_description *positional,
	186	po::options_description *options) {
	187	at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
	188	add_key_option(positional);
	189	}
	190
11fdf7f2 TL	191	int execute_get(const po::variables_map &vm,
11fdf7f2 TL	192	const std::vector<std::string> &ceph_global_init_args) {
7c673cae FG	193	size_t arg_index = 0;
7c673cae FG	194	std::string pool_name;
11fdf7f2	195	std::string namespace_name;
7c673cae FG	196	std::string image_name;
	197	std::string snap_name;
	198	int r = utils::get_pool_image_snapshot_names(
11fdf7f2 TL	199	vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
	200	&image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
	201	utils::SPEC_VALIDATION_NONE);
7c673cae FG	202	if (r < 0) {
	203	return r;
	204	}
	205
	206	std::string key;
11fdf7f2	207	r = get_key(vm, &arg_index, &key);
7c673cae FG	208	if (r < 0) {
	209	return r;
	210	}
	211
	212	librados::Rados rados;
	213	librados::IoCtx io_ctx;
	214	librbd::Image image;
11fdf7f2 TL	215	r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
11fdf7f2 TL	216	false, &rados, &io_ctx, &image);
7c673cae FG	217	if (r < 0) {
	218	return r;
	219	}
	220
11fdf7f2	221	r = do_metadata_get(image, key);
7c673cae FG	222	if (r < 0) {
	223	std::cerr << "rbd: getting metadata failed: " << cpp_strerror(r)
	224	<< std::endl;
	225	return r;
	226	}
	227	return 0;
	228	}
	229
	230	void get_set_arguments(po::options_description *positional,
	231	po::options_description *options) {
	232	at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
	233	add_key_option(positional);
	234	positional->add_options()
	235	("value", "image meta value");
	236	}
	237
11fdf7f2 TL	238	int execute_set(const po::variables_map &vm,
11fdf7f2 TL	239	const std::vector<std::string> &ceph_global_init_args) {
7c673cae FG	240	size_t arg_index = 0;
7c673cae FG	241	std::string pool_name;
11fdf7f2	242	std::string namespace_name;
7c673cae FG	243	std::string image_name;
	244	std::string snap_name;
	245	int r = utils::get_pool_image_snapshot_names(
11fdf7f2 TL	246	vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
	247	&image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
	248	utils::SPEC_VALIDATION_NONE);
7c673cae FG	249	if (r < 0) {
	250	return r;
	251	}
	252
	253	std::string key;
11fdf7f2	254	r = get_key(vm, &arg_index, &key);
7c673cae FG	255	if (r < 0) {
	256	return r;
	257	}
	258
494da23a	259	std::string value = utils::get_positional_argument(vm, arg_index);
7c673cae FG	260	if (value.empty()) {
	261	std::cerr << "rbd: metadata value was not specified" << std::endl;
	262	return -EINVAL;
	263	}
	264
	265	librados::Rados rados;
	266	librados::IoCtx io_ctx;
	267	librbd::Image image;
11fdf7f2 TL	268	r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
11fdf7f2 TL	269	false, &rados, &io_ctx, &image);
7c673cae FG	270	if (r < 0) {
	271	return r;
	272	}
	273
11fdf7f2	274	r = do_metadata_set(image, key, value);
7c673cae FG	275	if (r < 0) {
	276	std::cerr << "rbd: setting metadata failed: " << cpp_strerror(r)
	277	<< std::endl;
	278	return r;
	279	}
	280	return 0;
	281	}
	282
	283	void get_remove_arguments(po::options_description *positional,
	284	po::options_description *options) {
	285	at::add_image_spec_options(positional, options, at::ARGUMENT_MODIFIER_NONE);
	286	add_key_option(positional);
	287	}
	288
11fdf7f2 TL	289	int execute_remove(const po::variables_map &vm,
11fdf7f2 TL	290	const std::vector<std::string> &ceph_global_init_args) {
7c673cae FG	291	size_t arg_index = 0;
7c673cae FG	292	std::string pool_name;
11fdf7f2	293	std::string namespace_name;
7c673cae FG	294	std::string image_name;
	295	std::string snap_name;
	296	int r = utils::get_pool_image_snapshot_names(
11fdf7f2 TL	297	vm, at::ARGUMENT_MODIFIER_NONE, &arg_index, &pool_name, &namespace_name,
	298	&image_name, &snap_name, true, utils::SNAPSHOT_PRESENCE_NONE,
	299	utils::SPEC_VALIDATION_NONE);
7c673cae FG	300	if (r < 0) {
	301	return r;
	302	}
	303
	304	std::string key;
11fdf7f2	305	r = get_key(vm, &arg_index, &key);
7c673cae FG	306	if (r < 0) {
	307	return r;
	308	}
	309
	310	librados::Rados rados;
	311	librados::IoCtx io_ctx;
	312	librbd::Image image;
11fdf7f2 TL	313	r = utils::init_and_open_image(pool_name, namespace_name, image_name, "", "",
11fdf7f2 TL	314	false, &rados, &io_ctx, &image);
7c673cae FG	315	if (r < 0) {
	316	return r;
	317	}
	318
11fdf7f2	319	r = do_metadata_remove(image, key);
7c673cae FG	320	if (r < 0) {
	321	std::cerr << "rbd: removing metadata failed: " << cpp_strerror(r)
	322	<< std::endl;
	323	return r;
	324	}
	325	return 0;
	326	}
	327
	328	Shell::Action action_list(
11fdf7f2	329	{"image-meta", "list"}, {"image-meta", "ls"}, "Image metadata list keys with values.", "",
7c673cae FG	330	&get_list_arguments, &execute_list);
	331	Shell::Action action_get(
	332	{"image-meta", "get"}, {},
	333	"Image metadata get the value associated with the key.", "",
	334	&get_get_arguments, &execute_get);
	335	Shell::Action action_set(
	336	{"image-meta", "set"}, {}, "Image metadata set key with value.", "",
	337	&get_set_arguments, &execute_set);
	338	Shell::Action action_remove(
11fdf7f2	339	{"image-meta", "remove"}, {"image-meta", "rm"},
7c673cae FG	340	"Image metadata remove the key and value associated.", "",
	341	&get_remove_arguments, &execute_remove);
	342
	343	} // namespace image_meta
	344	} // namespace action
	345	} // namespace rbd