180 lines
3.6 KiB
TypeScript
180 lines
3.6 KiB
TypeScript
namespace _heimdall.state_repository
|
|
{
|
|
|
|
/**
|
|
*/
|
|
var _connection : (null | lib_plankton.sqlite.type_connection) = null;
|
|
|
|
|
|
/**
|
|
*/
|
|
function condition_decode(
|
|
condition_encoded : int
|
|
) : _heimdall.enum_condition
|
|
{
|
|
return {
|
|
0: enum_condition.unknown,
|
|
1: enum_condition.ok,
|
|
2: enum_condition.concerning,
|
|
3: enum_condition.critical,
|
|
}[condition_encoded];
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
function condition_encode(
|
|
condition : _heimdall.enum_condition
|
|
) : int
|
|
{
|
|
switch (condition) {
|
|
case enum_condition.unknown: return 0;
|
|
case enum_condition.ok: return 1;
|
|
case enum_condition.concerning: return 2;
|
|
case enum_condition.critical: return 3;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function init(
|
|
database_path : string
|
|
) : Promise<void>
|
|
{
|
|
_connection = await lib_plankton.sqlite.get_connection(database_path);
|
|
await setup();
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function kill(
|
|
) : Promise<void>
|
|
{
|
|
await lib_plankton.sqlite.drop_connection(_connection);
|
|
_connection = null;
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function setup(
|
|
) : Promise<void>
|
|
{
|
|
const result = await lib_plankton.sqlite.query_set(
|
|
_connection,
|
|
{
|
|
"template": "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);",
|
|
"arguments": {
|
|
},
|
|
},
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function clean(
|
|
time_to_live : int,
|
|
erase_state : boolean
|
|
) : Promise<int>
|
|
{
|
|
const result = await lib_plankton.sqlite.query_put(
|
|
_connection,
|
|
{
|
|
"template": "DELETE FROM results WHERE ((timestamp < :timestamp_min) OR :erase_state);",
|
|
"arguments": {
|
|
"timestamp_min": Math.floor((Date.now() / 1000) - time_to_live),
|
|
"erase_state": erase_state,
|
|
},
|
|
}
|
|
);
|
|
return result.affected;
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function probe(
|
|
check_name : string,
|
|
threshold : int
|
|
) : Promise<
|
|
Array<
|
|
{
|
|
timestamp : int;
|
|
condition : _heimdall.enum_condition;
|
|
notification_sent : boolean;
|
|
}
|
|
>
|
|
>
|
|
{
|
|
const rows : Array<Record<string, any>> = await lib_plankton.sqlite.query_get(
|
|
_connection,
|
|
{
|
|
"template": "SELECT timestamp, condition, notification_sent FROM results WHERE (check_name = :check_name) ORDER BY timestamp DESC LIMIT :limit;",
|
|
"arguments": {
|
|
"check_name": check_name,
|
|
"limit": threshold,
|
|
},
|
|
}
|
|
);
|
|
return (
|
|
rows
|
|
.map(
|
|
row => ({
|
|
"timestamp": row["timestamp"],
|
|
"condition": condition_decode(row["condition"]),
|
|
"notification_sent": row["notification_sent"],
|
|
})
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function get_last_notification_timestamp(
|
|
check_name : string
|
|
) : Promise<(null | int)>
|
|
{
|
|
const rows : Array<Record<string, any>> = await lib_plankton.sqlite.query_get(
|
|
_connection,
|
|
{
|
|
"template": "SELECT MAX(timestamp) AS max_timestamp FROM results WHERE (check_name = :check_name) AND (notification_sent = TRUE);",
|
|
"arguments": {
|
|
"check_name": check_name,
|
|
},
|
|
}
|
|
);
|
|
return rows[0]["max_timestamp"];
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
export async function feed(
|
|
check_name : string,
|
|
timestamp : int,
|
|
condition : _heimdall.enum_condition,
|
|
shall_send_notification : boolean,
|
|
info : any
|
|
) : Promise<void>
|
|
{
|
|
await lib_plankton.sqlite.query_put(
|
|
_connection,
|
|
{
|
|
"template": "INSERT INTO results(check_name, timestamp, condition, notification_sent, info) VALUES (:check_name, :timestamp, :condition, :notification_sent, :info);",
|
|
"arguments": {
|
|
"check_name": check_name,
|
|
"timestamp": timestamp,
|
|
"condition": condition_encode(condition),
|
|
"notification_sent": shall_send_notification,
|
|
"info": lib_plankton.json.encode(info),
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
}
|