src/collecty/client.py

   1 #!/usr/bin/python3
   2 ###############################################################################
   3 #                                                                             #
   4 # collecty - A system statistics collection daemon for IPFire                 #
   5 # Copyright (C) 2012 IPFire development team                                  #
   6 #                                                                             #
   7 # This program is free software: you can redistribute it and/or modify        #
   8 # it under the terms of the GNU General Public License as published by        #
   9 # the Free Software Foundation, either version 3 of the License, or           #
  10 # (at your option) any later version.                                         #
  11 #                                                                             #
  12 # This program is distributed in the hope that it will be useful,             #
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of              #
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
  15 # GNU General Public License for more details.                                #
  16 #                                                                             #
  17 # You should have received a copy of the GNU General Public License           #
  18 # along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
  19 #                                                                             #
  20 ###############################################################################
  21
  22 import argparse
  23 import dbus
  24 import os
  25 import platform
  26 import sys
  27
  28 from .constants import *
  29 from .i18n import _
  30
  31 import logging
  32 log = logging.getLogger("collectly.client")
  33
  34 class CollectyClient(object):
  35         def __init__(self):
  36                 self.bus = dbus.SystemBus()
  37
  38                 self.proxy = self.bus.get_object(BUS_DOMAIN, "/GraphGenerator")
  39
  40         def list_templates(self):
  41                 templates = self.proxy.ListTemplates()
  42
  43                 return ["%s" % t for t in templates]
  44
  45         def list_templates_cli(self, ns):
  46                 templates = self.list_templates()
  47
  48                 for t in sorted(templates):
  49                         print(t)
  50
  51         def graph_info(self, template_name, **kwargs):
  52                 graph_info = self.proxy.GraphInfo(template_name, kwargs,
  53                         signature="sa{sv}")
  54
  55                 return dict(graph_info)
  56
  57         def generate_graph(self, template_name, **kwargs):
  58                 graph = self.proxy.GenerateGraph(template_name, kwargs,
  59                         signature="sa{sv}")
  60
  61                 # Convert the byte array into a byte string again
  62                 if graph:
  63                         graph["image"] = bytes(graph["image"])
  64
  65                 return graph
  66
  67         def generate_graph_cli(self, ns):
  68                 kwargs = {
  69                         "format"    : ns.format,
  70                         "object_id" : ns.object,
  71                 }
  72
  73                 if ns.height or ns.width:
  74                         kwargs.update({
  75                                 "height" : ns.height or 0,
  76                                 "width"  : ns.width or 0,
  77                         })
  78
  79                 if ns.interval:
  80                         kwargs["interval"] = ns.interval
  81
  82                 kwargs.update({
  83                         "locale"   : ns.locale,
  84                         "timezone" : ns.timezone,
  85                 })
  86
  87                 # Generate the graph image
  88                 graph = self.generate_graph(ns.template, **kwargs)
  89
  90                 # Add some useful information
  91                 info = self.graph_info(ns.template, **kwargs)
  92                 if info:
  93                         graph.update(info)
  94
  95                 # Write file to disk
  96                 with open(ns.filename, "wb") as f:
  97                         f.write(graph["image"])
  98
  99                 print(_("Title      : %(title)s (%(template)s - %(object_id)s)") % graph)
 100                 print(_("Image size : %(image_width)sx%(image_height)spx") % graph)
 101
 102         def version_cli(self, args):
 103                 daemon_version = self.proxy.Version()
 104
 105                 print(_("collecty %s running on Python %s") % \
 106                         (COLLECTY_VERSION, platform.python_version()))
 107
 108                 if not COLLECTY_VERSION == daemon_version:
 109                         print(_("daemon %s") % daemon_version)
 110
 111         def parse_cli(self, args):
 112                 parser = argparse.ArgumentParser(prog="collecty-client")
 113                 subparsers = parser.add_subparsers(help="sub-command help")
 114
 115                 # generate-graph
 116                 parser_generate_graph = subparsers.add_parser("generate-graph",
 117                         help=_("Generate a graph image"))
 118                 parser_generate_graph.set_defaults(func=self.generate_graph_cli)
 119                 parser_generate_graph.add_argument("--filename",
 120                         help=_("filename"), required=True)
 121                 parser_generate_graph.add_argument("--format",
 122                         help=_("image format"), default=DEFAULT_IMAGE_FORMAT)
 123                 parser_generate_graph.add_argument("--interval", help=_("interval"))
 124                 parser_generate_graph.add_argument("--object",
 125                         help=_("Object identifier"), default="default")
 126                 parser_generate_graph.add_argument("--template",
 127                         help=_("The graph template identifier"), required=True)
 128                 parser_generate_graph.add_argument("--timezone", default=os.environ.get("TZ", "UTC"),
 129                         help=_("Generate the graph with timestamps plotted for the given timezone"))
 130                 parser_generate_graph.add_argument("--locale", default=os.environ.get("LANG", "en_GB.utf8"),
 131                         help=_("Generate the graph with this locale"))
 132
 133                 # Dimensions
 134                 parser_generate_graph.add_argument("--height", type=int, default=0,
 135                         help=_("Height of the generated image"))
 136                 parser_generate_graph.add_argument("--width", type=int, default=0,
 137                         help=_("Width of the generated image"))
 138
 139                 # list-templates
 140                 parser_list_templates = subparsers.add_parser("list-templates",
 141                         help=_("Lists all graph templates"))
 142                 parser_list_templates.set_defaults(func=self.list_templates_cli)
 143
 144                 # version
 145                 parser_version = subparsers.add_parser("version", help=_("Show version"))
 146                 parser_version.set_defaults(func=self.version_cli)
 147
 148                 return parser.parse_args(args)
 149
 150         def run_cli(self, args=None):
 151                 args = self.parse_cli(args or sys.argv[1:])
 152
 153                 return args.func(args)