def exec(self, dir_path):
"""
Exec merge files and sort by timestamp.
:param str dir_path: Directory path which contains log files.
:return: Merge result.
:rtype bool
"""
dir_path = dir_path.rstrip('/')
log.i("- start merge: [%s]" % dir_path)
lines = [self.Parsed(dt.min, b'')]
files = list(self.__files(dir_path))
if len(files) == 0:
return False
for l in list(fileinput.input(files, mode="rb")):
p = self.__parse(l)
if p.time is None:
lines[-1].line = lines[-1].line + p.line
continue
lines.append(p)
log.i("- write merged file: [%s%s]" % (dir_path, Merge.FILE_SUFFIX))
lines = sorted(lines, key=lambda x: x.time)
with open(dir_path + Merge.FILE_SUFFIX, "wb") as fd:
for l in lines:
fd.write(l.line)
return True
def test_set_level(self):
out = io.StringIO()
log.logger.addHandler(StreamHandler(stream=out))
log.set_level(log.Level.WARN)
log.i("message")
self.assertEqual(out.getvalue(), "")
log.set_level(log.Level.INFO)
log.i("message")
self.assertEqual(out.getvalue(), "message\n")
def __exec_convert(self, script_path):
"""
Execute conversion using `sed` command.
:param str script_path: Script file path, which is used by `sed` command.
"""
# execute conversion
f = os.path.splitext(self.__p.file)
dp = f[0] + Converter.DIR_SUFFIX + f[1]
log.i("- convert: %s" % dp)
self.__call(Converter.SED_CMD_FMT % (script_path, self.__p.file, dp))
def attach_bots_from_manager():
tokens = manager.get_tokens()
if not tokens:
log.i("Not bots found on database, adding default bot")
maker_token = config["defaults"]["maker"]["token"]
owner_id = config["defaults"]["owner"]["id"]
if not maker_token or not owner_id:
raise ConfigurationError("No bots on database and configuration file has no default token nor owner id")
if not mongo_interface.register_bot(maker_token, owner_id):
log.e("Could not even register default bot, interrupting execution abruptly")
exit(1)
attach_bots(manager.get_tokens())
def file(dirname, filename, timeout):
"""
Wait until a file created.
:param str dirname: Directory path to be watched.
:param str filename: File name to be watched.
:param num timeout: How many seconds to be wait. [sec]
:return: Is created the file.
:rtype bool
"""
is_glob = filename.find('*') >= 0
handler = ChangeHandler(dirname, filename, is_glob)
observer = Observer()
observer.schedule(handler, dirname, recursive=False)
observer.start()
try:
UPDATE_INTERVAL = 0.5
interval = UPDATE_INTERVAL
while interval >= 0 and timeout > 0:
time.sleep(0.1)
timeout -= 0.1
interval -= 0.1
log.d('- time out remain %.2f, update interval %.2f' %
(timeout, interval))
if handler.modified is True:
log.i('- now writing... %s ' % filename)
handler.modified = False
interval = UPDATE_INTERVAL
except KeyboardInterrupt:
observer.stop()
if not is_glob:
is_exists = os.path.exists(os.path.join(dirname, filename))
if is_exists:
if timeout <= 0:
log.w("- The file still updating.")
else:
log.i("- time out")
return False
observer.stop()
observer.join(timeout)
return True
def _elab_module_fun(function, instance, Module):
if not hasattr(instance, function.name):
if not function.optional:
log.w(f"{Module.__name__} has no function {function.name}")
return function.optional
real_function = getattr(instance, function.name)
if not callable(real_function):
if not function.optional:
log.w(f"{Module.__name__}.{function.name} is not a function")
return function.optional
if function.name == "on_new_trigger":
variables.on_new_trigger_functions.append(real_function)
log.i("Registered callback")
return True
if function.name == "on_trigger_change":
variables.on_trigger_change_functions.append(real_function)
log.i("Registered callback")
return True
return_value = real_function()
if type(return_value) is not function.type:
log.w(f"{Module.__name__}.{function.name} returns '{type(return_value).__name__}',"
f" '{type(function.type).__name__}' is required")
return False
log_string = function.elaborate_data(return_value)
log.i(f"Module: {log_string}")
return True
def detach_bot(token: str):
log.i(f"Detaching bot {token}")
for bot in variables.attached_bots:
log.d(bot.token)
if bot.token != str(token):
continue
variables.attached_bots.remove(bot)
log.i(f"Bot {token} detached")
return bot.stop()
log.i(f"Bot {token} not found")
def test_color(self):
log.d("debug")
log.i("info")
log.w("warn")
log.e("error")
def test_i(self):
out = io.StringIO()
log.logger.addHandler(StreamHandler(stream=out))
log.i("message")
self.assertEqual(out.getvalue(), "message\n")
from pymongo.collection import Collection
from entities.dialog import Dialog
from entities.group import Group
from entities.stats import Stats
from entities.user import User
from entities.trigger import Trigger
from exceptions.telegram_exception import TelegramException
from exceptions.unregistered_bot import UnregisteredBot
from logger import log
from ktelegram import methods
from configuration.config import config
log.i("Getting data from configuration file...")
_password = config["mongo"]["password"]
_username = config["mongo"]["username"]
_ip = config["mongo"]["ip"]
_db_name = config["mongo"]["db-name"]
_mongo_uri = f"mongodb://{_username}:{_password}@{_ip}/{_db_name}?retryWrites=true"
_client = None
_singleton_lock = Lock()
_default_language = config["defaults"]["language"]
log.d("Default language: " + _default_language)
# region MongoCore
def attach_bot(bot):
variables.attached_bots.append(bot)
log.i(f"Running bot {bot.bot_id}")
run_bot(bot)
def stop():
log.i("Stopping bots")
[bot.stop() for bot in variables.attached_bots]
log.i("Stopping mongo ")
mongo_interface.stop()
variables.running = False
def _init(bot):
if bot.clean_start:
methods.clean_updates(bot)
log.i(f"Bot @{bot.username} ok")
def run(threaded: bool = True, idle: bool = True, auto_attach: bool = True):
log.i(f"Starting Kitsu Ultimate version {config['lotus']['version']}")
_load_modules()
if config["startup"]["drop"]["dialogs"]:
log.i("Dropping dialogs")
mongo_interface.drop_dialogs()
if config["startup"]["drop"]["triggers"]:
log.i("Dropping triggers")
mongo_interface.drop_triggers()
if config["startup"]["drop"]["bots"]:
log.i("Dropping bots")
mongo_interface.drop_bots()
if config["startup"]["drop"]["groups"]:
log.i("Dropping groups")
mongo_interface.drop_groups()
if config["startup"]["drop"]["users"]:
log.i("Dropping users")
mongo_interface.drop_users()
if not threaded:
log.i("Running in webhook mode")
raise NotImplementedError()
if auto_attach:
log.d("Auto attaching bots from mongo")
attach_bots_from_manager()
log.i("Running attached bots")
[lotus_interface.run_bot(bot) for bot in variables.attached_bots]
variables.running = True
if idle:
lotus_interface.idle()
