def start():
logger.info("starting manager[pid=%s]" % common.PID)
storage.setup()
config = common.load_config()
output = config["output"]
for camera in config["cameras"].keys():
logger.info("found camera %s" % camera)
PROCESSES.append(camera)
MODULES[camera] = "runtime.recorder"
segment_dir = "%s/%s" % (output, camera)
if not exists(segment_dir):
makedirs(segment_dir)
logger.info("directory %s created" % segment_dir)
del config, output
with storage.get_connection() as conn:
for name in PROCESSES:
metric = "%sStatus" % name
storage.put(conn, metric, "Launching")
running[name] = start_process(name)
storage.put(conn, metric, "Launched")
try:
loop(conn)
finally:
logger.info("manager[pid=%s] is stopping" % common.PID)
def test_is_connected(self):
config = common.load_config()
with MqttClient("keepermqtttest", config) as mqtt_client:
mqtt_client.reconnect()
self.assertEqual(mqtt_client.connection_status(), 2)
self.assertEqual(mqtt_client.connection_status(), 0)
def test_monitor_in_time_no_delay(self):
config = common.load_config()
with Storage() as storage, MqttClient("keeperconnectortest", config) as mc, Heartbeater(config, storage,
mc) as heartbeater:
heartbeater.last_message = datetime.now() - timedelta(seconds=config["heartbeat.interval"])
heartbeater.monitor()
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 0)
def __init__(self):
"""
partially initializes format
"""
self.format = "%s " + current_process().name + "-keeper[%s]: %s"
self.is_debug = bool(load_config()["debug"])
def main():
config = load_config('web_server.json')
args = parse_args()
logger = configure_logger(config['name'], args.v, args.o)
if 'db_address' not in config:
raise Exception('Cannot start WebServer without database')
WebServer(config, logger).start()
def test_on_not_connected(self):
config = common.load_config()
with Storage() as storage, MqttClient("keeperconnectortest",
config) as mc, Connector(
config, storage,
mc) as connector:
connector.on_not_connect()
self.assertEqual(connector.attempts, 1)
self.assertEqual(
storage.get_int(constants.CONNECTOR_FAILED_CONNECTIONS), 1)
self.assertEqual(
storage.get_int(constants.CONNECTOR_MQTT_RESTARTS), 0)
connector.on_not_connect()
self.assertEqual(connector.attempts, 2)
self.assertEqual(
storage.get_int(constants.CONNECTOR_FAILED_CONNECTIONS), 2)
self.assertEqual(
storage.get_int(constants.CONNECTOR_MQTT_RESTARTS), 0)
connector.on_not_connect()
self.assertEqual(connector.attempts, 3)
self.assertEqual(
storage.get_int(constants.CONNECTOR_FAILED_CONNECTIONS), 3)
self.assertEqual(
storage.get_int(constants.CONNECTOR_MQTT_RESTARTS), 0)
connector.on_not_connect()
self.assertEqual(
storage.get_int(constants.CONNECTOR_MQTT_RESTARTS), 1)
self.assertEqual(connector.attempts, 0)
connector.on_not_connect()
self.assertEqual(connector.attempts, 1)
self.assertEqual(
storage.get_int(constants.CONNECTOR_FAILED_CONNECTIONS), 4)
self.assertEqual(
storage.get_int(constants.CONNECTOR_MQTT_RESTARTS), 1)
def test_send(self):
config = common.load_config()
with storage.get_connection() as conn:
storage.put(conn, "reporterStatus", "Running")
reporter.running = True
client = reporter.connect(config["mqtt.broker"],
config["mqtt.port"], config["mqtt.user"],
config["mqtt.pass"])
reporter.send_report(client, conn)
def test_not_connected(self):
config = common.load_config()
config["mqtt.broker"] = "1.1.1.1"
try:
with MqttClient("keepermqtttest", config, False) as mqtt_client:
mqtt_client.reconnect()
pass
except:
pass
def test_not_stable(self):
config = common.load_config()
with Storage() as storage, MqttClient("keeperconnectortest",
config) as mc, Connector(
config, storage,
mc) as connector:
now = datetime.now()
connector.started_at = now - timedelta(seconds=10)
connector.connected_at = now - timedelta(seconds=8)
self.assertFalse(connector.is_stable())
def test_monitor_restart_ha(self):
config = common.load_config()
with Storage() as storage, MqttClient("keeperconnectortest", config) as mc, Heartbeater(config, storage,
mc) as heartbeater:
diff = config["heartbeat.interval"] + config["heartbeat.delay"] + 1
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 1)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 1)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 0)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 2)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 2)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 0)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 3)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 3)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 0)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 0)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 3)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 1)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 1)
self.assertEqual(heartbeater.attempts, 1)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 4)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 1)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 2)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 5)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 1)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 3)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 6)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 1)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 0)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 6)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 2)
heartbeater.last_message = datetime.now() - timedelta(seconds=diff)
heartbeater.monitor()
self.assertEqual(heartbeater.misses, 1)
self.assertEqual(heartbeater.attempts, 2)
self.assertEqual(storage.get_int(constants.HEARTBEATER_MISSED_HEARTBEAT), 7)
self.assertEqual(storage.get_int(constants.HEARTBEATER_HA_RESTARTS), 2)
def start():
logger.info("starting reported[pid=%s]" % common.PID)
config = common.load_config()
broker = config["mqtt.broker"]
port = config["mqtt.port"]
user = config.get("mqtt.user")
pwd = config.get("mqtt.pass")
del config
with storage.get_connection() as conn:
storage.put(conn, REPORTER_STATUS, "Running")
try:
loop(conn, broker, port, user, pwd)
finally:
storage.put(conn, REPORTER_STATUS, "Not Running")
logger.info("stopping watcher[pid=%s]" % common.PID)
def start():
logger.info("starting cleaner[pid=%s]" % common.PID)
config = common.load_config()
output = config["output"]
cameras = config["cameras"]
loop_interval = 3600
for camera, config in cameras.items():
config["segment_dir"] = join(output, camera)
loop_interval = min(loop_interval, int(config["keep"]))
del config, output
with storage.get_connection() as conn:
storage.put(conn, CLEANER_STATUS, "Running")
try:
loop(conn, cameras, loop_interval)
finally:
storage.put(conn, CLEANER_STATUS, "Not Running")
logger.info("stopping cleaner[pid=%s]" % common.PID)
def start():
logger.info("starting recorder[pid=%s]" % common.PID)
config = common.load_config()
segment_dir = "%s/%s" % (config["output"], PROCESS_NAME)
config = config["cameras"][PROCESS_NAME]
logger.info("saving segments of camera %s in directory %s" %
(PROCESS_NAME, segment_dir))
duration = int(config["duration"])
command = [
"ffmpeg", "-rtsp_transport", "tcp", "-i", config["rtsp.url"], "-an",
"-sn", "-b:v", "132k", "-bufsize", "132k", "-c:v", "copy", "-r",
str(config["fps"]), "-bsf:v", "h264_mp4toannexb", "-map", "0",
"-shortest", "-strftime", "1", "-f", "segment", "-segment_time",
str(duration), "-segment_format", "mp4",
"%s/%s-%s.mp4" % (segment_dir, PROCESS_NAME, "%Y%m%d%H%M%S")
]
url = (config["rtsp.ip"], config["rtsp.port"])
request_command = bytes(
"OPTIONS rtsp://%s:%s RTSP/1.0\\r\\nCSeq: 1\\r\\nUser-Agent: python\\r\\nAccept: application/sdp\\r\\n\\r\\n"
% (url[0], str(url[1])), "utf-8")
del config, segment_dir
process = None
try:
while 1:
if not is_reachable(url, request_command):
logger.warning("destination %s:%s is not reachable" %
(url[0], str(url[1])))
logger.info("waiting for camera[%s:%s] to be available" %
(url[0], str(url[1])))
while not is_reachable(url, request_command):
sleep(1)
close(process)
process = None
if not is_running(process):
close(process)
process = launch(command)
else:
sleep(duration)
finally:
logger.info("stopping recorder[pid=%s]" % common.PID)
close(process)
def start():
logger.info("starting watcher[pid=%s]" % common.PID)
config = common.load_config()
output = config["output"]
threshold = config["filesystem.threshold"]
loop_interval = 10
segment_dirs = []
for camera, config in config["cameras"].items():
segment_dirs.append(join(output, camera))
loop_interval = min(loop_interval, int(config["duration"]))
del config
with storage.get_connection() as conn:
storage.put(conn, WATCHER_STATUS, "Running")
try:
loop(conn, segment_dirs, loop_interval, output, threshold)
finally:
storage.put(conn, WATCHER_STATUS, "Not Running")
logger.info("stopping watcher[pid=%s]" % common.PID)
def main():
config = load_config('web_server.json')
logger = configure_logger(config['name'])
os.environ['BC_DIR'] = sys.path[0]
WebServer(config, logger).start()
def main():
config = load_config('db_server.json')
logger = configure_logger(config['name'])
DBServer(config, logger).start()
'''
#Filling botconfig incase the file is missing
prompt_config("Enter bot prefix here: ", "prefix")
prompt_config("Enter channel (ID) to display blacklist responses: ",
"blacklistChannel")
prompt_config("Enter channel (ID) to display question suggestions: ",
"questionSuggestChannel")
prompt_config("Enter bot-spam channel (ID)", "botspamChannel")
prompt_config("Enter channel (ID) to display realm channel applications: ",
"realmChannelResponse")
prompt_config("Enter bot type (Stable/Beta)", "BotType")
prompt_config("Other bot's ID", "OtherBotID")
prompt_config("Bot's ID", "BotID")
prompt_config("Slash Commands Server ID", "ServerID")
config, _ = load_config()
#Applying towards intents
intents = discord.Intents.default()
intents.reactions = True
intents.members = True
intents.presences = True
#Defining client and SlashCommands
client = commands.Bot(command_prefix=config['prefix'],
intents=intents,
case_insensitive=True)
client.remove_command("help")
#Sentry Panel Stuff -
from discord_sentry_reporting import use_sentry
def main():
register_signal_handler(signal.SIGINT)
config = load_config('general.json')
start_modules(config)
def main():
config = load_config('db_server.json')
args = parse_args()
logger = configure_logger(config['name'], args.v, args.o)
DBServer(config, logger).start()
