def __init__(self, config): """Initialize AP.""" self.ssh_settings = settings.from_config(config["ssh_config"]) self.ssh = connection.SshConnection(self.ssh_settings) self.log = logger.create_logger(lambda msg: "[OpenWrtAP|%s] %s" % (self.ssh_settings.hostname, msg)) self.wireless_setting = None self.network_setting = network_settings.NetworkSettings( self.ssh, config["ssh_config"]["host"], self.log)
def __init__(self, adb): self._listen_for_port_lock = threading.Lock() self._sl4a_ports = set() self.adb = adb self.log = logger.create_logger(lambda msg: '[SL4A Manager|%s] %s' % (adb.serial, msg)) self.sessions = {} self._started = False self.error_reporter = error_reporter.ErrorReporter('SL4A %s' % adb.serial)
def __init__(self, serial, rpc_client): self._serial = serial self._rpc_client = rpc_client self._started = False self._executor = None self._event_dict = {} self._handlers = {} self._lock = threading.RLock() def _log_formatter(message): """Defines the formatting used in the logger.""" return '[E Dispatcher|%s|%s] %s' % (self._serial, self._rpc_client.uid, message) self.log = logger.create_logger(_log_formatter)
def __init__(self, configs): """ Args: configs: configs for the access point from config file. """ self.ssh_settings = settings.from_config(configs['ssh_config']) self.log = logger.create_logger(lambda msg: '[Access Point|%s] %s' % (self.ssh_settings.hostname, msg)) self.device_pdu_config = configs.get('PduDevice', None) self.identifier = self.ssh_settings.hostname if 'ap_subnet' in configs: self._AP_2G_SUBNET_STR = configs['ap_subnet']['2g'] self._AP_5G_SUBNET_STR = configs['ap_subnet']['5g'] else: self._AP_2G_SUBNET_STR = _AP_2GHZ_SUBNET_STR_DEFAULT self._AP_5G_SUBNET_STR = _AP_5GHZ_SUBNET_STR_DEFAULT self._AP_2G_SUBNET = dhcp_config.Subnet( ipaddress.ip_network(self._AP_2G_SUBNET_STR)) self._AP_5G_SUBNET = dhcp_config.Subnet( ipaddress.ip_network(self._AP_5G_SUBNET_STR)) self.ssh = connection.SshConnection(self.ssh_settings) # Singleton utilities for running various commands. self._ip_cmd = ip.LinuxIpCommand(self.ssh) self._route_cmd = route.LinuxRouteCommand(self.ssh) # A map from network interface name to _ApInstance objects representing # the hostapd instance running against the interface. self._aps = dict() self._dhcp = None self._dhcp_bss = dict() self.bridge = bridge_interface.BridgeInterface(self) self.interfaces = ap_get_interface.ApInterfaces(self) self.iwconfig = ap_iwconfig.ApIwconfig(self) # Get needed interface names and initialize the unneccessary ones. self.wan = self.interfaces.get_wan_interface() self.wlan = self.interfaces.get_wlan_interface() self.wlan_2g = self.wlan[0] self.wlan_5g = self.wlan[1] self.lan = self.interfaces.get_lan_interface() self._initial_ap() self.scapy_install_path = None self.setup_bridge = False
def __init__(self, adb, ports, client_socket, socket_fd, uid=UNKNOWN_UID): self._client_socket = client_socket self._socket_file = socket_fd self._ticket_counter = 0 self._ticket_lock = threading.Lock() self.adb = adb self.uid = uid def _log_formatter(message): """Defines the formatting used in the logger.""" return '[SL4A Client|%s|%s] %s' % (self.adb.serial, self.uid, message) self.log = logger.create_logger(_log_formatter) self.ports = ports self.set_timeout(rpc_client.SOCKET_TIMEOUT)
def __init__(self, settings): """ Args: settings: The ssh settings to use for this connection. formatter: The object that will handle formatting ssh command for use with the background job. """ self._settings = settings self._formatter = formatter.SshFormatter() self._lock = threading.Lock() self._master_ssh_proc = None self._master_ssh_tempdir = None self._tunnels = list() def log_line(msg): return '[SshConnection | %s] %s' % (self._settings.hostname, msg) self.log = logger.create_logger(log_line)
def __init__(self, adb, host_port, device_port, get_server_port_func, on_error_callback, max_connections=None): """Creates an SL4A Session. Args: adb: A reference to the adb proxy get_server_port_func: A lambda (int) that returns the corrected server port. The int passed in hints at which port to use, if possible. host_port: The port the host machine uses to connect to the SL4A server for its first connection. device_port: The SL4A server port to be used as a hint for which SL4A server to connect to. """ self._event_dispatcher = None self._terminate_lock = threading.Lock() self._terminated = False self.adb = adb def _log_formatter(message): return '[SL4A Session|%s|%s] %s' % (self.adb.serial, self.uid, message) self.log = logger.create_logger(_log_formatter) self.server_port = device_port self.uid = UNKNOWN_UID self.obtain_server_port = get_server_port_func self._on_error_callback = on_error_callback connection_creator = self._rpc_connection_creator(host_port) self.rpc_client = rpc_client.RpcClient(self.uid, self.adb.serial, self.diagnose_failure, connection_creator, max_connections=max_connections)
def __init__(self, configs): """Initialize objects. Args: configs: config for the packet capture. """ self.ssh_settings = settings.from_config(configs['ssh_config']) self.ssh = connection.SshConnection(self.ssh_settings) self.log = logger.create_logger(lambda msg: '[%s|%s] %s' % ( MOBLY_CONTROLLER_CONFIG_NAME, self.ssh_settings.hostname, msg)) self._create_interface(MON_2G, 'monitor') self._create_interface(MON_5G, 'monitor') self.managed_mode = True result = self.ssh.run('ifconfig -a', ignore_status=True) if result.stderr or SCAN_IFACE not in result.stdout: self.managed_mode = False if self.managed_mode: self._create_interface(SCAN_IFACE, 'managed') self.pcap_properties = dict() self._pcap_stop_lock = threading.Lock()
def __init__(self, uid, serial, on_error_callback, _create_connection_func, max_connections=None): """Creates a new RpcClient object. Args: uid: The session uid this client is a part of. serial: The serial of the Android device. Used for logging. on_error_callback: A callback for when a connection error is raised. _create_connection_func: A reference to the function that creates a new session. max_connections: The maximum number of connections the RpcClient can have. """ self._serial = serial self.on_error = on_error_callback self._create_connection_func = _create_connection_func self._free_connections = [self._create_connection_func(uid)] self.uid = self._free_connections[0].uid self._lock = threading.Lock() def _log_formatter(message): """Formats the message to be logged.""" return '[RPC Service|%s|%s] %s' % (self._serial, self.uid, message) self._log = logger.create_logger(_log_formatter) self._working_connections = [] if max_connections is None: self.max_connections = RpcClient.DEFAULT_MAX_CONNECTION else: self.max_connections = max_connections self._async_client = RpcClient.AsyncClient(self) self.is_alive = True
] # GPS TTFF Log Reading Config CONFIG_GPSTTFFLOG = { 'ttff_info': r'Loop:(?P<loop>\d+)\s+' r'(?P<start_datetime>\d+\/\d+\/\d+-\d+:\d+:\d+.\d+)\s+' r'(?P<stop_datetime>\d+\/\d+\/\d+-\d+:\d+:\d+.\d+)\s+' r'(?P<ttff>\d+.\d+)\s+' r'\[Antenna_Avg Top4 : (?P<ant_avg_top4_cn0>\d+.\d+)\]\s' r'\[Antenna_Avg : (?P<ant_avg_cn0>\d+.\d+)\]\s' r'\[Baseband_Avg Top4 : (?P<bb_avg_top4_cn0>\d+.\d+)\]\s' r'\[Baseband_Avg : (?P<bb_avg_cn0>\d+.\d+)\]\s+\[(?P<fix_type>\d+\w+ fix)\]\s+' r'\[Satellites used for fix : (?P<satnum_for_fix>\d+)\]' } LOGPARSE_UTIL_LOGGER = logger.create_logger() def parse_log_to_df(filename, configs, index_rownum=True): r"""Parse log to a dictionary of Pandas dataframes. Args: filename: log file name. Type String. configs: configs dictionary of parsed Pandas dataframes. Type dictionary. dict key, the parsed pattern name, such as 'Speed', dict value, regex of the config pattern, Type Raw String. index_rownum: index row number from raw data. Type Boolean.