def reset_modem_hardly(self): logger.info("Modem is resetting via hardware...") sbc = supported_sbcs.get(conf.sbc) sbc.modem_power_disable() time.sleep(2) sbc.modem_power_enable()
def read_geoloc_data(self): """ Reads required data from modem in order to use at geolocation API """ logger.info("Getting raw geolocation data...") radio_type_id = 2 output = send_at_com('AT+QENG="servingcell"', "OK") if output[2] == 0: data = output[0].split(",") radio_type = data[radio_type_id].replace('"', '').casefold() try: for key in self.serving_cell_response_map: if key.find(radio_type) != -1: temp = self.serving_cell_response_map.get(key, {}) for key in temp: self.geolocation[key] = data[temp[key]].replace( '"', '').casefold() except: raise ValueError("Geolocation data is broken") else: raise RuntimeError(output[0]) # str/hex/int conversation try: for key in self.geolocation: if key in ["tac", "lac", "psc", "cid"]: self.geolocation[key] = int(self.geolocation[key], 16) elif key in ["mcc", "mnc"]: self.geolocation[key] = int(self.geolocation[key]) except: raise ValueError( "read_geoloc_data --> error occured converting hex to int")
def identify_modem(): global identified_module # Get old system setup if it is exist old_system_id = {} if os.path.isfile(SYSTEM_PATH): try: old_system_id = read_yaml_all(SYSTEM_PATH) except Exception as error: logger.warning("Old system_id in system.yaml file couln't be read!") system_id["modem_vendor"] = "" system_id["modem_name"] = "" system_id["modem_vendor_id"] = "" system_id["modem_product_id"] = "" logger.info("Tyring to detect modem...") output = shell_command("lsusb") if output[2] == 0: for module in modules: if output[0].find(module.pid) != -1: system_id["modem_vendor"] = module.vendor_name system_id["modem_name"] = module.module_name system_id["modem_vendor_id"] = module.vid system_id["modem_product_id"] = module.pid identified_module = module return identified_module logger.warning("Modem don't exist in list of supported modems!") for module in modules: if output[0].find(module.vid) != -1: system_id["modem_vendor"] = module.vendor_name system_id["modem_name"] = default_modules.get(str(module.vid)).module_name system_id["modem_vendor_id"] = module.vid system_id["modem_product_id"] = default_modules.get(str(module.vid)).pid identified_module = default_modules.get(str(module.vid)) return identified_module logger.warning("Modem vendor couldn't be found!") # clear modem identification data system_id["modem_vendor"] = None system_id["modem_name"] = None system_id["modem_vendor_id"] = None system_id["modem_product_id"] = None system_id["iccid"] = None system_id["imei"] = None system_id["sw_version"] = None if old_system_id.get("modem_vendor") is not None: try: write_yaml_all(SYSTEM_PATH, system_id) except Exception as error: raise RuntimeError("Save ID's to file") from error raise RuntimeError("Modem vendor couldn't be found!") else: raise RuntimeError("lsusb command error!")
def check_sim_ready(self): logger.info("Checking the SIM is ready...") output = send_at_com("AT+CPIN?", "CPIN: READY") if output[2] == 0: logger.info("SIM is ready.") else: logger.error(output[0]) raise SIMNotReady(output[0])
def reset_modem_hardly(self): logger.info("Modem is resetting via hardware...") self.deregister_network() time.sleep( 5) # wait a while before rebooting to complete nvm processes sbc = supported_sbcs.get(conf.sbc) sbc.modem_power_disable() time.sleep(2) sbc.modem_power_enable()
def deregister_network(self): """ Deregister from network and disable auto-registering """ output = send_at_com("AT+COPS=2", "OK") if output[2] == 0: logger.info("Modem is deregistered from network") else: raise RuntimeError("Network deregistering is failed!")
def wrapper_func(event, context): logger.debug("Received %s request with event: %s" % (event['RequestType'], json.dumps(event))) response = { "StackId": event["StackId"], "RequestId": event["RequestId"], "LogicalResourceId": event["LogicalResourceId"], "PhysicalResourceId": "custom_resource_physical_id", "Status": SUCCESS, } if event.get("PhysicalResourceId", False): response["PhysicalResourceId"] = event["PhysicalResourceId"] if base_response is not None: response.update(base_response) try: response.update(func(event, context)) except NoResponse: # Do nothing, maybe we're being rescheduled? return except Exception as e: logger.exception("Failed to execute resource function") reason = "Exception was raised while handling custom resource." reason += " Message {}".format(e.args or e.message) response.update({ "Status": FAILED, "Reason": reason, "Data": { 'FailureReason': reason } }) serialized = json.dumps(response) logger.info("Responding to '%s' request with: %s" % (event['RequestType'], serialized)) req = requests.put(event['ResponseURL'], data=serialized, headers={ 'Content-Length': str(len(serialized)), 'Content-Type': '' }) try: req logger.debug("Request to CFN API succeeded, nothing to do here") except requests.HTTPError as e: logger.error("Callback to CFN API failed with status %d" % e.code) logger.error("Response: %s" % e.reason) except requests.ConnectionError as e: logger.error("Failed to reach the server - %s" % e.reason)
def get_actual_configs(): if os.path.isfile(CONFIG_PATH): try: actual_cfg = read_yaml_all(CONFIG_PATH) except Exception as error: raise RuntimeError("get_actual_configs() -->") from error else: return actual_cfg else: logger.info("Config file doesn't exist!") return {}
def reset_modem_softly(self): logger.info("Modem is resetting softly...") output = send_at_com(self.reboot_command, "OK") if output[2] == 0: try: self.wait_until_modem_turned_off() self.wait_until_modem_started() except Exception as error: raise error else: raise RuntimeError("Reboot command couldn't be reach to the modem!")
def check_network(self): logger.info("Checking the network is ready...") output = send_at_com("AT+CREG?", "OK") if output[2] == 0: if output[0].find("+CREG: 0,1") != -1 or output[0].find( "+CREG: 0,5") != -1: logger.info("Network is registered") else: raise NetworkRegFailed("Network not registered: ", output) else: raise NetworkRegFailed("Error occured sending AT+CREG?: ", output)
def set_modem_eps_data_centric(self): output = send_at_com(self.eps_mode_status_command, self.eps_data_centric_response) if output[2] == 0: logger.info("Modem mode for EPS is OK") else: output = send_at_com(self.eps_mode_setter_command, "OK") if output[2] == 0: logger.info("Modem mode for EPS updated succesfully") else: raise ModemNotReachable("Modem mode for EPS couldn't be set successfully!")
def update_geolocation(modem, immediately=False): global last_check periodically = False geolocation_data = {} old_geolocation = {} if os.path.isfile(GEOLOCATION_PATH): try: old_geolocation = read_yaml_all(GEOLOCATION_PATH) except: logger.warning("Old geolocation data in geolocation.yaml file couln't be read!") else: now = int(time.time()) if now - last_check > 24*60*60: # a day periodically = True last_check = now old_geolocation.pop("last_update", None) else: immediately = True if immediately or periodically: logger.info("Checking geolocation data...") try: modem.read_geoloc_data() except: logger.error("Error occured getting geolocation data") else: for key in modem.geolocation: geolocation_data[key] = modem.geolocation[key] if geolocation_data != old_geolocation and geolocation_data != {}: geolocation_data["last_update"] = int(time.time()) # Save ID's to file try: write_yaml_all(GEOLOCATION_PATH, geolocation_data) except Exception as error: logger.error("write_yaml_all(GEOLOCATION_PATH, geolocation_data) -> %s", error) else: logger.info("Geolocation data updated with changes.") # GEOLOCATION REPORT if conf.debug_mode and conf.verbose_mode: print("") print("********************************************************************") print("[?] GEOLOCATION REPORT") print("-------------------------") for item in geolocation_data.items(): print(f"[+] {item[0]} --> {item[1]}") print("********************************************************************") print("")
def configure_apn(self): apn_with_quotes = '"%s"' % conf.apn output = send_at_com("AT+CGDCONT?", apn_with_quotes) if output[2] == 0: logger.info("APN is up-to-date.") else: output = send_at_com(f'AT+CGDCONT=1,"IPV4V6","{conf.apn}"', "OK") if output[2] == 0: logger.info("APN is updated succesfully : %s", conf.apn) else: raise ModemNotReachable("APN couldn't be set successfully!")
def exclude(self, resource_generator): items = [] for resource in resource_generator: logger.debug('include resource {}'.format(resource.arn)) if resource.arn: items.append({'policy': self.policy.arn, 'arn': resource.arn}) if resource.assumed_role != self.role.name: resource.detach_policy(self.policy.arn) else: resource.stop_assume_role(self.role.name) if len(items) > 0: logger.info('Remove resources {}'.format(items)) self.table.remove(items)
def check_network(self): logger.info("Checking the network is ready...") output = send_at_com("AT+CREG?", "OK") if output[2] == 0: if output[0].find("+CREG: 0,1") != -1 or output[0].find("+CREG: 0,5") != -1: logger.info("Network is registered.") else: logger.error(output[0]) raise NetworkRegFailed(output[0]) else: logger.error(output[0]) raise NetworkRegFailed(output[0])
def _check_internet(): global first_connection_flag if queue.sub == "check_internet_base": queue.set_step( sub="organizer", base="check_internet_base", success="check_internet_base", fail="diagnose_base", interval=conf.check_internet_interval, is_ok=False, retry=1, ) elif queue.sub == "check_internet_after_rci": queue.set_step( sub="organizer", base="check_internet_after_rci", success="check_internet_base", fail="reset_usb_interface", interval=10, is_ok=False, retry=0, ) elif queue.sub == "check_internet_after_rui": queue.set_step( sub="organizer", base="check_internet_after_rui", success="check_internet_base", fail="reset_modem_softly", interval=10, is_ok=False, retry=0, ) try: modem.check_internet() except Exception as error: logger.error("check_internet() -> %s", error) queue.is_ok = False else: if not first_connection_flag: logger.info("Internet connection is established") first_connection_flag = True if modem.incident_flag: modem.monitor["fixed_incident"] += 1 modem.incident_flag = False logger.info("Internet connection is restored") queue.is_ok = True
def reset_usb_interface(self): logger.info("USB interface is reset...") vendor_id = self.vid product_id = self.pid vendor_id_int = int(vendor_id, 16) product_id_int = int(product_id, 16) try: dev = usb.core.find(idVendor=vendor_id_int, idProduct=product_id_int) dev.reset() except Exception as error: raise error
def initiate_ecm(self, connection_delay=10): logger.info("Checking the ECM initialization...") output = send_at_com(self.pdp_status_command, "OK") if output[2] == 0: if output[0].find("0,1") != -1 or output[0].find("1,1") != -1: logger.info("ECM is already initiated.") time.sleep(10) return 0 logger.info("ECM Connection is initiating...") output = send_at_com(self.pdp_activate_command, "OK") if output[2] == 0: for _ in range(2): output = send_at_com(self.pdp_status_command, "OK") if output[2] == 0: if output[0].find("0,1") != -1 or output[0].find( "1,1") != -1: logger.info("ECM is initiated.") time.sleep(connection_delay) return 0 else: time.sleep(5) else: time.sleep(2) raise PDPContextFailed("ECM initiation timeout!") else: raise PDPContextFailed("ECM initiation failed!")
def create(self, path, name, base_policy): try: response = self.iam_client.create_policy( Path='/{}/'.format(path), PolicyName=name, PolicyDocument=base_policy, Description='Set the access to resources provisioned by products \ associated with Service Catalog Portfolio {}'.format(name) ) logger.info('Policy created: {}'.format(name)) return response['Policy']['Arn'] except ClientError as e: if e.response['Error']['Code'] == 'EntityAlreadyExists': return self.find(path, name)
def reset_modem_softly(self): logger.info("Modem is resetting softly...") self.deregister_network() time.sleep( 5) # wait a while before rebooting to complete nvm processes output = send_at_com(self.reboot_command, "OK") if output[2] == 0: try: self.wait_until_modem_turned_off() self.wait_until_modem_started() except Exception as error: raise error else: raise RuntimeError( "Reboot command couldn't be reach to the modem!")
def _check_internet(): global first_connection_flag if queue.sub == 5: queue.set_step( sub=0, base=5, success=5, fail=6, interval=conf.check_internet_interval, is_ok=False, retry=1, ) elif queue.sub == 8: queue.set_step(sub=0, base=8, success=5, fail=9, interval=10, is_ok=False, retry=0) elif queue.sub == 10: queue.set_step(sub=0, base=10, success=5, fail=11, interval=10, is_ok=False, retry=0) try: modem.check_internet() except Exception as error: logger.error("check_internet() -> %s", error) queue.is_ok = False else: if not first_connection_flag: logger.info("Internet connection is established") first_connection_flag = True if modem.incident_flag: modem.monitor["fixed_incident"] += 1 modem.incident_flag = False logger.info("Internet connection is restored") queue.is_ok = True
def wait_until_modem_interface_up(self): counter = 0 logger.debug("Interface Name: %s", self.interface_name) # Check modem connection interface for _ in range(20): output = shell_command("route -n") if output[0].find(self.interface_name) != -1: logger.info("Modem interface is detected.") counter = 0 break else: time.sleep(1) counter += 1 if counter != 0: raise ModemNotFound("Modem interface couln't be detected.")
def read_geoloc_data(self): """ Reads required data from modem in order to use at geolocation API """ logger.info("Getting raw geolocation data...") radio_type_id = 0 output = send_at_com("AT^SMONI", "OK") if output[2] == 0: data = parse_output(output, "^SMONI:", "\n").split(",") radio_type = data[radio_type_id].replace('"', '').casefold() if radio_type == "4g": radio_type = "lte" elif radio_type == "3g": radio_type = "wcdma" elif radio_type == "2g": radio_type = "gsm" try: for key in self.smoni_response_map: if key.find(radio_type) != -1: temp = self.smoni_response_map.get(key, {}) for key in temp: self.geolocation[key] = data[temp[key]].replace( '"', '').casefold() except: raise ValueError("Geolocation data is broken") else: raise RuntimeError(output[0]) # str/hex/int conversation try: for key in self.geolocation: if key in ["tac", "lac", "psc", "cid"]: self.geolocation[key] = int(self.geolocation[key], 16) elif key in ["mcc", "mnc"]: self.geolocation[key] = int(self.geolocation[key]) elif key == "radio_type": self.geolocation[key] = radio_type except: raise ValueError( "read_geoloc_data --> error occured converting hex to int")
def configure(): get_requests() for _ in range(len(waiting_requests)): save_configuration() apply_configs() if conf.reload_required: try: conf.update_config(get_configs()) except Exception as error: logger.error("conf.update_config() --> %s", error) else: conf.reload_required = False if conf.is_config_changed(): logger.info("Configuration is changed.") if conf.modem_config_required: logger.info("Modem configuration will be start soon.") # go to modem configuration step queue.set_step(sub=0, base=2, success=14, fail=13, interval=1, is_ok=False, retry=5) conf.modem_config_required = False if conf.log_config_required: if conf.debug_mode is True: update_log_debug(logger, True) else: update_log_debug(logger, False) conf.log_config_required = False conf.config_changed = False config_report()
def apply_configs(): if len(processing_requests) > 0: try: for request in processing_requests: filename = os.path.basename(request) done = filename + "_done" old = os.path.join(CONFIG_REQUEST_PATH, filename) new = os.path.join(CONFIG_REQUEST_PATH, done) os.rename(old, new) logger.info("Request --> %s is done.", filename) except Exception as error: logger.error("apply_configs() --> %s", error) else: processing_requests.clear() conf.reload_required = True logger.info("New configs are applied.")
def handle_message(msg): logger.info('New message topic: %s, message: %s', msg.topic, str(msg.payload)) splitted = msg.topic.split('/') deviceName = splitted[2] toExec = splitted[3] if toExec in ['status']: return light = devices.get(deviceName) try: jsonMsg = json.loads(str(msg.payload.decode("utf-8", "ignore"))) except: jsonMsg = {} if light is None: logger.error('Device %s is not supported, update config file', deviceName) return command = Command(light=light, deviceName=deviceName) handlers = dict( turnOn=command.on, turnOff=command.off, getStatus=command.status, setBrightness=command.brightness, ) commandToExec = handlers.get(toExec) if (commandToExec is None): logger.error('Not supported command %s for device %s', toExec, deviceName) return commandToExec(jsonMsg) del command
def adjust_priorities(self): default_metric_factor = 10 for ifs in self.interfaces: ifs.metric_factor = conf.network_priority.get(ifs.name, default_metric_factor) for iface in self.interfaces: # action when connection status changes if not iface.connection_status: iface.desired_metric = LOWEST_PRIORTY_FACTOR * 100 else: iface.desired_metric = iface.metric_factor * 100 # do changes if iface.actual_metric != iface.desired_metric: try: self.adjust_metric(iface.name, iface.desired_metric) except: logger.error("Error occured changing metric : %s", iface.name) else: logger.info("%s metric changed : %s", iface.name, iface.desired_metric)
def __init__(self): self.bot = TeleBot(settings.TOKEN) log.info('delete webhook') self.bot.delete_webhook() log.info('set webhook') self.bot.set_webhook(url=f"{settings.DOMAIN}/" f"{settings.TOKEN}") log.info('setup webhook complete')
def include(self, resource_generator): items = [] for resource in resource_generator: logger.debug('include resource {}'.format(resource.arn)) if resource.access_to: items.append({ 'arn': resource.arn, 'policy': self.policy.arn, 'sid': resource.statement_id, 'actions': resource.actions }) if resource.assumed_role: resource.attach_policy(self.policy.arn) if resource.access_from and not resource.assumed_role: try: resource.assume_role(self.role.arn) except MissingTrustRelationshipError: self.role.update_trust_document( resource.trust_relationship_service) if resource.service_name != 'ec2': resource.assume_role(self.role.arn) if len(items) > 0: logger.info('Add resources {}'.format(items)) self.table.add(items)
def diagnose(self, diag_type=0): logger.info("Diagnostic is working...") self.diag_modem_reachable() self.diag_apn_set() self.diag_modem_mode() self.diag_sim_ready() self.diag_network_register() self.diag_ecm_pdp_context() self.diag_usb_driver() self.diag_connection_interface() self.diag_usb_interface() for key, value in self.diagnostic.items(): # little endian if value is True: self.diagnostic_zip |= (1 << self.diagnostic_map[key]) elif value is False: self.diagnostic_zip &= ~(1 << self.diagnostic_map[key]) timestamp = int(time.time()) self.diagnostic["timestamp"] = timestamp diag = {"last_update": timestamp, "value": self.diagnostic_zip} if diag_type == 0: diag_file_name = "diagnostic.yaml" diag_file_path = DIAG_FOLDER_PATH + diag_file_name logger.info("Creating diagnostic report on --> %s", diag_file_path) write_yaml_all(diag_file_path, diag) else: diag_file_name = "diagnostic-repeated.yaml" diag_file_path = DIAG_FOLDER_PATH + diag_file_name logger.info("Creating diagnostic report on --> %s", diag_file_path) write_yaml_all(diag_file_path, diag) if conf.debug_mode and conf.verbose_mode: print("") print( "********************************************************************" ) print("[?] DIAGNOSTIC REPORT") print("---------------------") for item in self.diagnostic.items(): print(f"[+] {item[0]} --> {item[1]}") print( "********************************************************************" ) print("")