RepoMirrors/ceph
1
0
Fork 0
mirror of https://github.com/ceph/ceph synced 2025-04-04 23:42:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

mon, ceph: transition to separate CLI parsing

Browse Source 
ceph is a new Python CLI that:
1) queries the underlying cephbin to get command descriptors,
2) parses user input and validates everything possible,
3) passes validated JSON command to cephbin for handling

The frontend also presents help, and takes over the CLI command
looping mode.

Signed-off-by: Dan Mick <dan.mick@inktank.com>

Conflicts:

	src/mon/Monitor.cc
	src/mon/OSDMonitor.cc
This commit is contained in:
Dan Mick 2013-05-21 16:23:04 -07:00
parent d9ff7d4a65
commit f26bd55e57
12 changed files with 4030 additions and 2533 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Makefile.am
View File

@ -75,7 +75,7 @@ endif
LIBOS_LDA += -lleveldb -lsnappy
# monitor
ceph_mon_SOURCES = ceph_mon.cc common/TextTable.cc
ceph_mon_SOURCES = ceph_mon.cc common/TextTable.cc common/cmdparse.cc
ceph_mon_LDFLAGS = $(AM_LDFLAGS)
ceph_mon_LDADD = libmon.a $(LIBOS_LDA) $(LIBGLOBAL_LDA)
ceph_mon_CXXFLAGS = ${CRYPTO_CXXFLAGS} ${AM_CXXFLAGS}
@ -1943,6 +1943,7 @@ noinst_HEADERS = \
mon/MonmapMonitor.h\
mon/MonCaps.h\
mon/MonClient.h\
mon/MonCommands.h\
mon/MonMap.h\
mon/Monitor.h\
mon/MonitorStore.h\
@ -2082,7 +2083,8 @@ noinst_HEADERS = \
os/ObjectMap.h \
os/DBObjectMap.h \
os/KeyValueDB.h \
os/LevelDBStore.h
os/LevelDBStore.h \
common/cmdparse.h
if ENABLE_COVERAGE
COV_DIR = $(DESTDIR)$(libdir)/ceph/coverage

1098
src/ceph Executable file
View File

File diff suppressed because it is too large Load Diff

516
src/mon/AuthMonitor.cc
View File

