def _log_response(self, session: Session, response: DBResponse):
network_id = ''
fcc_id = ''
cbsd_serial_number = ''
cbsd = response.request.cbsd
if cbsd and cbsd.network_id:
network_id = cbsd.network_id
if cbsd and cbsd.fcc_id:
fcc_id = cbsd.fcc_id
if cbsd and cbsd.cbsd_serial_number:
cbsd_serial_number = cbsd.cbsd_serial_number
log_name = request_response[response.request.type.name]
response_code = response.payload.get(
'response',
{},
).get('responseCode', None)
log = DBLog(
log_from='SAS',
log_to='DP',
log_name=f'{log_name}',
log_message=f'{response.payload}',
cbsd_serial_number=f'{cbsd_serial_number}',
network_id=f'{network_id}',
fcc_id=f'{fcc_id}',
response_code=response_code,
)
session.add(log)
def _get_or_create_grant_from_response(
obj: ResponseDBProcessor,
response: DBResponse,
session: Session,
) -> Optional[DBGrant]:
cbsd_id = response.payload.get(
CBSD_ID, ) or response.request.payload.get(CBSD_ID)
grant_id = response.payload.get(
GRANT_ID, ) or response.request.payload.get(GRANT_ID)
cbsd = session.query(DBCbsd).filter(DBCbsd.cbsd_id == cbsd_id).scalar()
grant = None
if grant_id:
logger.info(f'Getting grant by: {cbsd_id=} {grant_id=}')
grant = session.query(DBGrant).filter(
DBGrant.cbsd_id == cbsd.id,
DBGrant.grant_id == grant_id,
).scalar()
if grant_id and not grant:
grant_idle_state = obj.grant_states_map[GrantStates.IDLE.value]
grant = DBGrant(cbsd=cbsd, grant_id=grant_id, state=grant_idle_state)
_update_grant_from_request(response, grant)
session.add(grant)
logger.info(f'Created new grant: {grant}')
return grant
def _process_responses(
self,
requests: List[DBRequest],
sas_response: Response,
session: Session,
) -> None:
response_json_list = sas_response.json().get(self.response_type, [])
logger.debug(
f"[{self.response_type}] requests json list: {response_json_list}",
)
no_of_requests = len(requests)
no_of_responses = len(response_json_list)
if no_of_responses != no_of_requests:
logger.warning(
f"[{self.response_type}] Got {no_of_requests=} and {no_of_responses=}",
)
for response_json, db_request in zip(response_json_list, requests):
db_response = DBResponse(
response_code=int(response_json["response"]["responseCode"]),
payload=response_json,
request=db_request,
)
logger.info(
f"[{self.response_type}] Adding Response: {db_response} for Request {db_request}",
)
session.add(db_response)
self._log_response(session, db_response)
self._process_request(db_request)
logger.debug(
f'[{self.response_type}] About to process Response: {db_response}',
)
self._process_response(db_response, session)
def _create_or_update_active_mode_config(self, session: Session, cbsd: DBCbsd) -> DBActiveModeConfig:
registered_state = session.query(DBCbsdState). \
filter(DBCbsdState.name == CbsdStates.REGISTERED.value).first()
active_mode_config = session.query(DBActiveModeConfig). \
filter(DBActiveModeConfig.cbsd_id == cbsd.id).first()
if active_mode_config:
active_mode_config.desired_state = registered_state
return None
active_mode_config = DBActiveModeConfig(
desired_state=registered_state,
cbsd=cbsd,
)
session.add(active_mode_config)
return active_mode_config
def _get_or_create_cbsd(self, session: Session,
request: CBSDRequest) -> DBCbsd:
cbsd = session.query(DBCbsd).filter(
DBCbsd.cbsd_serial_number == request.serial_number, ).first()
if cbsd:
self._update_fields_from_request(cbsd, request)
return cbsd
unregistered_state = session.query(DBCbsdState). \
filter(DBCbsdState.name == CbsdStates.UNREGISTERED.value).first()
cbsd = DBCbsd(
cbsd_serial_number=request.serial_number,
state=unregistered_state,
)
self._update_fields_from_request(cbsd, request)
session.add(cbsd)
return cbsd
def _log_result(self, session: Session, method_name: str, result: CBSDStateResult, cbsd: DBCbsd, serial_number: str):
network_id = ''
fcc_id = ''
if cbsd:
network_id = cbsd.network_id or ''
fcc_id = cbsd.fcc_id or ''
log = DBLog(
log_from='DP',
log_to='CBSD',
log_name=method_name + 'Response',
log_message=f'{result}',
cbsd_serial_number=f'{serial_number}',
network_id=f'{network_id}',
fcc_id=f'{fcc_id}',
)
session.add(log)
def _create_cbsd(self, session: Session, request_payload: Dict, cbsd_id: Optional[str]):
cbsd_state = session.query(DBCbsdState).filter(
DBCbsdState.name == CbsdStates.UNREGISTERED.value,
).scalar()
user_id = request_payload.get("userId", None)
fcc_id = request_payload.get("fccId", None)
cbsd_serial_number = request_payload.get("cbsdSerialNumber", None)
cbsd = DBCbsd(
cbsd_id=cbsd_id,
state=cbsd_state,
user_id=user_id,
fcc_id=fcc_id,
cbsd_serial_number=cbsd_serial_number,
)
session.add(cbsd)
logging.info(f"New CBSD {cbsd=} created.")
return cbsd
def _log_request(self, session: Session, method_name: str, request: CBSDRequest, cbsd: DBCbsd):
cbsd_serial_number = request.serial_number
network_id = ''
fcc_id = ''
if cbsd:
network_id = cbsd.network_id or ''
fcc_id = cbsd.fcc_id or ''
log = DBLog(
log_from='CBSD',
log_to='DP',
log_name=method_name + 'Request',
log_message=f'{request}',
cbsd_serial_number=f'{cbsd_serial_number}',
network_id=f'{network_id}',
fcc_id=f'{fcc_id}',
)
session.add(log)
def _create_cbsd(self, session: Session, request_payload: Dict,
cbsd_id: Optional[str]):
cbsd_state_id = self.cbsd_states_map[CbsdStates.UNREGISTERED.value]
user_id = request_payload.get("userId", None)
fcc_id = request_payload.get("fccId", None)
cbsd_serial_number = request_payload.get("cbsdSerialNumber", None)
cbsd = DBCbsd(
cbsd_id=cbsd_id,
state_id=cbsd_state_id,
desired_state_id=cbsd_state_id,
user_id=user_id,
fcc_id=fcc_id,
cbsd_serial_number=cbsd_serial_number,
)
session.add(cbsd)
logging.info(f"New CBSD {cbsd=} created.")
return cbsd
def _create_grant_from_response(
response: DBResponse,
state: DBGrantState,
session: Session,
grant_id: str = None,
) -> Optional[DBGrant]:
grant_id = grant_id or response.grant_id
if not grant_id:
return None
cbsd_id = session.query(
DBCbsd.id).filter(DBCbsd.cbsd_id == response.cbsd_id)
grant = DBGrant(cbsd_id=cbsd_id.subquery(), grant_id=grant_id, state=state)
_update_grant_from_request(response, grant)
session.add(grant)
logger.info(f'Created new grant {grant}')
return grant
def _add_relinquish_requests(self, session: Session, cbsd: DBCbsd) -> None:
deregister_request_type = session.query(DBRequestType).filter(
DBRequestType.name == RequestTypes.RELINQUISHMENT.value,
).scalar()
grants = session.query(DBGrant).join(DBGrantState).filter(
DBGrant.cbsd_id == cbsd.id,
DBGrantState.name != GrantStates.IDLE.value,
)
for grant in grants:
request_dict = {"cbsdId": cbsd.cbsd_id, "grantId": grant.grant_id}
db_request = DBRequest(
type=deregister_request_type,
cbsd=cbsd,
payload=request_dict,
)
session.add(db_request)
logger.debug(f"Added {db_request=}.")
pass
def _create_channels(response: DBResponse, session: Session):
_terminate_all_grants_from_response(response, session)
cbsd_id = response.request.payload["cbsdId"]
cbsd = session.query(DBCbsd).filter(DBCbsd.cbsd_id == cbsd_id).scalar()
available_channels = response.payload.get("availableChannel")
if not available_channels:
logger.warning(
"Could not create channel from spectrumInquiryResponse. Response missing 'availableChannel' object",
)
return
for ac in available_channels:
frequency_range = ac["frequencyRange"]
channel = DBChannel(
cbsd=cbsd,
low_frequency=frequency_range["lowFrequency"],
high_frequency=frequency_range["highFrequency"],
channel_type=ac["channelType"],
rule_applied=ac["ruleApplied"],
max_eirp=ac.get("maxEirp"),
)
logger.info(f"Creating channel for {cbsd=}")
session.add(channel)
