[ceph.git] / ceph / src / mon / ConfigKeyService.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2013 Inktank, Inc
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software
 * Foundation.  See file COPYING.
 *
 */

#include <sstream>
#include <stdlib.h>
#include <limits.h>

#include "mon/Monitor.h"
#include "mon/ConfigKeyService.h"
#include "mon/MonitorDBStore.h"
#include "mon/OSDMonitor.h"
#include "common/errno.h"
#include "include/stringify.h"

#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, this)
static ostream& _prefix(std::ostream *_dout, const Monitor *mon,
                        const ConfigKeyService *service) {
  return *_dout << "mon." << mon->name << "@" << mon->rank
		<< "(" << mon->get_state_name() << ")." << service->get_name()
                << "(" << service->get_epoch() << ") ";
}

const string ConfigKeyService::STORE_PREFIX = "mon_config_key";

int ConfigKeyService::store_get(const string &key, bufferlist &bl)
{
  return mon->store->get(STORE_PREFIX, key, bl);
}

void ConfigKeyService::get_store_prefixes(set<string>& s)
{
  s.insert(STORE_PREFIX);
}

void ConfigKeyService::store_put(const string &key, bufferlist &bl, Context *cb)
{
  MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
  t->put(STORE_PREFIX, key, bl);
  if (cb)
    paxos->queue_pending_finisher(cb);
  paxos->trigger_propose();
}

void ConfigKeyService::store_delete(const string &key, Context *cb)
{
  MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
  store_delete(t, key);
  if (cb)
    paxos->queue_pending_finisher(cb);
  paxos->trigger_propose();
}

void ConfigKeyService::store_delete(
    MonitorDBStore::TransactionRef t,
    const string &key)
{
  t->erase(STORE_PREFIX, key);
}

bool ConfigKeyService::store_exists(const string &key)
{
  return mon->store->exists(STORE_PREFIX, key);
}

void ConfigKeyService::store_list(stringstream &ss)
{
  KeyValueDB::Iterator iter =
    mon->store->get_iterator(STORE_PREFIX);

  JSONFormatter f(true);
  f.open_array_section("keys");

  while (iter->valid()) {
    string key(iter->key());
    f.dump_string("key", key);
    iter->next();
  }
  f.close_section();
  f.flush(ss);
}

bool ConfigKeyService::store_has_prefix(const string &prefix)
{
  KeyValueDB::Iterator iter =
    mon->store->get_iterator(STORE_PREFIX);

  while (iter->valid()) {
    string key(iter->key());
    size_t p = key.find(prefix);
    if (p != string::npos && p == 0) {
      return true;
    }
    iter->next();
  }
  return false;
}

void ConfigKeyService::store_dump(stringstream &ss)
{
  KeyValueDB::Iterator iter =
    mon->store->get_iterator(STORE_PREFIX);

  JSONFormatter f(true);
  f.open_object_section("config-key store");

  while (iter->valid()) {
    f.dump_string(iter->key().c_str(), iter->value().to_str());
    iter->next();
  }
  f.close_section();
  f.flush(ss);
}

void ConfigKeyService::store_delete_prefix(
    MonitorDBStore::TransactionRef t,
    const string &prefix)
{
  KeyValueDB::Iterator iter =
    mon->store->get_iterator(STORE_PREFIX);

  while (iter->valid()) {
    string key(iter->key());

    size_t p = key.find(prefix);
    if (p != string::npos && p == 0) {
      store_delete(t, key);
    }
    iter->next();
  }
}

