+++ /dev/null
-
-"""
-Demonstrate writing a Ceph web interface inside a mgr module.
-"""
-
-# We must share a global reference to this instance, because it is the
-# gatekeeper to all accesses to data from the C++ side (e.g. the REST API
-# request handlers need to see it)
-from collections import defaultdict
-import collections
-
-_global_instance = {'plugin': None}
-def global_instance():
- assert _global_instance['plugin'] is not None
- return _global_instance['plugin']
-
-
-import os
-import logging
-import logging.config
-import json
-import sys
-import time
-import threading
-import socket
-
-import cherrypy
-import jinja2
-
-from mgr_module import MgrModule, MgrStandbyModule, CommandResult
-
-from types import OsdMap, NotFound, Config, FsMap, MonMap, \
- PgSummary, Health, MonStatus
-
-import rados
-import rbd_iscsi
-import rbd_mirroring
-from rbd_ls import RbdLs, RbdPoolLs
-from cephfs_clients import CephFSClients
-
-log = logging.getLogger("dashboard")
-
-
-# How many cluster log lines shall we hold onto in our
-# python module for the convenience of the GUI?
-LOG_BUFFER_SIZE = 30
-
-# cherrypy likes to sys.exit on error. don't let it take us down too!
-def os_exit_noop(*args, **kwargs):
- pass
-
-os._exit = os_exit_noop
-
-
-def recurse_refs(root, path):
- if isinstance(root, dict):
- for k, v in root.items():
- recurse_refs(v, path + "->%s" % k)
- elif isinstance(root, list):
- for n, i in enumerate(root):
- recurse_refs(i, path + "[%d]" % n)
-
- log.info("%s %d (%s)" % (path, sys.getrefcount(root), root.__class__))
-
-def get_prefixed_url(url):
- return global_instance().url_prefix + url
-
-
-
-class StandbyModule(MgrStandbyModule):
- def serve(self):
- server_addr = self.get_localized_config('server_addr', '::')
- server_port = self.get_localized_config('server_port', '7000')
- if server_addr is None:
- raise RuntimeError('no server_addr configured; try "ceph config-key set mgr/dashboard/server_addr <ip>"')
- log.info("server_addr: %s server_port: %s" % (server_addr, server_port))
- cherrypy.config.update({
- 'server.socket_host': server_addr,
- 'server.socket_port': int(server_port),
- 'engine.autoreload.on': False
- })
-
- current_dir = os.path.dirname(os.path.abspath(__file__))
- jinja_loader = jinja2.FileSystemLoader(current_dir)
- env = jinja2.Environment(loader=jinja_loader)
-
- module = self
-
- class Root(object):
- @cherrypy.expose
- def index(self):
- active_uri = module.get_active_uri()
- if active_uri:
- log.info("Redirecting to active '{0}'".format(active_uri))
- raise cherrypy.HTTPRedirect(active_uri)
- else:
- template = env.get_template("standby.html")
- return template.render(delay=5)
-
- cherrypy.tree.mount(Root(), "/", {})
- log.info("Starting engine...")
- cherrypy.engine.start()
- log.info("Waiting for engine...")
- cherrypy.engine.wait(state=cherrypy.engine.states.STOPPED)
- log.info("Engine done.")
-
- def shutdown(self):
- log.info("Stopping server...")
- cherrypy.engine.wait(state=cherrypy.engine.states.STARTED)
- cherrypy.engine.stop()
- log.info("Stopped server")
-
-
-class Module(MgrModule):
- def __init__(self, *args, **kwargs):
- super(Module, self).__init__(*args, **kwargs)
- _global_instance['plugin'] = self
- self.log.info("Constructing module {0}: instance {1}".format(
- __name__, _global_instance))
-
- self.log_primed = False
- self.log_buffer = collections.deque(maxlen=LOG_BUFFER_SIZE)
- self.audit_buffer = collections.deque(maxlen=LOG_BUFFER_SIZE)
-
- # Keep a librados instance for those that need it.
- self._rados = None
-
- # Stateful instances of RbdLs, hold cached results. Key to dict
- # is pool name.
- self.rbd_ls = {}
-
- # Stateful instance of RbdPoolLs, hold cached list of RBD
- # pools
- self.rbd_pool_ls = RbdPoolLs(self)
-
- # Stateful instance of RbdISCSI
- self.rbd_iscsi = rbd_iscsi.Controller(self)
-
- # Stateful instance of RbdMirroring, hold cached results.
- self.rbd_mirroring = rbd_mirroring.Controller(self)
-
- # Stateful instances of CephFSClients, hold cached results. Key to
- # dict is FSCID
- self.cephfs_clients = {}
-
- # A short history of pool df stats
- self.pool_stats = defaultdict(lambda: defaultdict(
- lambda: collections.deque(maxlen=10)))
-
- # A prefix for all URLs to use the dashboard with a reverse http proxy
- self.url_prefix = ''
-
- @property
- def rados(self):
- """
- A librados instance to be shared by any classes within
- this mgr module that want one.
- """
- if self._rados:
- return self._rados
-
- ctx_capsule = self.get_context()
- self._rados = rados.Rados(context=ctx_capsule)
- self._rados.connect()
-
- return self._rados
-
- def update_pool_stats(self):
- df = global_instance().get("df")
- pool_stats = dict([(p['id'], p['stats']) for p in df['pools']])
- now = time.time()
- for pool_id, stats in pool_stats.items():
- for stat_name, stat_val in stats.items():
- self.pool_stats[pool_id][stat_name].appendleft((now, stat_val))
-
- def notify(self, notify_type, notify_val):
- if notify_type == "clog":
- # Only store log messages once we've done our initial load,
- # so that we don't end up duplicating.
- if self.log_primed:
- if notify_val['channel'] == "audit":
- self.audit_buffer.appendleft(notify_val)
- else:
- self.log_buffer.appendleft(notify_val)
- elif notify_type == "pg_summary":
- self.update_pool_stats()
- else:
- pass
-
- def get_sync_object(self, object_type, path=None):
- if object_type == OsdMap:
- data = self.get("osd_map")
-
- assert data is not None
-
- data['tree'] = self.get("osd_map_tree")
- data['crush'] = self.get("osd_map_crush")
- data['crush_map_text'] = self.get("osd_map_crush_map_text")
- data['osd_metadata'] = self.get("osd_metadata")
- obj = OsdMap(data)
- elif object_type == Config:
- data = self.get("config")
- obj = Config( data)
- elif object_type == MonMap:
- data = self.get("mon_map")
- obj = MonMap(data)
- elif object_type == FsMap:
- data = self.get("fs_map")
- obj = FsMap(data)
- elif object_type == PgSummary:
- data = self.get("pg_summary")
- self.log.debug("JSON: {0}".format(data))
- obj = PgSummary(data)
- elif object_type == Health:
- data = self.get("health")
- obj = Health(json.loads(data['json']))
- elif object_type == MonStatus:
- data = self.get("mon_status")
- obj = MonStatus(json.loads(data['json']))
- else:
- raise NotImplementedError(object_type)
-
- # TODO: move 'path' handling up into C++ land so that we only
- # Pythonize the part we're interested in
- if path:
- try:
- for part in path:
- if isinstance(obj, dict):
- obj = obj[part]
- else:
- obj = getattr(obj, part)
- except (AttributeError, KeyError):
- raise NotFound(object_type, path)
-
- return obj
-
- def shutdown(self):
- log.info("Stopping server...")
- cherrypy.engine.exit()
- log.info("Stopped server")
-
- log.info("Stopping librados...")
- if self._rados:
- self._rados.shutdown()
- log.info("Stopped librados.")
-
- def get_latest(self, daemon_type, daemon_name, stat):
- data = self.get_counter(daemon_type, daemon_name, stat)[stat]
- if data:
- return data[-1][1]
- else:
- return 0
-
- def get_rate(self, daemon_type, daemon_name, stat):
- data = self.get_counter(daemon_type, daemon_name, stat)[stat]
-
- if data and len(data) > 1:
- return (data[-1][1] - data[-2][1]) / float(data[-1][0] - data[-2][0])
- else:
- return 0
-
- def format_dimless(self, n, width, colored=True):
- """
- Format a number without units, so as to fit into `width` characters, substituting
- an appropriate unit suffix.
- """
- units = [' ', 'k', 'M', 'G', 'T', 'P']
- unit = 0
- while len("%s" % (int(n) // (1000**unit))) > width - 1:
- unit += 1
-
- if unit > 0:
- truncated_float = ("%f" % (n / (1000.0 ** unit)))[0:width - 1]
- if truncated_float[-1] == '.':
- truncated_float = " " + truncated_float[0:-1]
- else:
- truncated_float = "%{wid}d".format(wid=width-1) % n
- formatted = "%s%s" % (truncated_float, units[unit])
-
- if colored:
- # TODO: html equivalent
- # if n == 0:
- # color = self.BLACK, False
- # else:
- # color = self.YELLOW, False
- # return self.bold(self.colorize(formatted[0:-1], color[0], color[1])) \
- # + self.bold(self.colorize(formatted[-1], self.BLACK, False))
- return formatted
- else:
- return formatted
-
- def fs_status(self, fs_id):
- mds_versions = defaultdict(list)
-
- fsmap = self.get("fs_map")
- filesystem = None
- for fs in fsmap['filesystems']:
- if fs['id'] == fs_id:
- filesystem = fs
- break
-
- rank_table = []
-
- mdsmap = filesystem['mdsmap']
-
- client_count = 0
-
- for rank in mdsmap["in"]:
- up = "mds_{0}".format(rank) in mdsmap["up"]
- if up:
- gid = mdsmap['up']["mds_{0}".format(rank)]
- info = mdsmap['info']['gid_{0}'.format(gid)]
- dns = self.get_latest("mds", info['name'], "mds.inodes")
- inos = self.get_latest("mds", info['name'], "mds_mem.ino")
-
- if rank == 0:
- client_count = self.get_latest("mds", info['name'],
- "mds_sessions.session_count")
- elif client_count == 0:
- # In case rank 0 was down, look at another rank's
- # sessionmap to get an indication of clients.
- client_count = self.get_latest("mds", info['name'],
- "mds_sessions.session_count")
-
- laggy = "laggy_since" in info
-
- state = info['state'].split(":")[1]
- if laggy:
- state += "(laggy)"
-
- # if state == "active" and not laggy:
- # c_state = self.colorize(state, self.GREEN)
- # else:
- # c_state = self.colorize(state, self.YELLOW)
-
- # Populate based on context of state, e.g. client
- # ops for an active daemon, replay progress, reconnect
- # progress
- activity = ""
-
- if state == "active":
- activity = "Reqs: " + self.format_dimless(
- self.get_rate("mds", info['name'], "mds_server.handle_client_request"),
- 5
- ) + "/s"
-
- metadata = self.get_metadata('mds', info['name'])
- mds_versions[metadata.get('ceph_version', 'unknown')].append(info['name'])
- rank_table.append(
- {
- "rank": rank,
- "state": state,
- "mds": info['name'],
- "activity": activity,
- "dns": dns,
- "inos": inos
- }
- )
-
- else:
- rank_table.append(
- {
- "rank": rank,
- "state": "failed",
- "mds": "",
- "activity": "",
- "dns": 0,
- "inos": 0
- }
- )
-
- # Find the standby replays
- for gid_str, daemon_info in mdsmap['info'].iteritems():
- if daemon_info['state'] != "up:standby-replay":
- continue
-
- inos = self.get_latest("mds", daemon_info['name'], "mds_mem.ino")
- dns = self.get_latest("mds", daemon_info['name'], "mds.inodes")
-
- activity = "Evts: " + self.format_dimless(
- self.get_rate("mds", daemon_info['name'], "mds_log.replay"),
- 5
- ) + "/s"
-
- rank_table.append(
- {
- "rank": "{0}-s".format(daemon_info['rank']),
- "state": "standby-replay",
- "mds": daemon_info['name'],
- "activity": activity,
- "dns": dns,
- "inos": inos
- }
- )
-
- df = self.get("df")
- pool_stats = dict([(p['id'], p['stats']) for p in df['pools']])
- osdmap = self.get("osd_map")
- pools = dict([(p['pool'], p) for p in osdmap['pools']])
- metadata_pool_id = mdsmap['metadata_pool']
- data_pool_ids = mdsmap['data_pools']
-
- pools_table = []
- for pool_id in [metadata_pool_id] + data_pool_ids:
- pool_type = "metadata" if pool_id == metadata_pool_id else "data"
- stats = pool_stats[pool_id]
- pools_table.append({
- "pool": pools[pool_id]['pool_name'],
- "type": pool_type,
- "used": stats['bytes_used'],
- "avail": stats['max_avail']
- })
-
- standby_table = []
- for standby in fsmap['standbys']:
- metadata = self.get_metadata('mds', standby['name'])
- mds_versions[metadata.get('ceph_version', 'unknown')].append(standby['name'])
-
- standby_table.append({
- 'name': standby['name']
- })
-
- return {
- "filesystem": {
- "id": fs_id,
- "name": mdsmap['fs_name'],
- "client_count": client_count,
- "clients_url": get_prefixed_url("/clients/{0}/".format(fs_id)),
- "ranks": rank_table,
- "pools": pools_table
- },
- "standbys": standby_table,
- "versions": mds_versions
- }
-
- def _prime_log(self):
- def load_buffer(buf, channel_name):
- result = CommandResult("")
- self.send_command(result, "mon", "", json.dumps({
- "prefix": "log last",
- "format": "json",
- "channel": channel_name,
- "num": LOG_BUFFER_SIZE
- }), "")
- r, outb, outs = result.wait()
- if r != 0:
- # Oh well. We won't let this stop us though.
- self.log.error("Error fetching log history (r={0}, \"{1}\")".format(
- r, outs))
- else:
- try:
- lines = json.loads(outb)
- except ValueError:
- self.log.error("Error decoding log history")
- else:
- for l in lines:
- buf.appendleft(l)
-
- load_buffer(self.log_buffer, "cluster")
- load_buffer(self.audit_buffer, "audit")
- self.log_primed = True
-
- def serve(self):
- current_dir = os.path.dirname(os.path.abspath(__file__))
-
- jinja_loader = jinja2.FileSystemLoader(current_dir)
- env = jinja2.Environment(loader=jinja_loader)
-
- self._prime_log()
-
- class EndPoint(object):
- def _health_data(self):
- health = global_instance().get_sync_object(Health).data
- # Transform the `checks` dict into a list for the convenience
- # of rendering from javascript.
- checks = []
- for k, v in health['checks'].iteritems():
- v['type'] = k
- checks.append(v)
-
- checks = sorted(checks, cmp=lambda a, b: a['severity'] > b['severity'])
-
- health['checks'] = checks
-
- return health
-
- def _toplevel_data(self):
- """
- Data consumed by the base.html template
- """
- status, data = global_instance().rbd_pool_ls.get()
- if data is None:
- log.warning("Failed to get RBD pool list")
- data = []
-
- rbd_pools = sorted([
- {
- "name": name,
- "url": get_prefixed_url("/rbd_pool/{0}/".format(name))
- }
- for name in data
- ], key=lambda k: k['name'])
-
- status, rbd_mirroring = global_instance().rbd_mirroring.toplevel.get()
- if rbd_mirroring is None:
- log.warning("Failed to get RBD mirroring summary")
- rbd_mirroring = {}
-
- fsmap = global_instance().get_sync_object(FsMap)
- filesystems = [
- {
- "id": f['id'],
- "name": f['mdsmap']['fs_name'],
- "url": get_prefixed_url("/filesystem/{0}/".format(f['id']))
- }
- for f in fsmap.data['filesystems']
- ]
-
- return {
- 'rbd_pools': rbd_pools,
- 'rbd_mirroring': rbd_mirroring,
- 'health_status': self._health_data()['status'],
- 'filesystems': filesystems
- }
-
- class Root(EndPoint):
- @cherrypy.expose
- def filesystem(self, fs_id):
- template = env.get_template("filesystem.html")
-
- toplevel_data = self._toplevel_data()
-
- content_data = {
- "fs_status": global_instance().fs_status(int(fs_id))
- }
-
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(toplevel_data, indent=2),
- content_data=json.dumps(content_data, indent=2)
- )
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def filesystem_data(self, fs_id):
- return global_instance().fs_status(int(fs_id))
-
- def _clients(self, fs_id):
- cephfs_clients = global_instance().cephfs_clients.get(fs_id, None)
- if cephfs_clients is None:
- cephfs_clients = CephFSClients(global_instance(), fs_id)
- global_instance().cephfs_clients[fs_id] = cephfs_clients
-
- status, clients = cephfs_clients.get()
- #TODO do something sensible with status
-
- # Decorate the metadata with some fields that will be
- # indepdendent of whether it's a kernel or userspace
- # client, so that the javascript doesn't have to grok that.
- for client in clients:
- if "ceph_version" in client['client_metadata']:
- client['type'] = "userspace"
- client['version'] = client['client_metadata']['ceph_version']
- client['hostname'] = client['client_metadata']['hostname']
- elif "kernel_version" in client['client_metadata']:
- client['type'] = "kernel"
- client['version'] = client['client_metadata']['kernel_version']
- client['hostname'] = client['client_metadata']['hostname']
- else:
- client['type'] = "unknown"
- client['version'] = ""
- client['hostname'] = ""
-
- return clients
-
- @cherrypy.expose
- def clients(self, fscid_str):
- try:
- fscid = int(fscid_str)
- except ValueError:
- raise cherrypy.HTTPError(400,
- "Invalid filesystem id {0}".format(fscid_str))
-
- try:
- fs_name = FsMap(global_instance().get(
- "fs_map")).get_filesystem(fscid)['mdsmap']['fs_name']
- except NotFound:
- log.warning("Missing FSCID, dumping fsmap:\n{0}".format(
- json.dumps(global_instance().get("fs_map"), indent=2)
- ))
- raise cherrypy.HTTPError(404,
- "No filesystem with id {0}".format(fscid))
-
- clients = self._clients(fscid)
- global_instance().log.debug(json.dumps(clients, indent=2))
- content_data = {
- "clients": clients,
- "fs_name": fs_name,
- "fscid": fscid,
- "fs_url": get_prefixed_url("/filesystem/" + fscid_str + "/")
- }
-
- template = env.get_template("clients.html")
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(self._toplevel_data(), indent=2),
- content_data=json.dumps(content_data, indent=2)
- )
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def clients_data(self, fs_id):
- return self._clients(int(fs_id))
-
- def _rbd_pool(self, pool_name):
- rbd_ls = global_instance().rbd_ls.get(pool_name, None)
- if rbd_ls is None:
- rbd_ls = RbdLs(global_instance(), pool_name)
- global_instance().rbd_ls[pool_name] = rbd_ls
-
- status, value = rbd_ls.get()
-
- interval = 5
-
- wait = interval - rbd_ls.latency
- def wait_and_load():
- time.sleep(wait)
- rbd_ls.get()
-
- threading.Thread(target=wait_and_load).start()
-
- assert status != RbdLs.VALUE_NONE # FIXME bubble status up to UI
- return value
-
- @cherrypy.expose
- def rbd_pool(self, pool_name):
- template = env.get_template("rbd_pool.html")
-
- toplevel_data = self._toplevel_data()
-
- images = self._rbd_pool(pool_name)
- content_data = {
- "images": images,
- "pool_name": pool_name
- }
-
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(toplevel_data, indent=2),
- content_data=json.dumps(content_data, indent=2)
- )
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def rbd_pool_data(self, pool_name):
- return self._rbd_pool(pool_name)
-
- def _rbd_mirroring(self):
- status, data = global_instance().rbd_mirroring.content_data.get()
- if data is None:
- log.warning("Failed to get RBD mirroring status")
- return {}
- return data
-
- @cherrypy.expose
- def rbd_mirroring(self):
- template = env.get_template("rbd_mirroring.html")
-
- toplevel_data = self._toplevel_data()
- content_data = self._rbd_mirroring()
-
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(toplevel_data, indent=2),
- content_data=json.dumps(content_data, indent=2)
- )
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def rbd_mirroring_data(self):
- return self._rbd_mirroring()
-
- def _rbd_iscsi(self):
- status, data = global_instance().rbd_iscsi.content_data.get()
- if data is None:
- log.warning("Failed to get RBD iSCSI status")
- return {}
- return data
-
- @cherrypy.expose
- def rbd_iscsi(self):
- template = env.get_template("rbd_iscsi.html")
-
- toplevel_data = self._toplevel_data()
- content_data = self._rbd_iscsi()
-
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(toplevel_data, indent=2),
- content_data=json.dumps(content_data, indent=2)
- )
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def rbd_iscsi_data(self):
- return self._rbd_iscsi()
-
- @cherrypy.expose
- def health(self):
- template = env.get_template("health.html")
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(self._toplevel_data(), indent=2),
- content_data=json.dumps(self._health(), indent=2)
- )
-
- @cherrypy.expose
- def servers(self):
- template = env.get_template("servers.html")
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info=cherrypy.request.path_info,
- toplevel_data=json.dumps(self._toplevel_data(), indent=2),
- content_data=json.dumps(self._servers(), indent=2)
- )
-
- def _servers(self):
- return {
- 'servers': global_instance().list_servers()
- }
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def servers_data(self):
- return self._servers()
-
- def _health(self):
- # Fuse osdmap with pg_summary to get description of pools
- # including their PG states
- osd_map = global_instance().get_sync_object(OsdMap).data
- pg_summary = global_instance().get_sync_object(PgSummary).data
- pools = []
-
- if len(global_instance().pool_stats) == 0:
- global_instance().update_pool_stats()
-
- for pool in osd_map['pools']:
- pool['pg_status'] = pg_summary['by_pool'][pool['pool'].__str__()]
- stats = global_instance().pool_stats[pool['pool']]
- s = {}
-
- def get_rate(series):
- if len(series) >= 2:
- return (float(series[0][1]) - float(series[1][1])) / (float(series[0][0]) - float(series[1][0]))
- else:
- return 0
-
- for stat_name, stat_series in stats.items():
- s[stat_name] = {
- 'latest': stat_series[0][1],
- 'rate': get_rate(stat_series),
- 'series': [i for i in stat_series]
- }
- pool['stats'] = s
- pools.append(pool)
-
- # Not needed, skip the effort of transmitting this
- # to UI
- del osd_map['pg_temp']
-
- df = global_instance().get("df")
- df['stats']['total_objects'] = sum(
- [p['stats']['objects'] for p in df['pools']])
-
- return {
- "health": self._health_data(),
- "mon_status": global_instance().get_sync_object(
- MonStatus).data,
- "fs_map": global_instance().get_sync_object(FsMap).data,
- "osd_map": osd_map,
- "clog": list(global_instance().log_buffer),
- "audit_log": list(global_instance().audit_buffer),
- "pools": pools,
- "mgr_map": global_instance().get("mgr_map"),
- "df": df
- }
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def health_data(self):
- return self._health()
-
- @cherrypy.expose
- def index(self):
- return self.health()
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def toplevel_data(self):
- return self._toplevel_data()
-
- def _get_mds_names(self, filesystem_id=None):
- names = []
-
- fsmap = global_instance().get("fs_map")
- for fs in fsmap['filesystems']:
- if filesystem_id is not None and fs['id'] != filesystem_id:
- continue
- names.extend([info['name'] for _, info in fs['mdsmap']['info'].items()])
-
- if filesystem_id is None:
- names.extend(info['name'] for info in fsmap['standbys'])
-
- return names
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def mds_counters(self, fs_id):
- """
- Result format: map of daemon name to map of counter to list of datapoints
- """
-
- # Opinionated list of interesting performance counters for the GUI --
- # if you need something else just add it. See how simple life is
- # when you don't have to write general purpose APIs?
- counters = [
- "mds_server.handle_client_request",
- "mds_log.ev",
- "mds_cache.num_strays",
- "mds.exported",
- "mds.exported_inodes",
- "mds.imported",
- "mds.imported_inodes",
- "mds.inodes",
- "mds.caps",
- "mds.subtrees"
- ]
-
- result = {}
- mds_names = self._get_mds_names(int(fs_id))
-
- for mds_name in mds_names:
- result[mds_name] = {}
- for counter in counters:
- data = global_instance().get_counter("mds", mds_name, counter)
- if data is not None:
- result[mds_name][counter] = data[counter]
- else:
- result[mds_name][counter] = []
-
- return dict(result)
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def get_counter(self, type, id, path):
- return global_instance().get_counter(type, id, path)
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def get_perf_schema(self, **args):
- type = args.get('type', '')
- id = args.get('id', '')
- schema = global_instance().get_perf_schema(type, id)
- ret = dict()
- for k1 in schema.keys(): # 'perf_schema'
- ret[k1] = collections.OrderedDict()
- for k2 in sorted(schema[k1].keys()):
- sorted_dict = collections.OrderedDict(
- sorted(schema[k1][k2].items(), key=lambda i: i[0])
- )
- ret[k1][k2] = sorted_dict
- return ret
-
- url_prefix = self.get_config('url_prefix')
- if url_prefix == None:
- url_prefix = ''
- else:
- if len(url_prefix) != 0:
- if url_prefix[0] != '/':
- url_prefix = '/'+url_prefix
- if url_prefix[-1] == '/':
- url_prefix = url_prefix[:-1]
- self.url_prefix = url_prefix
-
- server_addr = self.get_localized_config('server_addr', '::')
- server_port = self.get_localized_config('server_port', '7000')
- if server_addr is None:
- raise RuntimeError('no server_addr configured; try "ceph config-key set mgr/dashboard/server_addr <ip>"')
- log.info("server_addr: %s server_port: %s" % (server_addr, server_port))
- cherrypy.config.update({
- 'server.socket_host': server_addr,
- 'server.socket_port': int(server_port),
- 'engine.autoreload.on': False
- })
-
- osdmap = self.get_osdmap()
- log.info("latest osdmap is %d" % osdmap.get_epoch())
-
- # Publish the URI that others may use to access the service we're
- # about to start serving
- self.set_uri("http://{0}:{1}/".format(
- socket.getfqdn() if server_addr == "::" else server_addr,
- server_port
- ))
-
- static_dir = os.path.join(current_dir, 'static')
- conf = {
- "/static": {
- "tools.staticdir.on": True,
- 'tools.staticdir.dir': static_dir
- }
- }
- log.info("Serving static from {0}".format(static_dir))
-
- class OSDEndpoint(EndPoint):
- def _osd(self, osd_id):
- osd_id = int(osd_id)
-
- osd_map = global_instance().get("osd_map")
-
- osd = None
- for o in osd_map['osds']:
- if o['osd'] == osd_id:
- osd = o
- break
-
- assert osd is not None # TODO 400
-
- osd_spec = "{0}".format(osd_id)
-
- osd_metadata = global_instance().get_metadata(
- "osd", osd_spec)
-
- result = CommandResult("")
- global_instance().send_command(result, "osd", osd_spec,
- json.dumps({
- "prefix": "perf histogram dump",
- }),
- "")
- r, outb, outs = result.wait()
- assert r == 0
- histogram = json.loads(outb)
-
- return {
- "osd": osd,
- "osd_metadata": osd_metadata,
- "osd_histogram": histogram
- }
-
- @cherrypy.expose
- def perf(self, osd_id):
- template = env.get_template("osd_perf.html")
- toplevel_data = self._toplevel_data()
-
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info='/osd' + cherrypy.request.path_info,
- toplevel_data=json.dumps(toplevel_data, indent=2),
- content_data=json.dumps(self._osd(osd_id), indent=2)
- )
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def perf_data(self, osd_id):
- return self._osd(osd_id)
-
- @cherrypy.expose
- @cherrypy.tools.json_out()
- def list_data(self):
- return self._osds_by_server()
-
- def _osd_summary(self, osd_id, osd_info):
- """
- The info used for displaying an OSD in a table
- """
-
- osd_spec = "{0}".format(osd_id)
-
- result = {}
- result['id'] = osd_id
- result['stats'] = {}
- result['stats_history'] = {}
-
- # Counter stats
- for s in ['osd.op_w', 'osd.op_in_bytes', 'osd.op_r', 'osd.op_out_bytes']:
- result['stats'][s.split(".")[1]] = global_instance().get_rate('osd', osd_spec, s)
- result['stats_history'][s.split(".")[1]] = \
- global_instance().get_counter('osd', osd_spec, s)[s]
-
- # Gauge stats
- for s in ["osd.numpg", "osd.stat_bytes", "osd.stat_bytes_used"]:
- result['stats'][s.split(".")[1]] = global_instance().get_latest('osd', osd_spec, s)
-
- result['up'] = osd_info['up']
- result['in'] = osd_info['in']
-
- result['url'] = get_prefixed_url("/osd/perf/{0}".format(osd_id))
-
- return result
-
- def _osds_by_server(self):
- result = defaultdict(list)
- servers = global_instance().list_servers()
-
- osd_map = global_instance().get_sync_object(OsdMap)
-
- for server in servers:
- hostname = server['hostname']
- services = server['services']
- for s in services:
- if s["type"] == "osd":
- osd_id = int(s["id"])
- # If metadata doesn't tally with osdmap, drop it.
- if osd_id not in osd_map.osds_by_id:
- global_instance().log.warn(
- "OSD service {0} missing in OSDMap, stale metadata?".format(osd_id))
- continue
- summary = self._osd_summary(osd_id,
- osd_map.osds_by_id[osd_id])
-
- result[hostname].append(summary)
-
- result[hostname].sort(key=lambda a: a['id'])
- if len(result[hostname]):
- result[hostname][0]['first'] = True
-
- global_instance().log.warn("result.size {0} servers.size {1}".format(
- len(result), len(servers)
- ))
-
- # Return list form for convenience of rendering
- return sorted(result.items(), key=lambda a: a[0])
-
- @cherrypy.expose
- def index(self):
- """
- List of all OSDS grouped by host
- :return:
- """
-
- template = env.get_template("osds.html")
- toplevel_data = self._toplevel_data()
-
- content_data = {
- "osds_by_server": self._osds_by_server()
- }
-
- return template.render(
- url_prefix = global_instance().url_prefix,
- ceph_version=global_instance().version,
- path_info='/osd' + cherrypy.request.path_info,
- toplevel_data=json.dumps(toplevel_data, indent=2),
- content_data=json.dumps(content_data, indent=2)
- )
-
- cherrypy.tree.mount(Root(), get_prefixed_url("/"), conf)
- cherrypy.tree.mount(OSDEndpoint(), get_prefixed_url("/osd"), conf)
-
- log.info("Starting engine on {0}:{1}...".format(
- server_addr, server_port))
- cherrypy.engine.start()
- log.info("Waiting for engine...")
- cherrypy.engine.block()
- log.info("Engine done.")
Code Review / stor4nfv.git / blobdiff