Files
log_analysis/services/control/control.py
T

131 lines
4.4 KiB
Python

import argparse
import asyncio
import json
from modules.logging.logger import *
from modules.storages.storage import Storage
from modules.transports.server import Server
from services.control.context import *
from services.control.create_context import *
from services.control.response import *
def Handle(context, request):
"""
Обработка запроса
:param context: Контекст сервиса
:param request: Запрос
:return: Ответ
"""
# Парсим запрос
try:
request = json.loads(request)
except Exception as e:
return ErrorResponse("invalid request", "failed to parse request")
# Проверяем наличие нужных ключей
for key in ["handler", "parameters"]:
if key not in request:
return ErrorResponse("invalid request", f"key '{key}' is required")
# Проверяем наличие обработчика с указанным именем
handler_name = request["handler"]
if not context.handler_manager.contains(handler_name):
return ErrorResponse("not found", f"there is no handler with name {handler_name}")
# Достаём нужного обработчика
handler = context.handler_manager.get(handler_name)
# Запускаем обработку
try:
result = handler.do(context, request["parameters"])
return SuccessResponse(result)
except Exception as e:
return ErrorResponse("handling failed", str(e))
def ParseArguments():
parser = argparse.ArgumentParser(description="Console client for Log Analysis")
# Данные сервера
parser.add_argument("--host", type=str, required=True, help="server's host")
parser.add_argument("--port", type=int, required=True, help="server's port")
# Данные для подключения к базе данных
parser.add_argument("--psql-host", type=str, required=True, help="postgresql's host")
parser.add_argument("--psql-port", type=str, required=True, help="postgresql's port")
parser.add_argument("--psql-database", type=str, required=True, help="postgresql's database")
parser.add_argument("--psql-user", type=str, required=True, help="postgresql's user")
parser.add_argument("--psql-password", type=str, required=True, help="postgresql's password")
arguments = parser.parse_args()
return arguments
class PostgreSqlSettings:
def __init__(self):
self.host = None
self.port = None
self.database = None
self.user = None
self.password = None
class Settings:
def __init__(self):
self.host = None
self.port = None
self.postgresql_settings = None
def CreateSettings():
arguments = ParseArguments()
postgresql_settings = PostgreSqlSettings()
postgresql_settings.host = arguments.psql_host
postgresql_settings.port = arguments.psql_port
postgresql_settings.database = arguments.psql_database
postgresql_settings.user = arguments.psql_user
postgresql_settings.password = arguments.psql_password
settings = Settings()
settings.host = arguments.host
settings.port = arguments.port
settings.postgresql_settings = postgresql_settings
return settings
def LogCallback(level, message):
print(f"level: {level}, message: {message}")
def main():
settings = CreateSettings()
server = Server(settings.host, settings.port, Handle)
server.setLogger(LogLevel.Warning, LogCallback)
# Создаём контекст
context = CreateContext()
# Подключаемся к хранилищу
context.storage = Storage(
settings.postgresql_settings.host,
settings.postgresql_settings.port,
settings.postgresql_settings.database,
settings.postgresql_settings.user,
settings.postgresql_settings.password
)
# Заполняем пайплайны
query = "select name, pipes from pipelines;"
pipelines = context.storage.do(query, should_return=True)
for name, pipes in pipelines:
context.pipeline_manager.create(name, json.loads(pipes))
# Указываем контекст в сервере
server.context = context
# Запускаем сервер
asyncio.run(server.run())
if __name__ == "__main__":
main()