core/source/main.py

def state_encode(state):
	return {
		"timestamp": state["timestamp"],
		"condition": condition_encode(state["condition"]),
		"count": state["count"],
	}
	
	
def state_decode(state_encoded):
	return {
		"timestamp": state_encoded["timestamp"],
		"condition": condition_decode(state_encoded["condition"]),
		"count": state_encoded["count"],
	}
	

def conf_normalize_check(check_kind_implementations, defaults, name, node):
	if ("kind" not in node):
		raise ValueError("missing mandatory 'member' field 'kind'")
	else:
		if (node["kind"] not in check_kind_implementations):
			raise ValueError("unhandled kind: %s" % node["kind"])
		else:
			node_ = dict_merge(
				{
					"title": name,
					"active": True,
					"schedule": defaults["schedule"],
					"notifications": defaults["notifications"],
					"parameters": {},
				},
				node
			)
			return {
				"title": node_["title"],
				"active": node_["active"],
				"schedule": node_["schedule"],
				"notifications": node_["notifications"],
				"kind": node_["kind"],
				"parameters": check_kind_implementations[node_["kind"]].normalize_conf_node(node_["parameters"]),
			}
	

def conf_normalize_defaults(node):
	return dict_merge(
		{
			"active": True,
			"schedule": {"kind": "hourly"},
			"notifications": [],
		},
		node
	)
	

def conf_normalize_root(check_kind_implementations, node):
	return dict(
		map(
			lambda check_pair: (
				check_pair[0],
				conf_normalize_check(
					check_kind_implementations,
					conf_normalize_defaults(node["defaults"]),
					check_pair[0],
					check_pair[1]
				),
			),
			node["checks"].items()
		)
	)
	

def main():
	## args
	argumentparser = _argparse.ArgumentParser(
		description = "Heimdall-Monitoring-Tool",
		formatter_class = _argparse.ArgumentDefaultsHelpFormatter
	)
	argumentparser.add_argument(
		"-c",
		"--conf-path",
		type = str,
		default = "monitoring.hmdl.json",
		dest = "conf_path",
		metavar = "<conf-path>",
		help = "path to the configuration file"
	)
	argumentparser.add_argument(
		"-s",
		"--state-path",
		type = str,
		default = None,
		dest = "state_path",
		metavar = "<state-path>",
		help = "path to the state file, which contains information about the recent checks; default: file in temporary directory, unique for the conf-path input"
	)
	argumentparser.add_argument(
		"-t",
		"--threshold",
		type = int,
		default = 3,
		dest = "threshold",
		metavar = "<threshold>",
		help = "how often a condition has to occur in order to be reported"
	)
	argumentparser.add_argument(
		"-a",
		"--awareness-interval",
		type = int,
		default = 120,
		dest = "awareness_interval",
		metavar = "<awareness-interval>",
		help = "seconds to wait until starting the next run of a check, for which the condition has changed recently"
	)
	argumentparser.add_argument(
		"-k",
		"--keep-notifying",
		action = "store_true",
		default = False,
		dest = "keep_notifying",
		help = "whether notifications shall be kept sending after the threshold has been surpassed"
	)
	argumentparser.add_argument(
		"-x",
		"--expose-full-conf",
		action = "store_true",
		default = False,
		dest = "expose_full_conf",
		help = "only print the extended configuration to stdout and exit (useful for debug purposes)"
	)
	args = argumentparser.parse_args()
	
	## vars
	id_ = _hashlib.sha256(_os.path.abspath(args.conf_path).encode("ascii")).hexdigest()[:8]
	state_path = (
		args.state_path
		if (args.state_path is not None) else
		_os.path.join(
			_tempfile.gettempdir(),
			string_coin("monitoring-state-{{id}}.json", {"id": id_})
		)
	)
	
	## exec
	
	_sys.stderr.write(">> state file path: %s\n" % state_path)
	
	### load check kind implementations
	check_kind_implementations = {
		"script": implementation_check_kind_script(),
		"http_request": implementation_check_kind_http_request(),
	}
	
	### load notification channel implementations
	notification_channel_implementations = {
		"console": implementation_notification_channel_console(),
		"email": implementation_notification_channel_email(),
	}
	
	### get configuration data
	checks = conf_normalize_root(check_kind_implementations, _json.loads(file_read(args.conf_path)))
	if (args.expose_full_conf):
		_sys.stdout.write(_json.dumps(checks, indent = "\t") + "\n")
		_sys.exit(1)
	else:
		### get state data
		if (not _os.path.exists(state_path)):
			state_data = {}
			file_write(state_path, _json.dumps(state_data, indent = "\t"))
		else:
			state_data = _json.loads(file_read(state_path))
		
		### iterate through checks
		for (check_name, check_data, ) in checks.items():
			if (not check_data["active"]):
				pass
			else:
				### get old state and examine whether the check shall be executed
				old_item_state = (
					None
					if (check_name not in state_data) else
					state_decode(state_data[check_name])
				)
				timestamp = get_current_timestamp()
				due = (
					(old_item_state is None)
					or
					(
						(old_item_state["count"] is not None)
						and
						((timestamp - old_item_state["timestamp"]) >= args.awareness_interval)
					)
					or
					(
						(
							(check_data["schedule"]["kind"] == "minutely")
							and
							((timestamp - old_item_state["timestamp"]) >= (60))
						)
						or
						(
							(check_data["schedule"]["kind"] == "hourly")
							and
							((timestamp - old_item_state["timestamp"]) >= (60 * 60))
						)
						or
						(
							(check_data["schedule"]["kind"] == "daily")
							and
							((timestamp - old_item_state["timestamp"]) >= (60 * 60 * 24))
						)
					)
				)
				if (not due):
					pass
				else:
					_sys.stderr.write(
						string_coin(
							"-- {{check_name}}\n",
							{
								"check_name": check_name,
							}
						)
					)
					
					### execute check and set new state
					result = check_kind_implementations[check_data["kind"]].run(check_data)
					new_item_state = {
						"timestamp": timestamp,
						"condition": result["condition"],
						"count": (
							1
							if (
								(old_item_state is None)
								or
								(old_item_state["condition"] != result["condition"])
							) else
							(
								(old_item_state["count"] + 1)
								if (
									(old_item_state["count"] is not None)
									and
									((old_item_state["count"] + 1) <= args.threshold)
								) else
								None
							)
						),
					}
					state_data[check_name] = state_encode(new_item_state)
					file_write(state_path, _json.dumps(state_data, indent = "\t"))
					
					### send notifications
					if (
						(
							(new_item_state["count"] is not None)
							and
							(new_item_state["count"] == args.threshold)
						)
						or
						(
							(new_item_state["count"] is None)
							and
							args.keep_notifying
						)
					):
						for notification in check_data["notifications"]:
							if (notification["kind"] in notification_channel_implementations):
								notification_channel_implementations[notification["kind"]].notify(
									notification["parameters"],
									check_name,
									check_data,
									new_item_state,
									result["output"]
								)
							else:
								raise ValueError("invalid notification kind: %s" % notification["kind"])
	

main()