def feed(self, *res_list):
self.waiting_for = None
self.running = False
error_list, _ok_list, res_dict = res_list[0:3]
if error_list:
self.log(
"error fetching SNMP data from {}".format(self.device_name),
logging_tools.LOG_LEVEL_ERROR)
else:
headers = {
"name": self.device_name,
"uuid": self.uuid,
"time": "{:d}".format(int(self.last_start))
}
mv_tree = E.machine_vector(simple="0", **headers)
mon_info = E.monitor_info(**headers)
for _handler in self.snmp_handlers:
try:
_handler.collect_feed(res_dict,
mv_tree=mv_tree,
mon_info=mon_info,
vc=self.__vcache)
except:
self.log(
"error feeding for handler {} (IP {}): {}".format(
str(_handler),
self.ip,
process_tools.get_except_info(),
), logging_tools.LOG_LEVEL_CRITICAL)
for _log_line in process_tools.icswExceptionInfo(
).log_lines:
self.log(_log_line, logging_tools.LOG_LEVEL_CRITICAL)
# graphing
self.bg_proc.process_data_xml(mv_tree,
len(etree.tostring(mv_tree)))
def init_build(self):
do_exit = True
try:
cur_img = self.check_build_lock()
if not cur_img.builds:
cur_img.builds = 0
cur_img.builds += 1
cur_img.save()
self.log("setting build number to {:d}".format(cur_img.builds))
self._check_dirs(cur_img)
self._check_packages(cur_img)
self._umount_dirs(cur_img)
if global_config["CHECK_SIZE"]:
self._check_size(cur_img)
else:
self.log("size checking disabled", logging_tools.LOG_LEVEL_WARN)
# get image from database (in case something has changed)
cur_img = self._get_image()
self.log("building image from {}".format(cur_img.source))
self._generate_dir_list(cur_img)
self._copy_image(cur_img)
if not global_config["SKIPCLEANUP"]:
self._clean_image(cur_img)
self._init_compress_image()
do_exit = False
except:
self._int_error("build failed: {}".format(process_tools.get_except_info()))
for line in process_tools.icswExceptionInfo().log_lines:
self.log(" {}".format(line), logging_tools.LOG_LEVEL_ERROR)
else:
if do_exit:
self._int_error("done")
def handle_nodeinfo(self, src_id, node_text):
s_time = time.time()
s_req = simple_request(self, src_id, node_text)
com_call = self.__com_dict.get(s_req.command, None)
if com_call:
ConfigControl.update_router()
try:
ret_str = com_call(s_req)
except:
exc_info = process_tools.icswExceptionInfo()
ret_str = "error interpreting command {}: {}".format(
node_text,
process_tools.get_except_info(),
)
for _line in exc_info.log_lines:
self.log(" {}".format(_line), logging_tools.LOG_LEVEL_ERROR)
else:
ret_str = "error unknown command '{}'".format(node_text)
if ret_str is None:
self.log("waiting for answer")
else:
e_time = time.time()
self.log("handled nodeinfo '%s' (src_ip %s) in %s, returning %s" % (
s_req.node_text,
s_req.src_ip,
logging_tools.get_diff_time_str(e_time - s_time),
ret_str))
ConfigControl.srv_process._send_simple_return(s_req.zmq_id, ret_str)
del s_req
def init_commands(self, server_proc: object, verbose: bool) -> bool:
_init_ok = True
for call_name, add_server_proc in MODULE_STATE_INIT_LIST:
for cur_mod in self.module_list:
if verbose:
self.log(
"calling {} for module '{}'".format(
call_name,
cur_mod.name,
)
)
try:
if add_server_proc:
getattr(cur_mod, call_name)(server_proc)
else:
getattr(cur_mod, call_name)()
except:
exc_info = process_tools.icswExceptionInfo()
for log_line in exc_info.log_lines:
self.log(log_line, logging_tools.LOG_LEVEL_CRITICAL)
_init_ok = False
break
else:
cur_mod.module_state[call_name] = True
if not _init_ok:
break
return _init_ok
def loop(self):
try:
while self["run_flag"]:
self.__disp.runDispatcher()
self.step(blocking=self["run_flag"])
except ValueConstraintError:
self.log("caught ValueConstraintError, terminating process",
logging_tools.LOG_LEVEL_CRITICAL)
_term_cause = "ValueConstraintError"
except:
exc_info = process_tools.icswExceptionInfo()
self.log("exception in dispatcher, terminating process",
logging_tools.LOG_LEVEL_CRITICAL)
for log_line in exc_info.log_lines:
self.log(" - {}".format(log_line),
logging_tools.LOG_LEVEL_CRITICAL)
_term_cause = "internal error"
else:
self.log("no more jobs running")
_term_cause = ""
self.log("jobs pending: {:d}".format(len(self.__job_dict)))
# close all jobs
if _term_cause:
self._terminate_jobs(error="{}, check logs".format(_term_cause))
else:
self._terminate_jobs()
self.__disp.closeDispatcher()
def _handle_module_command(self, srv_com):
try:
self.local_mc[srv_com["command"].text](srv_com)
except:
for log_line in process_tools.icswExceptionInfo().log_lines:
self.log(log_line, logging_tools.LOG_LEVEL_ERROR)
srv_com.set_result(
"caught server exception '{}'".format(process_tools.get_except_info()),
server_command.SRV_REPLY_STATE_CRITICAL,
)
def handle_result(self, mes_id, result):
cur_mes = self.messages[mes_id]
# default: nor reuse (detection not possible or not important)
_reuse = False
if self.zmq_id != DUMMY_0MQ_ID:
if "machine_uuid" in result:
mach_uuid, dyn_uuid = (
result["*machine_uuid"],
result["*dynamic_uuid"],
)
else:
mach_uuid, dyn_uuid = (
self.zmq_id,
""
)
# reuse detected ?
_reuse = HostConnection.zmq_discovery.update_mapping(
self.__conn_str,
self.zmq_id,
mach_uuid,
dyn_uuid
)
if cur_mes.sent:
# ???
cur_mes.sent = False
if len(result.xpath(".//ns:raw", smart_strings=False)):
# raw response, no interpret
cur_mes.srv_com = result
self.send_result(cur_mes, None)
# self.send_result(cur_mes, None)
else:
try:
if _reuse:
_map = HostConnection.zmq_discovery.get_mapping(self.__conn_str)
print(id(_map))
ret = ExtReturn(
limits.mon_STATE_CRITICAL,
"0MQ-ID reuse detected ({})".format(
_map.reuse_info,
)
)
# _map.clear_reuse()
else:
ret = ExtReturn.get_ext_return(cur_mes.interpret(result))
except:
ret = ExtReturn(
limits.mon_STATE_CRITICAL,
"error interpreting result: {}".format(
process_tools.get_except_info()
)
)
exc_info = process_tools.icswExceptionInfo()
for line in exc_info.log_lines:
HostConnection.relayer_process.log(line, logging_tools.LOG_LEVEL_CRITICAL)
self.send_result(cur_mes, ret)
def compound_struct(in_list):
try:
_comps = DataStore.compound_tree.append_compounds(in_list)
except:
for _line in process_tools.icswExceptionInfo().log_lines:
DataStore.g_log(_line, logging_tools.LOG_LEVEL_ERROR)
_comps = []
else:
# pprint.pprint(_comps)
pass
return _comps
def process(self):
try:
self.__ct_struct.process(self)
except:
exc_info = process_tools.icswExceptionInfo()
for _line in exc_info.log_lines:
self.log(_line, logging_tools.LOG_LEVEL_ERROR)
self.srv_com.set_result(
"error in process() call: {}".format(
process_tools.get_except_info()),
server_command.SRV_REPLY_STATE_CRITICAL)
def check_rrd_file(self, f_name):
_changed = False
s_time = time.time()
try:
_old_size = os.stat(f_name)[stat.ST_SIZE]
except:
self.log(
"cannot get size of {}: {}".format(
f_name, process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
else:
if _old_size:
try:
_rrd = rrd_tools.RRD(f_name,
log_com=self.log,
build_rras=False,
verbose=self.__verbose)
except:
# check if file is not an rrd file
_content = open(f_name, "rb").read()
if f_name.endswith(".rrd") and _content[:3] != b"RRD":
self.log(
"file {} has no RRD header, trying to remove it".
format(f_name), logging_tools.LOG_LEVEL_ERROR)
try:
os.unlink(f_name)
except:
pass
else:
self.log(
"cannot get info about {}: {}".format(
f_name, process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
for _line in process_tools.icswExceptionInfo(
).log_lines:
self.log(_line, logging_tools.LOG_LEVEL_ERROR)
else:
_changed = self.check_rrd_file_2(f_name, _rrd)
if _changed:
_new_size = os.stat(f_name)[stat.ST_SIZE]
e_time = time.time()
self.log("modification of {} took {} ({} -> {} Bytes)".
format(
f_name,
logging_tools.get_diff_time_str(e_time -
s_time),
_old_size,
_new_size,
))
else:
self.log("file {} is empty".format(f_name),
logging_tools.LOG_LEVEL_WARN)
return _changed
def close_modules(self):
for cur_mod in self.module_list:
if hasattr(cur_mod, "stop_module"):
self.log("calling stop_module() for {}".format(cur_mod.name))
try:
cur_mod.stop_module()
except:
exc_info = process_tools.icswExceptionInfo()
for log_line in exc_info.log_lines:
self.log(log_line, logging_tools.LOG_LEVEL_CRITICAL)
if cur_mod.module_state["init_module"]:
cur_mod.close_module()
def feed_result(self, id_str, srv_reply):
if id_str in self.__pending_messages:
dc_action = self.__pending_messages[id_str]
dc_action.end_time = time.time()
run_str = logging_tools.get_diff_time_str(dc_action.end_time -
dc_action.start_time)
# print("----", id_str, id(dc_action), dc_action.special_instance.Meta.name)
try:
_str, _state = srv_reply.get_log_tuple()
dc_action.log("feed_result() got {}".format(_str), _state)
DeviceLogEntry.new(
device=dc_action.hbc.device,
source=global_config["LOG_SOURCE_IDX"],
level=_state,
text="result was '{}' after {}".format(
_str,
run_str,
),
)
# print("*")
# print(srv_reply.get_result())
for _action in dc_action.special_instance.feed_result(
dc_action, srv_reply):
# print("g", _action)
if _action:
self.call(
_action.salt(dc_action.hbc,
dc_action.special_instance))
except:
_info = process_tools.get_except_info()
DeviceLogEntry.new(
device=dc_action.hbc.device,
source=global_config["LOG_SOURCE_IDX"],
level=logging_tools.LOG_LEVEL_CRITICAL,
text="an error occured in feed_result: {} (after {})".
format(
_info,
run_str,
),
)
exc_info = process_tools.icswExceptionInfo()
self.log(
"an error occured (device={}): {}".format(
str(dc_action.hbc.device),
_info,
), logging_tools.LOG_LEVEL_ERROR)
for line in exc_info.log_lines:
self.log(" - {}".format(line),
logging_tools.LOG_LEVEL_ERROR)
del self.__pending_messages[id_str]
else:
self.log("Got unknown id_str {}".format(id_str))
def dispatch_call(self):
_now = timezone.now().replace(microsecond=0)
for asset_batch in AssetBatch.objects.filter(run_status__in=[
BatchStatus.PLANNED, BatchStatus.RUNNING,
BatchStatus.FINISHED_RUNS, BatchStatus.GENERATING_ASSETS
]):
if asset_batch.run_start_time:
diff_time = (_now - asset_batch.run_start_time).total_seconds()
if diff_time > 86400:
self.log(
"Closing pending/processing AssetBatch [now={}, run_start_time={}, diff_time={}]"
.format(_now, asset_batch.run_start_time,
diff_time), logging_tools.LOG_LEVEL_ERROR)
asset_batch.run_end_time = _now
asset_batch.run_status = BatchStatus.FINISHED
asset_batch.save()
for schedule_item in ScheduleItem.objects.all():
if schedule_item.run_now or schedule_item.planned_date < _now:
schedule_handler_function = getattr(
self, schedule_item.schedule_handler)
try:
schedule_handler_function(schedule_item)
except Exception as e:
_ = e
_exc = process_tools.icswExceptionInfo()
self.log(
"error in schedule_handler: {}".format(
schedule_item.schedule_handler),
logging_tools.LOG_LEVEL_ERROR)
for line in _exc.log_lines:
self.log(line, logging_tools.LOG_LEVEL_ERROR)
schedule_item.delete()
# timeout handling
_now = timezone.now()
for run_index, host_monitoring_command in list(
HostMonitoringCommand.host_monitoring_commands.items()):
if _now > host_monitoring_command.timeout_date:
self.log(
"HostMonitoring command [run_index:{} | command:{}] timed out"
.format(host_monitoring_command.run_index,
host_monitoring_command.command_string))
host_monitoring_command.handle()
self.discovery_process.send_pool_message(
"host_monitoring_command_timeout_handler", run_index)
def _handle_module_command(self, srv_com, cur_ns, rest_str):
cur_com = self.local_mc[srv_com["command"].text]
sp_struct = None
try:
if cur_ns is None:
cur_ns, _rest = cur_com.handle_commandline(
rest_str.strip().split())
sp_struct = cur_com(srv_com, cur_ns)
except:
exc_info = process_tools.icswExceptionInfo()
for log_line in exc_info.log_lines:
self.log(log_line, logging_tools.LOG_LEVEL_ERROR)
srv_com.set_result(
"caught server exception '{}'".format(
process_tools.get_except_info()),
server_command.SRV_REPLY_STATE_CRITICAL)
return sp_struct
def get_partition(self, *args):
part_name = args[0]
loc_tree = GeneratedTree()
loc_dev = device.objects.get(Q(pk=self.pk))
self.log("set act_partition_table and partdev to %s" % (part_name))
loc_dev.act_partition_table = loc_dev.partition_table
loc_dev.partdev = part_name
loc_dev.save()
success = False
dummy_cont = BuildContainer(self, {}, {"device": loc_dev}, loc_tree,
None)
try:
loc_ps = icswPartitionSetup(dummy_cont, self.log)
except:
self.log(
"cannot generate partition info: {}".format(
process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
for _line in process_tools.icswExceptionInfo().log_lines:
self.log(" {}".format(_line), logging_tools.LOG_LEVEL_ERROR)
else:
base_dir = os.path.join(global_config["CONFIG_DIR"], loc_dev.name)
pinfo_dir = os.path.join(base_dir, "pinfo")
if not os.path.isdir(pinfo_dir):
try:
os.mkdir(pinfo_dir)
except OSError:
self.log(
"cannot create pinfo_directory %s: %s" %
(pinfo_dir, process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
else:
self.log("created pinfo directory %s" % (pinfo_dir))
if os.path.isdir(pinfo_dir):
for file_name in os.listdir(pinfo_dir):
try:
os.unlink("%s/%s" % (pinfo_dir, file_name))
except:
self.log(
"error removing %s in %s: %s" %
(file_name, pinfo_dir,
process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
loc_ps.create_part_files(pinfo_dir)
success = True
return success
def handle(self, srv_com):
try:
p_args = self.parse(srv_com)
self.run(srv_com, p_args)
except DeviceNotFoundException:
srv_com.set_result(
"device not found",
server_command.SRV_REPLY_STATE_CRITICAL,
)
except:
exc_com = process_tools.icswExceptionInfo()
for _line in exc_com.log_lines:
self.log(_line, logging_tools.LOG_LEVEL_ERROR)
srv_com.set_result(
"an exception occured: {}".format(
process_tools.get_except_info()),
server_command.SRV_REPLY_STATE_CRITICAL,
)
def read(self):
_all_files = [
cur_entry for cur_entry in [
entry.split(".")[0] for entry in os.listdir(
self.__root_dir
) if entry.endswith(".py")
] if cur_entry and not cur_entry.startswith("_")
]
self.log(
"{} found: {}".format(
logging_tools.get_plural("file", len(_all_files)),
", ".join(sorted(_all_files)),
)
)
import_errors = []
_mod_list = []
for mod_name in _all_files:
try:
new_mod = importlib.import_module(
"{}.{}".format(
self.__parent_module_name,
mod_name
)
)
if hasattr(new_mod, "ModuleDefinition"):
_mod_list.append(new_mod)
else:
self.log(
"module {} is missing the 'ModuleDefinition' object".format(
mod_name
),
logging_tools.LOG_LEVEL_WARN
)
except:
exc_info = process_tools.icswExceptionInfo()
for log_line in exc_info.log_lines:
import_errors.append((mod_name, "import", log_line))
# list of modules
self.__pure_module_list = _mod_list
self.reload_module_checksum()
self._log_import_errors(import_errors)
def update(self, dev, scheme, result_dict, oid_list, flags):
# update dev with results from given snmp_scheme
# valid oid_list is oid_list
# results are in result_dict
_handler = self.get_handler(scheme)
if _handler:
try:
return _handler.update(dev, scheme, result_dict, oid_list,
flags)
except:
exc_info = process_tools.icswExceptionInfo()
_err_str = "unable to process results: {}".format(
process_tools.get_except_info())
self.log(_err_str, logging_tools.LOG_LEVEL_ERROR)
for _line in exc_info.log_lines:
self.log(" {}".format(_line),
logging_tools.LOG_LEVEL_ERROR)
return ResultNode(error=_err_str)
else:
return ResultNode(error="no handler found for {}".format(
scheme.full_name_version))
def periodic_update(self):
"""Recalculate all kpis and save result to database"""
enabled_kpis = Kpi.objects.filter(enabled=True)
if License.objects.has_valid_license(LicenseEnum.kpi) and enabled_kpis.exists():
KpiGlobals.set_context()
try:
kpi_data = KpiData(self.log, global_config)
except Exception as e:
_exc = process_tools.icswExceptionInfo()
self.log(
"Exception when gathering kpi data: {}".format(process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR,
)
for _line in _exc.log_lines:
self.log(" {}".format(_line), logging_tools.LOG_LEVEL_ERROR)
else:
# recalculate kpis
for kpi_db in enabled_kpis:
self._update_single_kpi_result(kpi_data, kpi_db)
"""
def _check_for_pending_jobs(self):
for c_name, _dev, scan_type_enum, _new_lock, _dev_xml in self.__job_list:
# todo: make calls parallel
s_time = time.time()
try:
getattr(self, c_name)(_dev_xml, _dev)
except:
_exc_info = process_tools.icswExceptionInfo()
for _line in _exc_info.log_lines:
self.log(" {}".format(_line),
logging_tools.LOG_LEVEL_ERROR)
finally:
[
self.log(_what, _level)
for _what, _level in _new_lock.close()
]
e_time = time.time()
self.log("calling {} for device {} took {}".format(
c_name, str(_dev),
logging_tools.get_diff_time_str(e_time - s_time)))
self.__job_list = []
def __call__(self, *args, **kwargs):
s_time = time.time()
display_name = getattr(args[0], "display_name", None)
# get: head.im_class.__name__ (contains class name for django class views)
view_class_name = getattr(getattr(getattr(args[0], 'head', None), 'im_class', None), '__name__', None)
if hasattr(args[0], "model") and args[0].model is not None:
self.__obj_name = args[0].model._meta.object_name
elif display_name is not None:
self.__obj_name = display_name
elif view_class_name is not None:
self.__obj_name = view_class_name
else:
self.__obj_name = "unknown"
try:
result = self._func(*args, **kwargs)
except:
exc_info = process_tools.icswExceptionInfo()
_err_str = process_tools.get_except_info()
self.log(
"exception: {}".format(_err_str),
logging_tools.LOG_LEVEL_ERROR
)
for line in exc_info.log_lines:
self.log(" {}".format(line))
result = Response(_err_str, status=status.HTTP_406_NOT_ACCEPTABLE)
# raise
e_time = time.time()
self.log(
"call took {}".format(
logging_tools.get_diff_time_str(e_time - s_time)
)
)
return result
def _fw_handle(self, *args, **kwargs):
src_id, data = args
srv_com = server_command.srv_command(source=data)
in_com = srv_com["command"].text
args = {}
if "arguments" in srv_com:
for entry in srv_com["arguments"]:
_key = entry.tag.split("}")[-1]
_val = entry.text
if _val is None:
self.log("key {} has empty value ({})".format(_key, in_com), logging_tools.LOG_LEVEL_ERROR)
else:
if _val.lower() in ["true", "false"]:
_val = bool(_val)
elif _val.isdigit():
_val = int(_val)
# if
args[_key] = _val
self.log(
"got '{}', {}: {}".format(
in_com,
logging_tools.get_plural("argument", len(args)),
", ".join(
[
"{}='{}' ({})".format(
key,
value,
type(value)
) for key, value in args.items()
]
)
)
)
args = {key.replace("-", "_"): value for key, value in args.items()}
found_keys = set(args.keys())
needed_keys = {
"register_file_watch": {
"send_id", "mode", "target_server", "target_port", "dir", "match"
},
"unregister_file_watch": {
"id",
},
}.get(in_com, set())
if needed_keys & found_keys == needed_keys:
# set default return value
srv_com.set_result(
"got command {}".format(in_com)
)
try:
getattr(self, "_{}".format(in_com))(srv_com, args)
except:
exc_info = process_tools.icswExceptionInfo()
for line in exc_info.log_lines:
self.log(" {}".format(line), logging_tools.LOG_LEVEL_ERROR)
srv_com.set_result(
"error processing '{}': {}".format(in_com, exc_info.except_info),
server_command.SRV_REPLY_STATE_CRITICAL
)
log_str, log_level = srv_com.get_log_tuple()
self.log("result: {}".format(log_str), log_level)
else:
srv_com.set_result(
"command {}, keys missing: {}".format(in_com, ", ".join(needed_keys - found_keys)),
server_command.SRV_REPLY_STATE_ERROR
)
self.send_pool_message("callback_result", src_id, str(srv_com))
def _get_node_status(self, srv_com_str, **kwargs):
def _salt_line(line, key, in_dict):
line["_comments"] = in_dict.get(line[key], [])
return line
srv_com = server_command.srv_command(source=srv_com_str)
# overview mode if overview is a top-level element
_host_overview = True if "host_overview" in srv_com else False
_service_overview = True if "service_overview" in srv_com else False
if not _host_overview:
# ToDo, FIXME: receive full names in srv_command
dev_names = srv_com.xpath(".//device_list/device/@full_name",
smart_strings=False)
# dev_names = sorted([cur_dev.full_name for cur_dev in device.objects.filter(Q(pk__in=pk_list))])
try:
cur_sock = self._open()
if cur_sock:
fetch_dict = LivstatusFetch(self.log, cur_sock)
if _host_overview:
fetch_dict["host"] = cur_sock.hosts.columns(
"name",
"address",
"state",
"plugin_output",
"custom_variables",
)
if _service_overview:
fetch_dict["service"] = cur_sock.services.columns(
"description",
"state",
"plugin_output",
"custom_variables",
)
else:
if dev_names:
fetch_dict["service"] = cur_sock.services.columns(
"host_name",
"description",
"state",
"plugin_output",
"last_check",
"check_type",
"state_type",
"last_state_change",
"max_check_attempts",
"display_name",
"current_attempt",
"custom_variables",
"acknowledged",
"acknowledgement_type",
"active_checks_enabled",
).filter("host_name", "=", dev_names)
fetch_dict["host"] = cur_sock.hosts.columns(
"name",
"address",
"state",
"plugin_output",
"last_check",
"check_type",
"state_type",
"last_state_change",
"max_check_attempts",
"current_attempt",
"custom_variables",
"acknowledged",
"acknowledgement_type",
"active_checks_enabled",
).filter("name", "=", dev_names)
fetch_dict["host_comment"] = cur_sock.comments.columns(
"host_name",
"author",
"comment",
"entry_type",
"entry_time",
).filter("host_name", "=", dev_names).filter(
"is_service",
"=",
"0",
method="and",
count=2,
)
fetch_dict[
"service_comment"] = cur_sock.comments.columns(
"host_name",
"service_description",
"author",
"comment",
"entry_type",
"entry_time",
).filter("host_name", "=", dev_names).filter(
"is_service",
"=",
"1",
method="and",
count=2,
)
# print str(fetch_dict["service_comment"])
fetch_dict.fetch()
_host_comments = {}
for entry in fetch_dict["host_comment_result"]:
_host_comments.setdefault(entry["host_name"],
[]).append(entry)
_service_comments = {}
for entry in fetch_dict["service_comment_result"]:
_service_comments.setdefault(entry["service_description"],
[]).append(entry)
# import pprint
# pprint.pprint(_host_comments)
# pprint.pprint(_service_comments)
srv_com["service_result"] = json.dumps([
_salt_line(_line, "description", _service_comments)
for _line in fetch_dict["service_result"]
if _line.get("host_name", "")
])
# import pprint
# pprint.pprint(fetch_dict["host_result"])
srv_com["host_result"] = json.dumps([
_salt_line(_line, "name", _host_comments)
for _line in fetch_dict["host_result"]
])
srv_com.set_result(fetch_dict.info_str)
# print(srv_com.pretty_print())
else:
srv_com.set_result("cannot connect to socket",
server_command.SRV_REPLY_STATE_CRITICAL)
except:
self.log(
"fetch exception: {}".format(process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
exc_info = process_tools.icswExceptionInfo()
for line in exc_info.log_lines:
self.log(" - {}".format(line), logging_tools.LOG_LEVEL_ERROR)
self._close()
srv_com.set_result(
"exception during fetch: {}".format(
process_tools.get_except_info()),
server_command.SRV_REPLY_STATE_CRITICAL)
self.send_pool_message("remote_call_async_result", str(srv_com))
def graph(self, dev_pks, graph_keys):
# end time with forecast
local_ds = DataSource(self.log_com, dev_pks, graph_keys,
self.colorizer)
self.para_dict["end_time_fc"] = self.para_dict["end_time"]
if self.para_dict["graph_setting"].graph_setting_forecast:
_fc = self.para_dict["graph_setting"].graph_setting_forecast
if _fc.seconds:
# add seconds
self.para_dict["end_time_fc"] += datetime.timedelta(
seconds=_fc.seconds)
else:
# add timeframe
self.para_dict["end_time_fc"] += self.para_dict[
"end_time"] - self.para_dict["start_time"]
timeframe = abs((self.para_dict["end_time_fc"] -
self.para_dict["start_time"]).total_seconds())
graph_width, graph_height = (
self.para_dict["graph_setting"].graph_setting_size.width,
self.para_dict["graph_setting"].graph_setting_size.height,
)
self.log("width / height : {:d} x {:d}, timeframe {}".format(
graph_width,
graph_height,
logging_tools.get_diff_time_str(timeframe),
))
# store for DEF generation
self.width = graph_width
self.height = graph_height
dev_dict = {
cur_dev.pk: str(cur_dev.display_name)
for cur_dev in device.objects.filter(Q(pk__in=dev_pks))
}
s_graph_key_dict = self._create_graph_keys(graph_keys)
self.log("found {}: {}".format(
logging_tools.get_plural("device", len(dev_pks)), ", ".join([
"{:d} ({})".format(pk, dev_dict.get(pk, "unknown"))
for pk in dev_pks
])))
if self.para_dict["graph_setting"].merge_graphs:
# reorder all graph_keys into one graph_key_dict
s_graph_key_dict = {
"all": sum(list(s_graph_key_dict.values()), [])
}
self.log("{}: {}".format(
logging_tools.get_plural("graph key", len(graph_keys)),
", ".join([full_graph_key(_v) for _v in graph_keys])))
self.log("{}: {}".format(
logging_tools.get_plural("top level key", len(s_graph_key_dict)),
", ".join(sorted(s_graph_key_dict)),
))
enumerated_dev_pks = [("{:d}.{:d}".format(_idx, _pk), _pk)
for _idx, _pk in enumerate(dev_pks)]
if self.para_dict["graph_setting"].merge_devices:
# one device per graph
graph_key_list = [[GraphTarget(g_key, enumerated_dev_pks, v_list)]
for g_key, v_list in s_graph_key_dict.items()]
else:
graph_key_list = []
for g_key, v_list in sorted(s_graph_key_dict.items()):
graph_key_list.append([
GraphTarget(g_key, [(dev_id, dev_pk)], v_list)
for dev_id, dev_pk in enumerated_dev_pks
])
if self.para_dict["graph_setting"].merge_graphs:
# set header
[_gt.set_header("all") for _gt in sum(graph_key_list, [])]
_num_g = sum([len(_graph_line) for _graph_line in graph_key_list])
if self.para_dict["ordering"]:
ORDER_MODE = self.para_dict["ordering"].upper()
if ORDER_MODE.startswith("-"):
_order_reverse = True
ORDER_MODE = ORDER_MODE[1:]
else:
_order_reverse = False
else:
ORDER_MODE = "none"
self.log("number of graphs to create: {:d}, ORDER_MODE is '{}'".format(
_num_g, ORDER_MODE))
graph_list = E.graph_list()
for _graph_line in graph_key_list:
graph_list.extend([
_graph_target.graph_xml(dev_dict)
for _graph_target in _graph_line
])
self.early_return_call(graph_list)
# print(etree.tostring(graph_list, pretty_print=True))
graph_list = E.graph_list()
_job_add_dict = self._get_jobs(dev_dict)
for _graph_line in graph_key_list:
self.log("starting graph_line")
# iterate in case scale_mode is not None
_iterate_line, _line_iteration = (True, 0)
while _iterate_line:
for _graph_target in _graph_line:
_graph_target.abs_file_loc = str(
os.path.join(self.para_dict["graph_root"],
_graph_target.graph_name))
# clear list of defs, reset result
_graph_target.reset()
# reset colorizer for current graph
self.colorizer.reset()
self.abs_start_time = int((self.para_dict["start_time"] -
self.dt_1970).total_seconds())
self.abs_end_time = int((self.para_dict["end_time_fc"] -
self.dt_1970).total_seconds())
rrd_pre_args = [
_graph_target.abs_file_loc,
"-E", # slope mode
"-Rlight", # font render mode, slight hint
"-Gnormal", # render mode
"-P", # use pango markup
# "-nDEFAULT:8:",
"-w {:d}".format(graph_width),
"-h {:d}".format(graph_height),
"-aPNG", # image format
# "--daemon", "unix:{}".format(global_config["RRD_CACHED_SOCKET"]), # rrd caching daemon address
"-W {} by init.at".format(
License.objects.get_init_product().name), # title
"--slope-mode", # slope mode
"-cBACK#ffffff",
"--end",
"{:d}".format(self.abs_end_time), # end
"--start",
"{:d}".format(self.abs_start_time), # start
GraphVar(self, _graph_target, None, None,
"").header_line,
]
# outer loop: iterate over all keys for the graph
for graph_key in sorted(_graph_target.graph_keys):
# inner loop: iterate over all dev ids for the graph
for _cur_id, cur_pk in _graph_target.dev_list:
# print "***", _cur_id, cur_pk
if (cur_pk, graph_key) in local_ds:
# resolve
for _mvs, _mvv in local_ds[(cur_pk,
graph_key)]:
_take = True
try:
if os.stat(_mvs.file_name)[
stat.ST_SIZE] < 100:
self.log(
"skipping {} (file is too small)"
.format(_mvs.file_name, ),
logging_tools.LOG_LEVEL_ERROR)
_take = False
except:
self.log(
"RRD file {} not accessible: {}".
format(
_mvs.file_name,
process_tools.get_except_info(
),
), logging_tools.LOG_LEVEL_ERROR)
_take = False
if _take and _line_iteration == 0:
# add GraphVars only on the first iteration
# print "**", graph_key, _mvs.key, _mvv.key
# store def
_graph_target.add_def(
(_mvs.key, _mvv.key),
GraphVar(self, _graph_target, _mvs,
_mvv, graph_key,
dev_dict[cur_pk]),
"header_str",
)
if _graph_target.draw_keys:
draw_it = True
removed_keys = set()
while draw_it:
if self.para_dict[
"graph_setting"].graph_setting_timeshift:
timeshift = self.para_dict[
"graph_setting"].graph_setting_timeshift.seconds
if timeshift == 0:
timeshift = self.abs_end_time - self.abs_start_time
else:
timeshift = 0
rrd_args = rrd_pre_args + sum([
_graph_target.graph_var_def(
_key,
timeshift=timeshift,
) for _key in _graph_target.draw_keys
], [])
rrd_args.extend(_graph_target.rrd_post_args)
rrd_args.extend([
"--title", "{} on {} (tf: {}{})".format(
_graph_target.header,
dev_dict.get(_graph_target.dev_list[0][1],
"unknown")
if len(_graph_target.dev_list) == 1 else
logging_tools.get_plural(
"device", len(_graph_target.dev_list)),
logging_tools.get_diff_time_str(timeframe),
", with forecast"
if self.para_dict["end_time"] !=
self.para_dict["end_time_fc"] else "",
)
])
rrd_args.extend(
self._create_job_args(_graph_target.dev_list,
_job_add_dict))
self.proc.flush_rrdcached(_graph_target.file_names)
try:
draw_result = rrdtool.graphv(
*[str(_val) for _val in rrd_args])
except:
# in case of strange 'argument 0 has to be a string or a list of strings'
self.log(
"error creating graph: {}".format(
process_tools.get_except_info()),
logging_tools.LOG_LEVEL_ERROR)
for _line in process_tools.icswExceptionInfo(
).log_lines:
self.log(" {}".format(_line),
logging_tools.LOG_LEVEL_ERROR)
if global_config["DEBUG"]:
for _idx, _entry in enumerate(rrd_args, 1):
self.log(" {:4d} {}".format(
_idx, _entry))
draw_result = None
draw_it = False
else:
# compare draw results, add -l / -u when scale_mode is not None
val_dict = {}
# new code
for key, value in draw_result.items():
if not key.startswith("print["):
continue
_xml = etree.fromstring(value)
_unique_id = int(_xml.get("unique_id"))
# print etree.tostring(_xml, pretty_print=True)
try:
value = float(_xml.text)
except:
value = None
else:
pass # value = None if value == 0.0 else value
_s_key, _v_key = (_xml.get("mvs_key"),
_xml.get("mvv_key"))
if value is not None:
_key = (_unique_id, (_s_key, _v_key))
val_dict.setdefault(
_key,
{})[_xml.get("cf")] = (value, _xml)
# list of empty (all none or 0.0 values) keys
_zero_keys = [
key for key, value in val_dict.items()
if all([
_v[0] in [0.0, None]
or math.isnan(_v[0])
for _k, _v in value.items()
])
]
if _zero_keys and self.para_dict[
"graph_setting"].hide_empty:
# remove all-zero structs
val_dict = {
key: value
for key, value in val_dict.items()
if key not in _zero_keys
}
for key, value in val_dict.items():
_graph_target.feed_draw_result(key, value)
# check if the graphs shall always include y=0
draw_it = False
if self.para_dict[
"graph_setting"].include_zero:
if "value_min" in draw_result and "value_max" in draw_result:
if draw_result["value_min"] > 0.0:
_graph_target.set_post_arg(
"-l", "0")
draw_it = True
if draw_result["value_max"] < 0.0:
_graph_target.set_post_arg(
"-u", "0")
draw_it = True
# check for empty graphs
empty_keys = set(
_graph_target.draw_keys) - set(
val_dict.keys())
if empty_keys and self.para_dict[
"graph_setting"].hide_empty:
self.log("{}: {}".format(
logging_tools.get_plural(
"empty key", len(empty_keys)),
", ".join(
sorted([
"{} (dev {:d})".format(
_key, _pk)
for _pk, _key in empty_keys
])),
))
removed_keys |= empty_keys
_graph_target.remove_keys(empty_keys)
# draw_keys = [_key for _key in draw_keys if _key not in empty_keys]
if not _graph_target.draw_keys:
draw_result = None
else:
draw_it = True
_graph_target.draw_result = draw_result
_graph_target.removed_keys = removed_keys
else:
self.log(
"no DEFs for graph_key_dict {}".format(
_graph_target.graph_key),
logging_tools.LOG_LEVEL_ERROR)
# check if we should rerun the graphing process
_iterate_line = False
_valid_graphs = [
_entry for _entry in _graph_line if _entry.valid
]
if _line_iteration == 0:
_iterate_scale = self.para_dict[
"graph_setting"].scale_mode in [
GraphScaleModeEnum.level.value,
GraphScaleModeEnum.to100
] and (len(_valid_graphs) > 1
or self.para_dict["graph_setting"].scale_mode
== GraphScaleModeEnum.to100)
_iterate_order = True if self.para_dict[
"ordering"] else False
if _iterate_order or _iterate_scale:
_line_iteration += 1
if _iterate_scale:
if self.para_dict[
"graph_setting"].scale_mode == GraphScaleModeEnum.level:
_vmin_v, _vmax_v = (
[
_entry.draw_result["value_min"]
for _entry in _valid_graphs
],
[
_entry.draw_result["value_max"]
for _entry in _valid_graphs
],
)
if set(_vmin_v) > 1 or set(_vmax_v) > 1:
_vmin, _vmax = (
FLOAT_FMT.format(min(_vmin_v)),
FLOAT_FMT.format(max(_vmax_v)),
)
self.log(
"setting y_min / y_max for {} to {} / {}"
.format(
_valid_graphs[0].graph_key,
_vmin,
_vmax,
))
[
_entry.set_y_mm(_vmin, _vmax)
for _entry in _valid_graphs
]
_iterate_line = True
else:
[
_entry.adjust_max_y(100)
for _entry in _valid_graphs
]
self.log("set max y_val to 100 for all graphs")
_iterate_line = True
if _iterate_order:
_order_any = False
for _graph in _valid_graphs:
if len(_graph.draw_keys):
_draw_res = _graph.get_draw_result(
only_valid=True)
new_draw_keys = sorted(
_graph.draw_keys,
key=lambda entry: _draw_res[entry][
ORDER_MODE][0],
reverse=_order_reverse)
if _graph.draw_keys != new_draw_keys:
_graph.draw_keys = new_draw_keys
_order_any = True
if _order_any:
_line_iteration += 1
_iterate_line = True
if not _iterate_line:
# graph list is no longer needed because we transfer the results via WebSocket(s)
# to the requiring frontend
graph_list.extend([
_graph_target.graph_xml(dev_dict)
for _graph_target in _graph_line
])
propagate_channel_object(
WSStreamEnum.rrd_graph, {
"list": [
_graph_target.graph_json(dev_dict)
for _graph_target in _graph_line
]
})
# print(etree.tostring(graph_list, pretty_print=True))
return graph_list
def _update(self, key, from_reply=False):
cur_time = time.time()
# print cur_time
# pprint.pprint(self.__work_dict)
if key in self and key not in self.__handled:
value = self[key]
if value["sent"] < value["num"]:
# send if last send was at least slide_time ago
if value["next_send"] <= cur_time: # or value["recv_ok"] == value["sent"]:
# print key, value["recv_ok"], value["sent"], value["next_send"] <= cur_time
value["sent"] += 1
try:
self.send_echo(value["host"])
except:
value["error_list"].append(process_tools.get_except_info())
for l in process_tools.icswExceptionInfo().log_lines:
print("l", l)
self.log(
"error sending to {}: {}".format(
value["host"],
", ".join(value["error_list"])
),
logging_tools.LOG_LEVEL_ERROR
)
else:
value["sent_list"][self.echo_seqno] = time.time()
value["next_send"] = cur_time + value["slide_time"]
self.__seqno_dict[self.echo_seqno] = key
if value["sent"] < value["num"]:
self.__process.register_timer(
self._update,
value["slide_time"] + 0.001,
oneshot=True,
data=key
)
if value["sent"] == 1:
# register final timeout
# print "reg_to", key, value["timeout"]
self.__process.register_timer(
self._update,
value["timeout"],
oneshot=True,
data=key
)
# check for timeout
# print value["sent_list"]
if not from_reply:
# only check timeouts when called from reactor via callLater
for seq_to in [
s_key for s_key, _s_value in value[
"sent_list"
].items() if cur_time >= value["end"] and s_key not in value["recv_list"]
]:
value["recv_fail"] += 1
value["recv_list"][seq_to] = None
# check for ping finish
if value["error_list"] or (
value["sent"] == value["num"] and value["recv_ok"] + value["recv_fail"] == value["num"] or abs(cur_time - value["start"]) > value["timeout"]
):
all_times = [
value["recv_list"][s_key] - value["sent_list"][s_key] for s_key in
value["sent_list"].keys() if value["recv_list"].get(s_key, None) is not None
]
if key in self.__group_dict:
t_seq_str = self.__group_dict[key]
self.__group_dict[t_seq_str][key] = (
value["host"],
value["sent"],
value["recv_ok"],
all_times,
", ".join(value["error_list"])
)
if len(
[
t_key for t_key, value in self.__group_dict[
t_seq_str
].items() if value is None
]
) == 0:
# group done
self.__process.send_ping_result(
t_seq_str,
list(self.__group_dict[t_seq_str].values())
)
del self.__group_dict[t_seq_str]
del self.__group_dict[key]
else:
self.__process.send_ping_result(
key,
value["sent"],
value["recv_ok"],
all_times,
", ".join(value["error_list"])
)
self.__handled.add(key) # del self[key]
self.__pings_in_flight -= 1
else:
if from_reply:
# should only happen for delayed pings or pings with error
self.log(
"got delayed ping reply ({})".format(
key
),
logging_tools.LOG_LEVEL_WARN
)
def _graph_rrd(self, *args, **kwargs):
srv_com = server_command.srv_command(source=args[0])
orig_dev_pks = srv_com.xpath(".//device_list/device/@pk",
smart_strings=False)
orig_dev_pks = device.objects.filter(
Q(pk__in=orig_dev_pks) & Q(machinevector__pk__gt=0)).values_list(
"pk", flat=True)
dev_pks = [
dev_pk for dev_pk in orig_dev_pks
if self.EC.consume("graph", dev_pk)
]
if len(orig_dev_pks) != len(dev_pks):
self.log(
"Access to device rrds denied due to ova limits: {}".format(
set(orig_dev_pks).difference(dev_pks)),
logging_tools.LOG_LEVEL_ERROR,
)
graph_keys = json.loads(srv_com["*graph_key_list"])
para_dict = {
para.tag: para.text
for para in srv_com.xpath(".//parameters", smart_strings=False)[0]
}
for key in ["start_time", "end_time"]:
# cast to datetime
para_dict[key] = dateutil.parser.parse(para_dict[key])
_raw = json.loads(para_dict["graph_setting"])
# fake name
_raw["name"] = uuid.uuid4().urn
_setting = GraphSettingSerializerCustom(data=_raw)
self._early_return_sent = False
def early_return_call(xml_el):
if not self._early_return_sent:
srv_com["graphs"] = xml_el
self._early_return_sent = True
srv_com.set_result(
"generated {}".format(
logging_tools.get_plural("graph", len(xml_el))),
server_command.SRV_REPLY_STATE_OK)
self.send_pool_message("remote_call_async_result",
str(srv_com))
else:
self.log("return already sent", logging_tools.LOG_LEVEL_ERROR)
if _setting.is_valid():
para_dict["graph_setting"] = _setting.save()
for key, _default in [
("debug_mode", "0"),
]:
para_dict[key] = True if int(para_dict.get(key,
"0")) else False
self._open_rrdcached_socket()
try:
graph_list = RRDGraph(
self.graph_root_debug if para_dict.get(
"debug_mode", False) else self.graph_root,
self.log,
self.colorizer,
para_dict,
self,
early_return_call,
).graph(dev_pks, graph_keys)
except:
for _line in process_tools.icswExceptionInfo().log_lines:
self.log(_line, logging_tools.LOG_LEVEL_ERROR)
srv_com["graphs"] = []
srv_com.set_result(
"error generating graphs: {}".format(
process_tools.get_except_info()),
server_command.SRV_REPLY_STATE_CRITICAL)
else:
if not self._early_return_sent:
early_return_call(graph_list)
# srv_com["graphs"] = graph_list
# srv_com.set_result(
# "generated {}".format(logging_tools.get_plural("graph", len(graph_list))),
# server_command.SRV_REPLY_STATE_OK
# )
else:
srv_com["graphs"] = []
srv_com.set_result(
"graphsettings are not valid: {}".format(str(_setting.errors)),
server_command.SRV_REPLY_STATE_CRITICAL)
self._close_rrdcached_socket()
if not self._early_return_sent:
self.send_pool_message("remote_call_async_result", str(srv_com))
def __call__(self):
if self.Meta.background:
if self.Meta.cur_running < self.Meta.max_instances:
self.Meta.cur_running += 1
icswCSComInstance.bg_idx += 1
new_bg_name = "bg_{}_{:d}".format(self.sc_obj.name,
icswCSComInstance.bg_idx)
self.sc_obj.main_proc.add_process(
BackgroundProcess(new_bg_name), start=True)
self.sc_obj.main_proc.send_to_process(new_bg_name,
"set_option_dict",
self.option_dict)
self.sc_obj.main_proc.send_to_process(
new_bg_name,
"set_srv_com",
str(self.srv_com),
)
self.sc_obj.main_proc.send_to_process(
new_bg_name,
"start_command",
self.sc_obj.name,
)
db_tools.close_connection()
self.srv_com.set_result("sent to background")
else:
self.srv_com.set_result(
"too many instances running ({:d} of {:d})".format(
self.Meta.cur_running, self.Meta.max_instances),
server_command.SRV_REPLY_STATE_ERROR)
else:
self.start_time = time.time()
try:
result = self.sc_obj._call(self)
except:
exc_info = process_tools.icswExceptionInfo()
for line in exc_info.log_lines:
self.log(line, logging_tools.LOG_LEVEL_CRITICAL)
self.srv_com.set_result(
process_tools.get_except_info(exc_info.except_info),
server_command.SRV_REPLY_STATE_CRITICAL)
# write to logging-server
err_h = io_stream_helper.icswIOStream(
icswLogHandleTypes.err_py, zmq_context=self.zmq_context)
err_h.write("\n".join(exc_info.log_lines))
err_h.close()
else:
if result is not None:
self.log(
"command got an (unexpected) result: '{}'".format(
str(result)), logging_tools.LOG_LEVEL_ERROR)
self.end_time = time.time()
if int(self.srv_com["result"].attrib["state"]):
self.log(
"result is ({:d}) {}".format(
int(self.srv_com["result"].attrib["state"]),
self.srv_com["result"].attrib["reply"]),
logging_tools.LOG_LEVEL_ERROR)
if self.Meta.show_execution_time:
self.log("run took {}".format(
logging_tools.get_diff_time_str(self.end_time -
self.start_time)))
self.srv_com["result"].attrib["reply"] = "{} in {}".format(
self.srv_com["result"].attrib["reply"],
logging_tools.get_diff_time_str(self.end_time -
self.start_time))
_mods = [
cur_entry for cur_entry in [
entry.split(".")[0] for entry in os.listdir(os.path.dirname(__file__))
if entry.endswith(".py")
] if cur_entry and not cur_entry.startswith("_")
]
ALL_PERFDATA = {}
IMPORT_ERRORS = []
for mod_name in _mods:
# no circular import
if mod_name in ["base"]:
continue
try:
new_mod = importlib.import_module(
"initat.collectd.collectd_types.{}".format(mod_name))
except:
exc_info = process_tools.icswExceptionInfo()
IMPORT_ERRORS.extend(exc_info.log_lines)
else:
for _name in dir(new_mod):
_entry = getattr(new_mod, _name)
if inspect.isclass(_entry):
if _entry != PerfdataObject and issubclass(
_entry, PerfdataObject):
_inst = _entry()
ALL_PERFDATA["{}_{}".format(mod_name,
_name)] = (_inst.PD_RE, _inst)
def _take_config(self, request, conf, ccat):
_sets = {}
# for key in conf.iterkeys():
# # remove all subsets, needed because of limitations in DRF
# if key.endswith("_set") and conf[key]:
# _sets[key] = conf[key]
# conf[key] = []
if not conf.get("description", None):
# fix missing or None description
conf["description"] = ""
import pprint
pprint.pprint(conf)
_ent = config_dump_serializer(data=conf)
added = 0
sub_added = 0
try:
_exists = config.objects.get(
Q(name=conf["name"]) & Q(config_catalog=ccat))
except config.DoesNotExist:
_take = True
else:
request.xml_response.error(
"config {} already exists in config catalog {}".format(
conf["name"], str(ccat)),
logger=logger)
_take = False
# we create the config with a dummy name to simplify matching of vars / scripts /
# monccs against configs with same name but different catalogs
dummy_name = "_ul_config_{:d}".format(int(time.time()))
taken = False
if _take:
if _ent.is_valid():
print(dir(_ent))
print("*", dummy_name)
_ent.create_default_entries = False
try:
# store config with config catalog
print("a")
_ent.save(name=dummy_name, config_catalog=ccat)
print("b")
# pass
except:
for entry in process_tools.icswExceptionInfo().log_lines:
logger.log(logging_tools.LOG_LEVEL_ERROR, entry)
request.xml_response.error(
"error saving entry '{}': {}".format(
str(_ent), process_tools.get_except_info()),
logger=logger)
else:
taken = True
# add sub-sets
for key in _sets.keys():
for entry in _sets[key]:
entry["config"] = dummy_name
if not entry.get("description", None):
# fix simple structure errors
entry["description"] = "dummy description"
_sub_ent = getattr(
serializers, "{}_nat_serializer".format(
key[:-4]))(data=entry)
if _sub_ent.is_valid():
try:
_sub_ent.object.save()
except:
request.xml_response.error(
"error saving subentry '{}': {}".
format(
str(_sub_ent),
process_tools.get_except_info()),
logger=logger)
else:
sub_added += 1
else:
request.xml_response.error(
"cannot create {} object: {}".format(
key, str(_sub_ent.errors)),
logger=logger)
added += 1
_ent.object.name = conf["name"]
_ent.object.save()
request.xml_response["new_pk"] = "{:d}".format(
_ent.object.pk)
request.xml_response.info(
"create new config {} ({:d}) in config catalog {}".
format(str(_ent.object), sub_added, str(ccat)))
else:
request.xml_response.error(
"cannot create config object: {}".format(str(_ent.errors)),
logger=logger)
return taken
def handle(self, gbc, hbc, cur_gc, s_check, mode):
# import reverse lut for meta subcommands
# init Dynamic Check Result
rv = DynamicCheckResult()
# mccs .... mon_check_command_special
# mccs = gbc.mccs_dict[s_check.mccs_id]
# mccs = s_check.mon_check_command_special
# mccs to be called
call_check = s_check
# store name of mccs (for parenting)
check_name = s_check.name
if s_check.special_parent_id:
print("handle special meta")
# to get the correct command_line
# link to parent
# mccs = mccs.parent
check_has_parent = True
else:
check_has_parent = False
# create lut entry to rewrite command name to mccs
rv.rewrite_lut["check_command"] = s_check.unique_name
# print("***", _rewrite_lut)
try:
# create special check instance
cur_special = self[s_check.name](
hbc.log,
self,
# get mon_check_command (we need arg_ll)
s_check=cur_gc["command"][s_check.unique_name],
# monitoring check command
parent_check=s_check,
host=hbc.device,
build_cache=gbc,
)
except:
rv.feed_error("unable to initialize special '{}': {}".format(
s_check.name, process_tools.get_except_info()))
else:
# calling handle to return a list of checks with format
# [(description, [ARG1, ARG2, ARG3, ...]), (...)]
try:
if mode == DynamicCheckMode.create:
if check_has_parent:
# for meta specials
sc_array = cur_special(mode, instance=check_name)
else:
# sc array is the list of instances to be called
sc_array = cur_special(mode)
else:
# fetch mode, currently not supported for meta checks
if cur_special.Meta.meta:
self.log(
"mode {} not supported for meta checks".format(
mode), logging_tools.LOG_LEVEL_CRITICAL)
else:
if cur_special.Meta.server_contact:
if hasattr(cur_special,
"dynamic_update_calls") and hasattr(
cur_special, "feed_result"):
rv.set_server_contact(cur_special)
else:
self.log(
"specialcheck {} has no dynamic_update_calls() or feed_result() function"
.format(check_name, ),
logging_tools.LOG_LEVEL_ERROR)
except:
exc_info = process_tools.icswExceptionInfo()
rv.feed_error("error calling special {}:".format(mccs.name), )
for line in exc_info.log_lines:
rv.feed_error(" - {}".format(line))
sc_array = []
finally:
cur_special.cleanup()
if mode == DynamicCheckMode.create:
if cur_special.Meta.meta and sc_array and not check_has_parent:
# dive in subcommands, for instance 'all SNMP checks'
# check for configs not really configured
# print("-" * 50)
# print("*", sc_array)
# this has to be fixed, check lines 329 ff. from build_cache.py
_dead_coms = [
# _entry for _entry in sc_array if not hasattr(gbc.mccs_dict[_entry], "check_command_name")
]
if _dead_coms:
rv.feed_error(
"unconfigured checks: {}".format(", ".join(
sorted(_dead_coms))), )
# we return a list of config names (to be iterated over)
rv.set_configs([
META_SUB_REVERSE_LUT[_entry] for _entry in sc_array
if _entry not in _dead_coms
])
else:
# we return a list of checks
rv.set_checks(sc_array)
return rv
