def _log_requests_map(requests_map: dict, fluentd_client: FluentdClient):
requests_type = next(iter(requests_map))
for request in requests_map[requests_type]:
try:
log = make_dp_log(request)
fluentd_client.send_dp_log(log)
except (FluentdClientException, TypeError) as err:
logging.error(f"Failed to log {requests_type} request. {err}")
def _get_response_processor(req_type):
return ResponseDBProcessor(
request_response[req_type],
process_responses_func=processor_strategies[req_type]
["process_responses"],
fluentd_client=FluentdClient(),
)
def run():
"""
Top-level function for radio controller
"""
logger.info("Starting grpc server")
config = get_config()
scheduler = BackgroundScheduler()
metricsd_client = get_metricsd_client()
scheduler.add_job(
process_metrics,
args=[metricsd_client, config.SERVICE_HOSTNAME, "radio_controller"],
trigger=IntervalTrigger(
seconds=config.METRICS_PROCESSING_INTERVAL_SEC, ),
max_instances=1,
name="metrics_processing_job",
)
scheduler.start()
logger.info(f"grpc port is: {config.GRPC_PORT}")
db_engine = create_engine(
url=config.SQLALCHEMY_DB_URI,
encoding=config.SQLALCHEMY_DB_ENCODING,
echo=config.SQLALCHEMY_ECHO,
future=config.SQLALCHEMY_FUTURE,
pool_size=config.SQLALCHEMY_ENGINE_POOL_SIZE,
max_overflow=config.SQLALCHEMY_ENGINE_MAX_OVERFLOW,
)
session_manager = SessionManager(db_engine)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
add_RadioControllerServicer_to_server(
RadioControllerService(session_manager=session_manager),
server,
)
add_ActiveModeControllerServicer_to_server(
ActiveModeControllerService(session_manager=session_manager),
server,
)
add_DPServiceServicer_to_server(
DPService(
session_manager=session_manager,
now_func=datetime.now,
fluentd_client=FluentdClient(),
),
server,
)
server.add_insecure_port(f"[::]:{config.GRPC_PORT}")
server.start()
logger.info(f"GRPC Server started on port {config.GRPC_PORT}")
def handle_sigterm(*_):
logger.info("Received shutdown signal")
all_rpcs_done_event = server.stop(30)
all_rpcs_done_event.wait(30)
logger.info("Shut down gracefully")
signal(SIGTERM, handle_sigterm)
server.wait_for_termination()
def setUp(self):
super().setUp()
self.dp_service = DPService(SessionManager(self.engine), self._now, FluentdClient())
DBInitializer(SessionManager(self.engine)).initialize()
self.cbsd_states = {
x.name: x.id for x in self.session.query(DBCbsdState).all()
}
self.grant_states = {
x.name: x.id for x in self.session.query(DBGrantState).all()
}
def run():
"""
Top-level function for configuration controller
"""
config = get_config()
scheduler = BackgroundScheduler()
db_engine = create_engine(
url=config.SQLALCHEMY_DB_URI,
encoding=config.SQLALCHEMY_DB_ENCODING,
echo=config.SQLALCHEMY_ECHO,
future=config.SQLALCHEMY_FUTURE,
pool_size=config.SQLALCHEMY_ENGINE_POOL_SIZE,
max_overflow=config.SQLALCHEMY_ENGINE_MAX_OVERFLOW,
)
session_manager = SessionManager(db_engine=db_engine)
router = RequestRouter(
sas_url=config.SAS_URL,
rc_ingest_url=config.RC_INGEST_URL,
cert_path=config.CC_CERT_PATH,
ssl_key_path=config.CC_SSL_KEY_PATH,
request_mapping=request_mapping,
ssl_verify=config.SAS_CERT_PATH,
)
fluentd_client = FluentdClient()
for request_type in RequestTypes:
req_type = request_type.value
response_type = request_response[req_type]
consumer = RequestDBConsumer(
request_type=req_type,
request_processing_limit=config.REQUEST_PROCESSING_LIMIT,
)
processor = ResponseDBProcessor(
response_type=response_type,
process_responses_func=processor_strategies[req_type]["process_responses"],
fluentd_client=fluentd_client,
)
scheduler.add_job(
process_requests,
args=[consumer, processor, router, session_manager, fluentd_client],
trigger=IntervalTrigger(
seconds=config.REQUEST_PROCESSING_INTERVAL_SEC,
),
max_instances=1,
name=f"{req_type}_job",
)
scheduler.start()
while True:
time.sleep(1)
def run():
"""
Top-level function for radio controller
"""
logger.info("Starting grpc server")
config = get_config()
logger.info(f"grpc port is: {config.GRPC_PORT}")
db_engine = create_engine(
url=config.SQLALCHEMY_DB_URI,
encoding=config.SQLALCHEMY_DB_ENCODING,
echo=config.SQLALCHEMY_ECHO,
future=config.SQLALCHEMY_FUTURE,
pool_size=config.SQLALCHEMY_ENGINE_POOL_SIZE,
max_overflow=config.SQLALCHEMY_ENGINE_MAX_OVERFLOW,
)
session_manager = SessionManager(db_engine)
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
add_RadioControllerServicer_to_server(
RadioControllerService(session_manager=session_manager),
server,
)
add_ActiveModeControllerServicer_to_server(
ActiveModeControllerService(session_manager=session_manager),
server,
)
add_DPServiceServicer_to_server(
DPService(
session_manager=session_manager,
now_func=datetime.now,
fluentd_client=FluentdClient(),
),
server,
)
server.add_insecure_port(f"[::]:{config.GRPC_PORT}")
server.start()
logger.info(f"GRPC Server started on port {config.GRPC_PORT}")
def handle_sigterm(*_):
logger.info("Received shutdown signal")
all_rpcs_done_event = server.stop(30)
all_rpcs_done_event.wait(30)
logger.info("Shut down gracefully")
signal(SIGTERM, handle_sigterm)
server.wait_for_termination()