bool ConfigKeyService::service_dispatch(MonOpRequestRef op)
{
  Message *m = op->get_req();
  assert(m != NULL);
  dout(10) << __func__ << " " << *m << dendl;

  if (!in_quorum()) {
    dout(1) << __func__ << " not in quorum -- waiting" << dendl;
    paxos->wait_for_readable(op, new Monitor::C_RetryMessage(mon, op));
    return false;
  }

  assert(m->get_type() == MSG_MON_COMMAND);

  MMonCommand *cmd = static_cast<MMonCommand*>(m);

  assert(!cmd->cmd.empty());

  int ret = 0;
  stringstream ss;
  bufferlist rdata;

  string prefix;
  map<string, cmd_vartype> cmdmap;

  if (!cmdmap_from_json(cmd->cmd, &cmdmap, ss)) {
    return false;
  }

  cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
  string key;
  cmd_getval(g_ceph_context, cmdmap, "key", key);

  if (prefix == "config-key get") {
    ret = store_get(key, rdata);
    if (ret < 0) {
      assert(!rdata.length());
      ss << "error obtaining '" << key << "': " << cpp_strerror(ret);
      goto out;
    }
    ss << "obtained '" << key << "'";

  } else if (prefix == "config-key put" ||
	     prefix == "config-key set") {
    if (!mon->is_leader()) {
      mon->forward_request_leader(op);
      // we forward the message; so return now.
      return true;
    }

    bufferlist data;
    string val;
    if (cmd_getval(g_ceph_context, cmdmap, "val", val)) {
      // they specified a value in the command instead of a file
      data.append(val);
    } else if (cmd->get_data_len() > 0) {
      // they specified '-i <file>'
      data = cmd->get_data();
    }
    if (data.length() > (size_t) g_conf->mon_config_key_max_entry_size) {
      ret = -EFBIG; // File too large
      ss << "error: entry size limited to "
         << g_conf->mon_config_key_max_entry_size << " bytes. "
         << "Use 'mon config key max entry size' to manually adjust";
      goto out;
    }
    // we'll reply to the message once the proposal has been handled
    ss << "set " << key;
    store_put(key, data,
	      new Monitor::C_Command(mon, op, 0, ss.str(), 0));
    // return for now; we'll put the message once it's done.
    return true;

  } else if (prefix == "config-key del" ||
             prefix == "config-key rm") {
    if (!mon->is_leader()) {
      mon->forward_request_leader(op);
      return true;
    }

    if (!store_exists(key)) {
      ret = 0;
      ss << "no such key '" << key << "'";
      goto out;
    }
    store_delete(key, new Monitor::C_Command(mon, op, 0, "key deleted", 0));
    // return for now; we'll put the message once it's done
    return true;

  } else if (prefix == "config-key exists") {
    bool exists = store_exists(key);
    ss << "key '" << key << "'";
    if (exists) {
      ss << " exists";
      ret = 0;
    } else {
      ss << " doesn't exist";
      ret = -ENOENT;
    }

  } else if (prefix == "config-key list" ||
	     prefix == "config-key ls") {
    stringstream tmp_ss;
    store_list(tmp_ss);
    rdata.append(tmp_ss);
    ret = 0;

  } else if (prefix == "config-key dump") {
    stringstream tmp_ss;
    store_dump(tmp_ss);
    rdata.append(tmp_ss);
    ret = 0;

  }

out:
  if (!cmd->get_source().is_mon()) {
    string rs = ss.str();
    mon->reply_command(op, ret, rs, rdata, 0);
  }

  return (ret == 0);
}

string _get_dmcrypt_prefix(const uuid_d& uuid, const string k)
{
  return "dm-crypt/osd/" + stringify(uuid) + "/" + k;
}

int ConfigKeyService::validate_osd_destroy(
    const int32_t id,
    const uuid_d& uuid)
{
  string dmcrypt_prefix = _get_dmcrypt_prefix(uuid, "");
  string daemon_prefix =
    "daemon-private/osd." + stringify(id) + "/";

  if (!store_has_prefix(dmcrypt_prefix) &&
      !store_has_prefix(daemon_prefix)) {
    return -ENOENT;
  }
  return 0;
}

void ConfigKeyService::do_osd_destroy(int32_t id, uuid_d& uuid)
{
  string dmcrypt_prefix = _get_dmcrypt_prefix(uuid, "");
  string daemon_prefix =
    "daemon-private/osd." + stringify(id) + "/";

  MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
  for (auto p : { dmcrypt_prefix, daemon_prefix }) {
    store_delete_prefix(t, p);
  }

  paxos->trigger_propose();
}

int ConfigKeyService::validate_osd_new(
    const uuid_d& uuid,
    const string& dmcrypt_key,
    stringstream& ss)
{
  string dmcrypt_prefix = _get_dmcrypt_prefix(uuid, "luks");
  bufferlist value;
  value.append(dmcrypt_key);

  if (store_exists(dmcrypt_prefix)) {
    bufferlist existing_value;
    int err = store_get(dmcrypt_prefix, existing_value);
    if (err < 0) {
      dout(10) << __func__ << " unable to get dm-crypt key from store (r = "
               << err << ")" << dendl;
      return err;
    }
    if (existing_value.contents_equal(value)) {
      // both values match; this will be an idempotent op.
      return EEXIST;
    }
    ss << "dm-crypt key already exists and does not match";
    return -EEXIST;
  }
  return 0;
}

