def get_single_enb_status(
device_serial: str,
state_machine_manager: StateMachineManager) -> SingleEnodebStatus:
try:
handler = state_machine_manager.get_handler_by_serial(device_serial)
except KeyError:
return _empty_enb_status()
# This namedtuple is missing IP and serial info
status = get_enb_status(handler)
# Get IP info
ip = state_machine_manager.get_ip_of_serial(device_serial)
def get_status_property(status: bool) -> SingleEnodebStatus.StatusProperty:
if status:
return SingleEnodebStatus.StatusProperty.Value('ON')
return SingleEnodebStatus.StatusProperty.Value('OFF')
# Build the message to return through gRPC
enb_status = SingleEnodebStatus()
enb_status.device_serial = device_serial
enb_status.ip_address = ip
enb_status.connected = get_status_property(status.enodeb_connected)
enb_status.configured = get_status_property(status.enodeb_configured)
enb_status.opstate_enabled = get_status_property(status.opstate_enabled)
enb_status.rf_tx_on = get_status_property(status.rf_tx_on)
enb_status.rf_tx_desired = get_status_property(status.rf_tx_desired)
enb_status.gps_connected = get_status_property(status.gps_connected)
enb_status.ptp_connected = get_status_property(status.ptp_connected)
enb_status.mme_connected = get_status_property(status.mme_connected)
enb_status.gps_longitude = status.gps_longitude
enb_status.gps_latitude = status.gps_latitude
enb_status.fsm_state = status.fsm_state
return enb_status
def get_all_enb_status(
enb_acs_manager: StateMachineManager, ) -> Dict[str, EnodebStatus]:
enb_status_by_serial = {}
serial_list = enb_acs_manager.get_connected_serial_id_list()
for enb_serial in serial_list:
handler = enb_acs_manager.get_handler_by_serial(enb_serial)
status = get_enb_status(handler)
enb_status_by_serial[enb_serial] = status
return enb_status_by_serial
def get_operational_states(enb_acs_manager: StateMachineManager,
mconfig: mconfigs_pb2.EnodebD) -> List[State]:
"""
Returns: A list of State with EnodebStatus encoded as JSON
"""
states = []
configured_serial_ids = []
enb_status_by_serial = get_all_enb_status(enb_acs_manager)
for serial_id in enb_status_by_serial:
enb_status_dict = enb_status_by_serial[serial_id]._asdict()
enb_status_dict['ip_address'] = enb_acs_manager.get_ip_of_serial(
serial_id)
serialized = json.dumps(enb_status_dict)
state = State(type="single_enodeb",
deviceID=serial_id,
value=serialized.encode('utf-8'))
configured_serial_ids.append(serial_id)
states.append(state)
# Get S1 connected eNBs
s1_states = get_enb_s1_connected_states(configured_serial_ids, mconfig)
for state in s1_states:
states.append(state)
return states
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 get_operational_states(
state_machine_manager: StateMachineManager) -> List[State]:
"""
Returns: A list of SingleEnodebStatus encoded as JSON into State
"""
states = []
for serial_id in state_machine_manager.get_connected_serial_id_list():
enb_state = get_single_enb_status(serial_id, state_machine_manager)
state = State(type="enodeb",
deviceID=serial_id,
value=MessageToJson(enb_state).encode('utf-8'))
states.append(state)
return states
def get_operational_states(
enb_acs_manager: StateMachineManager,
mconfig: mconfigs_pb2.EnodebD,
print_grpc_payload: bool = False,
) -> List[State]:
"""
Returns: A list of State with EnodebStatus encoded as JSON
"""
states = []
configured_serial_ids = []
enb_status_by_serial = get_all_enb_status(enb_acs_manager)
# Get S1 connected eNBs
enb_statuses = get_all_enb_state(print_grpc_payload)
for serial_id in enb_status_by_serial:
enb_status_dict = enb_status_by_serial[serial_id]._asdict()
# Add IP address to state
enb_status_dict['ip_address'] = enb_acs_manager.get_ip_of_serial(
serial_id,
)
# Add num of UEs connected
num_ue_connected = enb_statuses.get(enb_status_dict['cell_id'], 0)
enb_status_dict['ues_connected'] = num_ue_connected
serialized = json.dumps(enb_status_dict)
state = State(
type="single_enodeb",
deviceID=serial_id,
value=serialized.encode('utf-8'),
)
configured_serial_ids.append(serial_id)
states.append(state)
# Get state for externally configured enodebs
s1_states = get_enb_s1_connected_states(
enb_statuses,
configured_serial_ids,
mconfig,
)
states.extend(s1_states)
return states
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 _get_manager(self) -> StateMachineManager:
service = EnodebAcsStateMachineBuilder.build_magma_service()
return StateMachineManager(service)
def setUp(self) -> None:
service = EnodebConfigBuilder.get_service_config()
self.enb_acs_manager = StateMachineManager(service)
self.mgr = StatsManager(self.enb_acs_manager)
self.is_clear_stats_called = False
def build_multi_enb_acs_manager(cls, ) -> StateMachineManager:
service = cls.build_multi_enb_magma_service()
return StateMachineManager(service)
def build_acs_manager(
cls,
device: EnodebDeviceName = EnodebDeviceName.BAICELLS,
) -> StateMachineManager:
service = cls.build_magma_service(device)
return StateMachineManager(service)
