423 lines
11 KiB
Python
423 lines
11 KiB
Python
def main():
|
|
## const
|
|
version = "0.8"
|
|
|
|
## setup translation for the first time
|
|
translation_initialize("en", env_get_language())
|
|
|
|
## args
|
|
argumentparser = _argparse.ArgumentParser(
|
|
description = translation_get("help.title"),
|
|
formatter_class = _argparse.ArgumentDefaultsHelpFormatter
|
|
)
|
|
argumentparser.add_argument(
|
|
nargs = "?",
|
|
type = str,
|
|
default = "monitoring.hmdl.json",
|
|
dest = "order_path",
|
|
metavar = "<order-path>",
|
|
help = translation_get("help.args.order_path"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-v",
|
|
"--version",
|
|
action = "store_true",
|
|
default = False,
|
|
dest = "show_version",
|
|
help = translation_get("help.args.show_version"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-s",
|
|
"--show-schema",
|
|
action = "store_true",
|
|
default = False,
|
|
dest = "show_schema",
|
|
help = translation_get("help.args.show_schema"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-e",
|
|
"--expose-full-order",
|
|
action = "store_true",
|
|
default = False,
|
|
dest = "expose_full_order",
|
|
help = translation_get("help.args.expose_full_order"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-x",
|
|
"--erase-state",
|
|
action = "store_true",
|
|
default = False,
|
|
dest = "erase_state",
|
|
help = translation_get("help.args.erase_state"),
|
|
)
|
|
### v conf stuff v
|
|
argumentparser.add_argument(
|
|
"-d",
|
|
"--database-path",
|
|
type = str,
|
|
default = None,
|
|
dest = "database_path",
|
|
metavar = "<database-path>",
|
|
help = translation_get("help.args.database_path"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-m",
|
|
"--mutex-path",
|
|
type = str,
|
|
default = "/tmp/heimdall.lock",
|
|
dest = "mutex_path",
|
|
metavar = "<mutex-path>",
|
|
help = translation_get("help.args.mutex_path"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-y",
|
|
"--send-ok-notifications",
|
|
action = "store_true",
|
|
default = False,
|
|
dest = "send_ok_notifications",
|
|
help = translation_get("help.args.send_ok_notifications", {"condition_name": translation_get("conditions.ok")}),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-l",
|
|
"--language",
|
|
type = str,
|
|
choices = localization_data.keys(),
|
|
default = None,
|
|
dest = "language",
|
|
metavar = "<language>",
|
|
help = translation_get("help.args.language"),
|
|
)
|
|
argumentparser.add_argument(
|
|
"-t",
|
|
"--time-to-live",
|
|
type = int,
|
|
default = (60 * 60 * 24 * 7),
|
|
dest = "time_to_live",
|
|
metavar = "<time-to-live>",
|
|
help = translation_get("help.args.time_to_live"),
|
|
)
|
|
args = argumentparser.parse_args()
|
|
|
|
## exec
|
|
if (args.show_version):
|
|
_sys.stdout.write(version + "\n")
|
|
else:
|
|
### setup translation for the second time
|
|
if (args.language is not None):
|
|
translation_initialize("en", args.language)
|
|
|
|
### load check kind implementations
|
|
check_kind_implementations = {
|
|
"script": implementation_check_kind_script(),
|
|
"file_state": implementation_check_kind_file_state(),
|
|
"tls_certificate": implementation_check_kind_tls_certificate(),
|
|
"http_request": implementation_check_kind_http_request(),
|
|
"generic_remote" : implementation_check_kind_generic_remote(),
|
|
}
|
|
|
|
### load notification channel implementations
|
|
notification_channel_implementations = {
|
|
"console": implementation_notification_channel_console(),
|
|
"email": implementation_notification_channel_email(),
|
|
"libnotify": implementation_notification_channel_libnotify(),
|
|
}
|
|
|
|
if (args.show_schema):
|
|
_sys.stdout.write(
|
|
_json.dumps(
|
|
order_schema_root(
|
|
check_kind_implementations,
|
|
notification_channel_implementations
|
|
),
|
|
indent = "\t"
|
|
)
|
|
+
|
|
"\n"
|
|
)
|
|
else:
|
|
### vars
|
|
if (not _os.path.exists(args.order_path)):
|
|
_sys.stderr.write(
|
|
string_coin(
|
|
"{{message}}\n",
|
|
{
|
|
"message": translation_get(
|
|
"misc.order_file_not_found",
|
|
{
|
|
"path": args.order_path,
|
|
}
|
|
),
|
|
}
|
|
)
|
|
)
|
|
_sys.exit(1)
|
|
else:
|
|
database_path = (
|
|
args.database_path
|
|
if (args.database_path is not None) else
|
|
_os.path.join(
|
|
_tempfile.gettempdir(),
|
|
string_coin(
|
|
"monitoring-state-{{id}}.sqlite",
|
|
{
|
|
"id": _hashlib.sha256(_os.path.abspath(args.order_path).encode("ascii")).hexdigest()[:8]
|
|
}
|
|
)
|
|
)
|
|
)
|
|
|
|
### get order data
|
|
order = order_load(
|
|
check_kind_implementations,
|
|
notification_channel_implementations,
|
|
_os.path.abspath(args.order_path)
|
|
)
|
|
|
|
if (args.expose_full_order):
|
|
_sys.stdout.write(_json.dumps(order, indent = "\t") + "\n")
|
|
_sys.exit(1)
|
|
else:
|
|
_sys.stderr.write(
|
|
string_coin(
|
|
"[info] {{label}}: {{path}}\n",
|
|
{
|
|
"label": translation_get("misc.state_file_path"),
|
|
"path": database_path,
|
|
}
|
|
)
|
|
)
|
|
|
|
### mutex check
|
|
if (_os.path.exists(args.mutex_path)):
|
|
_sys.stderr.write(
|
|
string_coin(
|
|
"[error] {{message}} ({{path}})\n",
|
|
{
|
|
"message": translation_get("misc.still_running"),
|
|
"path": args.mutex_path,
|
|
}
|
|
)
|
|
)
|
|
_sys.exit(2)
|
|
else:
|
|
### setup database
|
|
sqlite_query_set(
|
|
database_path,
|
|
"CREATE TABLE IF NOT EXISTS results(check_name TEXT NOT NULL, timestamp INTEGER NOT NULL, condition TEXT NOT NULL, notification_sent BOOLEAN NOT NULL, info TEXT NOT NULL);",
|
|
{}
|
|
)
|
|
|
|
### clean database
|
|
result = sqlite_query_put(
|
|
database_path,
|
|
"DELETE FROM results WHERE ((timestamp < :timestamp_min) OR :erase_state);",
|
|
{
|
|
"timestamp_min": (get_current_timestamp() - args.time_to_live),
|
|
"erase_state": args.erase_state,
|
|
}
|
|
)
|
|
_sys.stderr.write(
|
|
string_coin(
|
|
"[info] {{text}}\n",
|
|
{
|
|
"text": translation_get(
|
|
"misc.cleanup_info",
|
|
{
|
|
"count": ("%u" % result.rowcount),
|
|
}
|
|
),
|
|
}
|
|
)
|
|
)
|
|
|
|
file_write(args.mutex_path, "", {"append": True})
|
|
|
|
### iterate through checks
|
|
for check_data in order["checks"]:
|
|
if (not check_data["active"]):
|
|
pass
|
|
else:
|
|
### get old state and examine whether the check shall be executed
|
|
rows = sqlite_query_get(
|
|
database_path,
|
|
"SELECT timestamp, condition, notification_sent FROM results WHERE (check_name = :check_name) ORDER BY timestamp DESC LIMIT :limit;",
|
|
{
|
|
"check_name": check_data["name"],
|
|
"limit": (check_data["threshold"] + 1),
|
|
}
|
|
)
|
|
if (len(rows) <= 0):
|
|
old_item_state = None
|
|
else:
|
|
last_notification_timestamp = None
|
|
count = 1
|
|
for row in rows[1:]:
|
|
if (row[1] == rows[0][1]):
|
|
count += 1
|
|
else:
|
|
break
|
|
if (count > check_data["threshold"]):
|
|
count = None
|
|
else:
|
|
pass
|
|
for row in rows:
|
|
if (row[2]):
|
|
last_notification_timestamp = row[0]
|
|
break
|
|
else:
|
|
pass
|
|
old_item_state = {
|
|
"timestamp": rows[0][0],
|
|
"condition": condition_decode(rows[0][1]),
|
|
"count": count,
|
|
"last_notification_timestamp": last_notification_timestamp,
|
|
}
|
|
|
|
timestamp = get_current_timestamp()
|
|
due = (
|
|
(old_item_state is None)
|
|
or
|
|
(old_item_state["condition"] != enum_condition.ok)
|
|
or
|
|
((timestamp - old_item_state["timestamp"]) >= check_data["schedule"]["regular_interval"])
|
|
or
|
|
(
|
|
(old_item_state["count"] is not None)
|
|
and
|
|
((timestamp - old_item_state["timestamp"]) >= check_data["schedule"]["attentive_interval"])
|
|
)
|
|
)
|
|
if (not due):
|
|
pass
|
|
else:
|
|
_sys.stderr.write(
|
|
string_coin(
|
|
"-- {{check_name}}\n",
|
|
{
|
|
"check_name": check_data["name"],
|
|
}
|
|
)
|
|
)
|
|
|
|
### execute check and set new state
|
|
try:
|
|
result = check_kind_implementations[check_data["kind"]].run(check_data["parameters"])
|
|
except Exception as error:
|
|
result = {
|
|
"condition": enum_condition.unknown,
|
|
"info": {
|
|
"cause": translation_get("misc.check_procedure_failed"),
|
|
"error": str(error),
|
|
},
|
|
}
|
|
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) <= check_data["threshold"])
|
|
) else
|
|
None
|
|
)
|
|
)
|
|
shall_send_notification = (
|
|
(
|
|
(
|
|
(count is not None)
|
|
and
|
|
(count == check_data["threshold"])
|
|
)
|
|
or
|
|
(
|
|
(count is None)
|
|
and
|
|
check_data["annoy"]
|
|
)
|
|
or
|
|
(
|
|
(count is None)
|
|
and
|
|
(
|
|
(old_item_state is not None)
|
|
and
|
|
(old_item_state["last_notification_timestamp"] is not None)
|
|
and
|
|
(check_data["schedule"]["reminding_interval"] is not None)
|
|
and
|
|
(
|
|
(timestamp - old_item_state["last_notification_timestamp"])
|
|
>=
|
|
check_data["schedule"]["reminding_interval"]
|
|
)
|
|
)
|
|
)
|
|
)
|
|
and
|
|
(
|
|
(result["condition"] != enum_condition.ok)
|
|
or
|
|
args.send_ok_notifications
|
|
)
|
|
)
|
|
new_item_state = {
|
|
"timestamp": timestamp,
|
|
"condition": result["condition"],
|
|
"count": count,
|
|
"last_notification_timestamp": (
|
|
timestamp
|
|
if shall_send_notification else
|
|
(
|
|
None
|
|
if (old_item_state is None) else
|
|
old_item_state["last_notification_timestamp"]
|
|
)
|
|
),
|
|
}
|
|
sqlite_query_put(
|
|
database_path,
|
|
"INSERT INTO results(check_name, timestamp, condition, notification_sent, info) VALUES (:check_name, :timestamp, :condition, :notification_sent, :info);",
|
|
{
|
|
"check_name": check_data["name"],
|
|
"timestamp": timestamp,
|
|
"condition": condition_encode(result["condition"]),
|
|
"notification_sent": shall_send_notification,
|
|
"info": _json.dumps(result["info"]),
|
|
}
|
|
)
|
|
|
|
### send notifications
|
|
if (not shall_send_notification):
|
|
pass
|
|
else:
|
|
for notification in check_data["notifications"]:
|
|
notification_channel_implementations[notification["kind"]].notify(
|
|
notification["parameters"],
|
|
check_data["name"],
|
|
check_data,
|
|
new_item_state,
|
|
dict_merge(
|
|
(
|
|
{}
|
|
if (check_data["custom"] is None) else
|
|
{"custom": check_data["custom"]}
|
|
),
|
|
result["info"]
|
|
)
|
|
)
|
|
|
|
if (not _os.exists(args.mutex_path)):
|
|
pass
|
|
else:
|
|
_os.remove(args.mutex_path)
|
|
|
|
|
|
main()
|
|
|