void ConfigKeyService::do_osd_new(
    const uuid_d& uuid,
    const string& dmcrypt_key)
{
  assert(paxos->is_plugged());

  string dmcrypt_key_prefix = _get_dmcrypt_prefix(uuid, "luks");
  bufferlist dmcrypt_key_value;
  dmcrypt_key_value.append(dmcrypt_key);
  // store_put() will call trigger_propose
  store_put(dmcrypt_key_prefix, dmcrypt_key_value, nullptr);
}
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	* Ceph - scalable distributed file system
	5	*
	6	* Copyright (C) 2013 Inktank, Inc
	7	*
	8	* This is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License version 2.1, as published by the Free Software
	11	* Foundation. See file COPYING.
	12	*
	13	*/
	14
	15	#include <sstream>
	16	#include <stdlib.h>
	17	#include <limits.h>
	18
	19	#include "mon/Monitor.h"
	20	#include "mon/ConfigKeyService.h"
	21	#include "mon/MonitorDBStore.h"
31f18b77	22	#include "mon/OSDMonitor.h"
7c673cae	23	#include "common/errno.h"
31f18b77	24	#include "include/stringify.h"
7c673cae FG	25
	26	#define dout_subsys ceph_subsys_mon
	27	#undef dout_prefix
	28	#define dout_prefix _prefix(_dout, mon, this)
	29	static ostream& _prefix(std::ostream _dout, const Monitor mon,
	30	const ConfigKeyService *service) {
	31	return *_dout << "mon." << mon->name << "@" << mon->rank
	32	<< "(" << mon->get_state_name() << ")." << service->get_name()
	33	<< "(" << service->get_epoch() << ") ";
	34	}
	35
	36	const string ConfigKeyService::STORE_PREFIX = "mon_config_key";
	37
	38	int ConfigKeyService::store_get(const string &key, bufferlist &bl)
	39	{
	40	return mon->store->get(STORE_PREFIX, key, bl);
	41	}
	42
	43	void ConfigKeyService::get_store_prefixes(set<string>& s)
	44	{
	45	s.insert(STORE_PREFIX);
	46	}
	47
	48	void ConfigKeyService::store_put(const string &key, bufferlist &bl, Context *cb)
	49	{
	50	MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
	51	t->put(STORE_PREFIX, key, bl);
	52	if (cb)
	53	paxos->queue_pending_finisher(cb);
	54	paxos->trigger_propose();
	55	}
	56
	57	void ConfigKeyService::store_delete(const string &key, Context *cb)
	58	{
	59	MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
31f18b77	60	store_delete(t, key);
7c673cae FG	61	if (cb)
	62	paxos->queue_pending_finisher(cb);
	63	paxos->trigger_propose();
	64	}
	65
31f18b77 FG	66	void ConfigKeyService::store_delete(
	67	MonitorDBStore::TransactionRef t,
	68	const string &key)
	69	{
	70	t->erase(STORE_PREFIX, key);
	71	}
	72
7c673cae FG	73	bool ConfigKeyService::store_exists(const string &key)
	74	{
	75	return mon->store->exists(STORE_PREFIX, key);
	76	}
	77
	78	void ConfigKeyService::store_list(stringstream &ss)
	79	{
	80	KeyValueDB::Iterator iter =
	81	mon->store->get_iterator(STORE_PREFIX);
	82
	83	JSONFormatter f(true);
	84	f.open_array_section("keys");
	85
	86	while (iter->valid()) {
	87	string key(iter->key());
	88	f.dump_string("key", key);
	89	iter->next();
	90	}
	91	f.close_section();
	92	f.flush(ss);
	93	}
	94
31f18b77 FG	95	bool ConfigKeyService::store_has_prefix(const string &prefix)
	96	{
	97	KeyValueDB::Iterator iter =
	98	mon->store->get_iterator(STORE_PREFIX);
	99
	100	while (iter->valid()) {
	101	string key(iter->key());
	102	size_t p = key.find(prefix);
	103	if (p != string::npos && p == 0) {
	104	return true;
	105	}
	106	iter->next();
	107	}
	108	return false;
	109	}
	110
