def main():
"""
Top-level function for enodebd
"""
service = MagmaService('enodebd', mconfigs_pb2.EnodebD())
logger.init()
# Optionally pipe errors to Sentry
sentry_init(service_name=service.name,
sentry_mconfig=service.shared_mconfig.sentry_config)
# State machine manager for tracking multiple connected eNB devices.
state_machine_manager = StateMachineManager(service)
# Statistics manager
stats_mgr = StatsManager(state_machine_manager)
stats_mgr.run()
# Start TR-069 thread
server_thread = Thread(
target=tr069_server,
args=(state_machine_manager, ),
daemon=True,
)
server_thread.start()
print_grpc_payload = service.config.get('print_grpc_payload', False)
# Add all servicers to the server
enodebd_servicer = EnodebdRpcServicer(
state_machine_manager,
print_grpc_payload,
)
enodebd_servicer.add_to_server(service.rpc_server)
# Register function to get service status
def get_enodebd_status():
return get_service_status_old(state_machine_manager)
service.register_get_status_callback(get_enodebd_status)
# Register a callback function for GetOperationalStates service303 function
def get_enodeb_operational_states() -> List[State]:
return get_operational_states(
state_machine_manager,
service.mconfig,
print_grpc_payload,
)
service.register_operational_states_callback(get_enodeb_operational_states)
# Set eNodeBD iptables rules due to exposing public IP to eNodeB
service.loop.create_task(set_enodebd_iptables_rule())
# Run the service loop
service.run()
# Cleanup the service
service.close()
def main():
"""
Main co-routine for linkstatsd
:return: None
"""
parser = create_parser()
args = parser.parse_args()
# set up logging
logging.basicConfig(
level=logging.DEBUG if args.verbose else logging.INFO,
format=
"[%(asctime)s %(levelname)s %(filename)s:%(lineno)d] %(message)s",
)
# Get service config
service = MagmaService("linkstatsd", wifi_mconfigs_pb2.Linkstatsd())
# Create stats collector
collector = LinkstatsCollector(service.loop, service.config,
service.mconfig)
# Create network state manager
state_mgr = NetworkStateManager(service.loop, service.config,
service.mconfig)
# Start state manager's state-updating loop
state_mgr.start()
# Register callback function to sync state with the cloud
service.register_get_status_callback(state_mgr.get_state)
# Start collector loop
collector.start_collector()
if SDWatchdog.has_notify():
# Create systemd watchdog
sdwatchdog = SDWatchdog([collector, state_mgr], update_status=True)
# Start watchdog loop
service.loop.create_task(sdwatchdog.run())
# Run the service loop
service.run()
# Cleanup the service
service.close()
def main():
"""
Top-level function for enodebd
"""
service = MagmaService('enodebd')
# State machine manager for tracking multiple connected eNB devices.
state_machine_manager = StateMachineManager(service)
# Statistics manager
stats_mgr = StatsManager(state_machine_manager)
stats_mgr.run()
# Start TR-069 thread
server_thread = Thread(target=tr069_server,
args=(state_machine_manager, ),
daemon=True)
server_thread.start()
# Add all servicers to the server
enodebd_servicer = EnodebdRpcServicer(state_machine_manager)
enodebd_servicer.add_to_server(service.rpc_server)
# Register function to get service status
def get_enodebd_status():
return get_service_status_old(state_machine_manager)
service.register_get_status_callback(get_enodebd_status)
# Register a callback function for GetOperationalStates service303 function
def get_enodeb_operational_states() -> List[State]:
return get_operational_states(state_machine_manager)
service.register_operational_states_callback(get_enodeb_operational_states)
# Set eNodeBD iptables rules due to exposing public IP to eNodeB
service.loop.create_task(set_enodebd_iptables_rule())
# Run the service loop
service.run()
# Cleanup the service
service.close()
def main():
"""
Top-level function for enodebd
"""
service = MagmaService('enodebd')
# Statistics manager
stats_mgr = StatsManager()
stats_mgr.run()
# We incorrectly assume that we are dealing with a Baicells device here.
# When this assumption is invalidated (after the device reports its
# make and model, then we recreate a new handler to use
acs_state_machine = BaicellsHandler(service, stats_mgr)
state_machine_pointer = StateMachinePointer(acs_state_machine)
# Start TR-069 thread
server_thread = Thread(target=tr069_server,
args=(state_machine_pointer, ),
daemon=True)
server_thread.start()
# Add all servicers to the server
enodebd_servicer = EnodebdRpcServicer(state_machine_pointer)
enodebd_servicer.add_to_server(service.rpc_server)
# Register function to get service status
def get_status():
return get_enodeb_status(state_machine_pointer.state_machine)
service.register_get_status_callback(get_status)
# Set eNodeBD iptables rules due to exposing public IP to eNodeB
service.loop.create_task(set_enodebd_iptables_rule())
# Run the service loop
service.run()
# Cleanup the service
service.close()