@ -33,6 +33,8 @@
#include "common/config.h"
#include "include/assert.h"
#include "common/cmdparse.h"
#include "include/str_list.h"
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
@ -520,95 +522,91 @@ bool AuthMonitor::preprocess_command(MMonCommand *m)
bufferlist rdata;
stringstream ss;
if (m->cmd.size() > 1) {
if (m->cmd[1] == "add" ||
m->cmd[1] == "del" ||
m->cmd[1] == "get-or-create" ||
m->cmd[1] == "get-or-create-key" ||
m->cmd[1] == "caps") {
return false;
}
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
// ss has reason for failure
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, rdata, get_version());
return true;
}
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!mon->_allowed_command(session, m->cmd))) {
mon->reply_command(m, -EACCES, "access denied", rdata, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
if (prefix == "auth add" ||
prefix == "auth del" ||
prefix == "auth get-or-create" ||
prefix == "auth get-or-create-key" ||
prefix == "auth import" ||
prefix == "auth caps") {
return false;
}
if (m->cmd[1] == "export") {
KeyRing keyring;
export_keyring(keyring);
if (m->cmd.size() > 2) {
EntityName ename;
EntityAuth eauth;
if (ename.from_str(m->cmd[2])) {
if (keyring.get_auth(ename, eauth)) {
KeyRing kr;
kr.add(ename, eauth);
kr.encode_plaintext(rdata);
ss << "export " << eauth;
r = 0;
} else {
ss << "no key for " << eauth;
r = -ENOENT;
}
} else {
ss << "invalid entity_auth " << m->cmd[2];
r = -EINVAL;
}
} else {
keyring.encode_plaintext(rdata);
ss << "exported master keyring";
MonSession *session = m->get_session();
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
if (!session ||
(!session->caps.get_allow_all() &&
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", rdata, get_version());
return true;
}
// entity might not be supplied, but if it is, it should be valid
string entity_name;
cmd_getval(g_ceph_context, cmdmap, "entity", entity_name);
EntityName entity;
if (!entity_name.empty() && !entity.from_str(entity_name)) {
ss << "invalid entity_auth " << entity_name;
r = -EINVAL;
}
if (prefix == "auth export") {
KeyRing keyring;
export_keyring(keyring);
if (!entity_name.empty()) {
EntityAuth eauth;
if (keyring.get_auth(entity, eauth)) {
KeyRing kr;
kr.add(entity, eauth);
kr.encode_plaintext(rdata);
ss << "export " << eauth;
r = 0;
}
}
else if (m->cmd[1] == "get" && m->cmd.size() > 2) {
KeyRing keyring;
EntityName entity;
if (!entity.from_str(m->cmd[2])) {
ss << "failed to identify entity name from " << m->cmd[2];
r = -ENOENT;
} else {
EntityAuth entity_auth;
if(!mon->key_server.get_auth(entity, entity_auth)) {
ss << "failed to find " << m->cmd[2] << " in keyring";
r = -ENOENT;
} else {
keyring.add(entity, entity_auth);
keyring.encode_plaintext(rdata);
ss << "exported keyring for " << m->cmd[2];
r = 0;
}
}
}
else if ((m->cmd[1] == "print-key" || m->cmd[1] == "print_key" || m->cmd[1] == "get-key") &&
m->cmd.size() == 3) {
EntityName ename;
if (!ename.from_str(m->cmd[2])) {
ss << "failed to identify entity name from " << m->cmd[2];
ss << "no key for " << eauth;
r = -ENOENT;
goto done;
}
EntityAuth auth;
if (!mon->key_server.get_auth(ename, auth)) {
ss << "don't have " << ename;
r = -ENOENT;
goto done;
}
ss << auth.key;
r = 0;
}
else if (m->cmd[1] == "list") {
mon->key_server.list_secrets(ss);
} else {
keyring.encode_plaintext(rdata);
ss << "exported master keyring";
r = 0;
}
} else if (prefix == "auth get" && !entity_name.empty()) {
KeyRing keyring;
EntityAuth entity_auth;
if(!mon->key_server.get_auth(entity, entity_auth)) {
ss << "failed to find " << entity_name << " in keyring";
r = -ENOENT;
} else {
keyring.add(entity, entity_auth);
keyring.encode_plaintext(rdata);
ss << "exported keyring for " << entity_name;
r = 0;
}
} else if (prefix == "auth print-key" ||
prefix == "auth print_key" ||
prefix == "auth get-key") {
EntityAuth auth;
if (!mon->key_server.get_auth(entity, auth)) {
ss << "don't have " << entity;
r = -ENOENT;
goto done;
}
else {
auth_usage(ss);
r = -EINVAL;
}
ss << auth.key;
r = 0;
} else if (prefix == "auth list") {
mon->key_server.list_secrets(ss);
r = 0;
goto done;
} else {
auth_usage(ss);
r = -EINVAL;
@ -648,215 +646,215 @@ bool AuthMonitor::prepare_command(MMonCommand *m)
string rs;
int err = -EINVAL;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
// ss has reason for failure
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, rdata, get_version());
return true;
}
string prefix;
vector<string>caps_vec;
string entity_name;
EntityName entity;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", rdata, get_version());
return true;
}
// nothing here yet
if (m->cmd.size() > 1) {
if (m->cmd[1] == "import") {
bufferlist bl = m->get_data();
cmd_getval(g_ceph_context, cmdmap, "caps", caps_vec);
if ((caps_vec.size() % 2) != 0) {
ss << "bad capabilities request; odd number of arguments";
err = -EINVAL;
goto done;
}
cmd_getval(g_ceph_context, cmdmap, "entity", entity_name);
if (!entity_name.empty() && !entity.from_str(entity_name)) {
ss << "bad entity name";
err = -EINVAL;
goto done;
}
if (prefix == "auth import") {
bufferlist bl = m->get_data();
bufferlist::iterator iter = bl.begin();
KeyRing keyring;
try {
::decode(keyring, iter);
} catch (const buffer::error &ex) {
ss << "error decoding keyring";
rs = err;
goto done;
}
import_keyring(keyring);
ss << "imported keyring";
getline(ss, rs);
err = 0;
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else if (prefix == "auth add") {
KeyServerData::Incremental auth_inc;
auth_inc.name = entity;
bufferlist bl = m->get_data();
dout(10) << "AuthMonitor::prepare_command bl.length()=" << bl.length() << dendl;
if (bl.length()) {
bufferlist::iterator iter = bl.begin();
KeyRing keyring;
try {
::decode(keyring, iter);
::decode(keyring, iter);
} catch (const buffer::error &ex) {
ss << "error decoding keyring";
rs = err;
goto done;
}
import_keyring(keyring);
ss << "imported keyring";
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
else if (m->cmd[1] == "add" && m->cmd.size() >= 3) {
KeyServerData::Incremental auth_inc;
if (m->cmd.size() >= 3) {
if (!auth_inc.name.from_str(m->cmd[2])) {
ss << "bad entity name";
err = -EINVAL;
goto done;
}
}
bufferlist bl = m->get_data();
dout(10) << "AuthMonitor::prepare_command bl.length()=" << bl.length() << dendl;
if (bl.length()) {
bufferlist::iterator iter = bl.begin();
KeyRing keyring;
try {
::decode(keyring, iter);
} catch (const buffer::error &ex) {
ss << "error decoding keyring";
err = -EINVAL;
goto done;
}
if (!keyring.get_auth(auth_inc.name, auth_inc.auth)) {
ss << "key for " << auth_inc.name << " not found in provided keyring";
err = -EINVAL;
goto done;
}
} else {
// generate a new random key
dout(10) << "AuthMonitor::prepare_command generating random key for " << auth_inc.name << dendl;
auth_inc.auth.key.create(g_ceph_context, CEPH_CRYPTO_AES);
}
auth_inc.op = KeyServerData::AUTH_INC_ADD;
// suck in any caps too
for (unsigned i=3; i+1<m->cmd.size(); i += 2)
::encode(m->cmd[i+1], auth_inc.auth.caps[m->cmd[i]]);
dout(10) << " importing " << auth_inc.name << dendl;
dout(30) << " " << auth_inc.auth << dendl;
push_cephx_inc(auth_inc);
ss << "added key for " << auth_inc.name;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
else if ((m->cmd[1] == "get-or-create-key" ||
m->cmd[1] == "get-or-create") &&
m->cmd.size() >= 3) {
// auth get-or-create <name> [mon osdcapa osd osdcapb ...]
EntityName entity;
if (!entity.from_str(m->cmd[2])) {
ss << "bad entity name";
ss << "error decoding keyring";
err = -EINVAL;
goto done;
}
// do we have it?
EntityAuth entity_auth;
if (mon->key_server.get_auth(entity, entity_auth)) {
for (unsigned i=3; i + 1<m->cmd.size(); i += 2) {
string sys = m->cmd[i];
bufferlist cap;
::encode(m->cmd[i+1], cap);
if (entity_auth.caps.count(sys) == 0 ||
!entity_auth.caps[sys].contents_equal(cap)) {
ss << "key for " << entity << " exists but cap " << sys << " does not match";
err = -EINVAL;
goto done;
}
}
if (m->cmd[1] == "get-or-create-key") {
ss << entity_auth.key;
} else {
KeyRing kr;
kr.add(entity, entity_auth.key);
kr.encode_plaintext(rdata);
}
err = 0;
if (!keyring.get_auth(auth_inc.name, auth_inc.auth)) {
ss << "key for " << auth_inc.name << " not found in provided keyring";
err = -EINVAL;
goto done;
}
} else {
// generate a new random key
dout(10) << "AuthMonitor::prepare_command generating random key for " << auth_inc.name << dendl;
auth_inc.auth.key.create(g_ceph_context, CEPH_CRYPTO_AES);
}
// ...or are we about to?
for (vector<Incremental>::iterator p = pending_auth.begin();
p != pending_auth.end();
++p) {
if (p->inc_type == AUTH_DATA) {
KeyServerData::Incremental auth_inc;
bufferlist::iterator q = p->auth_data.begin();
::decode(auth_inc, q);
if (auth_inc.op == KeyServerData::AUTH_INC_ADD &&
auth_inc.name == entity) {
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new C_RetryMessage(this, m));
return true;
}
auth_inc.op = KeyServerData::AUTH_INC_ADD;
for (vector<string>::iterator it = caps_vec.begin();
it != caps_vec.end(); it += 2)
::encode(*(it+1), auth_inc.auth.caps[*it]);
dout(10) << " importing " << auth_inc.name << dendl;
dout(30) << " " << auth_inc.auth << dendl;
push_cephx_inc(auth_inc);
ss << "added key for " << auth_inc.name;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else if ((prefix == "auth get-or-create-key" ||
prefix == "auth get-or-create") &&
!entity_name.empty()) {
// auth get-or-create <name> [mon osdcapa osd osdcapb ...]
// do we have it?
EntityAuth entity_auth;
if (mon->key_server.get_auth(entity, entity_auth)) {
for (vector<string>::iterator it = caps_vec.begin();
it != caps_vec.end(); it += 2) {
string sys = *it;
bufferlist cap;
::encode(*(it+1), cap);
if (entity_auth.caps.count(sys) == 0 ||
!entity_auth.caps[sys].contents_equal(cap)) {
ss << "key for " << entity << " exists but cap " << sys << " does not match";
err = -EINVAL;
goto done;
}
}
// create it
KeyServerData::Incremental auth_inc;
auth_inc.op = KeyServerData::AUTH_INC_ADD;
auth_inc.name = entity;
auth_inc.auth.key.create(g_ceph_context, CEPH_CRYPTO_AES);
for (unsigned i=3; i + 1<m->cmd.size(); i += 2)
::encode(m->cmd[i+1], auth_inc.auth.caps[m->cmd[i]]);
push_cephx_inc(auth_inc);
if (m->cmd[1] == "get-or-create-key") {
ss << auth_inc.auth.key;
if (prefix == "auth get-or-create-key") {
ss << entity_auth.key;
} else {
KeyRing kr;
kr.add(entity, auth_inc.auth.key);
kr.add(entity, entity_auth.key);
kr.encode_plaintext(rdata);
}
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, rdata, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
err = 0;
goto done;
}
else if (m->cmd[1] == "caps" && m->cmd.size() >= 3) {
KeyServerData::Incremental auth_inc;
if (!auth_inc.name.from_str(m->cmd[2])) {
ss << "bad entity name";
err = -EINVAL;
goto done;
// ...or are we about to?
for (vector<Incremental>::iterator p = pending_auth.begin();
p != pending_auth.end();
++p) {
if (p->inc_type == AUTH_DATA) {
KeyServerData::Incremental auth_inc;
bufferlist::iterator q = p->auth_data.begin();
::decode(auth_inc, q);
if (auth_inc.op == KeyServerData::AUTH_INC_ADD &&
auth_inc.name == entity) {
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new C_RetryMessage(this, m));
return true;
}
}
if (!mon->key_server.get_auth(auth_inc.name, auth_inc.auth)) {
ss << "couldn't find entry " << auth_inc.name;
err = -ENOENT;
goto done;
}
map<string,bufferlist> newcaps;
for (unsigned i=3; i+1<m->cmd.size(); i += 2)
::encode(m->cmd[i+1], newcaps[m->cmd[i]]);
auth_inc.op = KeyServerData::AUTH_INC_ADD;
auth_inc.auth.caps = newcaps;
push_cephx_inc(auth_inc);
ss << "updated caps for " << auth_inc.name;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
else if (m->cmd[1] == "del" && m->cmd.size() >= 3) {
string name = m->cmd[2];
KeyServerData::Incremental auth_inc;
bool r = auth_inc.name.from_str(name);
if (r == false) {
ss << "bad entity name " << name;
err = -EINVAL;
goto done;
}
if (!mon->key_server.contains(auth_inc.name)) {
ss << "couldn't find entry " << name;
err = -ENOENT;
goto done;
}
auth_inc.op = KeyServerData::AUTH_INC_DEL;
push_cephx_inc(auth_inc);
ss << "updated";
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
// create it
KeyServerData::Incremental auth_inc;
auth_inc.op = KeyServerData::AUTH_INC_ADD;
auth_inc.name = entity;
auth_inc.auth.key.create(g_ceph_context, CEPH_CRYPTO_AES);
for (vector<string>::iterator it = caps_vec.begin();
it != caps_vec.end(); it += 2)
::encode(*(it+1), auth_inc.auth.caps[*it]);
push_cephx_inc(auth_inc);
if (prefix == "auth get-or-create-key") {
ss << auth_inc.auth.key;
} else {
KeyRing kr;
kr.add(entity, auth_inc.auth.key);
kr.encode_plaintext(rdata);
}
else {
auth_usage(ss);
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, rdata, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else if (prefix == "auth caps" && !entity_name.empty()) {
KeyServerData::Incremental auth_inc;
auth_inc.name = entity;
if (!mon->key_server.get_auth(auth_inc.name, auth_inc.auth)) {
ss << "couldn't find entry " << auth_inc.name;
err = -ENOENT;
goto done;
}
} else {
auth_usage(ss);
map<string,bufferlist> newcaps;
for (vector<string>::iterator it = caps_vec.begin();
it != caps_vec.end(); it += 2)
::encode(*(it+1), newcaps[*it]);
auth_inc.op = KeyServerData::AUTH_INC_ADD;
auth_inc.auth.caps = newcaps;
push_cephx_inc(auth_inc);
ss << "updated caps for " << auth_inc.name;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else if (prefix == "auth del" && !entity_name.empty()) {
KeyServerData::Incremental auth_inc;
auth_inc.name = entity;
if (!mon->key_server.contains(auth_inc.name)) {
ss << "couldn't find entry " << entity;
err = -ENOENT;
goto done;
}
auth_inc.op = KeyServerData::AUTH_INC_DEL;
push_cephx_inc(auth_inc);
ss << "updated";
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
//paxos->wait_for_commit(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
done:

77
src/mon/ConfigKeyService.cc
View File

@ -25,6 +25,7 @@
#include "mon/MonitorDBStore.h"
#include "common/config.h"
#include "common/cmdparse.h"
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
@ -103,33 +104,33 @@ bool ConfigKeyService::service_dispatch(Message *m)
MMonCommand *cmd = static_cast<MMonCommand*>(m);
assert(!cmd->cmd.empty());
assert(cmd->cmd[0] == "config-key");
int ret = 0;
stringstream ss;
bufferlist rdata;
if (cmd->cmd.size() < 2) {
string prefix;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(cmd->cmd, &cmdmap, ss)) {
ret = -EINVAL;
ss << "usage: config-key <get|put|list|exists|delete> [<key>]";
goto out;
return false;
}
if (cmd->cmd[1] == "get") {
if (cmd->cmd.size() != 3) {
ret = -EINVAL;
ss << "usage: config-key get <key> -o <file>";
goto out;
}
ret = store_get(cmd->cmd[2], rdata);
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 '" << cmd->cmd[2] << "': "
<< cpp_strerror(ret);
ss << "error obtaining '" << key << "': " << cpp_strerror(ret);
goto out;
}
ss << "obtained '" << cmd->cmd[2] << "'";
} else if (cmd->cmd[1] == "put") {
ss << "obtained '" << key << "'";
} else if (prefix == "config-key put") {
if (!mon->is_leader()) {
mon->forward_request_leader(cmd);
// we forward the message; so return now.
@ -137,13 +138,10 @@ bool ConfigKeyService::service_dispatch(Message *m)
}
bufferlist data;
if (cmd->cmd.size() < 3 || cmd->cmd.size() > 4) {
ret = -EINVAL;
ss << "usage: store put <key> [-i <file>|<value>]";
goto out;
} else if (cmd->cmd.size() == 4) {
string val;
if (cmd_getval(g_ceph_context, cmdmap, "val", val)) {
// they specified a value in the command instead of a file
data.append(cmd->cmd[3]);
data.append(val);
} else if (cmd->get_data_len() > 0) {
// they specified '-i <file>'
data = cmd->get_data();
@ -156,38 +154,29 @@ bool ConfigKeyService::service_dispatch(Message *m)
goto out;
}
// we'll reply to the message once the proposal has been handled
store_put(cmd->cmd[2], data,
store_put(key, data,
new Monitor::C_Command(mon, cmd, 0, "value stored", 0));
// return for now; we'll put the message once it's done.
return true;
} else if (cmd->cmd[1] == "delete") {
} else if (prefix == "config-key del") {
if (!mon->is_leader()) {
mon->forward_request_leader(cmd);
return true;
}
if (cmd->cmd.size() != 3) {
ret = -EINVAL;
ss << "usage: config-key delete <key>";
goto out;
}
if (!store_exists(cmd->cmd[2])) {
if (!store_exists(key)) {
ret = 0;
ss << "no such key '" << cmd->cmd[2] << "'";
ss << "no such key '" << key << "'";
goto out;
}
store_delete(cmd->cmd[2],
new Monitor::C_Command(mon, cmd, 0, "key deleted", 0));
store_delete(key, new Monitor::C_Command(mon, cmd, 0, "key deleted", 0));
// return for now; we'll put the message once it's done
return true;
} else if (cmd->cmd[1] == "exists") {
if (cmd->cmd.size() != 3) {
ret = -EINVAL;
ss << "usage: config-key exists <key>";
goto out;
}
bool exists = store_exists(cmd->cmd[2]);
ss << "key '" << cmd->cmd[2] << "'";
} else if (prefix == "config-key exists") {
bool exists = store_exists(key);
ss << "key '" << key << "'";
if (exists) {
ss << " exists";
ret = 0;
@ -195,12 +184,8 @@ bool ConfigKeyService::service_dispatch(Message *m)
ss << " doesn't exist";
ret = -ENOENT;
}
} else if (cmd->cmd[1] == "list") {
if (cmd->cmd.size() > 2) {
ret = -EINVAL;
ss << "usage: config-key list";
goto out;
}
} else if (prefix == "config-key list") {
stringstream tmp_ss;
store_list(tmp_ss);
rdata.append(tmp_ss);

642
src/mon/MDSMonitor.cc
View File

@ -35,6 +35,10 @@
#include "common/config.h"
#include "include/assert.h"
#include "MonitorDBStore.h"
#include "common/cmdparse.h"
#include "include/str_list.h"
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
#define dout_prefix _prefix(_dout, mon, mdsmap)
@ -533,160 +537,138 @@ bool MDSMonitor::preprocess_command(MMonCommand *m)
bufferlist rdata;
stringstream ss;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
// ss has reason for failure
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, rdata, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!session->caps.check_privileges(PAXOS_MDSMAP, MON_CAP_R) &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", rdata, get_version());
return true;
}
vector<const char*> args;
for (unsigned i = 1; i < m->cmd.size(); i++)
args.push_back(m->cmd[i].c_str());
if (prefix == "mds stat") {
ss << mdsmap;
r = 0;
} else if (prefix == "mds dump") {
string format;
cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
string val;
int64_t epocharg;
epoch_t epoch;
epoch = epocharg;
if (m->cmd.size() > 1) {
if (m->cmd[1] == "stat") {
ss << mdsmap;
r = 0;
}
else if (m->cmd[1] == "dump") {
string format = "plain";
string val;
epoch_t epoch = 0;
for (std::vector<const char*>::iterator i = args.begin()+1; i != args.end(); ) {
if (ceph_argparse_double_dash(args, i))
break;
else if (ceph_argparse_witharg_daemon(args, i, &val, "-f", "--format",
(char*)NULL))
format = val;
else if (!epoch) {
long l = parse_pos_long(*i++, &ss);
if (l < 0) {
r = -EINVAL;
goto out;
}
epoch = l;
} else
++i;
}
MDSMap *p = &mdsmap;
if (epoch) {
bufferlist b;
int err = get_version(epoch, b);
if (err == -ENOENT) {
p = 0;
r = -ENOENT;
} else {
assert(err == 0);
assert(b.length());
p = new MDSMap;
p->decode(b);
}
}
if (p) {
stringstream ds;
if (format == "json") {
JSONFormatter jf(true);
jf.open_object_section("mdsmap");
p->dump(&jf);
jf.close_section();
jf.flush(ds);
r = 0;
} else if (format == "plain") {
p->print(ds);
r = 0;
} else {
ss << "unrecognized format '" << format << "'";
r = -EINVAL;
}
if (r == 0) {
rdata.append(ds);
ss << "dumped mdsmap epoch " << p->get_epoch();
}
if (p != &mdsmap)
delete p;
}
}
else if (m->cmd[1] == "getmap") {
if (m->cmd.size() > 2) {
long l = parse_pos_long(m->cmd[2].c_str(), &ss);
if (l < 0) {
r = -EINVAL;
goto out;
}
epoch_t e = l;
bufferlist b;
int err = get_version(e, b);
if (err == -ENOENT) {
r = -ENOENT;
} else {
assert(r == 0);
assert(b.length());
MDSMap mm;
mm.decode(b);
mm.encode(rdata, m->get_connection()->get_features());
ss << "got mdsmap epoch " << mm.get_epoch();
}
} else {
mdsmap.encode(rdata, m->get_connection()->get_features());
ss << "got mdsmap epoch " << mdsmap.get_epoch();
}
r = 0;
}
else if (m->cmd[1] == "tell") {
m->cmd.erase(m->cmd.begin()); //take out first two args; don't need them
m->cmd.erase(m->cmd.begin());
if (m->cmd[0] == "*") {
m->cmd.erase(m->cmd.begin()); //and now we're done with the target num
MDSMap *p = &mdsmap;
if (cmd_getval(g_ceph_context, cmdmap, "epoch", epocharg)) {
epoch = epocharg;
bufferlist b;
int err = get_version(epoch, b);
if (err == -ENOENT) {
p = 0;
r = -ENOENT;
const map<uint64_t, MDSMap::mds_info_t> mds_info = mdsmap.get_mds_info();
for (map<uint64_t, MDSMap::mds_info_t>::const_iterator i = mds_info.begin();
i != mds_info.end();
++i) {
mon->send_command(i->second.get_inst(), m->cmd, get_version());
r = 0;
}
if (r == -ENOENT) {
ss << "no mds active";
} else {
ss << "ok";
}
} else {
errno = 0;
int who = strtol(m->cmd[0].c_str(), 0, 10);
m->cmd.erase(m->cmd.begin()); //done with target num now
if (!errno && who >= 0) {
if (mdsmap.is_up(who)) {
mon->send_command(mdsmap.get_inst(who), m->cmd, get_version());
r = 0;
ss << "ok";
} else {
ss << "mds." << who << " no up";
r = -ENOENT;
}
} else ss << "specify mds number or *";
assert(err == 0);
assert(b.length());
p = new MDSMap;
p->decode(b);
}
}
else if (m->cmd[1] == "compat") {
if (m->cmd.size() >= 3) {
if (m->cmd[2] == "show") {
ss << mdsmap.compat;
r = 0;
} else if (m->cmd[2] == "help") {
ss << "mds compat <rm_compat|rm_ro_compat|rm_incompat> <id>";
r = 0;
}
if (p) {
stringstream ds;
boost::scoped_ptr<Formatter> f(new_formatter(format));
if (f != NULL) {
f->open_object_section("mdsmap");
p->dump(f.get());
f->close_section();
f->flush(ds);
r = 0;
} else {
ss << "mds compat <rm_compat|rm_ro_compat|rm_incompat> <id>";
p->print(ds);
r = 0;
}
if (r == 0) {
rdata.append(ds);
ss << "dumped mdsmap epoch " << p->get_epoch();
}
if (p != &mdsmap)
delete p;
}
} else if (prefix == "mds getmap") {
epoch_t e;
int64_t epocharg;
bufferlist b;
if (cmd_getval(g_ceph_context, cmdmap, "epoch", epocharg)) {
e = epocharg;
int err = get_version(e, b);
if (err == -ENOENT) {
r = -ENOENT;
} else {
assert(r == 0);
assert(b.length());
MDSMap mm;
mm.decode(b);
mm.encode(rdata, m->get_connection()->get_features());
ss << "got mdsmap epoch " << mm.get_epoch();
}
} else {
mdsmap.encode(rdata, m->get_connection()->get_features());
ss << "got mdsmap epoch " << mdsmap.get_epoch();
}
r = 0;
} else if (prefix == "mds tell") {
string whostr;
cmd_getval(g_ceph_context, cmdmap, "who", whostr);
string args;
vector<string>args_vec;
cmd_getval(g_ceph_context, cmdmap, "args", args_vec);
if (whostr == "*") {
r = -ENOENT;
const map<uint64_t, MDSMap::mds_info_t> mds_info = mdsmap.get_mds_info();
for (map<uint64_t, MDSMap::mds_info_t>::const_iterator i = mds_info.begin();
i != mds_info.end();
++i) {
m->cmd = args_vec;
mon->send_command(i->second.get_inst(), m->cmd, get_version());
r = 0;
}
if (r == -ENOENT) {
ss << "no mds active";
} else {
ss << "ok";
}
} else {
errno = 0;
long who = strtol(whostr.c_str(), 0, 10);
if (!errno && who >= 0) {
if (mdsmap.is_up(who)) {
m->cmd = args_vec;
mon->send_command(mdsmap.get_inst(who), m->cmd, get_version());
r = 0;
ss << "ok";
} else {
ss << "mds." << who << " not up";
r = -ENOENT;
}
} else ss << "specify mds number or *";
}
} else if (prefix == "mds compat show") {
ss << mdsmap.compat;
r = 0;
}
out:
if (r != -1) {
string rs;
getline(ss, rs);
@ -797,215 +779,225 @@ bool MDSMonitor::prepare_command(MMonCommand *m)
stringstream ss;
bufferlist rdata;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, rdata, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!session->caps.check_privileges(PAXOS_MDSMAP, MON_CAP_W) &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", rdata, get_version());
return true;
}
if (m->cmd.size() > 1) {
if ((m->cmd[1] == "stop" || m->cmd[1] == "deactivate") && m->cmd.size() > 2) {
int who = parse_pos_long(m->cmd[2].c_str(), &ss);
if (who < 0)
goto out;
if (!pending_mdsmap.is_active(who)) {
r = -EEXIST;
ss << "mds." << who << " not active ("
<< ceph_mds_state_name(pending_mdsmap.get_state(who)) << ")";
} else if ((pending_mdsmap.get_root() == who ||
pending_mdsmap.get_tableserver() == who) &&
pending_mdsmap.get_num_in_mds() > 1) {
r = -EBUSY;
ss << "can't tell the root (" << pending_mdsmap.get_root()
<< ") or tableserver (" << pending_mdsmap.get_tableserver()
<< " to deactivate unless it is the last mds in the cluster";
} else if (pending_mdsmap.get_num_in_mds() <= pending_mdsmap.get_max_mds()) {
r = -EBUSY;
ss << "must decrease max_mds or else MDS will immediately reactivate";
} else {
r = 0;
uint64_t gid = pending_mdsmap.up[who];
ss << "telling mds." << who << " " << pending_mdsmap.mds_info[gid].addr << " to deactivate";
pending_mdsmap.mds_info[gid].state = MDSMap::STATE_STOPPING;
}
}
else if (m->cmd[1] == "set_max_mds" && m->cmd.size() > 2) {
long l = parse_pos_long(m->cmd[2].c_str(), &ss);
if (l < 0)
goto out;
pending_mdsmap.max_mds = l;
string whostr;
cmd_getval(g_ceph_context, cmdmap, "who", whostr);
if (prefix == "mds stop" ||
prefix == "mds deactivate") {
int who = parse_pos_long(whostr.c_str(), &ss);
if (who < 0)
goto out;
if (!pending_mdsmap.is_active(who)) {
r = -EEXIST;
ss << "mds." << who << " not active ("
<< ceph_mds_state_name(pending_mdsmap.get_state(who)) << ")";
} else if ((pending_mdsmap.get_root() == who ||
pending_mdsmap.get_tableserver() == who) &&
pending_mdsmap.get_num_in_mds() > 1) {
r = -EBUSY;
ss << "can't tell the root (" << pending_mdsmap.get_root()
<< ") or tableserver (" << pending_mdsmap.get_tableserver()
<< " to deactivate unless it is the last mds in the cluster";
} else if (pending_mdsmap.get_num_in_mds() <= pending_mdsmap.get_max_mds()) {
r = -EBUSY;
ss << "must decrease max_mds or else MDS will immediately reactivate";
} else {
r = 0;
ss << "max_mds = " << pending_mdsmap.max_mds;
uint64_t gid = pending_mdsmap.up[who];
ss << "telling mds." << who << " " << pending_mdsmap.mds_info[gid].addr << " to deactivate";
pending_mdsmap.mds_info[gid].state = MDSMap::STATE_STOPPING;
}
else if (m->cmd[1] == "setmap" && m->cmd.size() == 3) {
MDSMap map;
map.decode(m->get_data());
long l = parse_pos_long(m->cmd[2].c_str(), &ss);
if (l < 0)
goto out;
epoch_t e = l;
//if (ceph_fsid_compare(&map.get_fsid(), &mon->monmap->fsid) == 0) {
if (pending_mdsmap.epoch == e) {
map.epoch = pending_mdsmap.epoch; // make sure epoch is correct
pending_mdsmap = map;
string rs = "set mds map";
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else
ss << "next mdsmap epoch " << pending_mdsmap.epoch << " != " << e;
//} else
//ss << "mdsmap fsid " << map.fsid << " does not match monitor fsid " << mon->monmap->fsid;
} else if (prefix == "mds set_max_mds") {
int64_t maxmds;
cmd_getval(g_ceph_context, cmdmap, "maxmds", maxmds);
if (maxmds < 0)
goto out;
pending_mdsmap.max_mds = maxmds;
r = 0;
ss << "max_mds = " << pending_mdsmap.max_mds;
} else if (prefix == "mds setmap") {
MDSMap map;
map.decode(m->get_data());
epoch_t e = 0;
int64_t epochnum;
if (cmd_getval(g_ceph_context, cmdmap, "epoch", epochnum))
e = epochnum;
if (pending_mdsmap.epoch == e) {
map.epoch = pending_mdsmap.epoch; // make sure epoch is correct
pending_mdsmap = map;
string rs = "set mds map";
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else {
ss << "next mdsmap epoch " << pending_mdsmap.epoch << " != " << e;
}
else if (m->cmd[1] == "set_state" && m->cmd.size() == 4) {
long l = parse_pos_long(m->cmd[2].c_str(), &ss);
if (l < 0)
goto out;
uint64_t gid = l;
long state = parse_pos_long(m->cmd[3].c_str(), &ss);
if (state < 0)
goto out;
if (!pending_mdsmap.is_dne_gid(gid)) {
MDSMap::mds_info_t& info = pending_mdsmap.get_info_gid(gid);
info.state = state;
stringstream ss;
ss << "set mds gid " << gid << " to state " << state << " " << ceph_mds_state_name(state);
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
}
else if (m->cmd[1] == "fail" && m->cmd.size() == 3) {
r = fail_mds(ss, m->cmd[2]);
if (r < 0 && r == -EAGAIN) {
mon->osdmon()->wait_for_writeable(new C_RetryMessage(this, m));
return false; // don't propose yet; wait for message to be retried
}
}
else if (m->cmd[1] == "rm" && m->cmd.size() == 3) {
int64_t gid = parse_pos_long(m->cmd[2].c_str(), &ss);
if (gid < 0)
goto out;
int state = pending_mdsmap.get_state_gid(gid);
if (state == 0) {
ss << "mds gid " << gid << " dne";
r = 0;
} else if (state > 0) {
ss << "cannot remove active mds." << pending_mdsmap.get_info_gid(gid).name
<< " rank " << pending_mdsmap.get_info_gid(gid).rank;
r = -EBUSY;
} else {
pending_mdsmap.mds_info.erase(gid);
stringstream ss;
ss << "removed mds gid " << gid;
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
}
else if (m->cmd[1] == "rmfailed" && m->cmd.size() == 3) {
long w = parse_pos_long(m->cmd[2].c_str(), &ss);
if (w < 0)
goto out;
pending_mdsmap.failed.erase(w);
} else if (prefix == "mds set_state") {
int64_t gid;
if (!cmd_getval(g_ceph_context, cmdmap, "gid", gid))
goto out;
int64_t state;
cmd_getval(g_ceph_context, cmdmap, "state", state);
if (!pending_mdsmap.is_dne_gid(gid)) {
MDSMap::mds_info_t& info = pending_mdsmap.get_info_gid(gid);
info.state = state;
stringstream ss;
ss << "removed failed mds." << w;
ss << "set mds gid " << gid << " to state " << state << " " << ceph_mds_state_name(state);
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
else if (m->cmd[1] == "cluster_fail") {
r = cluster_fail(ss);
if (r < 0 && r == -EAGAIN) {
mon->osdmon()->wait_for_writeable(new C_RetryMessage(this,m));
return false; // don't propose yet; wait for message to be retried
}
} else if (prefix == "mds fail") {
string who;
cmd_getval(g_ceph_context, cmdmap, "who", who);
r = fail_mds(ss, who);
if (r < 0 && r == -EAGAIN) {
mon->osdmon()->wait_for_writeable(new C_RetryMessage(this, m));
return false; // don't propose yet; wait for message to be retried
}
else if (m->cmd[1] == "cluster_down") {
if (pending_mdsmap.test_flag(CEPH_MDSMAP_DOWN)) {
ss << "mdsmap already marked DOWN";
r = -EPERM;
} else {
pending_mdsmap.set_flag(CEPH_MDSMAP_DOWN);
ss << "marked mdsmap DOWN";
r = 0;
}
}
else if (m->cmd[1] == "cluster_up") {
if (pending_mdsmap.test_flag(CEPH_MDSMAP_DOWN)) {
pending_mdsmap.clear_flag(CEPH_MDSMAP_DOWN);
ss << "unmarked mdsmap DOWN";
r = 0;
} else {
ss << "mdsmap not marked DOWN";
r = -EPERM;
}
}
else if (m->cmd[1] == "compat" && m->cmd.size() == 4) {
int64_t f = parse_pos_long(m->cmd[3].c_str(), &ss);
if (f < 0)
goto out;
if (m->cmd[2] == "rm_compat") {
if (pending_mdsmap.compat.compat.contains(f)) {
ss << "removing compat feature " << f;
pending_mdsmap.compat.compat.remove(f);
r = 0;
} else {
ss << "compat feature " << f << " not present in " << pending_mdsmap.compat;
r = -ENOENT;
}
} else if (m->cmd[2] == "rm_incompat") {
if (pending_mdsmap.compat.incompat.contains(f)) {
ss << "removing incompat feature " << f;
pending_mdsmap.compat.incompat.remove(f);
r = 0;
} else {
ss << "incompat feature " << f << " not present in " << pending_mdsmap.compat;
r = -ENOENT;
}
}
} else if (m->cmd[1] == "add_data_pool" && m->cmd.size() == 3) {
int64_t poolid = parse_pos_long(m->cmd[2].c_str(), &ss);
if (poolid < 0)
goto out;
pending_mdsmap.add_data_pool(poolid);
ss << "added data pool " << poolid << " to mdsmap";
} else if (prefix == "mds rm") {
int64_t gid;
cmd_getval(g_ceph_context, cmdmap, "gid", gid);
int state = pending_mdsmap.get_state_gid(gid);
if (state == 0) {
ss << "mds gid " << gid << " dne";
r = 0;
} else if (m->cmd[1] == "remove_data_pool" && m->cmd.size() == 3) {
int64_t poolid = parse_pos_long(m->cmd[2].c_str(), &ss);
if (poolid < 0)
goto out;
r = pending_mdsmap.remove_data_pool(poolid);
if (r == 0)
ss << "removed data pool " << poolid << " from mdsmap";
} else if (m->cmd[1] == "newfs" && m->cmd.size() >= 4) {
MDSMap newmap;
long metadata = parse_pos_long(m->cmd[2].c_str(), &ss);
if (metadata < 0)
goto out;
long data = parse_pos_long(m->cmd[3].c_str());
if (data < 0)
goto out;
if (m->cmd.size() < 5 || m->cmd[4] != "--yes-i-really-mean-it") {
ss << "this is DANGEROUS and will wipe out the mdsmap's fs, and may clobber data in the new pools you specify. add --yes-i-really-mean-it if you do.";
r = -EPERM;
} else {
pending_mdsmap = newmap;
pending_mdsmap.epoch = mdsmap.epoch + 1;
create_new_fs(pending_mdsmap, metadata, data);
ss << "new fs with metadata pool " << metadata << " and data pool " << data;
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
}
}
} else if (state > 0) {
ss << "cannot remove active mds." << pending_mdsmap.get_info_gid(gid).name
<< " rank " << pending_mdsmap.get_info_gid(gid).rank;
r = -EBUSY;
} else {
pending_mdsmap.mds_info.erase(gid);
stringstream ss;
ss << "removed mds gid " << gid;
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
} else if (prefix == "mds rmfailed") {
int64_t w;
cmd_getval(g_ceph_context, cmdmap, "who", w);
pending_mdsmap.failed.erase(w);
stringstream ss;
ss << "removed failed mds." << w;
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else if (prefix == "mds cluster_fail") {
r = cluster_fail(ss);
if (r < 0 && r == -EAGAIN) {
mon->osdmon()->wait_for_writeable(new C_RetryMessage(this,m));
return false; // don't propose yet; wait for message to be retried
}
} else if (prefix == "mds cluster_down") {
if (pending_mdsmap.test_flag(CEPH_MDSMAP_DOWN)) {
ss << "mdsmap already marked DOWN";
r = -EPERM;
} else {
pending_mdsmap.set_flag(CEPH_MDSMAP_DOWN);
ss << "marked mdsmap DOWN";
r = 0;
}
} else if (prefix == "mds cluster_up") {
if (pending_mdsmap.test_flag(CEPH_MDSMAP_DOWN)) {
pending_mdsmap.clear_flag(CEPH_MDSMAP_DOWN);
ss << "unmarked mdsmap DOWN";
r = 0;
} else {
ss << "mdsmap not marked DOWN";
r = -EPERM;
}
} else if (prefix == "mds compat rm_compat") {
int64_t f;
cmd_getval(g_ceph_context, cmdmap, "feature", f);
if (pending_mdsmap.compat.compat.contains(f)) {
ss << "removing compat feature " << f;
pending_mdsmap.compat.compat.remove(f);
r = 0;
} else {
ss << "compat feature " << f << " not present in " << pending_mdsmap.compat;
r = -ENOENT;
}
} else if (prefix == "mds compat rm_incompat") {
int64_t f;
cmd_getval(g_ceph_context, cmdmap, "feature", f);
if (pending_mdsmap.compat.incompat.contains(f)) {
ss << "removing incompat feature " << f;
pending_mdsmap.compat.incompat.remove(f);
r = 0;
} else {
ss << "incompat feature " << f << " not present in " << pending_mdsmap.compat;
r = -ENOENT;
}
} else if (prefix == "mds add_data_pool") {
int64_t poolid;
cmd_getval(g_ceph_context, cmdmap, "poolid", poolid);
pending_mdsmap.add_data_pool(poolid);
ss << "added data pool " << poolid << " to mdsmap";
r = 0;
} else if (prefix == "mds remove_data_pool") {
int64_t poolid;
cmd_getval(g_ceph_context, cmdmap, "poolid", poolid);
r = pending_mdsmap.remove_data_pool(poolid);
if (r == 0)
ss << "removed data pool " << poolid << " from mdsmap";
} else if (prefix == "mds newfs") {
MDSMap newmap;
int64_t metadata, data;
cmd_getval(g_ceph_context, cmdmap, "metadata", metadata);
cmd_getval(g_ceph_context, cmdmap, "data", data);
string sure;
cmd_getval(g_ceph_context, cmdmap, "sure", sure);
if (sure != "--yes-i-really-mean-it") {
ss << "this is DANGEROUS and will wipe out the mdsmap's fs, and may clobber data in the new pools you specify. add --yes-i-really-mean-it if you do.";
r = -EPERM;
} else {
pending_mdsmap = newmap;
pending_mdsmap.epoch = mdsmap.epoch + 1;
create_new_fs(pending_mdsmap, metadata, data);
ss << "new fs with metadata pool " << metadata << " and data pool " << data;
string rs;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
}
if (r == -EINVAL)
ss << "unrecognized command";
out:

482
src/mon/MonCommands.h Normal file
View File

@ -0,0 +1,482 @@
// -*- 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 Storage, 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.
*
*/
/* no guard; may be included multiple times */
/*
* Define commands that are reported by the monitor's
* "get_command_descriptions" command, and parsed by the Python
* frontend 'ceph' (and perhaps by other frontends, such as a RESTful
* server). The format is:
*
* COMMAND(signature, helpstring)
*
* The commands describe themselves completely enough for the separate
* frontend(s) to be able to accept user input and validate it against
* the command descriptions, and generate a JSON object that contains
* key:value mappings of parameter names to validated parameter values.
*
* 'signature' is a space-separated list of individual command descriptors;
* each descriptor is either a literal string, which can contain no spaces or
* '=' signs (for instance, in "pg stat", both "pg" and "stat" are literal
* strings representing one descriptor each), or a list of key=val[,key=val...]
* which also includes no spaces.
*
* The key=val form describes a non-literal parameter. Each will have at
* least a name= and type=, and each type can have its own type-specific
* parameters. The parser is the arbiter of these types and their
* interpretation. A few more non-type-specific key=val pairs exist:
*
* req=false marks an optional parameter (default for req is 'true')
* n=<n> is a repeat count for how many of this argument must be supplied.
* n=1 is the default.
* n=N is a special case that means "1 or more".
*
* A perhaps-incomplete list of types:
*
* CephInt: Optional: range=min[|max]
* CephFloat: Optional range
* CephString: optional badchars
* CephSocketpath: validation involves "is it S_ISSOCK"
* CephIPAddr: v4 or v6 addr with optional port, syntax validated
* CephEntityAddr: CephIPAddr + '/nonce'
* CephPoolname: Plainold string
* CephObjectname: Another plainold string
* CephPgid: n.xxx where n is an int > 0, xxx is a hex number > 0
* CephName: daemon name, '*' or '<type>.<id>' (id must be int for type osd)
* CephChoices: strings="foo|bar" means this param can be either
* CephFilepath: openable file
* CephFragment: cephfs 'fragID': val/bits, val in hex 0xnnn, bits in dec
* CephUUID: uuid in text matching Python uuid.UUID()
* CephPrefix: special type assigned to literals
*
* Example:
*
* COMMAND("auth add " \
* "name=entity,type=CephString " \
* "name=caps,type=CephString,n=N,req=false", \
* "add auth info for <name> from input file, or random key " \
* "if no input given, and/or any caps specified in the command")
*
* defines a command "auth add" that takes a required argument "entity"
* of type "CephString", and from 1 to N arguments named "caps" of type
* CephString, at least one of which is required. The front end will
* validate user input against this description. Let's say the user
* enters auth add client.admin 'mon rwx' 'osd *'. The result will be a
* JSON object like {"prefix":"auth add", "entity":"client.admin",
* "caps":["mon rwx", "osd *"]}.
* Note that
* - string literals are accumulated into 'prefix'
* - n=1 descriptors are given normal string or int object values
* - n=N descriptors are given array values
*
* NOTE: be careful with spaces. Each descriptor must be separated by
* one space, no other characters, so if you split lines as above, be
* sure to close and reopen the quotes, and be careful to include the '
* separating spaces in the quoted string.
*
* The monitor marshals this JSON into a std::map<string, cmd_vartype>
* where cmd_vartype is a boost::variant type-enforcing discriminated
* type, so the monitor is expected to know the type of each argument.
* See cmdparse.cc/h for more details.
*/
/*
* pg commands PgMonitor.cc
*/
COMMAND("pg stat", "show placement group status.")
COMMAND("pg getmap", "get binary pg map to -o/stdout")
COMMAND("pg send_pg_creates", "trigger pg creates to be issued")
COMMAND("pg dump " \
"name=dumpcontents,type=CephChoices,strings=all|summary|sum|pools|osds|pgs,n=N,req=false", \
"show human-readable versions of pg map")
COMMAND("pg dump_json " \
"name=dumpcontents,type=CephChoices,strings=all|summary|sum|pools|osds|pgs,n=N,req=false", \
"show human-readable version of pg map in json only")
COMMAND("pg dump_pools_json", "show pg pools info in json only")
COMMAND("pg dump_stuck " \
"name=stuckops,type=CephChoices,strings=inactive|unclean|stale,req=false " \
"name=threshold,type=CephInt,req=false",
"show information about stuck pgs [--threshold=seconds to consider stuck]")
COMMAND("pg map name=pgid,type=CephPgid", "show mapping of pg to osds")
COMMAND("pg scrub name=pgid,type=CephPgid", "start scrub on <pgid>")
COMMAND("pg deep-scrub name=pgid,type=CephPgid", "start deep-scrub on <pgid>")
COMMAND("pg repair name=pgid,type=CephPgid", "start repair on <pgid>")
COMMAND("pg debug " \
"name=debugop,type=CephChoices,strings=unfound_objects_exist|degraded_pgs_exist", \
"show debug info about pgs")
COMMAND("pg force_create_pg name=pgid,type=CephPgid", \
"force creation of pg <pgid>")
COMMAND("pg set_full_ratio name=ratio,type=CephFloat,range=0.0|1.0", \
"set ratio at which pgs are considered full")
COMMAND("pg set_nearfull_ratio name=ratio,type=CephFloat,range=0.0|1.0", \
"set ratio at which pgs are considered nearly full")
/*
* auth commands AuthMonitor.cc
*/
COMMAND("auth export name=entity,type=CephString,req=false", \
"write keyring for requested entity, or master keyring if none given")
COMMAND("auth get name=entity,type=CephString", \
"write keyring file with requested key")
COMMAND("auth get-key name=entity,type=CephString", "display requested key")
COMMAND("auth print-key name=entity,type=CephString", "display requested key")
COMMAND("auth print_key name=entity,type=CephString", "display requested key")
COMMAND("auth list", "list authentication state")
COMMAND("auth import", "auth import: read keyring file from input")
COMMAND("auth add " \
"name=entity,type=CephString " \
"name=caps,type=CephString,n=N", \
"add auth info for <name> from input file, or random key if no input given, and/or any caps specified in the command")
COMMAND("auth get-or-create-key " \
"name=entity,type=CephString " \
"name=caps,type=CephString,n=N,req=false", \
"get, or add, key for <name> from system/caps pairs specified in the command. If key already exists, any given caps must match the existing caps for that key.")
COMMAND("auth get-or-create " \
"name=entity,type=CephString " \
"name=caps,type=CephString,n=N,req=false", \
"add auth info for <name> from input file, or random key if no input given, and/or any caps specified in the command")
COMMAND("auth caps " \
"name=entity,type=CephString " \
"name=caps,type=CephString,n=N", \
"update caps for <name> from caps specified in the command")
COMMAND("auth del " \
"name=entity,type=CephString", \
"delete all caps for <name>")
/*
* Monitor commands (Monitor.cc)
*/
COMMAND("fsid", "show cluster FSID/UUID")
COMMAND("log name=logtext,type=CephString,n=N", \
"log supplied text to the monitor log")
COMMAND("stop_cluster", "DEPRECATED")
COMMAND("injectargs " \
"name=injected_args,type=CephString,n=N", \
"inject config arguments into monitor")
COMMAND("status", "show cluster status")
COMMAND("health name=detail,type=CephChoices,strings=detail,req=false", \
"show cluster health")
COMMAND("df name=detail,type=CephChoices,strings=detail,req=false", \
"show cluster free space stats")
COMMAND("report name=tags,type=CephString,n=N,req=false", \
"report full status of cluster, optional title tag strings")
COMMAND("quorum_status", "report status of monitor quorum")
COMMAND("mon_status", "report status of monitors")
COMMAND("sync status", "report status of monitors")
COMMAND("sync force " \
"name=validate1,type=CephChoices,strings=--yes-i-really-mean-it " \
"name=validate2,type=CephChoices,strings=--i-know-what-i-am-doing", \
"force sync of and clear monitor store")
COMMAND("heap " \
"name=heapcmd,type=CephChoices,strings=dump|start_profiler|stop_profiler|release|stats", \
"show heap usage info (available only if compiled with tcmalloc)")
COMMAND("quorum name=quorumcmd,type=CephChoices,strings=enter|exit,n=1", \
"enter or exit quorum")
COMMAND("tell " \
"name=target,type=CephName " \
"name=args,type=CephString,n=N", \
"send a command to a specific daemon")
COMMAND("pg name=pgid,type=CephPgid " \
"name=args,type=CephString,n=N", \
"send a command to a specific pg")
/*
* MDS commands (MDSMonitor.cc)
*/
COMMAND("mds stat", "show MDS status")
COMMAND("mds dump " \
"name=epoch,type=CephInt,req=false,range=0", \
"dump info, optionally from epoch")
COMMAND("mds getmap " \
"name=epoch,type=CephInt,req=false,range=0", \
"get MDS map, optionally from epoch")
COMMAND("mds tell " \
"name=who,type=CephString " \
"name=args,type=CephString,n=N", \
"send command to particular mds")
COMMAND("mds compat show", "show mds compatibility settings")
COMMAND("mds stop name=who,type=CephString", "stop mds")
COMMAND("mds deactivate name=who,type=CephString", "stop mds")
COMMAND("mds set_max_mds " \
"name=maxmds,type=CephInt,range=0", \
"set max MDS index")
COMMAND("mds setmap " \
"name=epoch,type=CephInt,range=0", \
"set mds map; must supply correct epoch number")
// arbitrary limit 0-20 below; worth standing on head to make it
// relate to actual state definitions?
// #include "include/ceph_fs.h"
COMMAND("mds set_state " \
"name=gid,type=CephInt,range=0 " \
"name=state,type=CephInt,range=0|20", \
"set mds state of <gid> to <numeric-state>")
COMMAND("mds fail name=who,type=CephString", \
"force mds to status failed")
COMMAND("mds rm " \
"name=gid,type=CephInt,range=0 " \
"name=who,type=CephName", \
"remove nonactive mds")
COMMAND("mds rmfailed name=who,type=CephInt,range=0", "remove failed mds")
COMMAND("mds cluster_down", "take MDS cluster down")
COMMAND("mds cluster_up", "bring MDS cluster up")
COMMAND("mds compat rm_compat " \
"name=feature,type=CephInt,range=0", \
"remove compatible feature")
COMMAND("mds compat rm_incompat " \
"name=feature,type=CephInt,range=0", \
"remove incompatible feature")
COMMAND("mds add_data_pool " \
"name=poolid,type=CephInt,range=0", \
"add data pool <poolid>")
COMMAND("mds remove_data_pool " \
"name=poolid,type=CephInt,range=0", \
"remove data pool <poolid>")
COMMAND("mds newfs " \
"name=metadata,type=CephInt,range=0 " \
"name=data,type=CephInt,range=0 " \
"name=sure,type=CephChoices,strings=--yes-i-really-mean-it", \
"make new filesystom using pools <metadata> and <data>")
/*
* Monmap commands
*/
COMMAND("mon dump " \
"name=epoch,type=CephInt,req=false", \
"dump formatted monmap (optionally from epoch)")
COMMAND("mon stat", "summarize monitor status")
COMMAND("mon getmap " \
"name=epoch,type=CephInt,range=0,req=false", \
"get monmap")
COMMAND("mon tell " \
"name=who,type=CephString " \
"name=args,type=CephString,n=N", \
"send command to specific monitor(s)")
COMMAND("mon add " \
"name=name,type=CephString " \
"name=addr,type=CephIPAddr", \
"add new monitor named <name> at <addr>")
COMMAND("mon remove " \
"name=name,type=CephString", \
"remove monitor named <name>")
/*
* OSD commands
*/
COMMAND("osd stat", "print summary of OSD map")
COMMAND("osd dump", "print summary of OSD map")
COMMAND("osd tree " \
"name=epoch,type=CephInt,range=0,req=false", \
"print OSD tree")
COMMAND("osd ls " \
"name=epoch,type=CephInt,range=0,req=false", \
"show all OSD ids")
COMMAND("osd getmap " \
"name=epoch,type=CephInt,range=0,req=false", \
"get OSD map")
COMMAND("osd getcrushmap " \
"name=epoch,type=CephInt,range=0,req=false", \
"get CRUSH map")
COMMAND("osd getmaxosd", "show largest OSD id")
COMMAND("osd tell " \
"name=who,type=CephString " \
"name=args,type=CephString,n=N", \
"send command to particular osd")
COMMAND("osd find " \
"name=id,type=CephInt,range=0", \
"find osd <id> in the CRUSH map and show its location")
COMMAND("osd map " \
"name=pool,type=CephPoolname " \
"name=object,type=CephObjectname", \
"find pg for <object> in <pool>")
COMMAND("osd scrub " \
"name=who,type=CephString", \
"initiate scrub on osd <who>")
COMMAND("osd deep-scrub " \
"name=who,type=CephString", \
"initiate deep scrub on osd <who>")
COMMAND("osd repair " \
"name=who,type=CephString", \
"initiate repair on osd <who>")
COMMAND("osd lspools " \
"name=auid,type=CephInt,req=false", \
"list pools")
COMMAND("osd blacklist ls", "show blacklisted clients")
COMMAND("osd crush rule list", "list crush rules")
COMMAND("osd crush rule ls", "list crush rules")
COMMAND("osd crush rule dump", "dump crush rules")
COMMAND("osd crush dump", "dump crush map")
COMMAND("osd setcrushmap", "set crush map from input file")
COMMAND("osd crush set", "set crush map from input file")
COMMAND("osd crush add-bucket " \
"name=name,type=CephString " \
"name=type,type=CephString", \
"add no-parent (probably root) crush bucket <name> of type <type>")
COMMAND("osd crush set " \
"name=id,type=CephInt,range=0 " \
"name=name,type=CephName,req=false " \
"name=weight,type=CephFloat,range=0.0 " \
"name=args,type=CephString,n=N", \
"set crushmap entry for <id> to <weight> with location <args>")
COMMAND("osd crush add " \
"name=id,type=CephInt,range=0 " \
"name=name,type=CephName,req=false " \
"name=weight,type=CephFloat,range=0.0 " \
"name=args,type=CephString,n=N", \
"add crushmap entry for <id> with <weight> and location <args>")
COMMAND("osd crush create-or-move " \
"name=id,type=CephInt,range=0 " \
"name=weight,type=CephFloat,range=0.0 " \
"name=args,type=CephString,n=N", \
"create entry or move existing entry for <id> <weight> at/to location <args>")
COMMAND("osd crush move " \
"name=name,type=CephString " \
"name=args,type=CephString,n=N", \
"move existing entry for <name> to location <args>")
COMMAND("osd crush link " \
"name=name,type=CephString " \
"name=args,type=CephString,n=N", \
"link existing entry for <name> under location <args>")
COMMAND("osd crush rm " \
"name=name,type=CephString", \
"remove <name> from crush map")
COMMAND("osd crush remove " \
"name=name,type=CephString", \
"remove <name> from crush map")
COMMAND("osd crush unlink " \
"name=name,type=CephString " \
"name=ancestor,type=CephString,req=false", \
"unlink <name> from crush map (everywhere, or just at <ancestor>")
COMMAND("osd crush reweight " \
"name=name,type=CephString " \
"name=weight,type=CephFloat,range=0.0", \
"change <name>'s weight to <weight> in crush map")
COMMAND("osd crush tunables " \
"name=profile,type=CephChoices,strings=legacy|argonaut|bobtail|optimal|default", \
"set crush tunables values to <profile>")
COMMAND("osd crush rule create-simple " \
"name=name,type=CephString " \
"name=root,type=CephString " \
"name=type,type=CephString", \
"create crush rule <name> in <root> of type <type>")
COMMAND("osd crush rule rm " \
"name=name,type=CephString", \
"remove crush rule <name>")
COMMAND("osd setmaxosd " \
"name=newmax,type=CephInt,range=0", \
"set new maximum osd value")
COMMAND("osd pause", "pause osd")
COMMAND("osd unpause", "unpause osd")
COMMAND("osd set " \
"name=key,type=CephChoices,strings=pause|noup|nodown|noout|noin|nobackfile|norecover", \
"set <key>")
COMMAND("osd unset " \
"name=key,type=CephChoices,strings=pause|noup|nodown|noout|noin|nobackfile|norecover", \
"unset <key>")
COMMAND("osd cluster_snap", "take cluster snapshot (disabled)")
COMMAND("osd down " \
"type=CephString,name=ids,n=N", \
"set osd(s) <id> [<id>...] down")
COMMAND("osd out " \
"name=ids,type=CephString,n=N", \
"set osd(s) <id> [<id>...] out")
COMMAND("osd in " \
"name=ids,type=CephString,n=N", \
"set osd(s) <id> [<id>...] in")
COMMAND("osd rm " \
"name=ids,type=CephString,n=N", \
"remove osd(s) <id> [<id>...] in")
COMMAND("osd reweight " \
"name=id,type=CephInt,range=0 " \
"type=CephFloat,name=weight,range=0.0|1.0", \
"reweight osd to 0.0 < <weight> < 1.0")
COMMAND("osd lost " \
"name=id,type=CephInt,range=0 " \
"name=sure,type=CephChoices,strings=--yes-i-really-mean-it", \
"mark osd as permanently lost. THIS DESTROYS DATA IF NO MORE REPLICAS EXIST, BE CAREFUL")
COMMAND("osd create " \
"name=uuid,type=CephUUID,req=false", \
"create new osd (with optional UUID)")
COMMAND("osd blacklist " \
"name=blacklistop,type=CephChoices,strings=add|rm " \
"name=addr,type=CephEntityAddr " \
"name=expire,type=CephFloat,range=0.0,req=false", \
"add (optionally until <expire> seconds from now) or remove <addr> from blacklist")
COMMAND("osd pool mksnap " \
"name=pool,type=CephPoolname " \
"name=snap,type=CephString", \
"make snapshot <snap> in <pool>")
COMMAND("osd pool rmsnap " \
"name=pool,type=CephPoolname " \
"name=snap,type=CephString", \
"remove snapshot <snap> from <pool>")
COMMAND("osd pool create " \
"name=pool,type=CephPoolname " \
"name=pg_num,type=CephInt,range=0 " \
"name=pgp_num,type=CephInt,range=0,req=false", \
"create pool")
COMMAND("osd pool delete " \
"name=pool,type=CephPoolname " \
"name=pool2,type=CephPoolname " \
"name=sure,type=CephChoices,strings=--yes-i-really-really-mean-it", \
"delete pool (say pool twice, add --yes-i-really-really-mean-it)")
COMMAND("osd pool rename " \
"name=srcpool,type=CephPoolname " \
"name=destpool,type=CephPoolname", \
"rename <srcpool> to <destpool>")
COMMAND("osd pool get " \
"name=pool,type=CephPoolname " \
"name=var,type=CephChoices,strings=size|min_size|crash_replay_interval|pg_num|pgp_num|crush_ruleset", \
"get pool parameter <var>")
COMMAND("osd pool set " \
"name=pool,type=CephPoolname " \
"name=var,type=CephChoices,strings=size|min_size|crash_replay_interval|pg_num|pgp_num|crush_ruleset " \
"name=val,type=CephInt " \
"name=sure,type=CephChoices,strings=--allow-experimental-feature,req=false", \
"set pool parameter <var> to <val>")
// 'val' is a CephString because it can include a unit. Perhaps
// there should be a Python type for validation/conversion of strings
// with units.
COMMAND("osd pool set-quota " \
"name=pool,type=CephPoolname " \
"name=field,type=CephChoices,strings=max_objects|max_bytes " \
"name=val,type=CephString",
"set object or byte limit on pool")
COMMAND("osd reweight-by-utilization " \
"name=oload,type=CephInt,range=100,req=false", \
"reweight OSDs by utilization [overload-percentage-for-consideration, default 120]")
COMMAND("osd thrash " \
"name=num_epochs,type=CephInt,range=0", \
"thrash OSDs for <num_epochs>")
/*
* mon/ConfigKeyService.cc
*/
COMMAND("config-key get " \
"name=key,type=CephString", \
"get <key>")
COMMAND("config-key put " \
"name=key,type=CephString " \
"name=val,type=CephString,req=false", \
"put <key>, value <val>")
COMMAND("config-key del " \
"name=key,type=CephString", \
"delete <key>")
COMMAND("config-key exists " \
"name=key,type=CephString", \
"check for <key>'s existence")
COMMAND("config-key list ", "list keys")

407
src/mon/Monitor.cc
View File

@ -17,6 +17,7 @@
#include <stdlib.h>
#include <signal.h>
#include <limits.h>
#include <cstring>
#include "Monitor.h"
#include "common/version.h"
@ -77,6 +78,7 @@
#include "auth/KeyRing.h"
#include "common/config.h"
#include "common/cmdparse.h"
#include "include/assert.h"
#define dout_subsys ceph_subsys_mon
@ -2463,6 +2465,75 @@ void Monitor::get_status(stringstream &ss, Formatter *f)
}
}
/**
* Read a command description list out of cmds, and dump it to f.
* A signature description is a set of space-separated words;
* see MonCommands.h for more info.
*/
static void
dump_cmds_to_json(Formatter *f, const char *cmds)
{
// put whole command signature in an already-opened container
// elements are: "name", meaning "the typeless name that means a literal"
// an object {} with key:value pairs representing an argument
int argnum = 0;
stringstream ss(cmds);
std::string word;
while (std::getline(ss, word, ' ')) {
argnum++;
// if no , or =, must be a plain word to put out
if (word.find_first_of(",=") == string::npos) {
f->dump_string("arg", word);
continue;
}
// Snarf up all the key=val,key=val pairs, put 'em in a dict.
// no '=val' implies '=True'.
std::stringstream argdesc(word);
std::string keyval, name;
std::map<std::string, std::string>desckv;
// accumulate descriptor keywords in desckv
size_t pos;
while (std::getline(argdesc, keyval, ',')) {
// key=value; key by itself implies value is bool true
// name="name" means arg dict will be titled 'name'
pos = keyval.find('=');
std::string key, val;
if (pos != std::string::npos) {
key = keyval.substr(0, pos);
val = keyval.substr(pos+1);
} else {
key = keyval;
val = true;
}
desckv.insert(std::pair<std::string, std::string> (key, val));
}
// name the individual desc object based on the name key
f->open_object_section(desckv["name"].c_str());
// dump all the keys including name into the array
for (std::map<std::string, std::string>::iterator it = desckv.begin();
it != desckv.end(); it++) {
f->dump_string(it->first.c_str(), it->second);
}
f->close_section(); // attribute object for individual desc
}
}
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*a))
#undef COMMAND
struct MonCommand {
const char *cmdstring;
const char *helpstring;
} mon_commands[] = {
#define COMMAND(parsesig, helptext) \
{parsesig, helptext},
#include <mon/MonCommands.h>
};
void Monitor::handle_command(MMonCommand *m)
{
if (m->fsid != monmap->fsid) {
@ -2478,45 +2549,105 @@ void Monitor::handle_command(MMonCommand *m)
return;
}
bool access_cmd = _allowed_command(session, m->cmd);
bool access_r = (session->caps.check_privileges(PAXOS_MONMAP, MON_CAP_R) ||
access_cmd);
bool access_all = (session->caps.get_allow_all() || access_cmd);
if (m->cmd.empty()) {
string rs = "No command supplied";
reply_command(m, -EINVAL, rs, 0);
return;
}
dout(0) << "handle_command " << *m << dendl;
string prefix;
vector<string> fullcmd;
map<string, cmd_vartype> cmdmap;
stringstream ss;
bufferlist rdata;
string rs;
int r = -EINVAL;
rs = "unrecognized command";
if (m->cmd.empty())
goto out;
if (m->cmd[0] == "mds") {
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
// ss has reason for failure
r = -EINVAL;
rs = ss.str();
if (!m->get_source().is_mon()) // don't reply to mon->mon commands
reply_command(m, r, rs, 0);
else
m->put();
return;
}
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
if (prefix == "get_command_descriptions") {
int cmdnum = 0;
JSONFormatter *f = new JSONFormatter();
f->open_object_section("command_descriptions");
for (MonCommand *cp = mon_commands;
cp < &mon_commands[ARRAY_SIZE(mon_commands)]; cp++) {
ostringstream secname;
secname << "cmd" << setfill('0') << std::setw(3) << cmdnum;
f->open_object_section(secname.str().c_str());
f->open_array_section("sig");
dump_cmds_to_json(f, cp->cmdstring);
f->close_section(); // desc array
f->dump_string("help", string(cp->helpstring));
f->close_section(); // overall object
cmdnum++;
}
f->close_section(); // command_descriptions
stringstream ds, ss;
bufferlist rdata;
f->flush(ds);
delete f;
rdata.append(ds);
reply_command(m, 0, "", rdata, 0);
return;
}
bool access_cmd;
bool access_r;
bool access_all;
string module;
string err;
dout(0) << "handle_command " << *m << dendl;
string format;
cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
boost::scoped_ptr<Formatter> f(new_formatter(format));
build_fullcmd(prefix, cmdmap, &fullcmd);
module = fullcmd[0];
access_cmd = _allowed_command(session, fullcmd);
access_r = (session->caps.check_privileges(PAXOS_MONMAP, MON_CAP_R) ||
access_cmd);
access_all = (session->caps.get_allow_all() || access_cmd);
if (module == "mds") {
mdsmon()->dispatch(m);
return;
}
if (m->cmd[0] == "osd") {
if (module == "osd") {
osdmon()->dispatch(m);
return;
}
if (m->cmd[0] == "pg") {
if (module == "pg") {
pgmon()->dispatch(m);
return;
}
if (m->cmd[0] == "mon") {
if (module == "mon") {
monmon()->dispatch(m);
return;
}
if (m->cmd[0] == "class") {
reply_command(m, -EINVAL, "class distribution is no longer handled by the monitor", 0);
return;
}
if (m->cmd[0] == "auth") {
if (module == "auth") {
authmon()->dispatch(m);
return;
}
if (m->cmd[0] == "config-key") {
if (module == "config-key") {
if (!access_all) {
r = -EACCES;
rs = "access denied";
@ -2526,31 +2657,30 @@ void Monitor::handle_command(MMonCommand *m)
return;
}
if (m->cmd[0] == "fsid") {
if (prefix == "fsid") {
stringstream ss;
ss << monmap->fsid;
reply_command(m, 0, ss.str(), rdata, 0);
return;
}
if (m->cmd[0] == "log") {
if (prefix == "log") {
if (!access_r) {
r = -EACCES;
rs = "access denied";
goto out;
}
vector<string> logtext;
cmd_getval(g_ceph_context, cmdmap, "logtext", logtext);
stringstream ss;
for (unsigned i=1; i<m->cmd.size(); i++) {
if (i > 1)
ss << ' ';
ss << m->cmd[i];
}
std::copy(logtext.begin(), logtext.end(),
ostream_iterator<string>(ss, " "));
clog.info(ss);
rs = "ok";
reply_command(m, 0, rs, rdata, 0);
return;
}
if (m->cmd[0] == "compact") {
if (prefix == "compact") {
if (!access_all) {
r = -EACCES;
rs = "access denied";
@ -2567,100 +2697,73 @@ void Monitor::handle_command(MMonCommand *m)
rs = oss.str();
r = 0;
}
if (m->cmd[0] == "injectargs") {
else if (prefix == "injectargs") {
if (!access_all) {
r = -EACCES;
rs = "access denied";
goto out;
}
if (m->cmd.size() == 2) {
dout(0) << "parsing injected options '" << m->cmd[1] << "'" << dendl;
vector<string> injected_args;
cmd_getval(g_ceph_context, cmdmap, "injected_args", injected_args);
if (!injected_args.empty()) {
dout(0) << "parsing injected options '" << injected_args << "'" << dendl;
ostringstream argss;
std::copy(injected_args.begin(), injected_args.end(),
ostream_iterator<string>(argss, " "));
ostringstream oss;
g_conf->injectargs(m->cmd[1], &oss);
derr << "injectargs:" << dendl;
derr << oss.str() << dendl;
rs = "parsed options";
r = 0;
r = g_conf->injectargs(argss.str().c_str(), &oss);
ss << "injectargs:" << oss.str();
rs = ss.str();
goto out;
} else {
rs = "must supply options to be parsed in a single string";
r = -EINVAL;
}
} else if ((m->cmd[0] == "status") || (m->cmd[0] == "health")
|| (m->cmd[0] == "df")) {
} else if (prefix == "status" ||
prefix == "health" ||
prefix == "df") {
if (!access_r) {
r = -EACCES;
rs = "access denied";
goto out;
}
vector<const char *> args;
for (unsigned int i = 0; i < m->cmd.size(); ++i)
args.push_back(m->cmd[i].c_str());
string format = "plain";
JSONFormatter *jf = NULL;
for (vector<const char*>::iterator i = args.begin(); i != args.end();) {
string val;
if (ceph_argparse_witharg_daemon(args, i, &val,
"-f", "--format", (char*)NULL)) {
format = val;
} else {
++i;
}
}
if (format != "plain") {
if (format == "json") {
jf = new JSONFormatter(true);
} else {
r = -EINVAL;
stringstream err_ss;
err_ss << "unrecognized format '" << format
<< "' (available: plain, json)";
rs = err_ss.str();
goto out;
}
}
stringstream ss;
if (string(args[0]) == "status") {
get_status(ss, jf);
string detail;
cmd_getval(g_ceph_context, cmdmap, "detail", detail);
if (jf) {
jf->flush(ss);
if (prefix == "status") {
// get_status handles f == NULL
get_status(ss, f.get());
if (f) {
f->flush(ss);
ss << '\n';
}
} else if (string(args[0]) == "health") {
} else if (prefix == "health") {
string health_str;
get_health(health_str, (args.size() > 1) ? &rdata : NULL, jf);
if (jf) {
jf->flush(ss);
get_health(health_str, detail == "detail" ? &rdata : NULL, f.get());
if (f) {
f->flush(ss);
ss << '\n';
} else {
ss << health_str;
}
} else if (string(args[0]) == "df") {
if (args.size() > 1) {
if (string(args[1]) != "detail") {
delete jf;
r = -EINVAL;
rs = "usage: df [detail]";
goto out;
}
}
bool verbose = (args.size() > 1);
if (jf)
jf->open_object_section("stats");
rs = ss.str();
r = 0;
} else if (prefix == "df") {
bool verbose = (detail == "detail");
if (f)
f->open_object_section("stats");
pgmon()->dump_fs_stats(ss, jf, verbose);
if (!jf)
pgmon()->dump_fs_stats(ss, f.get(), verbose);
if (!f)
ss << '\n';
pgmon()->dump_pool_stats(ss, jf, verbose);
pgmon()->dump_pool_stats(ss, f.get(), verbose);
if (jf) {
jf->close_section();
jf->flush(ss);
if (f) {
f->close_section();
f->flush(ss);
ss << '\n';
}
} else {
@ -2669,39 +2772,42 @@ void Monitor::handle_command(MMonCommand *m)
}
rs = ss.str();
r = 0;
} else if (m->cmd[0] == "report") {
} else if (prefix == "report") {
if (!access_r) {
r = -EACCES;
rs = "access denied";
goto out;
}
JSONFormatter jf(true);
// this must be formatted, in its current form
if (!f)
f.reset(new_formatter("json-pretty"));
f->open_object_section("report");
f->dump_string("version", ceph_version_to_str());
f->dump_string("commit", git_version_to_str());
f->dump_stream("timestamp") << ceph_clock_now(NULL);
jf.open_object_section("report");
jf.dump_string("version", ceph_version_to_str());
jf.dump_string("commit", git_version_to_str());
jf.dump_stream("timestamp") << ceph_clock_now(NULL);
string d;
for (unsigned i = 1; i < m->cmd.size(); i++) {
if (i > 1)
d += " ";
d += m->cmd[i];
}
jf.dump_string("tag", d);
vector<string> tagsvec;
cmd_getval(g_ceph_context, cmdmap, "tags", tagsvec);
stringstream tags;
std::copy(tagsvec.begin(), tagsvec.end(),
ostream_iterator<string>(tags, " "));
string tagstr = tags.str();
if (!tagstr.empty())
tagstr = tagstr.substr(0, tagstr.find_last_of(' '));
f->dump_string("tag", tagstr);
string hs;
get_health(hs, NULL, &jf);
get_health(hs, NULL, f.get());
monmon()->dump_info(&jf);
osdmon()->dump_info(&jf);
mdsmon()->dump_info(&jf);
pgmon()->dump_info(&jf);
monmon()->dump_info(f.get());
osdmon()->dump_info(f.get());
mdsmon()->dump_info(f.get());
pgmon()->dump_info(f.get());
jf.close_section();
f->close_section();
stringstream ss;
jf.flush(ss);
f->flush(ss);
bufferlist bl;
bl.append("-------- BEGIN REPORT --------\n");
@ -2712,7 +2818,7 @@ void Monitor::handle_command(MMonCommand *m)
rdata.append(ss2.str());
rs = string();
r = 0;
} else if (m->cmd[0] == "quorum_status") {
} else if (prefix == "quorum_status") {
if (!access_r) {
r = -EACCES;
rs = "access denied";
@ -2728,7 +2834,7 @@ void Monitor::handle_command(MMonCommand *m)
_quorum_status(ss);
rs = ss.str();
r = 0;
} else if (m->cmd[0] == "mon_status") {
} else if (prefix == "mon_status") {
if (!access_r) {
r = -EACCES;
rs = "access denied";
@ -2738,36 +2844,33 @@ void Monitor::handle_command(MMonCommand *m)
_mon_status(ss);
rs = ss.str();
r = 0;
} else if (m->cmd[0] == "sync") {
} else if (prefix == "sync status") {
if (!access_r) {
r = -EACCES;
rs = "access denied";
goto out;
}
if (m->cmd[1] == "status") {
stringstream ss;
_sync_status(ss);
rs = ss.str();
r = 0;
} else if (m->cmd[1] == "force") {
if (m->cmd.size() < 4 || m->cmd[2] != "--yes-i-really-mean-it"
|| m->cmd[3] != "--i-know-what-i-am-doing") {
r = -EINVAL;
rs = "are you SURE? this will mean the monitor store will be "
"erased. pass '--yes-i-really-mean-it "
"--i-know-what-i-am-doing' if you really do.";
goto out;
}
stringstream ss;
_sync_force(ss);
rs = ss.str();
r = 0;
} else {
rs = "unknown command";
r = -EINVAL;
goto out;
}
} else if (m->cmd[0] == "heap") {
stringstream ss;
_sync_status(ss);
rs = ss.str();
r = 0;
} else if (prefix == "sync force") {
string validate1, validate2;
cmd_getval(g_ceph_context, cmdmap, "validate1", validate1);
cmd_getval(g_ceph_context, cmdmap, "validate2", validate2);
if (validate1 != "--yes-i-really-mean-it" ||
validate2 != "--i-know-what-i-am-doing") {
r = -EINVAL;
rs = "are you SURE? this will mean the monitor store will be "
"erased. pass '--yes-i-really-mean-it "
"--i-know-what-i-am-doing' if you really do.";
goto out;
}
stringstream ss;
_sync_force(ss);
rs = ss.str();
r = 0;
} else if (prefix == "heap") {
if (!access_all) {
r = -EACCES;
rs = "access denied";
@ -2776,37 +2879,39 @@ void Monitor::handle_command(MMonCommand *m)
if (!ceph_using_tcmalloc())
rs = "tcmalloc not enabled, can't use heap profiler commands\n";
else {
string heapcmd;
cmd_getval(g_ceph_context, cmdmap, "heapcmd", heapcmd);
ostringstream ss;
ceph_heap_profiler_handle_command(m->cmd, ss);
// XXX 1-element vector, change at callee or make vector here?
vector<string> heapcmd_vec;
get_str_vec(heapcmd, heapcmd_vec);
ceph_heap_profiler_handle_command(heapcmd_vec, ss);
rs = ss.str();
}
} else if (m->cmd[0] == "quorum") {
} else if (prefix == "quorum") {
if (!access_all) {
r = -EACCES;
rs = "access denied";
goto out;
}
if (m->cmd.size() < 2) {
r = -EINVAL;
rs = "'quorum' requires an argument: 'exit' or 'enter'";
goto out;
}
if (m->cmd[1] == "exit") {
string quorumcmd;
cmd_getval(g_ceph_context, cmdmap, "quorumcmd", quorumcmd);
if (quorumcmd == "exit") {
reset();
start_election();
elector.stop_participating();
rs = "stopped responding to quorum, initiated new election";
r = 0;
} else if (m->cmd[1] == "enter") {
} else if (quorumcmd == "enter") {
elector.start_participating();
reset();
start_election();
rs = "started responding to quorum, initiated new election";
r = 0;
} else {
rs = "unknown quorum subcommand; use exit or enter";
r = -EINVAL;
}
} else if (!access_cmd) {
r = -EACCES;
rs = "access denied";
}
out:

338
src/mon/MonmapMonitor.cc
View File

@ -27,6 +27,8 @@
#include <sstream>
#include "common/config.h"
#include "common/cmdparse.h"
#include "include/str_list.h"
#include "include/assert.h"
#define dout_subsys ceph_subsys_mon
@ -190,135 +192,116 @@ bool MonmapMonitor::preprocess_command(MMonCommand *m)
bufferlist rdata;
stringstream ss;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, rdata, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!session->caps.check_privileges(PAXOS_MONMAP, MON_CAP_R) &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", get_version());
return true;
}
vector<const char*> args;
for (unsigned i = 1; i < m->cmd.size(); i++)
args.push_back(m->cmd[i].c_str());
if (prefix == "mon stat") {
mon->monmap->print_summary(ss);
ss << ", election epoch " << mon->get_epoch() << ", quorum " << mon->get_quorum()
<< " " << mon->get_quorum_names();
r = 0;
if (m->cmd.size() > 1) {
if (m->cmd[1] == "stat") {
mon->monmap->print_summary(ss);
ss << ", election epoch " << mon->get_epoch() << ", quorum " << mon->get_quorum()
<< " " << mon->get_quorum_names();
r = 0;
}
else if (m->cmd.size() == 2 && m->cmd[1] == "getmap") {
mon->monmap->encode(rdata, CEPH_FEATURES_ALL);
r = 0;
ss << "got latest monmap";
}
else if (m->cmd[1] == "dump") {
string format = "plain";
string val;
epoch_t epoch = 0;
for (std::vector<const char*>::iterator i = args.begin()+1; i != args.end(); ) {
if (ceph_argparse_double_dash(args, i))
break;
else if (ceph_argparse_witharg_daemon(args, i, &val, "-f", "--format",
(char*)NULL))
format = val;
else if (!epoch) {
long l = parse_pos_long(*i++, &ss);
if (l < 0) {
r = -EINVAL;
goto out;
}
epoch = l;
} else
++i;
}
} else if (prefix == "mon getmap") {
mon->monmap->encode(rdata, CEPH_FEATURES_ALL);
r = 0;
ss << "got latest monmap";
MonMap *p = mon->monmap;
if (epoch) {
/*
bufferlist b;
mon->store->get_bl_sn(b,"osdmap_full", epoch);
if (!b.length()) {
p = 0;
r = -ENOENT;
} else {
p = new OSDMap;
p->decode(b);
}
*/
}
if (p) {
stringstream ds;
if (format == "json") {
Formatter *f = new JSONFormatter(true);
f->open_object_section("monmap");
p->dump(f);
f->open_array_section("quorum");
for (set<int>::iterator q = mon->get_quorum().begin(); q != mon->get_quorum().end(); ++q)
f->dump_int("mon", *q);
f->close_section();
f->close_section();
f->flush(ds);
delete f;
r = 0;
} else if (format == "plain") {
p->print(ds);
r = 0;
} else {
ss << "unrecognized format '" << format << "'";
r = -EINVAL;
}
if (r == 0) {
rdata.append(ds);
ss << "dumped monmap epoch " << p->get_epoch();
}
if (p != mon->monmap)
delete p;
}
} else if (prefix == "mon dump") {
string format;
cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
epoch_t epoch = 0;
int64_t epochval;
if (cmd_getval(g_ceph_context, cmdmap, "epoch", epochval))
epoch = epochval;
}
else if (m->cmd.size() >= 3 && m->cmd[1] == "tell") {
dout(20) << "got tell: " << m->cmd << dendl;
if (m->cmd[2] == "*") { // send to all mons and do myself
for (unsigned i = 0; i < mon->monmap->size(); ++i) {
MMonCommand *newm = new MMonCommand(m->fsid, m->version);
newm->cmd.insert(newm->cmd.begin(), m->cmd.begin() + 3, m->cmd.end());
mon->messenger->send_message(newm, mon->monmap->get_inst(i));
}
ss << "bcast to all mons";
r = 0;
MonMap *p = mon->monmap;
if (epoch) {
bufferlist b;
r = get_version(epoch, b);
if (r == -ENOENT) {
p = 0;
} else {
// find target
long target = parse_pos_long(m->cmd[2].c_str(), &ss);
if (target < 0) {
r = -EINVAL;
goto out;
}
if (target >= (long)mon->monmap->size()) {
ss << "mon." << target << " does not exist";
r = -ENOENT;
goto out;
}
// send to target, or handle if it's me
stringstream ss;
MMonCommand *newm = new MMonCommand(m->fsid, m->version);
newm->cmd.insert(newm->cmd.begin(), m->cmd.begin() + 3, m->cmd.end());
mon->messenger->send_message(newm, mon->monmap->get_inst(target));
ss << "fw to mon." << target;
r = 0;
p = new MonMap;
p->decode(b);
}
}
else if (m->cmd[1] == "add")
return false;
else if (m->cmd[1] == "remove")
return false;
if (p) {
stringstream ds;
boost::scoped_ptr<Formatter> f(new_formatter(format));
if (f) {
f->open_object_section("monmap");
p->dump(f.get());
f->open_array_section("quorum");
for (set<int>::iterator q = mon->get_quorum().begin(); q != mon->get_quorum().end(); ++q)
f->dump_int("mon", *q);
f->close_section();
f->close_section();
f->flush(ds);
r = 0;
} else {
p->print(ds);
r = 0;
}
rdata.append(ds);
ss << "dumped monmap epoch " << p->get_epoch();
if (p != mon->monmap)
delete p;
}
} else if (prefix == "mon tell") {
dout(20) << "got tell: " << m->cmd << dendl;
string whostr;
cmd_getval(g_ceph_context, cmdmap, "who", whostr);
vector<string> argvec;
cmd_getval(g_ceph_context, cmdmap, "args", argvec);
if (whostr == "*") { // send to all mons and do myself
for (unsigned i = 0; i < mon->monmap->size(); ++i) {
MMonCommand *newm = new MMonCommand(m->fsid, m->version);
newm->cmd.insert(newm->cmd.begin(), argvec.begin(), argvec.end());
mon->messenger->send_message(newm, mon->monmap->get_inst(i));
}
ss << "bcast to all mons";
r = 0;
} else {
// find target
long who = parse_pos_long(whostr.c_str(), &ss);
if (who >= (long)mon->monmap->size()) {
ss << "mon." << whostr << " does not exist";
r = -ENOENT;
goto out;
}
// send to target, or handle if it's me
stringstream ss;
MMonCommand *newm = new MMonCommand(m->fsid, m->version);
newm->cmd.insert(newm->cmd.begin(), argvec.begin(), argvec.end());
mon->messenger->send_message(newm, mon->monmap->get_inst(whostr));
ss << "fw to mon." << whostr;
r = 0;
}
}
else if (prefix == "mon add")
return false;
else if (prefix == "mon remove")
return false;
out:
if (r != -1) {
@ -355,75 +338,88 @@ bool MonmapMonitor::prepare_command(MMonCommand *m)
string rs;
int err = -EINVAL;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!session->caps.check_privileges(PAXOS_MONMAP, MON_CAP_R) &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", get_version());
return true;
}
if (m->cmd.size() > 1) {
if (m->cmd.size() == 4 && m->cmd[1] == "add") {
string name = m->cmd[2];
entity_addr_t addr;
bufferlist rdata;
if (prefix == "mon add") {
string name;
cmd_getval(g_ceph_context, cmdmap, "name", name);
string addrstr;
cmd_getval(g_ceph_context, cmdmap, "addr", addrstr);
entity_addr_t addr;
bufferlist rdata;
if (!addr.parse(m->cmd[3].c_str())) {
err = -EINVAL;
ss << "addr " << m->cmd[3] << "does not parse";
goto out;
}
if (addr.get_port() == 0) {
ss << "port defaulted to " << CEPH_MON_PORT;
addr.set_port(CEPH_MON_PORT);
}
if (pending_map.contains(addr) ||
pending_map.contains(name)) {
err = -EEXIST;
if (!ss.str().empty())
ss << "; ";
ss << "mon " << name << " " << addr << " already exists";
goto out;
}
pending_map.add(name, addr);
pending_map.last_changed = ceph_clock_now(g_ceph_context);
ss << "added mon." << name << " at " << addr;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
if (!addr.parse(addrstr.c_str())) {
err = -EINVAL;
ss << "addr " << addrstr << "does not parse";
goto out;
}
else if (m->cmd.size() == 3 && m->cmd[1] == "remove") {
string name = m->cmd[2];
if (!pending_map.contains(name)) {
err = -ENOENT;
ss << "mon " << name << " does not exist";
goto out;
}
if (pending_map.size() == 1) {
err = -EINVAL;
ss << "error: refusing removal of last monitor " << name;
goto out;
}
entity_addr_t addr = pending_map.get_addr(name);
pending_map.remove(name);
pending_map.last_changed = ceph_clock_now(g_ceph_context);
ss << "removed mon." << name << " at " << addr << ", there are now " << pending_map.size() << " monitors" ;
getline(ss, rs);
// send reply immediately in case we get removed
mon->reply_command(m, 0, rs, get_version());
return true;
if (addr.get_port() == 0) {
ss << "port defaulted to " << CEPH_MON_PORT;
addr.set_port(CEPH_MON_PORT);
}
else
ss << "unknown command " << m->cmd[1];
} else
ss << "no command?";
if (pending_map.contains(addr) ||
pending_map.contains(name)) {
err = -EEXIST;
if (!ss.str().empty())
ss << "; ";
ss << "mon " << name << " " << addr << " already exists";
goto out;
}
pending_map.add(name, addr);
pending_map.last_changed = ceph_clock_now(g_ceph_context);
ss << "added mon." << name << " at " << addr;
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
} else if (prefix == "mon remove") {
string name;
cmd_getval(g_ceph_context, cmdmap, "name", name);
if (!pending_map.contains(name)) {
err = -ENOENT;
ss << "mon " << name << " does not exist";
goto out;
}
if (pending_map.size() == 1) {
err = -EINVAL;
ss << "error: refusing removal of last monitor " << name;
goto out;
}
entity_addr_t addr = pending_map.get_addr(name);
pending_map.remove(name);
pending_map.last_changed = ceph_clock_now(g_ceph_context);
ss << "removed mon." << name << " at " << addr << ", there are now " << pending_map.size() << " monitors" ;
getline(ss, rs);
// send reply immediately in case we get removed
mon->reply_command(m, 0, rs, get_version());
return true;
}
else
ss << "unknown command " << prefix;
out:
getline(ss, rs);
mon->reply_command(m, err, rs, get_version());

2500
src/mon/OSDMonitor.cc
View File

File diff suppressed because it is too large Load Diff

2
src/mon/OSDMonitor.h
View File

@ -295,7 +295,7 @@ private:
void tick(); // check state, take actions
int parse_osd_id(const char *s, stringstream *pss);
void parse_loc_map(const vector<string>& args, int start, map<string,string> *ploc);
void parse_loc_map(const vector<string>& args, map<string,string> *ploc);
void get_health(list<pair<health_status_t,string> >& summary,
list<pair<health_status_t,string> > *detail) const;

491
src/mon/PGMonitor.cc
View File

@ -13,6 +13,8 @@
*/
#include "json_spirit/json_spirit.h"
#include "common/debug.h" // undo damage
#include "PGMonitor.h"
#include "Monitor.h"
#include "MDSMonitor.h"
@ -42,7 +44,11 @@
#include "common/config.h"
#include "common/errno.h"
#include "common/strtol.h"
#include "include/str_list.h"
#include <sstream>
#include <boost/variant.hpp>
#include "common/cmdparse.h"
#define dout_subsys ceph_subsys_mon
#undef dout_prefix
@ -924,6 +930,7 @@ bool PGMonitor::check_down_pgs()
}
}
need_check_down_pgs = false;
return ret;
}
@ -1091,207 +1098,200 @@ bool PGMonitor::preprocess_command(MMonCommand *m)
bufferlist rdata;
stringstream ss;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
// ss has reason for failure
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, rdata, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!session->caps.check_privileges(PAXOS_PGMAP, MON_CAP_R) &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", rdata, get_version());
return true;
}
vector<const char*> args;
for (unsigned i = 1; i < m->cmd.size(); i++)
args.push_back(m->cmd[i].c_str());
if (m->cmd.size() > 1) {
if (m->cmd[1] == "stat") {
ss << pg_map;
r = 0;
if (prefix == "pg stat") {
ss << pg_map;
r = 0;
} else if (prefix == "pg getmap") {
pg_map.encode(rdata);
ss << "got pgmap version " << pg_map.version;
r = 0;
} else if (prefix == "pg map_pg_creates") {
map_pg_creates();
ss << "mapped pg creates ";
r = 0;
} else if (prefix == "pg send_pg_creates") {
send_pg_creates();
ss << "sent pg creates ";
r = 0;
} else if (prefix == "pg dump" ||
prefix == "pg dump_json" ||
prefix == "pg dump_pools_json") {
string format;
string val;
r = 0;
// perhaps these would be better in the parsing, but it's weird
if (prefix == "pg dump_json") {
cmd_putval(g_ceph_context, cmdmap, "format", string("json"));
cmd_putval(g_ceph_context, cmdmap, "dumpcontents", string("all"));
} else if (prefix == "dump_pools_json") {
cmd_putval(g_ceph_context, cmdmap, "format", string("json"));
cmd_putval(g_ceph_context, cmdmap, "dumpcontents", string("pool"));
}
else if (m->cmd[1] == "getmap") {
pg_map.encode(rdata);
ss << "got pgmap version " << pg_map.version;
r = 0;
cmd_getval(g_ceph_context, cmdmap, "format", format, string("json"));
boost::scoped_ptr<Formatter> f(new_formatter(format));
stringstream ds;
vector<string> dumpcontents;
set<string> what;
if (cmd_getval(g_ceph_context, cmdmap, "dumpcontents", dumpcontents)) {
copy(dumpcontents.begin(), dumpcontents.end(),
inserter(what, what.end()));
}
else if (m->cmd[1] == "map_pg_creates") {
map_pg_creates();
ss << "mapped pg creates ";
r = 0;
}
else if (m->cmd[1] == "send_pg_creates") {
send_pg_creates();
ss << "sent pg creates ";
r = 0;
}
else if (m->cmd[1] == "dump") {
string format = "plain";
string what = "all";
string val;
for (std::vector<const char*>::iterator i = args.begin()+1; i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
} else if (ceph_argparse_witharg_daemon(args, i, &val, "-f",
"--format", (char*)NULL)) {
format = val;
} else {
what = *i++;
if (what.empty())
what.insert("all");
if (f) {
vector<string> dumpcontents;
if (cmd_getval(g_ceph_context, cmdmap, "dumpcontents", dumpcontents)) {
copy(dumpcontents.begin(), dumpcontents.end(),
inserter(what, what.end()));
}
if (what.empty())
what.insert("all");
if (what.count("all")) {
f->open_object_section("pg_map");
pg_map.dump(f.get());
f->close_section();
} else if (what.count("summary") || what.count("sum")) {
f->open_object_section("pg_map");
pg_map.dump_basic(f.get());
f->close_section();
} else {
if (what.count("pools")) {
pg_map.dump_pool_stats(f.get());
}
if (what.count("osds")) {
pg_map.dump_osd_stats(f.get());
}
if (what.count("pgs")) {
pg_map.dump_pg_stats(f.get());
}
}
Formatter *f = 0;
r = 0;
if (format == "json")
f = new JSONFormatter(true);
else if (format == "plain")
f = 0; //new PlainFormatter();
else {
r = -EINVAL;
ss << "unknown format '" << format << "'";
}
f->flush(ds);
} else {
// plain format ignores dumpcontents
pg_map.dump(ds);
}
rdata.append(ds);
ss << "dumped " << what << " in format " << format;
r = 0;
} else if (prefix == "pg dump_stuck") {
vector<string> stuckop_vec;
string format;
cmd_getval(g_ceph_context, cmdmap, "stuckops", stuckop_vec);
cmd_getval(g_ceph_context, cmdmap, "format", format, string("plain"));
if (stuckop_vec.empty())
stuckop_vec.push_back("unclean");
int64_t threshold;
cmd_getval(g_ceph_context, cmdmap, "threshold", threshold,
int64_t(g_conf->mon_pg_stuck_threshold));
if (r == 0) {
stringstream ds;
if (f) {
if (what == "all") {
f->open_object_section("pg_map");
pg_map.dump(f);
f->close_section();
} else if (what == "summary" || what == "sum") {
f->open_object_section("pg_map");
pg_map.dump_basic(f);
f->close_section();
} else if (what == "pools") {
pg_map.dump_pool_stats(f);
} else if (what == "osds") {
pg_map.dump_osd_stats(f);
} else if (what == "pgs") {
pg_map.dump_pg_stats(f);
} else {
r = -EINVAL;
ss << "i don't know how to dump '" << what << "' is";
}
if (r == 0)
f->flush(ds);
delete f;
} else {
pg_map.dump(ds);
}
if (r == 0) {
rdata.append(ds);
ss << "dumped " << what << " in format " << format;
}
r = dump_stuck_pg_stats(ss, rdata, format, (int)threshold, stuckop_vec);
} else if (prefix == "pg map") {
pg_t pgid;
r = -EINVAL;
string pgidstr;
cmd_getval(g_ceph_context, cmdmap, "pgid", pgidstr);
if (pgid.parse(pgidstr.c_str())) {
vector<int> up, acting;
if (mon->osdmon()->osdmap.have_pg_pool(pgid.pool())) {
pg_t mpgid = mon->osdmon()->osdmap.raw_pg_to_pg(pgid);
mon->osdmon()->osdmap.pg_to_up_acting_osds(pgid, up, acting);
ss << "osdmap e" << mon->osdmon()->osdmap.get_epoch()
<< " pg " << pgid << " (" << mpgid << ")"
<< " -> up " << up << " acting " << acting;
r = 0;
} else {
r = -ENOENT;
ss << "pg '" << pgidstr << "' does not exist";
}
} else {
ss << "invalid pgid '" << pgidstr << "'";
}
else if (m->cmd[1] == "dump_json") {
ss << "ok";
r = 0;
JSONFormatter jsf(true);
jsf.open_object_section("pg_map");
pg_map.dump(&jsf);
jsf.close_section();
stringstream ds;
jsf.flush(ds);
rdata.append(ds);
}
else if (m->cmd[1] == "dump_stuck") {
r = dump_stuck_pg_stats(ss, rdata, args);
}
else if (m->cmd[1] == "dump_pools_json") {
ss << "ok";
r = 0;
JSONFormatter jsf(true);
jsf.open_object_section("pg_map");
pg_map.dump(&jsf);
jsf.close_section();
stringstream ds;
jsf.flush(ds);
rdata.append(ds);
}
else if (m->cmd[1] == "map" && m->cmd.size() == 3) {
pg_t pgid;
r = -EINVAL;
if (pgid.parse(m->cmd[2].c_str())) {
vector<int> up, acting;
if (mon->osdmon()->osdmap.have_pg_pool(pgid.pool())) {
pg_t mpgid = mon->osdmon()->osdmap.raw_pg_to_pg(pgid);
mon->osdmon()->osdmap.pg_to_up_acting_osds(pgid, up, acting);
ss << "osdmap e" << mon->osdmon()->osdmap.get_epoch()
<< " pg " << pgid << " (" << mpgid << ")"
<< " -> up " << up << " acting " << acting;
r = 0;
} else {
r = -ENOENT;
ss << "pg '" << m->cmd[2] << "' does not exist";
}
} else
ss << "invalid pgid '" << m->cmd[2] << "'";
}
else if ((m->cmd[1] == "scrub" ||
m->cmd[1] == "deep-scrub" ||
m->cmd[1] == "repair") && m->cmd.size() == 3) {
pg_t pgid;
r = -EINVAL;
if (pgid.parse(m->cmd[2].c_str())) {
if (pg_map.pg_stat.count(pgid)) {
if (pg_map.pg_stat[pgid].acting.size()) {
int osd = pg_map.pg_stat[pgid].acting[0];
if (mon->osdmon()->osdmap.is_up(osd)) {
vector<pg_t> pgs(1);
pgs[0] = pgid;
mon->try_send_message(new MOSDScrub(mon->monmap->fsid, pgs,
m->cmd[1] == "repair",
m->cmd[1] == "deep-scrub"),
mon->osdmon()->osdmap.get_inst(osd));
ss << "instructing pg " << pgid << " on osd." << osd << " to " << m->cmd[1];
r = 0;
} else
ss << "pg " << pgid << " primary osd." << osd << " not up";
} else if (prefix == "pg scrub" ||
prefix == "pg repair" ||
prefix == "pg deep-scrub") {
string scrubop = prefix.substr(3, string::npos);
pg_t pgid;
r = -EINVAL;
string pgidstr;
cmd_getval(g_ceph_context, cmdmap, "pgid", pgidstr);
if (pgid.parse(pgidstr.c_str())) {
if (pg_map.pg_stat.count(pgid)) {
if (pg_map.pg_stat[pgid].acting.size()) {
int osd = pg_map.pg_stat[pgid].acting[0];
if (mon->osdmon()->osdmap.is_up(osd)) {
vector<pg_t> pgs(1);
pgs[0] = pgid;
mon->try_send_message(new MOSDScrub(mon->monmap->fsid, pgs,
scrubop == "repair",
scrubop == "deep-scrub"),
mon->osdmon()->osdmap.get_inst(osd));
ss << "instructing pg " << pgid << " on osd." << osd << " to " << scrubop;
r = 0;
} else
ss << "pg " << pgid << " has no primary osd";
ss << "pg " << pgid << " primary osd." << osd << " not up";
} else
ss << "pg " << pgid << " dne";
ss << "pg " << pgid << " has no primary osd";
} else
ss << "invalid pgid '" << m->cmd[2] << "'";
}
else if ((m->cmd[1] == "debug") && (m->cmd.size() > 2)) {
if (m->cmd[2] == "unfound_objects_exist") {
bool unfound_objects_exist = false;
hash_map<pg_t,pg_stat_t>::const_iterator end = pg_map.pg_stat.end();
for (hash_map<pg_t,pg_stat_t>::const_iterator s = pg_map.pg_stat.begin();
s != end; ++s)
{
if (s->second.stats.sum.num_objects_unfound > 0) {
unfound_objects_exist = true;
break;
}
ss << "pg " << pgid << " dne";
} else
ss << "invalid pgid '" << pgidstr << "'";
} else if (prefix == "pg debug") {
string debugop;
cmd_getval(g_ceph_context, cmdmap, "debugop", debugop, string("unfound_objects_exist"));
if (debugop == "unfound_objects_exist") {
bool unfound_objects_exist = false;
hash_map<pg_t,pg_stat_t>::const_iterator end = pg_map.pg_stat.end();
for (hash_map<pg_t,pg_stat_t>::const_iterator s = pg_map.pg_stat.begin();
s != end; ++s) {
if (s->second.stats.sum.num_objects_unfound > 0) {
unfound_objects_exist = true;
break;
}
if (unfound_objects_exist)
ss << "TRUE";
else
ss << "FALSE";
r = 0;
}
else if (m->cmd[2] == "degraded_pgs_exist") {
bool degraded_pgs_exist = false;
hash_map<pg_t,pg_stat_t>::const_iterator end = pg_map.pg_stat.end();
for (hash_map<pg_t,pg_stat_t>::const_iterator s = pg_map.pg_stat.begin();
s != end; ++s)
{
if (s->second.stats.sum.num_objects_degraded > 0) {
degraded_pgs_exist = true;
break;
}
if (unfound_objects_exist)
ss << "TRUE";
else
ss << "FALSE";
} else if (debugop == "degraded_pgs_exist") {
bool degraded_pgs_exist = false;
hash_map<pg_t,pg_stat_t>::const_iterator end = pg_map.pg_stat.end();
for (hash_map<pg_t,pg_stat_t>::const_iterator s = pg_map.pg_stat.begin();
s != end; ++s) {
if (s->second.stats.sum.num_objects_degraded > 0) {
degraded_pgs_exist = true;
break;
}
if (degraded_pgs_exist)
ss << "TRUE";
else
ss << "FALSE";
r = 0;
}
if (degraded_pgs_exist)
ss << "TRUE";
else
ss << "FALSE";
}
r = 0;
} else {
ss << "unknown command " << prefix;
}
if (r != -1) {
@ -1303,7 +1303,6 @@ bool PGMonitor::preprocess_command(MMonCommand *m)
return false;
}
bool PGMonitor::prepare_command(MMonCommand *m)
{
stringstream ss;
@ -1312,22 +1311,33 @@ bool PGMonitor::prepare_command(MMonCommand *m)
int r = -EINVAL;
string rs;
map<string, cmd_vartype> cmdmap;
if (!cmdmap_from_json(m->cmd, &cmdmap, ss)) {
// ss has reason for failure
string rs = ss.str();
mon->reply_command(m, -EINVAL, rs, get_version());
return true;
}
string prefix;
cmd_getval(g_ceph_context, cmdmap, "prefix", prefix);
vector<string> fullcmd;
build_fullcmd(prefix, cmdmap, &fullcmd);
MonSession *session = m->get_session();
if (!session ||
(!session->caps.get_allow_all() &&
!session->caps.check_privileges(PAXOS_PGMAP, MON_CAP_W) &&
!mon->_allowed_command(session, m->cmd))) {
!mon->_allowed_command(session, fullcmd))) {
mon->reply_command(m, -EACCES, "access denied", get_version());
return true;
}
if (m->cmd.size() >= 1 && m->cmd[1] == "force_create_pg") {
if (m->cmd.size() <= 2) {
ss << "usage: pg force_create_pg <pg>";
goto out;
}
if (!pgid.parse(m->cmd[2].c_str())) {
ss << "pg " << m->cmd[2] << " invalid";
if (prefix == "pg force_create_pg") {
string pgidstr;
cmd_getval(g_ceph_context, cmdmap, "pgid", pgidstr);
if (!pgid.parse(pgidstr.c_str())) {
ss << "pg " << pgidstr << " invalid";
goto out;
}
if (!pg_map.pg_stat.count(pgid)) {
@ -1344,43 +1354,21 @@ bool PGMonitor::prepare_command(MMonCommand *m)
s.created = epoch;
s.last_change = ceph_clock_now(g_ceph_context);
}
ss << "pg " << m->cmd[2] << " now creating, ok";
ss << "pg " << pgidstr << " now creating, ok";
getline(ss, rs);
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
else if (m->cmd.size() > 1 && m->cmd[1] == "set_full_ratio") {
if (m->cmd.size() != 3) {
ss << "set_full_ratio takes exactly one argument: the new full ratio";
goto out;
}
const char *start = m->cmd[2].c_str();
char *end = (char *)start;
float n = strtof(start, &end);
if (*end != '\0') { // conversion didn't work
ss << "could not convert " << m->cmd[2] << " to a float";
goto out;
}
pending_inc.full_ratio = n;
} else if (prefix == "pg set_full_ratio" ||
prefix == "pg set_nearfull_ratio") {
double n;
cmd_getval(g_ceph_context, cmdmap, "ratio", n);
string op = prefix.substr(3, string::npos);
if (op == "set_full_ratio")
pending_inc.full_ratio = n;
else if (op == "set_nearfull_ratio")
pending_inc.nearfull_ratio = n;
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
else if (m->cmd.size() > 1 && m->cmd[1] == "set_nearfull_ratio") {
if (m->cmd.size() != 3) {
ss << "set_nearfull_ratio takes exactly one argument: the new nearfull ratio";
goto out;
}
const char *start = m->cmd[2].c_str();
char *end = (char *)start;
float n = strtof(start, &end);
if (*end != '\0') { // conversion didn't work
ss << "could not convert " << m->cmd[2] << " to a float";
goto out;
}
pending_inc.nearfull_ratio = n;
wait_for_finished_proposal(new Monitor::C_Command(mon, m, 0, rs, get_version()));
return true;
}
return true;
out:
getline(ss, rs);
@ -1577,77 +1565,30 @@ void PGMonitor::check_full_osd_health(list<pair<health_status_t,string> >& summa
int PGMonitor::dump_stuck_pg_stats(ostream& ss,
bufferlist& rdata,
vector<const char*>& args) const
string format,
int threshold,
vector<string>& args) const
{
string format = "plain";
string val;
int threshold = g_conf->mon_pg_stuck_threshold;
int seconds;
ostringstream err;
if (args.size() < 2) {
ss << "Must specify inactive or unclean or stale.";
return -EINVAL;
}
PGMap::StuckPG stuck_type = PGMap::STUCK_NONE;
string type = args[1];
PGMap::StuckPG stuck_type;
string type = args[0];
if (type == "inactive")
stuck_type = PGMap::STUCK_INACTIVE;
if (type == "unclean")
stuck_type = PGMap::STUCK_UNCLEAN;
if (type == "stale")
stuck_type = PGMap::STUCK_STALE;
if (stuck_type == PGMap::STUCK_NONE) {
ss << "Invalid stuck type '" << type
<< "'. Valid types are: inactive, unclean, or stale";
return -EINVAL;
}
for (std::vector<const char*>::iterator i = args.begin() + 2;
i != args.end(); ) {
if (ceph_argparse_double_dash(args, i)) {
break;
} else if (ceph_argparse_witharg_daemon(args, i, &val,
"-f", "--format", (char*)NULL)) {
if (val != "json" && val != "plain") {
ss << "format must be json or plain";
return -EINVAL;
}
format = val;
} else if (ceph_argparse_withint_daemon(args, i, &seconds, &err,
"-t", "--threshold", (char*)NULL)) {
if (!err.str().empty()) {
ss << err.str();
return -EINVAL;
}
threshold = seconds;
} else if (ceph_argparse_flag(args, i, "-h", "--help", (char*)NULL)) {
stringstream ds;
ds << "Usage: ceph pg dump_stuck inactive|unclean|stale [options]" << std::endl
<< std::endl
<< "Get stats for pgs that have not been active, clean, or refreshed in some number of seconds." << std::endl
<< std::endl
<< "Options: " << std::endl
<< " -h, --help display usage info" << std::endl
<< " -f, --format [plain|json] output format (default: plain)" << std::endl
<< " -t, --threshold [seconds] how many seconds 'stuck' is (default: 300)" << std::endl;
rdata.append(ds);
return 0;
} else {
ss << "invalid argument '" << *i << "'";
return -EINVAL;
}
}
utime_t now(ceph_clock_now(g_ceph_context));
utime_t cutoff = now - utime_t(threshold, 0);
stringstream ds;
if (format == "json") {
JSONFormatter jsf(true);
pg_map.dump_stuck(&jsf, stuck_type, cutoff);
jsf.flush(ds);
boost::scoped_ptr<Formatter> f(new_formatter(format));
if (f) {
pg_map.dump_stuck(f.get(), stuck_type, cutoff);
f->flush(ds);
} else {
pg_map.dump_stuck_plain(ds, stuck_type, cutoff);
}

4
src/mon/PGMonitor.h
View File

@ -130,7 +130,9 @@ private:
*/
int dump_stuck_pg_stats(ostream& ss,
bufferlist& rdata,
vector<const char*>& args) const;
string format,
int threshold,
vector<string>& args) const;
void dump_object_stat_sum(TextTable &tbl, Formatter *f,
object_stat_sum_t &sum, bool verbose);