7c673cae FG	111	void ConfigKeyService::store_dump(stringstream &ss)
	112	{
	113	KeyValueDB::Iterator iter =
	114	mon->store->get_iterator(STORE_PREFIX);
	115
	116	JSONFormatter f(true);
	117	f.open_object_section("config-key store");
	118
	119	while (iter->valid()) {
	120	f.dump_string(iter->key().c_str(), iter->value().to_str());
	121	iter->next();
	122	}
	123	f.close_section();
	124	f.flush(ss);
	125	}
	126
31f18b77 FG	127	void ConfigKeyService::store_delete_prefix(
	128	MonitorDBStore::TransactionRef t,
	129	const string &prefix)
	130	{
	131	KeyValueDB::Iterator iter =
	132	mon->store->get_iterator(STORE_PREFIX);
	133
	134	while (iter->valid()) {
	135	string key(iter->key());
	136
	137	size_t p = key.find(prefix);
	138	if (p != string::npos && p == 0) {
	139	store_delete(t, key);
	140	}
	141	iter->next();
	142	}
	143	}
	144
7c673cae FG	145	bool ConfigKeyService::service_dispatch(MonOpRequestRef op)
	146	{
	147	Message *m = op->get_req();
	148	assert(m != NULL);
	149	dout(10) << __func__ << " " << *m << dendl;
	150
	151	if (!in_quorum()) {
	152	dout(1) << __func__ << " not in quorum -- waiting" << dendl;
	153	paxos->wait_for_readable(op, new Monitor::C_RetryMessage(mon, op));
	154	return false;
	155	}
	156
	157	assert(m->get_type() == MSG_MON_COMMAND);
	158
	159	MMonCommand cmd = static_cast<MMonCommand>(m);
	160
	161	assert(!cmd->cmd.empty());
	162
	163	int ret = 0;
	164	stringstream ss;
	165	bufferlist rdata;
	166
	167	string prefix;
	168	map<string, cmd_vartype> cmdmap;
	169
	170	if (!cmdmap_from_json(cmd->cmd, &cmdmap, ss)) {
	171	return false;
	172	}
	173
	174	cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
	175	string key;
	176	cmd_getval(g_ceph_context, cmdmap, "key", key);
	177
	178	if (prefix == "config-key get") {
	179	ret = store_get(key, rdata);
	180	if (ret < 0) {
	181	assert(!rdata.length());
	182	ss << "error obtaining '" << key << "': " << cpp_strerror(ret);
	183	goto out;
	184	}
	185	ss << "obtained '" << key << "'";
	186
c07f9fc5 FG	187	} else if (prefix == "config-key put" \|\|
c07f9fc5 FG	188	prefix == "config-key set") {
7c673cae FG	189	if (!mon->is_leader()) {
	190	mon->forward_request_leader(op);
	191	// we forward the message; so return now.
	192	return true;
	193	}
	194
	195	bufferlist data;
	196	string val;
	197	if (cmd_getval(g_ceph_context, cmdmap, "val", val)) {
	198	// they specified a value in the command instead of a file
	199	data.append(val);
	200	} else if (cmd->get_data_len() > 0) {
	201	// they specified '-i <file>'
	202	data = cmd->get_data();
	203	}
	204	if (data.length() > (size_t) g_conf->mon_config_key_max_entry_size) {
	205	ret = -EFBIG; // File too large
	206	ss << "error: entry size limited to "
	207	<< g_conf->mon_config_key_max_entry_size << " bytes. "
	208	<< "Use 'mon config key max entry size' to manually adjust";
	209	goto out;
	210	}
	211	// we'll reply to the message once the proposal has been handled
31f18b77	212	ss << "set " << key;
7c673cae	213	store_put(key, data,
31f18b77	214	new Monitor::C_Command(mon, op, 0, ss.str(), 0));
7c673cae FG	215	// return for now; we'll put the message once it's done.
	216	return true;
	217
	218	} else if (prefix == "config-key del" \|\|
	219	prefix == "config-key rm") {
	220	if (!mon->is_leader()) {
	221	mon->forward_request_leader(op);
	222	return true;
	223	}
	224
	225	if (!store_exists(key)) {
	226	ret = 0;
	227	ss << "no such key '" << key << "'";
	228	goto out;
	229	}
	230	store_delete(key, new Monitor::C_Command(mon, op, 0, "key deleted", 0));
	231	// return for now; we'll put the message once it's done
	232	return true;
	233
	234	} else if (prefix == "config-key exists") {
	235	bool exists = store_exists(key);
	236	ss << "key '" << key << "'";
	237	if (exists) {
	238	ss << " exists";
	239	ret = 0;
	240	} else {
	241	ss << " doesn't exist";
	242	ret = -ENOENT;
	243	}
	244
c07f9fc5 FG	245	} else if (prefix == "config-key list" \|\|
c07f9fc5 FG	246	prefix == "config-key ls") {
7c673cae FG	247	stringstream tmp_ss;
	248	store_list(tmp_ss);
	249	rdata.append(tmp_ss);
	250	ret = 0;
	251
	252	} else if (prefix == "config-key dump") {
	253	stringstream tmp_ss;
	254	store_dump(tmp_ss);
	255	rdata.append(tmp_ss);
	256	ret = 0;
31f18b77	257
7c673cae FG	258	}
	259
	260	out:
	261	if (!cmd->get_source().is_mon()) {
	262	string rs = ss.str();
	263	mon->reply_command(op, ret, rs, rdata, 0);
	264	}
	265
	266	return (ret == 0);
	267	}
	268
