+++ /dev/null
-# -*- mode:python -*-
-# vim: ts=4 sw=4 smarttab expandtab
-
-"""
-Copyright (C) 2015 Red Hat
-
-This is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public
-License version 2, as published by the Free Software
-Foundation. See file COPYING.
-"""
-
-import sys
-import json
-import socket
-import struct
-import time
-from collections import OrderedDict
-from fcntl import ioctl
-from fnmatch import fnmatch
-from prettytable import PrettyTable, HEADER
-from signal import signal, SIGWINCH
-from termios import TIOCGWINSZ
-
-from ceph_argparse import parse_json_funcsigs, validate_command
-
-COUNTER = 0x8
-LONG_RUNNING_AVG = 0x4
-READ_CHUNK_SIZE = 4096
-
-
-def admin_socket(asok_path, cmd, format=''):
- """
- Send a daemon (--admin-daemon) command 'cmd'. asok_path is the
- path to the admin socket; cmd is a list of strings; format may be
- set to one of the formatted forms to get output in that form
- (daemon commands don't support 'plain' output).
- """
-
- def do_sockio(path, cmd_bytes):
- """ helper: do all the actual low-level stream I/O """
- sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- sock.connect(path)
- try:
- sock.sendall(cmd_bytes + b'\0')
- len_str = sock.recv(4)
- if len(len_str) < 4:
- raise RuntimeError("no data returned from admin socket")
- l, = struct.unpack(">I", len_str)
- sock_ret = b''
-
- got = 0
- while got < l:
- # recv() receives signed int, i.e max 2GB
- # workaround by capping READ_CHUNK_SIZE per call.
- want = min(l - got, READ_CHUNK_SIZE)
- bit = sock.recv(want)
- sock_ret += bit
- got += len(bit)
-
- except Exception as sock_e:
- raise RuntimeError('exception: ' + str(sock_e))
- return sock_ret
-
- try:
- cmd_json = do_sockio(asok_path,
- b'{"prefix": "get_command_descriptions"}')
- except Exception as e:
- raise RuntimeError('exception getting command descriptions: ' + str(e))
-
- if cmd == 'get_command_descriptions':
- return cmd_json
-
- sigdict = parse_json_funcsigs(cmd_json.decode('utf-8'), 'cli')
- valid_dict = validate_command(sigdict, cmd)
- if not valid_dict:
- raise RuntimeError('invalid command')
-
- if format:
- valid_dict['format'] = format
-
- try:
- ret = do_sockio(asok_path, json.dumps(valid_dict).encode('utf-8'))
- except Exception as e:
- raise RuntimeError('exception: ' + str(e))
-
- return ret
-
-
-class Termsize(object):
- DEFAULT_SIZE = (25, 80)
- def __init__(self):
- self.rows, self.cols = self._gettermsize()
- self.changed = False
-
- def _gettermsize(self):
- try:
- fd = sys.stdin.fileno()
- sz = struct.pack('hhhh', 0, 0, 0, 0)
- rows, cols = struct.unpack('hhhh', ioctl(fd, TIOCGWINSZ, sz))[:2]
- return rows, cols
- except IOError:
- return self.DEFAULT_SIZE
-
- def update(self):
- rows, cols = self._gettermsize()
- if not self.changed:
- self.changed = (self.rows, self.cols) != (rows, cols)
- self.rows, self.cols = rows, cols
-
- def reset_changed(self):
- self.changed = False
-
- def __str__(self):
- return '%s(%dx%d, changed %s)' % (self.__class__,
- self.rows, self.cols, self.changed)
-
- def __repr__(self):
- return 'Termsize(%d,%d,%s)' % (self.__class__,
- self.rows, self.cols, self.changed)
-
-
-class DaemonWatcher(object):
- """
- Given a Ceph daemon's admin socket path, poll its performance counters
- and output a series of output lines showing the momentary values of
- counters of interest (those with the 'nick' property in Ceph's schema)
- """
- (
- BLACK,
- RED,
- GREEN,
- YELLOW,
- BLUE,
- MAGENTA,
- CYAN,
- GRAY
- ) = range(8)
-
- RESET_SEQ = "\033[0m"
- COLOR_SEQ = "\033[1;%dm"
- COLOR_DARK_SEQ = "\033[0;%dm"
- BOLD_SEQ = "\033[1m"
- UNDERLINE_SEQ = "\033[4m"
-
- def __init__(self, asok, statpats=None, min_prio=0):
- self.asok_path = asok
- self._colored = False
-
- self._stats = None
- self._schema = None
- self._statpats = statpats
- self._stats_that_fit = dict()
- self._min_prio = min_prio
- self.termsize = Termsize()
-
- def supports_color(self, ostr):
- """
- Returns True if the running system's terminal supports color, and False
- otherwise.
- """
- unsupported_platform = (sys.platform in ('win32', 'Pocket PC'))
- # isatty is not always implemented, #6223.
- is_a_tty = hasattr(ostr, 'isatty') and ostr.isatty()
- if unsupported_platform or not is_a_tty:
- return False
- return True
-
- def colorize(self, msg, color, dark=False):
- """
- Decorate `msg` with escape sequences to give the requested color
- """
- return (self.COLOR_DARK_SEQ if dark else self.COLOR_SEQ) % (30 + color) \
- + msg + self.RESET_SEQ
-
- def bold(self, msg):
- """
- Decorate `msg` with escape sequences to make it appear bold
- """
- return self.BOLD_SEQ + msg + self.RESET_SEQ
-
- def format_dimless(self, n, width):
- """
- 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 self._colored:
- 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))
- else:
- return formatted
-
- def col_width(self, nick):
- """
- Given the short name `nick` for a column, how many characters
- of width should the column be allocated? Does not include spacing
- between columns.
- """
- return max(len(nick), 4)
-
- def get_stats_that_fit(self):
- '''
- Get a possibly-truncated list of stats to display based on
- current terminal width. Allow breaking mid-section.
- '''
- current_fit = OrderedDict()
- if self.termsize.changed or not self._stats_that_fit:
- width = 0
- for section_name, names in self._stats.items():
- for name, stat_data in names.items():
- width += self.col_width(stat_data) + 1
- if width > self.termsize.cols:
- break
- if section_name not in current_fit:
- current_fit[section_name] = OrderedDict()
- current_fit[section_name][name] = stat_data
- if width > self.termsize.cols:
- break
-
- self.termsize.reset_changed()
- changed = current_fit and (current_fit != self._stats_that_fit)
- if changed:
- self._stats_that_fit = current_fit
- return self._stats_that_fit, changed
-
- def _print_headers(self, ostr):
- """
- Print a header row to `ostr`
- """
- header = ""
- stats, _ = self.get_stats_that_fit()
- for section_name, names in stats.items():
- section_width = \
- sum([self.col_width(x) + 1 for x in names.values()]) - 1
- pad = max(section_width - len(section_name), 0)
- pad_prefix = pad // 2
- header += (pad_prefix * '-')
- header += (section_name[0:section_width])
- header += ((pad - pad_prefix) * '-')
- header += ' '
- header += "\n"
- ostr.write(self.colorize(header, self.BLUE, True))
-
- sub_header = ""
- for section_name, names in stats.items():
- for stat_name, stat_nick in names.items():
- sub_header += self.UNDERLINE_SEQ \
- + self.colorize(
- stat_nick.ljust(self.col_width(stat_nick)),
- self.BLUE) \
- + ' '
- sub_header = sub_header[0:-1] + self.colorize('|', self.BLUE)
- sub_header += "\n"
- ostr.write(sub_header)
-
- def _print_vals(self, ostr, dump, last_dump):
- """
- Print a single row of values to `ostr`, based on deltas between `dump` and
- `last_dump`.
- """
- val_row = ""
- fit, changed = self.get_stats_that_fit()
- if changed:
- self._print_headers(ostr)
- for section_name, names in fit.items():
- for stat_name, stat_nick in names.items():
- stat_type = self._schema[section_name][stat_name]['type']
- if bool(stat_type & COUNTER):
- n = max(dump[section_name][stat_name] -
- last_dump[section_name][stat_name], 0)
- elif bool(stat_type & LONG_RUNNING_AVG):
- entries = dump[section_name][stat_name]['avgcount'] - \
- last_dump[section_name][stat_name]['avgcount']
- if entries:
- n = (dump[section_name][stat_name]['sum'] -
- last_dump[section_name][stat_name]['sum']) \
- / float(entries)
- n *= 1000.0 # Present in milliseconds
- else:
- n = 0
- else:
- n = dump[section_name][stat_name]
-
- val_row += self.format_dimless(n, self.col_width(stat_nick))
- val_row += " "
- val_row = val_row[0:-1]
- val_row += self.colorize("|", self.BLUE)
- val_row = val_row[0:-len(self.colorize("|", self.BLUE))]
- ostr.write("{0}\n".format(val_row))
-
- def _should_include(self, sect, name, prio):
- '''
- boolean: should we output this stat?
-
- 1) If self._statpats exists and the name filename-glob-matches
- anything in the list, and prio is high enough, or
- 2) If self._statpats doesn't exist and prio is high enough
-
- then yes.
- '''
- if self._statpats:
- sectname = '.'.join((sect, name))
- if not any([
- p for p in self._statpats
- if fnmatch(name, p) or fnmatch(sectname, p)
- ]):
- return False
-
- if self._min_prio is not None and prio is not None:
- return (prio >= self._min_prio)
-
- return True
-
- def _load_schema(self):
- """
- Populate our instance-local copy of the daemon's performance counter
- schema, and work out which stats we will display.
- """
- self._schema = json.loads(
- admin_socket(self.asok_path, ["perf", "schema"]).decode('utf-8'),
- object_pairs_hook=OrderedDict)
-
- # Build list of which stats we will display
- self._stats = OrderedDict()
- for section_name, section_stats in self._schema.items():
- for name, schema_data in section_stats.items():
- prio = schema_data.get('priority', 0)
- if self._should_include(section_name, name, prio):
- if section_name not in self._stats:
- self._stats[section_name] = OrderedDict()
- self._stats[section_name][name] = schema_data['nick']
- if not len(self._stats):
- raise RuntimeError("no stats selected by filters")
-
- def _handle_sigwinch(self, signo, frame):
- self.termsize.update()
-
- def run(self, interval, count=None, ostr=sys.stdout):
- """
- Print output at regular intervals until interrupted.
-
- :param ostr: Stream to which to send output
- """
-
- self._load_schema()
- self._colored = self.supports_color(ostr)
-
- self._print_headers(ostr)
-
- last_dump = json.loads(admin_socket(self.asok_path, ["perf", "dump"]).decode('utf-8'))
- rows_since_header = 0
-
- try:
- signal(SIGWINCH, self._handle_sigwinch)
- while True:
- dump = json.loads(admin_socket(self.asok_path, ["perf", "dump"]).decode('utf-8'))
- if rows_since_header >= self.termsize.rows - 2:
- self._print_headers(ostr)
- rows_since_header = 0
- self._print_vals(ostr, dump, last_dump)
- if count is not None:
- count -= 1
- if count <= 0:
- break
- rows_since_header += 1
- last_dump = dump
-
- # time.sleep() is interrupted by SIGWINCH; avoid that
- end = time.time() + interval
- while time.time() < end:
- time.sleep(end - time.time())
-
- except KeyboardInterrupt:
- return
-
- def list(self, ostr=sys.stdout):
- """
- Show all selected stats with section, full name, nick, and prio
- """
- table = PrettyTable(('section', 'name', 'nick', 'prio'))
- table.align['section'] = 'l'
- table.align['name'] = 'l'
- table.align['nick'] = 'l'
- table.align['prio'] = 'r'
- self._load_schema()
- for section_name, section_stats in self._stats.items():
- for name, nick in section_stats.items():
- prio = self._schema[section_name][name].get('priority') or 0
- table.add_row((section_name, name, nick, prio))
- ostr.write(table.get_string(hrules=HEADER) + '\n')
Code Review / stor4nfv.git / blobdiff