def address(self): if not self.__read: from initat.icsw.service.instance import InstanceXML from initat.cluster.backbone.server_enums import icswServiceEnum _xml = InstanceXML(quiet=True) _port = _xml.get_port_dict(icswServiceEnum.memcached, command=True) self.__address = ["127.0.0.1:{:d}".format(_port)] self.__read = True return self.__address
def _get_parser(): _xml = InstanceXML(quiet=True) parser = argparse.ArgumentParser("set a passive check command") parser.add_argument("-p", type=int, default=_xml.get_port_dict(icswServiceEnum.monitor_slave, command=True), dest="port", help="target port [%(default)d]") parser.add_argument("-H", type=str, default="localhost", dest="host", help="target host [%(default)s]") parser.add_argument("--device", type=str, default="", help="device [%(default)s]", required=True) parser.add_argument("--check", type=str, default="", help="name of check [%(default)s]", required=True) parser.add_argument("--state", type=str, default="OK", choices=["OK", "WARN", "CRITICAL"], help="check state [%(default)s]") parser.add_argument("--output", type=str, default="", help="check output [%(default)s]", required=True) parser.add_argument("-v", help="verbose mode [%(default)s]", default=False, dest="verbose", action="store_true") parser.add_argument("-t", type=int, default=10, dest="timeout", help="set timeout [%(default)d]") return parser
def _register_local_syncer(self): _inst_xml = InstanceXML(log_com=self.log) self.__local_syncer_uuid = "urn:uuid:{}:{}:".format( uuid_tools.get_uuid(), _inst_xml.get_uuid_postfix(icswServiceEnum.monitor_slave)) self.__local_syncer_addr = "tcp://127.0.0.1:{:d}".format( _inst_xml.get_port_dict(icswServiceEnum.monitor_slave, command=True)) self.log("connecting to local syncer {} (uuid={})".format( self.__local_syncer_addr, self.__local_syncer_uuid, )) self.main_socket.connect(self.__local_syncer_addr)
class LocalParser(argparse.ArgumentParser): def __init__(self): argparse.ArgumentParser.__init__( self, "send command to servers of the init.at Clustersoftware") self.inst_xml = InstanceXML(quiet=True) inst_list = [] for inst in self.inst_xml.get_all_instances(): if len(inst.xpath(".//network/ports/port[@type='command']")): inst_list.append(inst.get("name")) self.add_argument("arguments", nargs="+", help="additional arguments, first one is command") self.add_argument("-t", help="set timeout [%(default)d]", default=10, type=int, dest="timeout") self.add_argument("-p", help="port or instance/service [%(default)s]", default="{:d}".format( self.inst_xml.get_port_dict( icswServiceEnum.host_monitoring, command=True)), dest="port", type=str) self.add_argument("-P", help="protocoll [%(default)s]", type=str, default="tcp", choices=["tcp", "ipc"], dest="protocoll") self.add_argument("-S", help="servername [%(default)s]", type=str, default="collrelay", dest="server_name") self.add_argument("-H", "--host", help="host [%(default)s] or server", default="localhost", dest="host") self.add_argument("-v", help="verbose mode [%(default)s]", default=False, dest="verbose", action="store_true") self.add_argument("-i", help="set identity substring [%(default)s]", type=str, default="sc", dest="identity_substring") self.add_argument( "-I", help="set identity string [%(default)s], has precedence over -i", type=str, default="", dest="identity_string") self.add_argument("-n", help="set number of iterations [%(default)d]", type=int, default=1, dest="iterations") self.add_argument("-q", help="be quiet [%(default)s], overrides verbose", default=False, action="store_true", dest="quiet") self.add_argument("--raw", help="do not convert to server_command", default=False, action="store_true") self.add_argument("--root", help="connect to root-socket [%(default)s]", default=False, action="store_true") self.add_argument("--kv", help="key-value pair, colon-separated [key:value]", action="append") self.add_argument( "--kva", help="key-attribute pair, colon-separated [key:attribute:value]", action="append") self.add_argument("--kv-path", help="path to store key-value pairs under", type=str, default="") self.add_argument( "--split", help="set read socket (for split-socket command), [%(default)s]", type=str, default="") self.add_argument("--only-send", help="only send command, [%(default)s]", default=False, action="store_true") def parse(self): opts = self.parse_args() if isinstance(opts.port, str) and opts.port.isdigit(): opts.port = int(opts.port) else: if opts.port in self.inst_xml: opts.port = self.inst_xml.get_port_dict(opts.port, command=True) else: print("Invalid service / instance name '{}'".format(opts.port)) sys.exit(-1) return opts
def device_syslog(opt_ns, cur_dev, j_logs): print( u"Information about device '{}' (full name {}, devicegroup {})".format( unicode(cur_dev), unicode(cur_dev.full_name), unicode(cur_dev.device_group))) print("UUID is '{}', database-ID is {:d}".format(cur_dev.uuid, cur_dev.pk)) _cr = routing.SrvTypeRouting(force=True, ignore_errors=True) _ST = "logcheck-server" if _ST in _cr.service_types: _inst_xml = InstanceXML(quiet=True) # get logcheck-server IP _ls_ip = _cr[_ST][0][1] # get logcheck-server Port _ls_port = _inst_xml.get_port_dict(_ST, ptype="command") _sc = server_command.srv_command(command="get_syslog", ) _sc["devices"] = _sc.builder( "devices", *[ _sc.builder( "device", pk="{:d}".format(cur_dev.pk), lines="{:d}".format(opt_ns.loglines), minutes="{:d}".format(opt_ns.minutes), ) ]) _conn_str = "tcp://{}:{:d}".format(_ls_ip, _ls_port) _result = net_tools.ZMQConnection("icsw_state_{:d}".format( os.getpid())).add_connection( _conn_str, _sc, ) if _result is not None: _dev = _result.xpath(".//ns:devices/ns:device[@pk]")[0] _lines = _result.xpath("ns:lines", start_el=_dev)[0] _rates = _result.xpath("ns:rates", start_el=_dev) if _rates: _rates = { int(_el.get("timeframe")): float(_el.get("rate")) for _el in _rates[0] } print("rate info: {}".format(", ".join([ "{:.2f} lines/sec in {}".format( _rates[_seconds], logging_tools.get_diff_time_str(_seconds)) for _seconds in sorted(_rates) ]))) else: print("no rate info found") print(_rates) _out_lines = logging_tools.new_form_list() for _entry in process_tools.decompress_struct(_lines.text): _out_lines.append([ logging_tools.form_entry(_entry["line_id"], header="idx"), logging_tools.form_entry( "{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}".format( *_entry["line_datetime_parsed"]), header="Timestamp", ), ] + [ logging_tools.form_entry(_entry[_key], header=_key) for _key in ["hostname", "priority", "facility", "tag"] ] + [ logging_tools.form_entry(_entry["text"], header="text"), ]) print(unicode(_out_lines)) else: print("got no result from {} ({})".format(_conn_str, _ST)) else: print("No logcheck-server found, skipping syslog display")
class CapabilityProcess(threading_tools.process_obj): def process_init(self): global_config.close() self.__log_template = logging_tools.get_logger( global_config["LOG_NAME"], global_config["LOG_DESTINATION"], zmq=True, context=self.zmq_context) db_tools.close_connection() self._instance = InstanceXML(log_com=self.log) self._init_network() self._init_capabilities() self.__last_user_scan = None self.__scan_running = False self.register_timer(self._update, 2 if global_config["DEBUG"] else 30, instant=True) def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): self.__log_template.log(log_level, what) def loop_post(self): self.collectd_socket.close() self.vector_socket.close() self.__log_template.close() def _init_network(self): # connection to local collserver socket conn_str = process_tools.get_zmq_ipc_name( "vector", s_name="collserver", connect_to_root_instance=True) vector_socket = self.zmq_context.socket(zmq.PUSH) # @UndefinedVariable vector_socket.setsockopt(zmq.LINGER, 0) # @UndefinedVariable vector_socket.connect(conn_str) self.vector_socket = vector_socket self.log("connected vector_socket to {}".format(conn_str)) # connection to local collectd server _cc_str = "tcp://localhost:{:d}".format( # get receive port for collectd-server drop self._instance.get_port_dict(icswServiceEnum.collectd_server, ptype="receive")) collectd_socket = self.zmq_context.socket(zmq.PUSH) collectd_socket.setsockopt(zmq.LINGER, 0) collectd_socket.connect(_cc_str) self.log("connected collectd_socket to {}".format(_cc_str)) self.collectd_socket = collectd_socket def _init_capabilities(self): self.__cap_list = [] if global_config["BACKUP_DATABASE"]: self.log("doing database backup, ignoring capabilities", logging_tools.LOG_LEVEL_WARN) else: # read caps _dir = os.path.dirname(__file__) self.log("init server capabilities from directory {}".format(_dir)) SRV_CAPS = [] for entry in os.listdir(_dir): if entry.endswith(".py") and entry not in ["__init__.py"]: _imp_name = "initat.cluster_server.capabilities.{}".format( entry.split(".")[0]) _mod = importlib.import_module(_imp_name) for _key in dir(_mod): _value = getattr(_mod, _key) if inspect.isclass(_value) and issubclass( _value, base.BackgroundBase ) and _value != base.BackgroundBase: SRV_CAPS.append(_value) self.log("checking {}".format( logging_tools.get_plural("capability", len(SRV_CAPS)))) self.__server_cap_dict = {} self.__cap_list = [] try: sys_cc = config_catalog.objects.get(Q(system_catalog=True)) except config_catalog.DoesNotExist: sys_cc = factories.ConfigCatalog(name="local", system_catalog=True) for _srv_cap in SRV_CAPS: cap_name = _srv_cap.Meta.name try: cap_descr = _srv_cap.Meta.description except: self.log( "capability {} has no description set, ignoring...". format(cap_name), logging_tools.LOG_LEVEL_ERROR) else: _new_c = factories.Config( name=cap_name, description=cap_descr, config_catalog=sys_cc, server_config=True, # system_config=True, ) _sql_info = config_tools.server_check(server_type=cap_name) if _sql_info.effective_device: self.__cap_list.append(cap_name) self.__server_cap_dict[cap_name] = _srv_cap( self, _sql_info) self.log("capability {} is enabled on {}".format( cap_name, unicode(_sql_info.effective_device), )) else: self.log("capability {} is disabled".format(cap_name)) def add_ova_statistics(self, cur_time, drop_com): _bldr = drop_com.builder # print "*", cur_time, drop_com, _bldr my_vector = _bldr("values") for _csr in icswEggConsumer.objects.all(): my_vector.append( hm_classes.mvect_entry( "icsw.ova.{}.{}".format(_csr.content_type.model, _csr.action), info="Ova consumed by {} on {}".format( _csr.action, _csr.content_type.model), default=0, value=_csr.consumed, factor=1, base=1, valid_until=cur_time + 3600, ).build_xml(_bldr)) drop_com["vector_ova"] = my_vector drop_com["vector_ova"].attrib["type"] = "vector" def _update(self): cur_time = time.time() drop_com = server_command.srv_command(command="set_vector") mach_vectors = [] for cap_name in self.__cap_list: self.__server_cap_dict[cap_name](cur_time, drop_com, mach_vectors) self.add_ova_statistics(cur_time, drop_com) self.vector_socket.send_unicode(unicode(drop_com)) # print drop_com.pretty_print() for _mv in mach_vectors: try: self.collectd_socket.send_unicode(etree.tostring(_mv)) except: self.log( "unable to send machvector to collectd: {}".format( process_tools.get_except_info(), ), logging_tools.LOG_LEVEL_ERROR, )
def network_bind(self, **kwargs): _need_all_binds = kwargs.get("need_all_binds", False) pollin = kwargs.get("pollin", None) ext_call = kwargs.get("ext_call", False) immediate = kwargs.get("immediate", True) if "server_type" in kwargs: _inst = InstanceXML(log_com=self.log) _srv_type = kwargs["server_type"] bind_port = _inst.get_port_dict(_srv_type, ptype="command") elif "service_type_enum" in kwargs: _inst = InstanceXML(log_com=self.log) _srv_type = kwargs["service_type_enum"] bind_port = _inst.get_port_dict(_srv_type, ptype="command") elif "bind_port" in kwargs: bind_port = kwargs["bind_port"] else: raise KeyError("neither bind_port, service_type_enum nor server_type defined in kwargs") main_socket_name = kwargs.get("main_socket_name", "main_socket") virtual_sockets_name = kwargs.get("virtual_sockets_name", "virtual_sockets") bind_to_localhost = kwargs.get("bind_to_localhost", False) _sock_type = kwargs.get("socket_type", "ROUTER") if "client_type" in kwargs: uuid = uuid_tools.get_uuid().get_urn() if not uuid.startswith("urn"): uuid = "urn:uuid:{}".format(uuid) self.bind_id = "{}:{}:".format( uuid, InstanceXML(quiet=True).get_uuid_postfix(kwargs["client_type"]), ) dev_r = None else: from initat.tools import cluster_location from initat.cluster.backbone.routing import get_server_uuid self.bind_id = get_server_uuid(_srv_type) if kwargs.get("simple_server_bind", False): dev_r = None else: # device recognition dev_r = cluster_location.DeviceRecognition() # virtual sockets if hasattr(self, virtual_sockets_name): _virtual_sockets = getattr(self, virtual_sockets_name) else: _virtual_sockets = [] # main socket _main_socket = None # create bind list if dev_r and dev_r.device_dict: _bind_ips = set( list(dev_r.local_ips) + sum( [ _list for _dev, _list in dev_r.ip_r_lut.iteritems() ], [] ) ) # complex bind master_bind_list = [ ( True, [ "tcp://{}:{:d}".format(_local_ip, bind_port) for _local_ip in dev_r.local_ips ], self.bind_id, None, ) ] _virt_list = [] for _dev, _ip_list in dev_r.ip_r_lut.iteritems(): if _dev.pk != dev_r.device.pk: _virt_list.append( ( False, [ "tcp://{}:{:d}".format(_virtual_ip, bind_port) for _virtual_ip in _ip_list ], # ignore local device get_server_uuid(_srv_type, _dev.uuid), _dev, ) ) else: self.log( "ignoring virtual IP list ({}) (same device)".format( ", ".join(sorted(_ip_list)), ) ) master_bind_list.extend(_virt_list) # we have to bind to localhost but localhost is not present in bind_list, add master_bind if bind_to_localhost and not any([_ip.startswith("127.") for _ip in _bind_ips]): self.log( "bind_to_localhost is set but not IP in range 127.0.0.0/8 found in list, adding virtual_bind", logging_tools.LOG_LEVEL_WARN ) master_bind_list.append( ( False, [ "tcp://127.0.0.1:{:d}".format(bind_port) ], self.bind_id, None, ) ) else: # simple bind master_bind_list = [ ( True, [ "tcp://*:{:d}".format(bind_port) ], self.bind_id, None, ) ] _errors = [] # pprint.pprint(master_bind_list) bound_list = set() for master_bind, bind_list, bind_id, bind_dev in master_bind_list: client = process_tools.get_socket( self.zmq_context, _sock_type, identity=bind_id, immediate=immediate ) for _bind_str in bind_list: if _bind_str in bound_list: self.log( "bind_str '{}' (for {}) already used, skipping ...".format( _bind_str, " device '{}'".format(bind_dev) if bind_dev is not None else " master device", ), logging_tools.LOG_LEVEL_ERROR ) else: bound_list.add(_bind_str) try: client.bind(_bind_str) except zmq.ZMQError: self.log( "error binding to {}: {}".format( _bind_str, process_tools.get_except_info(), ), logging_tools.LOG_LEVEL_CRITICAL ) _errors.append(_bind_str) else: self.log("bound {} to {} with id {}".format(_sock_type, _bind_str, bind_id)) if pollin: self.register_poller(client, zmq.POLLIN, pollin, ext_call=ext_call, bind_id=bind_id) if master_bind: _main_socket = client else: _virtual_sockets.append(client) setattr(self, main_socket_name, _main_socket) setattr(self, virtual_sockets_name, _virtual_sockets) if _errors and _need_all_binds: raise ValueError("{} went wrong: {}".format(logging_tools.get_plural("bind", len(_errors)), ", ".join(_errors)))
class ConfigCheckObject(object): def __init__(self, proc): self.__process = proc # self.log = self.__process.log def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): self.__process.log("[CC] {}".format(what), log_level) def init(self, srv_type_enum, global_config, add_config_store=True, init_logging=True, native_logging=False, init_msi_block=True, log_name_postfix=None): if srv_type_enum is None: # srv_type_enum is None, use value stored in global config from initat.cluster.backbone.server_enums import icswServiceEnum # force reload of global-config global_config.close() srv_type_enum = getattr(icswServiceEnum, global_config["SERVICE_ENUM_NAME"]) self.srv_type_enum = srv_type_enum self.global_config = global_config self.__native_logging = native_logging self.__init_msi_block = init_msi_block self._inst_xml = InstanceXML(self.log) if self.__init_msi_block: # init MSI block self.__msi_block = None if add_config_store: self.__cs = config_store.ConfigStore("client", self.log) else: self.__cs = None global_config.add_config_entries( [ ("SERVICE_ENUM_NAME", configfile.str_c_var(self.srv_type_enum.name)) ] ) if init_logging: if "LOG_DESTINATION" not in global_config: global_config.add_config_entries( [ ("LOG_DESTINATION", configfile.str_c_var("uds:/var/lib/logging-server/py_log_zmq")), ] ) if "LOG_NAME" not in global_config: _log_name = self._inst_xml[self.srv_type_enum.value.instance_name].attrib["name"] if log_name_postfix: _log_name = "{}-{}".format( _log_name, log_name_postfix, ) global_config.add_config_entries( [ ( "LOG_NAME", configfile.str_c_var( _log_name, source="instance" ) ) ] ) if self.__native_logging: # build logger name logger_name = "{}.{}".format( process_tools.get_machine_name(), global_config["LOG_NAME"] ) # get logger self.__process.log_template = logging_functions.get_logger( self.__cs, logger_name.replace(".", "/"), logger_name, ) else: self.__process.log_template = logging_tools.get_logger( global_config["LOG_NAME"], global_config["LOG_DESTINATION"], context=self.__process.zmq_context, ) def create_hfp(self): from initat.tools import hfp_tools _cur_hfp = hfp_tools.create_db_entry( self.__sql_info.effective_device, hfp_tools.get_local_hfp() ) @property def CS(self): return self.__cs @property def Instance(self): return self._inst_xml def check_config(self): # late import (for clients without django) if self.srv_type_enum.value.server_service: from initat.tools import config_tools from django.db.models import Q from initat.cluster.backbone.models import LogSource if self.srv_type_enum.value.instance_name is None: raise KeyError("No instance_name set for srv_type_enum '{}'".format(self.srv_type_enum.name)) self._instance = self._inst_xml[self.srv_type_enum.value.instance_name] # conf_names = self._inst_xml.get_config_names(self._instance) self.log( "check for service_type {} (==enum {})".format( self.srv_type_enum.value.name, self.srv_type_enum.name, ) ) _opts = [ ( "PID_NAME", configfile.str_c_var(self._inst_xml.get_pid_file_name(self._instance), source="instance", database=False) ), ] for _name, _value in self._inst_xml.get_port_dict(self._instance).iteritems(): _opts.append( ( "{}_PORT".format(_name.upper()), configfile.int_c_var(_value, source="instance", database=False) ), ) if self.srv_type_enum.value.server_service: self.__sql_info = config_tools.server_check(service_type_enum=self.srv_type_enum) if self.__sql_info is None or not self.__sql_info.effective_device: # this can normally not happen due to start / stop via meta-server self.log("Not a valid {}".format(self.srv_type_enum.name), logging_tools.LOG_LEVEL_ERROR) sys.exit(5) else: # check eggConsumers # set values _opts.extend( [ ( "SERVICE_ENUM_NAME", configfile.str_c_var(self.srv_type_enum.name), ), ( "SERVER_SHORT_NAME", configfile.str_c_var(process_tools.get_machine_name(True)), ), ( "SERVER_IDX", configfile.int_c_var(self.__sql_info.device.pk, database=False, source="instance") ), ( "CONFIG_IDX", configfile.int_c_var(self.__sql_info.config.pk, database=False, source="instance") ), ( "EFFECTIVE_DEVICE_IDX", configfile.int_c_var(self.__sql_info.effective_device.pk, database=False, source="instance") ), ( "LOG_SOURCE_IDX", configfile.int_c_var( LogSource.new(self.srv_type_enum.name, device=self.__sql_info.effective_device).pk, source="instance", ) ), ( "MEMCACHE_PORT", configfile.int_c_var(self._inst_xml.get_port_dict("memcached", command=True), source="instance") ), ] ) self.global_config.add_config_entries(_opts) if self.__init_msi_block: self.__pid_name = self.global_config["PID_NAME"] process_tools.save_pid(self.__pid_name) self.log("init MSI Block") self.__msi_block = process_tools.MSIBlock(self.srv_type_enum.value.msi_block_name) self.__msi_block.add_actual_pid(process_name="main") self.__msi_block.save() def process_added(self, src_process, src_pid): if self.__init_msi_block: process_tools.append_pids(self.__pid_name, src_pid) self.__msi_block.add_actual_pid(src_pid, process_name=src_process) self.__msi_block.save() def process_removed(self, src_pid): if self.__init_msi_block: process_tools.remove_pids(self.__pid_name, src_pid) self.__msi_block.remove_actual_pid(src_pid) self.__msi_block.save() # property functions to access device and config @property def server(self): return self.__sql_info.device @property def config(self): return self.__sql_info.config @property def msi_block(self): if self.__init_msi_block: return self.__msi_block else: raise AttributeError("No MSI Block defined") def close(self): if self.__init_msi_block and self.__msi_block: process_tools.delete_pid(self.__pid_name) self.__msi_block.remove() self.__msi_block = None if not self.__native_logging: self.__process.log_template.close() if isinstance(self.__process, threading_tools.process_pool): # remove global config if we were called from the process poll self.global_config.delete() def log_config(self): _log = self.global_config.get_log(clear=True) if len(_log): self.log( "Config log ({}):".format( logging_tools.get_plural("line", len(_log)), ) ) for line, log_level in _log: self.log(" - clf: [{:d}] {}".format(log_level, line)) else: self.log("no Config log") conf_info = self.global_config.get_config_info() self.log( "Found {}:".format( logging_tools.get_plural("valid config-line", len(conf_info)) ) ) for conf in conf_info: self.log("Config : {}".format(conf)) def read_config_from_db(self, default_list=[]): from initat.tools import cluster_location cluster_location.read_config_from_db( self.global_config, self.__sql_info, default_list, ) def re_insert_config(self): if self.__sql_info: from initat.tools import cluster_location self.log( "re-inserting config for srv_type {} (config_name is {})".format( self.srv_type_enum.name, self.__sql_info.config_name, ) ) cluster_location.write_config_to_db( self.global_config, self.__sql_info, ) else: self.log( "refuse to re-insert config because sql_info is None (srv_type={})".format( self.srv_type, ), logging_tools.LOG_LEVEL_ERROR )
class CapabilityProcess(threading_tools.icswProcessObj): def process_init(self): global_config.enable_pm(self) self.__log_template = logging_tools.get_logger( global_config["LOG_NAME"], global_config["LOG_DESTINATION"], context=self.zmq_context) # db_tools.close_connection() self._instance = InstanceXML(log_com=self.log) self._init_network() self._init_capabilities() self.__last_user_scan = None self.__scan_running = False self.register_timer(self._update, 2 if global_config["DEBUG"] else 30, instant=True) def log(self, what, log_level=logging_tools.LOG_LEVEL_OK): self.__log_template.log(log_level, what) def loop_post(self): self.collectd_socket.close() self.vector_socket.close() self.__log_template.close() def _init_network(self): # connection to local collserver socket conn_str = process_tools.get_zmq_ipc_name( "vector", s_name="collserver", connect_to_root_instance=True) vector_socket = self.zmq_context.socket(zmq.PUSH) vector_socket.setsockopt(zmq.LINGER, 0) vector_socket.connect(conn_str) self.vector_socket = vector_socket self.log("connected vector_socket to {}".format(conn_str)) # connection to local collectd server _cc_str = "tcp://*****:*****@{} on {} ({})".format( csr.action, service.name, csr.content_type.model, v_type, ), default=0, value=csr.consumed, factor=1, base=1, valid_until=cur_time + 3600, ).build_xml(_bldr) _bldr = drop_com.builder # print "*", cur_time, drop_com, _bldr my_vector = _bldr("values") _total = 0 _total_ghost = 0 for _csr in icswEggConsumer.objects.all().select_related( "config_service_enum"): my_vector.append(_vector_entry("ghost", _csr)) _total_ghost += _csr.consumed if not _csr.ghost: my_vector.append(_vector_entry("consume", _csr)) _total += _csr.consumed my_vector.append( hm_classes.MachineVectorEntry( "icsw.ova.overall.total", info="Ova consumed by all actions on all models", default=0, value=_total, factor=1, base=1, valid_until=cur_time + 3600, ).build_xml(_bldr)) my_vector.append( hm_classes.MachineVectorEntry( "icsw.ova.overall.ghost", info="Ova consumed by all actions on all models (ghost)", default=0, value=_total_ghost, factor=1, base=1, valid_until=cur_time + 3600, ).build_xml(_bldr)) # add ova per license ova_per_lic = icswEggBasket.objects.get_values_per_license_name() for lic_id_name, values in ova_per_lic.items(): lic_id_name = lic_id_name or "global" for v_name, v_value in values.items(): my_vector.append( hm_classes.MachineVectorEntry( "icsw.ova.license.{}.{}".format(lic_id_name, v_name), info="Ova {} for license {}".format( v_name, lic_id_name), default=0, value=v_value, factor=1, base=1, valid_until=cur_time + 3600, ).build_xml(_bldr)) drop_com["vector_ova"] = my_vector drop_com["vector_ova"].attrib["type"] = "vector" def _update(self): cur_time = time.time() drop_com = server_command.srv_command(command="set_vector") mach_vectors = [] for cap_name in self.__cap_list: self.__server_cap_dict[cap_name](cur_time, drop_com, mach_vectors) self.add_ova_statistics(cur_time, drop_com) self.vector_socket.send_unicode(str(drop_com)) # print drop_com.pretty_print() for _mv in mach_vectors: try: self.collectd_socket.send_unicode(etree.tostring(_mv)) except: self.log( "unable to send machvector to collectd: {}".format( process_tools.get_except_info(), ), logging_tools.LOG_LEVEL_ERROR, )