31f18b77 FG	269	string _get_dmcrypt_prefix(const uuid_d& uuid, const string k)
	270	{
	271	return "dm-crypt/osd/" + stringify(uuid) + "/" + k;
	272	}
	273
	274	int ConfigKeyService::validate_osd_destroy(
	275	const int32_t id,
	276	const uuid_d& uuid)
	277	{
	278	string dmcrypt_prefix = _get_dmcrypt_prefix(uuid, "");
	279	string daemon_prefix =
	280	"daemon-private/osd." + stringify(id) + "/";
	281
	282	if (!store_has_prefix(dmcrypt_prefix) &&
	283	!store_has_prefix(daemon_prefix)) {
	284	return -ENOENT;
	285	}
	286	return 0;
	287	}
	288
	289	void ConfigKeyService::do_osd_destroy(int32_t id, uuid_d& uuid)
	290	{
	291	string dmcrypt_prefix = _get_dmcrypt_prefix(uuid, "");
	292	string daemon_prefix =
	293	"daemon-private/osd." + stringify(id) + "/";
	294
	295	MonitorDBStore::TransactionRef t = paxos->get_pending_transaction();
	296	for (auto p : { dmcrypt_prefix, daemon_prefix }) {
	297	store_delete_prefix(t, p);
	298	}
	299
	300	paxos->trigger_propose();
	301	}
	302
	303	int ConfigKeyService::validate_osd_new(
	304	const uuid_d& uuid,
	305	const string& dmcrypt_key,
	306	stringstream& ss)
	307	{
	308	string dmcrypt_prefix = _get_dmcrypt_prefix(uuid, "luks");
	309	bufferlist value;
	310	value.append(dmcrypt_key);
	311
	312	if (store_exists(dmcrypt_prefix)) {
	313	bufferlist existing_value;
	314	int err = store_get(dmcrypt_prefix, existing_value);
	315	if (err < 0) {
	316	dout(10) << __func__ << " unable to get dm-crypt key from store (r = "
	317	<< err << ")" << dendl;
	318	return err;
	319	}
	320	if (existing_value.contents_equal(value)) {
	321	// both values match; this will be an idempotent op.
	322	return EEXIST;
	323	}
	324	ss << "dm-crypt key already exists and does not match";
	325	return -EEXIST;
	326	}
	327	return 0;
	328	}
	329
	330	void ConfigKeyService::do_osd_new(
	331	const uuid_d& uuid,
	332	const string& dmcrypt_key)
333	{
334	assert(paxos->is_plugged());
335
336	string dmcrypt_key_prefix = _get_dmcrypt_prefix(uuid, "luks");
337	bufferlist dmcrypt_key_value;
338	dmcrypt_key_value.append(dmcrypt_key);
339	// store_put() will call trigger_propose
340	store_put(dmcrypt_key_prefix, dmcrypt_key_value, nullptr);
341	}