Current File : //snap/lxd/28373/lib/python3/dist-packages/ceph_daemon.py
# -*- 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
try:
from collections.abc import OrderedDict
except ImportError:
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', 'E', 'Z']
unit = 0
while len("%s" % (int(n) // (1000**unit))) > width - 1:
if unit >= len(units) - 1:
break;
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')
Mini Shell