team-builder/builder-service.py at main · RCSS-Tournament-Manager/team-builder · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
import asyncio
import aio_pika

from src.docker import Docker
from src.logger import get_logger
from src.message_handlers.kill_build import kill_build_command_handler
from src.message_handlers.ping import ping_command_handler
from src.message_handlers.build import build_command_handler
from src.message_handlers.status import status_command_handler
from src.message_handler import MessageHandler
from src.rabbitmq import RabbitMQ
from src.routes.status import handle_status
from src.states import StateManager
from src.storage import MinioClient
from src.webserver import Webserver
from src import env
logger = get_logger(__name__)

loop = asyncio.get_event_loop()


async def main(loop):


    # ----------------------
    # RabbitMQ
    # ----------------------
    rabbit = RabbitMQ(
        loop=loop,
        server=env.RABBITMQ_ADDRESS,
        port=61613,
        queue="build_queue",
        username=env.RABBITMQ_USERNAME,
        password=env.RABBITMQ_PASSWORD
    )
    logger.info("rabbitmq consumer started")
    try:
        logger.info("rabbitmq connecting...")
        await rabbit.connect()
        logger.info("rabbitmq connected")
    except Exception as e:
        logger.error("rabbitmq connection failed")
        logger.error(e)
        exit(1)


    # ----------------------
    # Storage
    # ----------------------
    storage = MinioClient(
        endpoint=env.MINIO_ADDRESS+ ":" + str(env.MINIO_PORT),
        access_key=env.MINIO_USERNAME,
        secret_key=env.MINIO_PASSWORD,
        secure=False
    )
    try:
        logger.info("storage connecting...")
        storage.connect()
        logger.info("storage connected")
    except Exception as e:
        logger.error("storage connection failed")
        logger.error(e)
        exit(1)


    # ----------------------
    # Docker
    # ----------------------
    docker = Docker(
        default_registry=env.DOCKER_REGISTERY_ADDRESS+ ":" + str(env.DOCKER_REGISTERY_PORT),
        username=env.DOCKER_REGISTERY_USERNAME,
        password=env.DOCKER_REGISTERY_PASSWORD
    )
    try:
        logger.info("docker connecting...")
        docker.connect()
        logger.info("docker connected")
    except Exception as e:
        logger.error("docker connection failed")
        logger.error(e)
        exit(1)


    # ----------------------
    # Webserver
    # ----------------------
    server = Webserver(
        host=env.WEBSERVER_ADDRESS,
        port=env.WEBSERVER_PORT
    )

    # --- routes
    server.add_get('/status', handle_status)
    try:
        await server.listen()
        logger.info("webserver connected")
    except Exception as e:
        logger.error("webserver connection failed")
        logger.error(e)
        exit(1)


    # ----------------------
    # State Manager
    # ----------------------
    state_manager = StateManager()


    # ----------------------

    # --- add message handler
    mh = MessageHandler(
        rabbit=rabbit,
        storage=storage,
        docker=docker,
        server=server,
        state_manager=state_manager
    )

    mh.add_command_handler("build", build_command_handler)
    mh.add_command_handler("kill_build" , kill_build_command_handler)
    mh.add_command_handler("ping", ping_command_handler)
    mh.add_command_handler("status", status_command_handler)


    await rabbit.add_message_handler(mh.message_processor)


if __name__ == "__main__":
    try:
        loop.run_until_complete(main(loop))
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    finally:
        loop.run_until_complete(loop.shutdown_asyncgens())
        loop.close()