ceph/src/pybind/mgr/mgr_module.py

   1
   2 import ceph_state  #noqa
   3 import json
   4 import logging
   5 import threading
   6
   7
   8 class CommandResult(object):
   9     """
  10     Use with MgrModule.send_command
  11     """
  12     def __init__(self, tag):
  13         self.ev = threading.Event()
  14         self.outs = ""
  15         self.outb = ""
  16         self.r = 0
  17
  18         # This is just a convenience for notifications from
  19         # C++ land, to avoid passing addresses around in messages.
  20         self.tag = tag
  21
  22     def complete(self, r, outb, outs):
  23         self.r = r
  24         self.outb = outb
  25         self.outs = outs
  26         self.ev.set()
  27
  28     def wait(self):
  29         self.ev.wait()
  30         return self.r, self.outb, self.outs
  31
  32
  33 class MgrModule(object):
  34     COMMANDS = []
  35
  36     def __init__(self, handle):
  37         self._handle = handle
  38         self._logger = logging.getLogger(handle)
  39
  40         # Don't filter any logs at the python level, leave it to C++
  41         self._logger.setLevel(logging.DEBUG)
  42
  43         # FIXME: we should learn the log level from C++ land, and then
  44         # avoid calling ceph_state.log when we know a message is of
  45         # an insufficient level to be ultimately output
  46
  47         class CPlusPlusHandler(logging.Handler):
  48             def emit(self, record):
  49                 if record.levelno <= logging.DEBUG:
  50                     ceph_level = 20
  51                 elif record.levelno <= logging.INFO:
  52                     ceph_level = 4
  53                 elif record.levelno <= logging.WARNING:
  54                     ceph_level = 1
  55                 else:
  56                     ceph_level = 0
  57
  58                 ceph_state.log(handle, ceph_level, self.format(record))
  59
  60         self._logger.addHandler(CPlusPlusHandler())
  61
  62         self._version = ceph_state.get_version()
  63
  64     @property
  65     def log(self):
  66         return self._logger
  67
  68     @property
  69     def version(self):
  70         return self._version
  71
  72     def notify(self, notify_type, notify_id):
  73         """
  74         Called by the ceph-mgr service to notify the Python plugin
  75         that new state is available.
  76         """
  77         pass
  78
  79     def serve(self):
  80         """
  81         Called by the ceph-mgr service to start any server that
  82         is provided by this Python plugin.  The implementation
  83         of this function should block until ``shutdown`` is called.
  84
  85         You *must* implement ``shutdown`` if you implement ``serve``
  86         """
  87         pass
  88
  89     def shutdown(self):
  90         """
  91         Called by the ceph-mgr service to request that this
  92         module drop out of its serve() function.  You do not
  93         need to implement this if you do not implement serve()
  94
  95         :return: None
  96         """
  97         pass
  98
  99     def get(self, data_name):
 100         """
 101         Called by the plugin to load some cluster state from ceph-mgr
 102         """
 103         return ceph_state.get(self._handle, data_name)
 104
 105     def get_server(self, hostname):
 106         """
 107         Called by the plugin to load information about a particular
 108         node from ceph-mgr.
 109
 110         :param hostname: a hostame
 111         """
 112         return ceph_state.get_server(self._handle, hostname)
 113
 114     def get_counter(self, svc_type, svc_name, path):
 115         """
 116         Called by the plugin to fetch data for a particular perf counter
 117         on a particular service.
 118
 119         :param svc_type:
 120         :param svc_name:
 121         :param path:
 122         :return: A list of two-element lists containing time and value
 123         """
 124         return ceph_state.get_counter(self._handle, svc_type, svc_name, path)
 125
 126     def list_servers(self):
 127         """
 128         Like ``get_server``, but instead of returning information
 129         about just one node, return all the nodes in an array.
 130         """
 131         return ceph_state.get_server(self._handle, None)
 132
 133     def get_metadata(self, svc_type, svc_id):
 134         """
 135         Fetch the metadata for a particular service.
 136
 137         :param svc_type: one of 'mds', 'osd', 'mon'
 138         :param svc_id: string
 139         :return: dict
 140         """
 141         return ceph_state.get_metadata(self._handle, svc_type, svc_id)
 142
 143     def send_command(self, *args, **kwargs):
 144         """
 145         Called by the plugin to send a command to the mon
 146         cluster.
 147         """
 148         ceph_state.send_command(self._handle, *args, **kwargs)
 149
 150     def handle_command(self, cmd):
 151         """
 152         Called by ceph-mgr to request the plugin to handle one
 153         of the commands that it declared in self.COMMANDS
 154
 155         Return a status code, an output buffer, and an
 156         output string.  The output buffer is for data results,
 157         the output string is for informative text.
 158
 159         :param cmd: dict, from Ceph's cmdmap_t
 160
 161         :return: 3-tuple of (int, str, str)
 162         """
 163
 164         # Should never get called if they didn't declare
 165         # any ``COMMANDS``
 166         raise NotImplementedError()
 167
 168     def get_mgr_id(self):
 169         """
 170         Retrieve the mgr id.
 171
 172         :return: str
 173         """
 174         return ceph_state.get_mgr_id()
 175
 176     def get_config(self, key):
 177         """
 178         Retrieve the value of a persistent configuration setting
 179
 180         :param key: str
 181         :return: str
 182         """
 183         return ceph_state.get_config(self._handle, key)
 184
 185     def get_config_prefix(self, key_prefix):
 186         """
 187         Retrieve a dict of config values with the given prefix
 188
 189         :param key_prefix: str
 190         :return: str
 191         """
 192         return ceph_state.get_config_prefix(self._handle, key_prefix)
 193
 194     def set_config(self, key, val):
 195         """
 196         Set the value of a persistent configuration setting
 197
 198         :param key: str
 199         :param val: str
 200         """
 201         ceph_state.set_config(self._handle, key, val)
 202
 203     def set_config_json(self, key, val):
 204         """
 205         Helper for setting json-serialized-config
 206
 207         :param key: str
 208         :param val: json-serializable object
 209         """
 210         self.set_config(key, json.dumps(val))
 211
 212     def get_config_json(self, key):
 213         """
 214         Helper for getting json-serialized config
 215
 216         :param key: str
 217         :return: object
 218         """
 219         raw = self.get_config(key)
 220         if raw is None:
 221             return None
 222         else:
 223             return json.loads(raw)