ceph/src/mgr/PyState.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2016 John Spray <john.spray@redhat.com>
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  */
  13
  14 /**
  15  * The interface we present to python code that runs within
  16  * ceph-mgr.
  17  */
  18
  19 #include "Mgr.h"
  20
  21 #include "mon/MonClient.h"
  22 #include "common/errno.h"
  23 #include "common/version.h"
  24
  25 #include "PyState.h"
  26 #include "Gil.h"
  27
  28 #define dout_context g_ceph_context
  29 #define dout_subsys ceph_subsys_mgr
  30
  31 PyModules *global_handle = NULL;
  32
  33
  34 class MonCommandCompletion : public Context
  35 {
  36   PyObject *python_completion;
  37   const std::string tag;
  38   PyThreadState *pThreadState;
  39
  40 public:
  41   std::string outs;
  42   bufferlist outbl;
  43
  44   MonCommandCompletion(PyObject* ev, const std::string &tag_, PyThreadState *ts_)
  45     : python_completion(ev), tag(tag_), pThreadState(ts_)
  46   {
  47     assert(python_completion != nullptr);
  48     Py_INCREF(python_completion);
  49   }
  50
  51   ~MonCommandCompletion() override
  52   {
  53     Py_DECREF(python_completion);
  54   }
  55
  56   void finish(int r) override
  57   {
  58     dout(10) << "MonCommandCompletion::finish()" << dendl;
  59     {
  60       // Scoped so the Gil is released before calling notify_all()
  61       Gil gil(pThreadState);
  62
  63       auto set_fn = PyObject_GetAttrString(python_completion, "complete");
  64       assert(set_fn != nullptr);
  65
  66       auto pyR = PyInt_FromLong(r);
  67       auto pyOutBl = PyString_FromString(outbl.to_str().c_str());
  68       auto pyOutS = PyString_FromString(outs.c_str());
  69       auto args = PyTuple_Pack(3, pyR, pyOutBl, pyOutS);
  70       Py_DECREF(pyR);
  71       Py_DECREF(pyOutBl);
  72       Py_DECREF(pyOutS);
  73
  74       auto rtn = PyObject_CallObject(set_fn, args);
  75       if (rtn != nullptr) {
  76         Py_DECREF(rtn);
  77       }
  78       Py_DECREF(args);
  79     }
  80     global_handle->notify_all("command", tag);
  81   }
  82 };
  83
  84
  85 static PyObject*
  86 ceph_send_command(PyObject *self, PyObject *args)
  87 {
  88   char *handle = nullptr;
  89
  90   // Like mon, osd, mds
  91   char *type = nullptr;
  92
  93   // Like "23" for an OSD or "myid" for an MDS
  94   char *name = nullptr;
  95
  96   char *cmd_json = nullptr;
  97   char *tag = nullptr;
  98   PyObject *completion = nullptr;
  99   if (!PyArg_ParseTuple(args, "sOssss:ceph_send_command",
 100         &handle, &completion, &type, &name, &cmd_json, &tag)) {
 101     return nullptr;
 102   }
 103
 104   auto set_fn = PyObject_GetAttrString(completion, "complete");
 105   if (set_fn == nullptr) {
 106     ceph_abort();  // TODO raise python exception instead
 107   } else {
 108     assert(PyCallable_Check(set_fn));
 109   }
 110   Py_DECREF(set_fn);
 111
 112   auto c = new MonCommandCompletion(completion, tag, PyThreadState_Get());
 113   if (std::string(type) == "mon") {
 114     global_handle->get_monc().start_mon_command(
 115         {cmd_json},
 116         {},
 117         &c->outbl,
 118         &c->outs,
 119         c);
 120   } else if (std::string(type) == "osd") {
 121     std::string err;
 122     uint64_t osd_id = strict_strtoll(name, 10, &err);
 123     if (!err.empty()) {
 124       delete c;
 125       string msg("invalid osd_id: ");
 126       msg.append("\"").append(name).append("\"");
 127       PyErr_SetString(PyExc_ValueError, msg.c_str());
 128       return nullptr;
 129     }
 130
 131     ceph_tid_t tid;
 132     global_handle->get_objecter().osd_command(
 133         osd_id,
 134         {cmd_json},
 135         {},
 136         &tid,
 137         &c->outbl,
 138         &c->outs,
 139         c);
 140   } else if (std::string(type) == "mds") {
 141     int r = global_handle->get_client().mds_command(
 142         name,
 143         {cmd_json},
 144         {},
 145         &c->outbl,
 146         &c->outs,
 147         c);
 148     if (r != 0) {
 149       string msg("failed to send command to mds: ");
 150       msg.append(cpp_strerror(r));
 151       PyErr_SetString(PyExc_RuntimeError, msg.c_str());
 152       return nullptr;
 153     }
 154   } else if (std::string(type) == "pg") {
 155     // TODO: expose objecter::pg_command
 156     return nullptr;
 157   } else {
 158     string msg("unknown service type: ");
 159     msg.append(type);
 160     PyErr_SetString(PyExc_ValueError, msg.c_str());
 161     return nullptr;
 162   }
 163
 164   Py_RETURN_NONE;
 165 }
 166
 167
 168 static PyObject*
 169 ceph_state_get(PyObject *self, PyObject *args)
 170 {
 171   char *handle = nullptr;
 172   char *what = NULL;
 173   if (!PyArg_ParseTuple(args, "ss:ceph_state_get", &handle, &what)) {
 174     return NULL;
 175   }
 176
 177   return global_handle->get_python(what);
 178 }
 179
 180
 181 static PyObject*
 182 ceph_get_server(PyObject *self, PyObject *args)
 183 {
 184   char *handle = nullptr;
 185   char *hostname = NULL;
 186   if (!PyArg_ParseTuple(args, "sz:ceph_get_server", &handle, &hostname)) {
 187     return NULL;
 188   }
 189
 190   if (hostname) {
 191     return global_handle->get_server_python(hostname);
 192   } else {
 193     return global_handle->list_servers_python();
 194   }
 195 }
 196
 197 static PyObject*
 198 ceph_get_mgr_id(PyObject *self, PyObject *args)
 199 {
 200   return PyString_FromString(g_conf->name.get_id().c_str());
 201 }
 202
 203 static PyObject*
 204 ceph_config_get(PyObject *self, PyObject *args)
 205 {
 206   char *handle = nullptr;
 207   char *what = nullptr;
 208   if (!PyArg_ParseTuple(args, "ss:ceph_config_get", &handle, &what)) {
 209     derr << "Invalid args!" << dendl;
 210     return nullptr;
 211   }
 212
 213   std::string value;
 214   bool found = global_handle->get_config(handle, what, &value);
 215   if (found) {
 216     dout(10) << "ceph_config_get " << what << " found: " << value.c_str() << dendl;
 217     return PyString_FromString(value.c_str());
 218   } else {
 219     derr << "ceph_config_get " << what << " not found " << dendl;
 220     Py_RETURN_NONE;
 221   }
 222 }
 223
 224 static PyObject*
 225 ceph_config_get_prefix(PyObject *self, PyObject *args)
 226 {
 227   char *handle = nullptr;
 228   char *prefix = nullptr;
 229   if (!PyArg_ParseTuple(args, "ss:ceph_config_get", &handle, &prefix)) {
 230     derr << "Invalid args!" << dendl;
 231     return nullptr;
 232   }
 233
 234   return global_handle->get_config_prefix(handle, prefix);
 235 }
 236
 237 static PyObject*
 238 ceph_config_set(PyObject *self, PyObject *args)
 239 {
 240   char *handle = nullptr;
 241   char *key = nullptr;
 242   char *value = nullptr;
 243   if (!PyArg_ParseTuple(args, "sss:ceph_config_set", &handle, &key, &value)) {
 244     return nullptr;
 245   }
 246
 247   global_handle->set_config(handle, key, value);
 248
 249   Py_RETURN_NONE;
 250 }
 251
 252 static entity_type_t svc_type_from_str(const std::string &type_str)
 253 {
 254   if (type_str == std::string("mds")) {
 255     return CEPH_ENTITY_TYPE_MDS;
 256   } else if (type_str == std::string("osd")) {
 257     return CEPH_ENTITY_TYPE_OSD;
 258   } else if (type_str == std::string("mon")) {
 259     return CEPH_ENTITY_TYPE_MON;
 260   } else {
 261     return CEPH_ENTITY_TYPE_ANY;
 262   }
 263 }
 264
 265 static PyObject*
 266 get_metadata(PyObject *self, PyObject *args)
 267 {
 268   char *handle = nullptr;
 269   char *type_str = NULL;
 270   char *svc_id = NULL;
 271   if (!PyArg_ParseTuple(args, "sss:get_metadata", &handle, &type_str, &svc_id)) {
 272     return nullptr;
 273   }
 274
 275   entity_type_t svc_type = svc_type_from_str(type_str);
 276   if (svc_type == CEPH_ENTITY_TYPE_ANY) {
 277     // FIXME: form a proper exception
 278     return nullptr;
 279   }
 280
 281
 282   return global_handle->get_metadata_python(handle, svc_type, svc_id);
 283 }
 284
 285 static PyObject*
 286 ceph_log(PyObject *self, PyObject *args)
 287 {
 288   int level = 0;
 289   char *record = nullptr;
 290   char *handle = nullptr;
 291   if (!PyArg_ParseTuple(args, "sis:log", &handle, &level, &record)) {
 292     return nullptr;
 293   }
 294
 295   global_handle->log(handle, level, record);
 296
 297   Py_RETURN_NONE;
 298 }
 299
 300 static PyObject *
 301 ceph_get_version(PyObject *self, PyObject *args)
 302 {
 303   return PyString_FromString(pretty_version_to_str().c_str());
 304 }
 305
 306 static PyObject *
 307 ceph_get_context(PyObject *self, PyObject *args)
 308 {
 309   return global_handle->get_context();
 310 }
 311
 312 static PyObject*
 313 get_counter(PyObject *self, PyObject *args)
 314 {
 315   char *handle = nullptr;
 316   char *type_str = nullptr;
 317   char *svc_id = nullptr;
 318   char *counter_path = nullptr;
 319   if (!PyArg_ParseTuple(args, "ssss:get_counter", &handle, &type_str,
 320                                                   &svc_id, &counter_path)) {
 321     return nullptr;
 322   }
 323
 324   entity_type_t svc_type = svc_type_from_str(type_str);
 325   if (svc_type == CEPH_ENTITY_TYPE_ANY) {
 326     // FIXME: form a proper exception
 327     return nullptr;
 328   }
 329
 330   return global_handle->get_counter_python(
 331       handle, svc_type, svc_id, counter_path);
 332 }
 333
 334 PyMethodDef CephStateMethods[] = {
 335     {"get", ceph_state_get, METH_VARARGS,
 336      "Get a cluster object"},
 337     {"get_server", ceph_get_server, METH_VARARGS,
 338      "Get a server object"},
 339     {"get_metadata", get_metadata, METH_VARARGS,
 340      "Get a service's metadata"},
 341     {"send_command", ceph_send_command, METH_VARARGS,
 342      "Send a mon command"},
 343     {"get_mgr_id", ceph_get_mgr_id, METH_NOARGS,
 344      "Get the mgr id"},
 345     {"get_config", ceph_config_get, METH_VARARGS,
 346      "Get a configuration value"},
 347     {"get_config_prefix", ceph_config_get_prefix, METH_VARARGS,
 348      "Get all configuration values with a given prefix"},
 349     {"set_config", ceph_config_set, METH_VARARGS,
 350      "Set a configuration value"},
 351     {"get_counter", get_counter, METH_VARARGS,
 352       "Get a performance counter"},
 353     {"log", ceph_log, METH_VARARGS,
 354      "Emit a (local) log message"},
 355     {"get_version", ceph_get_version, METH_VARARGS,
 356      "Get the ceph version of this process"},
 357     {"get_context", ceph_get_context, METH_NOARGS,
 358       "Get a CephContext* in a python capsule"},
 359     {NULL, NULL, 0, NULL}
 360 };
 361