def list_all_yaml_files(self, *args): ret_list = [] util.loadConfig() for conf_file in os.listdir(util.configLocation): if os.path.isfile(os.path.join(util.configLocation, conf_file)): m = re.search(".yaml", conf_file) if m != None: ret_list.append(conf_file) if len(ret_list) == 0: ret_list.insert(0, "Error:") ret_list.append("No yaml files found at <[" + util.configLocation + "]>") return ret_list
def test_WINNF_FT_S_SDS_10(self, config_filename): """Certificate of wrong type presented during registration. Checks that SAS UUT response with fatal alert message. """ config = loadConfig(config_filename) try: # This uses the same base_url as Registration(). self.assertTlsHandshakeFailure( self._sas.cbsd_sas_active_base_url, client_cert=config['domainProxyCert'], client_key=config['domainProxyKey']) except AssertionError as e: self.SasReset() # Load Devices device_a = json.load( open(os.path.join('testcases', 'testdata', 'device_a.json'))) # Register the devices devices = [device_a] request = {'registrationRequest': devices} response = self._sas.Registration( request, ssl_cert=config['domainProxyCert'], ssl_key=config['domainProxyKey'])['registrationResponse'] # Check Registration Response self.assertEqual(response[0]['response']['responseCode'], 104)
def test_WINNF_FT_S_SSS_10(self, config_filename): """Certificate of wrong type presented during Full Activity Dump. Checks that SAS UUT response with fatal alert message. """ config = loadConfig(config_filename) # Reset the SAS UUT self.SasReset() # Notify SAS UUT about peer SAS certificate_hash = getCertificateFingerprint(config['sasCert']) self._sas_admin.InjectPeerSas({'certificateHash': certificate_hash,\ 'url': SAS_TEST_HARNESS_URL}) try: self.assertTlsHandshakeFailure(client_cert=config['sasCert'], client_key=config['sasKey']) except AssertionError: trigger_succeed = False try: self.TriggerFullActivityDumpAndWaitUntilComplete( config['sasCert'], config['sasKey']) trigger_succeed = True except HTTPError as e: # Check if HTTP status is 403 self.assertEqual(e.error_code, 403) self.assertFalse(trigger_succeed, "Full Activity Dump is expected to fail")
def test_WINNF_FT_S_SCS_15(self,config_filename): """Certificate with inapplicable fields presented during registration. Checks that SAS UUT response with tls connection succedded and response should be 104. """ config = loadConfig(config_filename) # Load the keys/certs and check that TLS handshake is valid device_a_cert = config['clientCert'] device_a_key = config['clientKey'] # This uses the same base_url as Registration(). self.assertTlsHandshakeSucceed(self._sas.cbsd_sas_active_base_url, ['AES128-GCM-SHA256'], device_a_cert, device_a_key) # Load device and inject fccId and userId device_a = json.load(open(os.path.join('testcases', 'testdata', 'device_a.json'))) self.SasReset() self._sas_admin.InjectFccId({'fccId': device_a['fccId']}) self._sas_admin.InjectUserId({'userId': device_a['userId']}) # Send registration Request with certs(inapplicable fields) to SAS UUT request = {'registrationRequest': [device_a]} response = self._sas.Registration(request,ssl_cert=device_a_cert,ssl_key=device_a_key)['registrationResponse'][0] # Check registration response self.assertEqual(response['response']['responseCode'],104)
def test_WINNF_FT_S_PCR_5(self, config_filename): """Unsuccessful PPA Creation with one or more CBSDs Outside Service Area. Checks SAS UUT rejects creation of a PPA boundary if at least one of the CBSDs included in the CBSD cluster list does not belong to the PAL holder. """ # Load the Config file. config = loadConfig(config_filename) # Inject the PAL records. for pal_record in config['palRecords']: self._sas_admin.InjectPalDatabaseRecord(pal_record) # Register devices and check the response. cbsd_ids = self.assertRegistered(config['registrationRequests'], config['conditionalRegistrationData']) # Prepares the PAL Ids to trigger ppa creation request. pal_ids = [record['palId'] for record in config['palRecords']] # Create PPA creation request to SAS UUT. ppa_creation_request = {"cbsdIds": cbsd_ids, "palIds": pal_ids} # Trigger PPA Creation to SAS UUT and expect the failure response. # SAS does not create a PPA and generates an error. self.assertPpaCreationFailure(ppa_creation_request)
def test_WINNF_FT_S_GPR_3(self, config_filename): """GWPZ Exclusion Zone One or more CBSDs, located inside a GWPZ, request Grants and are rejected """ config = loadConfig(config_filename) # Step1: Admin Test Harness injects a GWPZ into the SAS UUT self._sas_admin.InjectWisp(config['gwpzRecord']) # Step2: Admin Test Harness triggers CPAS and waits until completion of CPAS self.TriggerDailyActivitiesImmediatelyAndWaitUntilComplete() # Step3: DP Test Harness registers N > 0 CBSDs cbsd_ids = self.assertRegistered(config['registrationRequests'], config['conditionalRegistrationData']) # Step4: DP Test Harness requests one Grant per registered CBSD grant_request = config['grantRequests'] addCbsdIdsToRequests(cbsd_ids, grant_request) request = {'grantRequest': grant_request} response = self._sas.Grant(request)['grantResponse'] self.assertEqual(len(response), len(grant_request)) for response_num, response in enumerate(response): self.assertEqual(response['cbsdId'], request['grantRequest'][response_num]['cbsdId']) self.assertEqual(response['response']['responseCode'], 400)
def test_WINNF_FT_S_QPR_2(self, config_filename): """[Configurable] Rejecting Registration of CBSD inside the NRAO/NRRO Quiet Zone. """ config = loadConfig(config_filename) # Very light checking of the config file. self.assertValidConfig(config, { 'registrationRequests': list, 'conditionalRegistrationData': list }) # Whitelist FCC IDs and User IDs. for device in config['registrationRequests']: self._sas_admin.InjectFccId({'fccId': device['fccId']}) self._sas_admin.InjectUserId({'userId': device['userId']}) # Pre-load conditional registration data. if config['conditionalRegistrationData']: self._sas_admin.PreloadRegistrationData( {'registrationData': config['conditionalRegistrationData']}) # Register CBSDs. request = {'registrationRequest': config['registrationRequests']} responses = self._sas.Registration(request)['registrationResponse'] # Check registration responses. self.assertEqual(len(responses), len(config['registrationRequests'])) for i, response in enumerate(responses): response = responses[i] logging.debug('Looking at response number %d', i) self.assertNotEqual(response['response']['responseCode'], 0) self.assertFalse('cbsdId' in response)
def prepare(): parser = argparse.ArgumentParser( description='Collect data for the paper to display') parser.add_argument('--config', required=True, help="File with the configuration") parser.add_argument('--collect', required=True, help="Data to collect") parser.add_argument('--target', required=True, help="Target to store the collected data to") args = parser.parse_args() collect_functions = { "base": get_base_data, "schemes": get_schemes_data, "labels": get_labels_data, "models2agg": get_models_agg, "labels2score": get_labels_score } config = util.loadConfig(args.config) config["req_collect"] = args.collect config["target"] = args.target config["collect_function"] = (collect_functions.get( args.collect, default_function)) config["labels"] = util.getLabels(config) return config
def test_WINNF_FT_S_SSS_15(self, config_filename): """Certificate with inapplicable fields presented during Full Activity Dump """ config = loadConfig(config_filename) # Reset the SAS UUT self.SasReset() # Notify SAS UUT about peer SAS certificate_hash = getCertificateFingerprint(config['sasCert']) self._sas_admin.InjectPeerSas({'certificateHash': certificate_hash,\ 'url': SAS_TEST_HARNESS_URL }) self.assertTlsHandshakeSucceed(self._sas_admin._base_url, ['AES128-GCM-SHA256'], config['sasCert'], config['sasKey']) trigger_succeed = False # Initiate Full Activity Dump try: self.TriggerFullActivityDumpAndWaitUntilComplete( config['sasCert'], config['sasKey']) trigger_succeed = True except HTTPError as e: # Check if HTTP status is 403 self.assertEqual(e.error_code, 403) self.assertFalse(trigger_succeed, "Full Activity Dump is expected to fail")
def __init__(self, conf = {}, daoClass = Dao): global logger if any(conf) == False: self.__conf = util.loadConfig(appName = moduleName) global webServerRoot webServerRoot = self.__conf['outputDir'] else: self.__conf = conf logger = logging.getLogger(moduleName) self.__daoClass = daoClass self.__dao = daoClass.getInstance() self.openclosDbSessionPlugin = OpenclosDbSessionPlugin(daoClass) if 'httpServer' in self.__conf and 'ipAddr' in self.__conf['httpServer'] and self.__conf['httpServer']['ipAddr'] is not None: self.host = self.__conf['httpServer']['ipAddr'] else: self.host = 'localhost' if 'httpServer' in self.__conf and 'port' in self.__conf['httpServer']: self.port = self.__conf['httpServer']['port'] else: self.port = 8080 self.baseUrl = 'http://%s:%d' % (self.host, self.port) self.report = ResourceAllocationReport(self.__conf, daoClass) # Create a single instance of l2Report as it holds thread-pool # for device connection. Don't create l2Report multiple times self.l2Report = L2Report(self.__conf, daoClass) # Create a single instance of l3Report as it holds thread-pool # for device connection. Don't create l3Report multiple times self.l3Report = L3Report(self.__conf, daoClass)
def test_WINNF_FT_S_SSS_11(self, config_filename): """Blacklisted certificate presented by SAS Test Harness. Checks that SAS UUT response with fatal alert message. """ # Reset SAS UUT self.SasReset() # Read the configuration config = loadConfig(config_filename) # Read the fingerprint from the certificate certificate_hash = getCertificateFingerprint(config['sasCert']) self._sas_admin.InjectPeerSas({ 'certificateHash': certificate_hash, 'url': SAS_TEST_HARNESS_URL }) # Tls handshake fails or Http 403 self.assertTlsHandshakeFailureOrHttp403(client_cert=config['sasCert'], client_key=config['sasKey'], is_sas=True) logging.info( "TLS handshake failed as the sas certificate has blacklisted")
def __init__(self, conf = {}): global logger if conf is None or any(conf) == False: self.__conf = util.loadConfig(appName = moduleName) else: self.__conf = conf logger = logging.getLogger(moduleName) # default value self.target = DEFAULT_HOST self.port = DEFAULT_PORT # validate required parameter if 'snmpTrap' in self.__conf and 'openclos_trap_group' in self.__conf['snmpTrap'] and 'target' in self.__conf['snmpTrap']['openclos_trap_group']: self.target = self.__conf['snmpTrap']['openclos_trap_group']['target'] else: logger.info("snmpTrap:openclos_trap_group:target is missing from configuration. using %s" % (self.target)) if 'snmpTrap' in self.__conf and 'openclos_trap_group' in self.__conf['snmpTrap'] and 'port' in self.__conf['snmpTrap']['openclos_trap_group']: self.port = int(self.__conf['snmpTrap']['openclos_trap_group']['port']) else: logger.info("snmpTrap:openclos_trap_group:port is missing from configuration. using %d" % (self.port)) if 'snmpTrap' in self.__conf and 'threadCount' in self.__conf['snmpTrap']: self.executor = concurrent.futures.ThreadPoolExecutor(max_workers = self.__conf['snmpTrap']['threadCount']) else: self.executor = concurrent.futures.ThreadPoolExecutor(max_workers = DEFAULT_MAX_THREADS) # event to stop from sleep self.stopEvent = Event() self.twoStageConfigurationCallback = util.getTwoStageConfigurationCallback(self.__conf)
def __init__(self, configuration_file, database_file='jonnyboards.db'): self.config = {} self.database = database.Database(database_file) (self.api_key, self.sensors) = util.loadConfig(configuration_file) self.ipaddress = util.get_ip_address() self._configureSensors()
def __init__(self, conf = {}): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel(logging.getLevelName(self.conf['logLevel'][moduleName])) else: self.conf = conf self.dao = Dao(self.conf)
def test_WINNF_FT_S_SCS_12(self,config_filename): """Expired certificate presented during registration. Checks that SAS UUT response with fatal alert message. """ config = loadConfig(config_filename) self.assertTlsHandshakeFailureOrHttp403(client_cert=config['clientCert'], client_key=config['clientKey'])
def test_WINNF_FT_S_SCS_6(self, config_filename): """Unrecognized root of trust certificate presented during registration. Checks that SAS UUT response with fatal alert with unknown_ca. """ config = loadConfig(config_filename) self.assertTlsHandshakeFailureOrHttp403(client_cert=config['clientCert'], client_key=config['clientKey'])
def __init__(self, conf={}): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel( logging.getLevelName(self.conf['logLevel'][moduleName])) else: self.conf = conf self.dao = Dao(self.conf)
def test_WINNF_FT_S_SDS_9(self, config_filename): """Non-CBRS trust root signed certificate presented during registration. Checks that SAS UUT response with fatal alert message. """ config = loadConfig(config_filename) self.assertTlsHandshakeFailureOrHttp403( client_cert=config['domainProxyCert'], client_key=config['domainProxyKey'])
def __init__(self, conf = {}, daoClass = Dao): global logger if any(conf) == False: self._conf = util.loadConfig(appName = moduleName) else: self._conf = conf logger = logging.getLogger(moduleName) self._dao = daoClass.getInstance()
def __init__(self, conf = {}): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel(logging.getLevelName(self.conf['logLevel'][moduleName])) else: self.conf = conf self.dao = Dao(self.conf) self.templateEnv = Environment(loader=PackageLoader('jnpr.openclos', junosTemplateLocation)) self.templateEnv.keep_trailing_newline = True
def test_WINNF_FT_S_WDB_1(self, config_filename): """PAL Database Update.""" # Load the configuration file config = loadConfig(config_filename) # Very light checking of the configuration file. self.assertEqual(len(config['registrationRequests']), len(config['palIds'])) # Step 1: Register device(s) 'C' with conditional registration data cbsd_ids = self.assertRegistered(config['registrationRequests'], config['conditionalRegistrationData']) # Step 2: Request creation of PPA(s). # Forming of PPA creation request(s) ppa_creation_requests = [] for cbsd_id, pal_ids in zip(cbsd_ids, config['palIds']): ppa_creation_requests.append({ "cbsdIds": [cbsd_id], "palIds": pal_ids }) # Trigger PPA creation. for ppa_creation_request in ppa_creation_requests: self.assertPpaCreationFailure(ppa_creation_request) # Step 3: Create PAL database with a PAL record containing the PAL ID 'P'. pal_database = DatabaseServer('PAL Database', config['palDatabaseConfig']['hostName'], config['palDatabaseConfig']['port']) # Start PAL database server. pal_database.start() # Set file path. pal_database.setFileToServe(config['palDatabaseConfig']['fileUrl'], config['palDatabaseConfig']['filePath']) # Inject the PAL database URL into the SAS UUT. self._sas_admin.InjectDatabaseUrl({ 'type': 'PAL', 'url': pal_database.getBaseUrl() + config['palDatabaseConfig']['fileUrl'] }) # Step 4: Admin Test Harness triggers CPAS. self.TriggerDailyActivitiesImmediatelyAndWaitUntilComplete() # Step 5: Request creation of PPA(s) again for ppa_creation_request in ppa_creation_requests: ppa_id = self.triggerPpaCreationAndWaitUntilComplete( ppa_creation_request) logging.debug('ppa_id received from SAS UUT:%s', ppa_id)
def __init__(self, conf = {}, templateEnv = None): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel(logging.getLevelName(self.conf['logLevel'][moduleName])) else: self.conf = conf self.dao = Dao(self.conf) if templateEnv is None: self.templateEnv = Environment(loader=PackageLoader('jnpr.openclos', ztpTemplateLocation))
def test_WINNF_FT_S_PCR_7(self, config_filename): """Overlapping PPA Boundaries. Checks SAS UUT shall doesnt create PPA zone within the service area. Checks SAS UUT shall confirm a valid PPA boundary claimed by the PAL holder, composed of one or more adjacent Census Tracts was overlapped by another PPA zone. """ # Load the Config file. config = loadConfig(config_filename) # Load the test_WINNF_FT_S_PCR_1 config. All other inputs must be identical # to those used in the corresponding configuration of PCR.1. pcr_1_test_config = loadConfig(config['configPCR_1']) # Inject the PAL records. for pal_record in pcr_1_test_config['palRecords']: self._sas_admin.InjectPalDatabaseRecord(pal_record) # Inject the overlap ppa zone into SAS UUT. zone_id = self._sas_admin.InjectZoneData( {'record': config['overlapPpaRecord']}) self.assertTrue(zone_id) # Register devices and check the response. cbsd_ids = self.assertRegistered( pcr_1_test_config['registrationRequests'], pcr_1_test_config['conditionalRegistrationData']) # Prepares the PAL Ids to trigger ppa creation request. pal_ids = [ record['palId'] for record in pcr_1_test_config['palRecords'] ] # Create PPA creation request with device which is already part of # existing PPA zone. ppa_creation_request = {"cbsdIds": cbsd_ids, "palIds": pal_ids} # Trigger PPA Creation to SAS UUT and check SAS UUT should not create PPA boundary # claimed by PAL holder was overlapped by PPA zone. self.assertPpaCreationFailure(ppa_creation_request)
def __init__(self, deviceId, conf = {}, daoClass = Dao): global logger if any(conf) == False: self._conf = util.loadConfig(appName = moduleName) else: self._conf = conf logger = logging.getLogger(moduleName) self.daoClass = daoClass self.pod = None self.deviceId = deviceId self.deviceConnectionHandle = None
def test_WINNF_FT_S_SCS_16(self, config_filename): """Certificate signed by a revoked CA presented during registration. Checks that SAS UUT response with fatal alert message. """ # Read the configuration config = loadConfig(config_filename) # Tls handshake fails since CA is revoked self.assertTlsHandshakeFailureOrHttp403(client_cert=config['clientCert'], client_key=config['clientKey']) logging.info("TLS handshake failed as the CA certificate has been revoked")
def test_WINNF_FT_S_SCS_11(self, config_filename): """Blacklisted certificate presented during registration. Checks that SAS UUT response with fatal alert message. """ # Read the configuration config = loadConfig(config_filename) # Tls handshake fails or http 403 response self.assertTlsHandshakeFailureOrHttp403(client_cert=config['clientCert'], client_key=config['clientKey']) logging.info("TLS handshake failed as the client certificate has blacklisted")
def test_WINNF_FT_S_SSS_17(self, config_filename): """Unknown SAS attempts to establish a TLS session. """ config = loadConfig(config_filename) # Reset the SAS UUT self.SasReset() # Attempt TLS handshake without injecting peer SAS info and verify it fails self.assertTlsHandshakeFailureOrHttp403(client_cert=config['sasCert'], client_key=config['sasKey'], is_sas=True)
def __init__(self, conf = {}, daoClass = Dao): global logger if any(conf) == False: self._conf = util.loadConfig(appName = moduleName) else: self._conf = conf logger = logging.getLogger(moduleName) self._dao = daoClass.getInstance() self._templateEnv = Environment(loader=PackageLoader('jnpr.openclos', junosTemplateLocation)) self._templateEnv.keep_trailing_newline = True self.isZtpStaged = util.isZtpStaged(self._conf)
def __init__(self, conf={}, templateEnv=None): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel( logging.getLevelName(self.conf['logLevel'][moduleName])) else: self.conf = conf self.dao = Dao(self.conf) if templateEnv is None: self.templateEnv = Environment( loader=PackageLoader('jnpr.openclos', ztpTemplateLocation))
def __init__(self, conf = {}, templateEnv = None, daoClass = Dao): global logger if any(conf) == False: self.__conf = util.loadConfig(appName = moduleName) else: self.__conf = conf logger = logging.getLogger(moduleName) self._dao = daoClass.getInstance() if templateEnv is None: self.templateEnv = Environment(loader=PackageLoader('jnpr.openclos', ztpTemplateLocation)) self.templateEnv.lstrip_blocks = True self.templateEnv.trim_blocks = True
def test_WINNF_FT_S_PCR_6(self, config_filename): """Unsuccessful PPA boundary Claimed by PAL Holder Not contained within Maximum PPA Boundary. SAS UUT shall reject a PPA boundary claimed by the PAL holder, that is not fully contained within the maximum PPA boundary created by SAS UUT. """ # Load the Config file. config = loadConfig(config_filename) # Load the test_WINNF_FT_S_PCR_1 config. All other inputs must be identical # to those used in the corresponding configuration of PCR.1. pcr_1_test_config = loadConfig(config['configPCR_1']) # Inject the PAL records. for pal_record in pcr_1_test_config['palRecords']: self._sas_admin.InjectPalDatabaseRecord(pal_record) # Register devices and check response. cbsd_ids = self.assertRegistered( pcr_1_test_config['registrationRequests'], pcr_1_test_config['conditionalRegistrationData']) # Prepares the PAL Ids to trigger ppa creation request. pal_ids = [ record['palId'] for record in pcr_1_test_config['palRecords'] ] # Create PPA creation request with user claimed ppa contour. ppa_creation_request = { "cbsdIds": cbsd_ids, "palIds": pal_ids, "providedContour": config['userClaimedPpaContour'] } # Trigger PPA Creation to SAS UUT. self.assertPpaCreationFailure(ppa_creation_request)
def test_WINNF_FT_S_SSS_12(self, config_filename): """Expired certificate presented by SAS Test Harness. Checks that SAS UUT response with fatal alert message. """ self.SasReset() config = loadConfig(config_filename) certificate_hash = getCertificateFingerprint(config['sasCert']) self._sas_admin.InjectPeerSas({ 'certificateHash': certificate_hash, 'url': SAS_TEST_HARNESS_URL }) self.assertTlsHandshakeFailureOrHttp403(client_cert=config['sasCert'], client_key=config['sasKey'], is_sas=True)
def test_WINNF_FT_S_SSS_18(self, config_filename): """Security requirement for Full Activity Dump message Request """ config = loadConfig(config_filename) # Reset the SAS UUT self.SasReset() # Notify SAS UUT about peer SAS certificate_hash = getCertificateFingerprint( config['validCertKeyPair']['cert']) self._sas_admin.InjectPeerSas({'certificateHash': certificate_hash,\ 'url': SAS_TEST_HARNESS_URL }) # Load a Device device_a = json.load( open(os.path.join('testcases', 'testdata', 'device_a.json'))) # Load grant request grant_a = json.load( open(os.path.join('testcases', 'testdata', 'grant_0.json'))) cbsd_ids, grant_ids = self.assertRegisteredAndGranted([device_a], [grant_a]) # Initiate Full Activity Dump with valid cert, key pair fadResponse = self.TriggerFullActivityDumpAndWaitUntilComplete(config['validCertKeyPair']['cert'], \ config['validCertKeyPair']['key']) self.assertContainsRequiredFields("FullActivityDump.schema.json", fadResponse) url = fadResponse['files'][0]['url'] # Attempting FAD record download with different invalid cert,key pair try: # This uses the same base_url as GetFullActivityDump(). self.assertTlsHandshakeFailure( self._sas.sas_sas_active_base_url, client_cert=config['invalidCertKeyPair']['cert'], client_key=config['invalidCertKeyPair']['key']) except AssertionError as e: try: self._sas.DownloadFile(url,config['invalidCertKeyPair']['cert'], \ config['invalidCertKeyPair']['key']) except HTTPError as e: self.assertEqual(e.error_code, 403) else: self.fail("FAD record file download should have failed")
def __init__(self, conf = {}): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel(logging.getLevelName(self.conf['logLevel'][moduleName])) global webServerRoot webServerRoot = self.conf['outputDir'] else: self.conf = conf self.dao = Dao(self.conf) if 'httpServer' in self.conf and 'ipAddr' in self.conf['httpServer'] and self.conf['httpServer']['ipAddr'] is not None: self.host = self.conf['httpServer']['ipAddr'] else: self.host = 'localhost' if 'httpServer' in self.conf and 'port' in self.conf['httpServer']: self.port = self.conf['httpServer']['port'] else: self.port = 8080 self.baseUrl = 'http://%s:%d' % (self.host, self.port)
def prepare(): parser = argparse.ArgumentParser( description='Print a config to a given hash and step' ) parser.add_argument('--config', required = True, help = "Main configuration file") parser.add_argument('--hash', required = True, help = "Hash to be checked") parser.add_argument('--step', required = True, help = "Step to be checked") args = parser.parse_args() config = loadConfig(args.config) config["cHash"] = args.hash config["step"] = args.step return config
def test_WINNF_FT_S_SSS_13(self, config_filename): """ Disallowed TLS method attempted during registration. Checks that SAS UUT response with fatal alert message. """ self.SasReset() # Load the configuration config = loadConfig(config_filename) # Read the fingerprint from the certificate certificate_hash = getCertificateFingerprint(config['sasCert']) self._sas_admin.InjectPeerSas({ 'certificateHash': certificate_hash, 'url': SAS_TEST_HARNESS_URL }) self.assertTlsHandshakeFailureOrHttp403(client_cert=config['sasCert'], client_key=config['sasKey'], ssl_method=SSL.TLSv1_1_METHOD, is_sas=True)
def test_WINNF_FT_S_REG_13(self, config_filename): """[Configurable] Unsupported SAS Protocol version.""" config = loadConfig(config_filename) # Very light checking of the config file. self.assertValidConfig( config, { 'fccIds': list, 'userIds': list, 'registrationRequests': list, 'sasVersion': basestring }) self.assertEqual(len(config['fccIds']), len(config['userIds'])) self.assertEqual(len(config['fccIds']), len(config['registrationRequests'])) # Use the (higher) SAS version set in the config file. self._sas.cbsd_sas_version = config['sasVersion'] # Whitelist N1 FCC ID. for fcc_id, max_eirp_dbm_per_10_mhz in config['fccIds']: self._sas_admin.InjectFccId({ 'fccId': fcc_id, 'fccMaxEirp': max_eirp_dbm_per_10_mhz }) # Whitelist N1 user ID. for user_id in config['userIds']: self._sas_admin.InjectUserId({'userId': user_id}) # Register N1 CBSD. request = {'registrationRequest': config['registrationRequests']} try: responses = self._sas.Registration(request)['registrationResponse'] # Check registration response. self.assertEqual(len(responses), len(config['registrationRequests'])) for i in range(len(responses)): response = responses[i] logging.debug('Looking at response number %d', i) self.assertEqual(response['response']['responseCode'], 100) except HTTPError as e: # Allow HTTP status 404 self.assertEqual(e.error_code, 404)
def test_WINNF_FT_S_SSS_14(self, config_filename): """ Invalid cipher suite presented during registration. Checks that SAS UUT response with fatal alert message. """ self.SasReset() # Load the configuration config = loadConfig(config_filename) # Read the fingerprint from the certificate certificate_hash = getCertificateFingerprint(config['sasCert']) self._sas_admin.InjectPeerSas({ 'certificateHash': certificate_hash, 'url': SAS_TEST_HARNESS_URL }) self.assertTlsHandshakeFailureOrHttp403( client_cert=config['sasCert'], client_key=config['sasKey'], ciphers='ECDHE-RSA-AES256-GCM-SHA384', is_sas=True)
def __init__(self, conf={}): if any(conf) == False: self.conf = util.loadConfig() logger.setLevel( logging.getLevelName(self.conf['logLevel'][moduleName])) global webServerRoot webServerRoot = self.conf['outputDir'] else: self.conf = conf self.dao = Dao(self.conf) if 'httpServer' in self.conf and 'ipAddr' in self.conf[ 'httpServer'] and self.conf['httpServer']['ipAddr'] is not None: self.host = self.conf['httpServer']['ipAddr'] else: self.host = 'localhost' if 'httpServer' in self.conf and 'port' in self.conf['httpServer']: self.port = self.conf['httpServer']['port'] else: self.port = 8080 self.baseUrl = 'http://%s:%d' % (self.host, self.port)
def __init__(self): config = util.loadConfig() host = config['mongoDB']['host'] port = config['mongoDB']['port'] dbName = config['mongoDB']['dbName'] objColName = config['mongoDB']['objCol'] tagColName = config['mongoDB']['tagCol'] rawColName = config['mongoDB']['rawCol'] recgColName = config['mongoDB']['recgCol'] toggleColName = config['mongoDB']['toggleCol'] path = 'mongodb://' + host + ':' + str(port) + '/' self.client = pymongo.MongoClient(path) self.db = self.client[dbName] self.objCol = self.db[objColName] self.tagCol = self.db[tagColName] self.togCol = self.db[toggleColName] self.rawCol = self.db[rawColName] self.recgCol = self.db[recgColName] self.updateTag = True self.updateObj = True self.relatedTags = {} self.rawToInsert = [] self.recgToInsert = []
def main(): """ Test CCNN. """ # Load the config settings. cfg = util.loadConfig() # Total patches in the dataset. n_patches = cfg.IMG_NUM * cfg.PATCH_PER_IMG # Build the test graph. test_graph = tf.Graph() with test_graph.as_default(): # Determine the testing size. test_n_patches = n_patches * cfg.TEST_PCT test_n_epoch = int(test_n_patches / cfg.BATCH_SIZE) # Pass through CCNN> test_patches, \ test_densities = ccnn.inputs('test', 0, cfg) test_predict = ccnn.inference(test_patches, is_train=True, cfg=cfg) test_loss = ccnn.miscount(test_predict, test_densities, totals=True) # Train on the entire training set. test_saver = tf.train.Saver() with tf.Session() as test_sess: # Load the last training checkpoint. ckpt = tf.train.get_checkpoint_state(cfg.TRAIN_CHECKPOINT_DIR) if ckpt and ckpt.model_checkpoint_path: test_saver.restore(test_sess, ckpt.model_checkpoint_path) else: print 'No checkpoint found!' # SUPER IMPORTANT. # Start filename queue runner. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) print 'Running {} batches ({} patches with batch size {})'.format( test_n_epoch, test_n_patches, cfg.BATCH_SIZE) # Run the testing session. num = test_n_epoch miscount = np.zeros([num * cfg.BATCH_SIZE, 3]) for step in xrange(num): # Slice for batch totals. s = slice(step*cfg.BATCH_SIZE, (step+1)*cfg.BATCH_SIZE) miscount[s, 0], miscount[s, 1], miscount[s, 2] = \ np.squeeze(test_sess.run(test_loss)) print 'Batch: {} -- True count: {:05.2f} Predict count: {:05.2f}'\ ' (err {:04.2f} - {:05.2f}%)'.format( step, np.mean(miscount[s, 0]), np.mean(miscount[s, 1]), np.mean(miscount[s, 2]), (100. * np.mean(miscount[s, 2])/np.mean(miscount[s, 0])) ) # Finish off filename queue coordinator. coord.request_stop() coord.join(threads) # Display histogram. path = os.path.join(cfg.TEST_CHECKPOINT_DIR, 'hist.png') dispColorHistogram(miscount, path)
# reorder tblNms according to tableOrder x = [d for d in configDict['applications'] if d['appName'] == app_name][0] if x and 'tableOrder' in x.keys(): tableOrder = x['tableOrder'] tn_in_db = [] for tn in tableOrder: if tn in tblNms: tn_in_db.append(tn) tblNms.remove(tn) tblNms = tn_in_db + tblNms tblTags= ["#%s"%tblNm for tblNm in tblNms] # Iterate over individual tables and retrieve the row data for display for tblNm in tblNms: rowcount = [row for row in c.execute("SELECT count(*) row_count FROM %s"%tblNm)][0][0] if rowcount < 500: rows = c.execute('select * from %s'%tblNm) # force ascii conversion for display colnames[tblNm] = [asciiDammit(description[0]) for description in c.description] dbTables[tblNm] = [[wpu.renderHtmlTableCell(x) for x in row] for row in rows] conn.close() return render_template('report.html', dbpaths=databases, run_id=run_id, tableNames=tblTags, filenames=filenames, filepaths=filepaths, imagetags=imagetags, dbTables=dbTables, colnames=colnames, app_name=app_name) if __name__ == '__main__': # read in the configuration file, then run the server configDict, appDataDirDict = wpu.loadConfig(configFile = 'appconfig.json') app.run(debug=True, host='0.0.0.0', port=5757)
def __init__(self, configuration_file, database_file='jonnyboards.db'): self.config = {} self.api_key, self.sensors = util.loadConfig(configuration_file) self.database = database.Database(database_file) self.ubidotsConfig()
#!/usr/bin/env python3 """ main loop starter for the ftpusbwatch program """ import os,sys,subprocess,time os.chdir(os.path.dirname(__file__)) # ensure correct working direcory try: import util,usbwait util.ntpTimeWait() config=util.loadConfig("config.json") log=util.initLogger(config) except KeyboardInterrupt: raise except Exception as e: """ if all else fails, do a git pull, hoping that will fix it """ import traceback traceback.print_exc() util.waitForNetwork(timeout=None) gitlog = subprocess.check_output("git pull -f",shell=True).decode('utf-8').strip() subprocess.call("sync") print(gitlog) if gitlog == "Already up-to-date.": print("Could not start. Waiting and git-pulling") time.sleep(3600) subprocess.Popen("./main.py",shell=True) sys.exit(0) try: log.info("boot|Waiting for network and updating") util.waitForNetwork(timeout=None)