def get_endpoints(self): """Return a list of all Endpoints from Asterisk.""" result = self._api.call('endpoints', http_method='GET') # Temporary until method is implemented result_list = [Endpoint(self._api), Endpoint(self._api)] #endpoints = [Endpoint(x) for x in result] return result_list
def _parse_scenarios(scenarios, lab): result = {} for line in scenarios.splitlines(): try: _, flow = line.split('From ') from_, to_ = flow.split(' to ') from_point = Endpoint(from_) to_point = Endpoint(to_) result.setdefault(from_point, []).append(to_point) except: print('*** Failed to parse scenario {}'.format(line)) raise return result
def setUp(self): self.videos = [Video(0, 50), Video(1, 30)] self.cache_servers = [CacheServer(0, 40)] self.endpoints = [ Endpoint(0, { 0: 100, 1: 200 }, [(10, self.cache_servers[0])]), Endpoint(0, { 0: 100, 1: 50 }) ]
def __init__(self, hostname, username, password, port_or_endpoint=None, path=None): self.isql = ISQLWrapper(hostname, username, password) if type(port_or_endpoint) == str: #full endpoint path self.endpoint = Endpoint(port_or_endpoint) elif type(port_or_endpoint) == int: #just the port self.endpoint = Endpoint(hostname, port_or_endpoint, path) else: raise Exception("Incorrect endpoint url or port.")
def test_mock_request(self): endpoint = Endpoint("mock") response = endpoint.make_request(None, "warfarin") obj = response.json() self.assertTrue("200", response.status_code) # print(obj["results"][0]["brand_name"]) self.assertEqual("Warfarin Sodium", obj["results"][0]["brand_name"])
def get_endpoints(urls, config): """ get all endpoints from config """ endpoints = [] for e in urls: try: # now before we create the endpoint object lets see if we specified credentials # if not we will add the credentials from the environment by default if not 'credentials' in e or not 'username' in e[ 'credentials'] or not 'password' in e['credentials']: e['credentials'] = { 'username': config.http_user, 'password': config.http_pass } # add the timezone info to the endpoint (to render the correct date/time) e['timezone'] = config.timezone # create an endpoint object endpoints.append(Endpoint(**e)) except: logger.warn( "Not able to load entrypoint definition for '{}'.".format( e['id'])) pass return endpoints
def parse(self): with open(self.filename, 'r') as input_f: lines = [line.strip('\n') for line in input_f.readlines()] # Global parameters. self.n_videos, self.n_endpoints, self.n_requests, self.n_caches, self.cache_size = to_int( lines[0]) self.video_sizes = to_int(lines[1]) self.videos = [Video(i) for i in range(self.n_videos)] # Endpoints number_handled = 0 i = 2 while number_handled != self.n_endpoints: dc_latency, caches = to_int(lines[i]) i += caches # Register the latencies for this datacenter. latencies = {} for j in range(1, 1 + caches): info = to_int(lines[i + j]) latencies[info[0]] = info[1] self.endpoints.append( Endpoint(number_handled, dc_latency, latencies)) number_handled += 1 i += 1 number_handled = 0 for j in range(i, self.n_requests + i): video, source, qty = to_int(lines[j]) self.endpoints[source].requests.append( Request(number_handled, source, video, qty)) self.videos[video].requests.append( Request(number_handled, source, video, qty))
def __init__(self, endpoint, timestamp=None, value=None): if isinstance(endpoint, Endpoint): self.endpoint = endpoint elif isinstance(endpoint, dict): self.endpoint = Endpoint(endpoint["service_name"], endpoint["ipv4"]) self.timestamp = timestamp self.value = value
def __init__(self): parser = Parser(CONFIG_PATH) self._host = parser.server()['host'] self._port = parser.server()['port'] self._endpoints = {} for ep in parser.endpoints(): self._endpoints[ep['endpoint_url']] = Endpoint(ep)
def load_data(self, input_file): with open(input_file, 'r') as f: self.n_videos, self.n_endpoints, self.n_requests, self.n_caches, self.s_caches = list( map(int, f.readline().split())) self.video_sizes = list(map(int, f.readline().split())) for i in range(self.n_endpoints): datacenter_latency, num_connected_caches = list( map(int, f.readline().split())) e = Endpoint(datacenter_latency) for j in range(num_connected_caches): id_cache, latency_cache = list( map(int, f.readline().split())) conn = CacheConnection(id_cache, latency_cache) e.connected_caches.append(conn) self.endpoints.append(e) for i in range(self.n_requests): video, endpoint, num_requests = list( map(int, f.readline().split())) r = VideoRequest(video, endpoint, num_requests) self.endpoints[endpoint].video_requests.append(r) self.requests.append(r)
def add_endpoint(my_request): if not my_request.pmh_url: return None endpoint_with_this_id = Endpoint.query.filter( Endpoint.repo_request_id == my_request.id).first() if endpoint_with_this_id: print u"one already matches {}".format(my_request.id) return None raw_endpoint = my_request.pmh_url clean_endpoint = raw_endpoint.strip() clean_endpoint = clean_endpoint.strip("?") clean_endpoint = re.sub(u"\?verb=.*$", "", clean_endpoint, re.IGNORECASE) print u"raw endpoint is {}, clean endpoint is {}".format( raw_endpoint, clean_endpoint) matching_endpoint = Endpoint() matching_endpoint.pmh_url = clean_endpoint repo_matches = my_request.matching_repositories() if repo_matches: matching_repo = repo_matches[0] print u"yay! for {} {} matches repository {}".format( my_request.institution_name, my_request.repo_name, matching_repo) else: print u"no matching repository for {}: {}".format( my_request.institution_name, my_request.repo_name) matching_repo = Repository() # overwrite stuff with request matching_repo.institution_name = my_request.institution_name matching_repo.repository_name = my_request.repo_name matching_repo.home_page = my_request.repo_home_page matching_endpoint.repo_unique_id = matching_repo.id matching_endpoint.email = my_request.email matching_endpoint.repo_request_id = my_request.id matching_endpoint.ready_to_run = True matching_endpoint.set_identify_and_initial_query() db.session.merge(matching_endpoint) db.session.merge(matching_repo) print u"added {} {}".format(matching_endpoint, matching_repo) print u"see at url http://unpaywall.org/sources/repository/{}".format( matching_endpoint.id) safe_commit(db) print "saved" print "now sending email" # get the endpoint again, so it gets with all the meta info etc matching_endpoint = Endpoint.query.get(matching_endpoint.id) matching_endpoint.contacted_text = "automated welcome email" matching_endpoint.contacted = datetime.datetime.utcnow().isoformat() safe_commit(db) send_announcement_email(matching_endpoint) print "email sent" return matching_endpoint
def read_data(filename): with open('../inputs/%s.in' % filename) as f: fl = line_to_int_list(f) num_endpoint = fl[1] num_request = fl[2] num_cache = fl[3] cache_size = fl[4] cache_servers = [CacheServer(i, cache_size) for i in range(num_cache)] vidoe_sizes = line_to_int_list(f) vidoes = [Video(i, s) for i, s in enumerate(vidoe_sizes)] end_points = list() for i in range(num_endpoint): l = line_to_int_list(f) endpoint = Endpoint(i) for j in range(l[1]): ll = line_to_int_list(f) cache_serv = cache_servers[ll[0]] endpoint.latency.append((ll[1], cache_serv)) end_points.append(endpoint) for i in range(num_request): lr = line_to_int_list(f) vi = vidoes[lr[0]] end_points[lr[1]].requests.append((lr[2], vi)) return (cache_servers, vidoes, end_points)
def get_endpoint(self, object_id): """Return Endpoint specified by object_id.""" result = self._api.call('endpoints', http_method='GET', object_id=object_id) # Temporary until method is implemented result = Endpoint(self._api) #endpoint = Endpoint(result) return result
def test_other_queries(self): endpoint_cache = Endpoint("mock") endpoint_cache.create_cache() results = endpoint_cache.query_cache('Aspirin', 'brand_name', ['product_ndc', 'dosage_form']) self.assertEqual(results[0]['product_ndc'], '0615-8058') self.assertEqual(results[1]['dosage_form'], 'TABLET, COATED')
def test_part_2_lookup_pharm_classes_warfarin(self): # TODO: Complete test by adding call to method to look up pharm classes for warfarin endpoint = Endpoint("mock") pharm_classes = endpoint.get_pharm_class("warfarin") expected_mappings = { 'EPC': ['Vitamin K Antagonist'], 'MoA': ['Vitamin K Inhibitors'] } self.assertDictEqual(pharm_classes, expected_mappings)
def __init__(self, host, port): """ Define the main components useful for the loop """ self.__endpoint = Endpoint(host, port) self.__connections = [] self.__pendings = []
def __init__(self, argv): logger = Logger().logger self.appConfig = AppConfig(logger) self.logger = logger self.quitting = False self.handling_events = False self.accounts = {} self.logger.debug("Creating the Endpoint") self.endpoint = Endpoint(self)
def test_part_4_look_up_all_product_ndc_for_ingredients(self): # TODO: Complete test by adding call to look up the 'product_ndc' for the drugs which have # `CLOPIDOGREL BISULFATE` as an 'active_ingredients' # Example: lookup_method('CLOPIDOGREL BISULFATE', 'active_ingredients', ['product_ndc']) endpoint_cache = Endpoint("mock") endpoint_cache.create_cache() results = endpoint_cache.query_cache('CLOPIDOGREL BISULFATE', 'active_ingredients', ['product_ndc']) self.assertEqual(results[0]['product_ndc'], '21695-665')
def __init__(self, name, version, context, service_url=None, **kwargs): super().__init__() self.client = None # REST API Client self.id = None self._data = None self.name = name self.context = context self.version = version self.endpoint = DotDict() if service_url: inline_endpoint_name = "{}_{}".format(Endpoint.CONST.TYPES.SANDBOX, name) self.endpoint[Endpoint.CONST.TYPES.SANDBOX] = Endpoint( inline_endpoint_name, 'http', service_url) inline_endpoint_name = "{}_{}".format( Endpoint.CONST.TYPES.PRODUCTION, name) self.endpoint[Endpoint.CONST.TYPES.PRODUCTION] = Endpoint( inline_endpoint_name, 'http', service_url) if kwargs: self._parse_json(kwargs)
def test_part_4_look_up_active_ingredients_for_product_ndc(self): # TODO: Complete test by adding call to look up the 'active_ingredients' for the product_ndc: '21695-665' # Example lookup_method('21695-665', 'product_ndc', ['active_ingredients']) endpoint_cache = Endpoint("mock") endpoint_cache.create_cache() results = endpoint_cache.query_cache('21695-665', 'product_ndc', ['active_ingredients']) self.assertEqual(results[0]['active_ingredients'], [{ "strength": "75 mg/1", "name": "CLOPIDOGREL BISULFATE" }])
def parse(self): flows = [line for line in self.flows.split('\n') if line and not line.startswith('#')] for line in flows: if 'Failed' in line and line[0].isdigit(): scenario = dict() seq, actions = self.split_strip(line, 'Failed') parsed_action = [Endpoint(word) for word in self.split_strip(actions, ',')] flow_key = (seq, tuple(parsed_action)) self.parsed_flows[flow_key] = scenario elif all([token in line for token in ['From', 'to', 'via']]): _, rule = self.split_strip(line, 'From') from_device, to_via = self.split_strip(rule, 'to') from_point = Endpoint(from_device) to_device, flow = self.split_strip(to_via, 'via') to_point = Endpoint(to_device) flow_and = self.split_strip(flow, ',') flow_and_or = [['OR', self.split_strip(word, 'or')] if 'or' in word else word for word in flow_and] flow_and_or_not = [word.split() if 'not' in word else word for word in flow_and_or] flow_final = [['AND', word] if type(word) is str else word for word in flow_and_or_not] scenario_key = (from_point, to_point) scenario[scenario_key] = {'text': flow, 'parsed': flow_final} else: raise Exception('Incorrect traffic flow syntax in {}'.format(line)) return self.parsed_flows
def set_endpoints(self): """ Sets API endpoints This function initializes one endpoint per region. """ self.engines = {} for region in self.get_regions(): self.engines[region] = Endpoint( key=self.get_user_name(), secret=self.get_user_password(), region=region)
def populate_global_endpoints(self, count=20): endpoint_types = ['basic', 'digest'] endpoints = [] for index in range(count): random_char = random.choice( string.ascii_lowercase) + random.choice(string.ascii_lowercase) name = "{}_sample_endpoint_{}".format(random_char, index) service_url = "https://sample.knnect.com/api/endpoint/" + name max_tps = random.randint(1, 1000) endpoint = Endpoint(name, "http", service_url, max_tps) rand_endpoint = endpoint_types[random.randint(0, 1)] endpoint.set_security(rand_endpoint, name, "sample_password") endpoint.set_rest_client(self.client) endpoint.save() endpoints.append(endpoint) return endpoints
def parse(self): self.trace = [line for line in self.trace.split('\n') if line] seq, ip = None, None for line in self.trace: try: trace_match = self.trace_re.search(line) if trace_match: ip = trace_match.group(3) if trace_match.group(1): seq = trace_match.group(1) if seq and ip: self.parsed_result.setdefault(int(seq), []).append(Endpoint(ip)) except AttributeError: print('Cannot parse traceroute output {}'.format(line)) raise return self.parsed_result
def __init__(self, apiurl='http://localhost/api', username=None, password=None, token=None): self.apiurl = apiurl self.username = username self.password = password self.token = token self.headers = {} self.headers['Content-Type'] = 'application/json' self.headers['Accept'] = "application/json; indent=4" if token: self.headers['Authorization'] = token self.auth=None if username and password: self.auth = (username,password) self.tenants = Endpoint('tenants')
def test_node(self): print('***** Test get_node_by_id ***') handle = Endpoint(key='k', secret='s', region='dd-eu', orgId='*org') node = handle.get_node_by_id(body=node_1_body) self.assertEqual(node, node_1_dict) node = handle.get_node_by_id(body=node_2_body) self.assertEqual(node, node_2_dict) node = handle.get_node_by_id(body=node_3_body) self.assertEqual(node, node_3_dict) node = handle.get_node_by_id(body=node_4_body) self.assertEqual(node, node_4_dict)
def __init__(self, f): # First line params = f.readline().split(" ") videoCount = int(params[0]) endpointCount = int(params[1]) requestCount = int(params[2]) cacheCount = int(params[3]) cacheCapacity = int(params[4]) # Chaches self.caches = [] for i in range(cacheCount): self.caches.append(Cache(i, cacheCapacity)) # Videos line videoSizes = f.readline().split(" ") self.videos = [] for i in range(videoCount): self.videos.append(Video(i, int(videoSizes[i]))) # Endpoints section self.endpoints = [] for i in range(endpointCount): endpointLine = f.readline().split(" ") latency = int(endpointLine[0]) availableCacheCount = int(endpointLine[1]) caches = [] for j in range(availableCacheCount): cacheLine = f.readline().split(" ") cacheTuple = (self.caches[int(cacheLine[0])], int(cacheLine[1])) caches.append(cacheTuple) self.endpoints.append(Endpoint(latency, caches)) # Requests section self.requests = [] for i in range(requestCount): requestLine = f.readline().split(" ") videoId = int(requestLine[0]) endpointId = int(requestLine[1]) requestCount = int(requestLine[2]) request = Request(self.videos[videoId], self.endpoints[endpointId], requestCount) self.requests.append(request) self.endpoints[endpointId].requests.append(request)
def test_part_2_lookup_pharm_classes_aspirin(self): # TODO: Complete test by adding call to method to look up pharm classes for aspirin endpoint = Endpoint("mock") pharm_classes = endpoint.get_pharm_class("aspirin") expected_mappings = { 'Chemical/Ingredient': ['Nonsteroidal Anti-inflammatory Compounds'], 'PE': [ 'Decreased Prostaglandin Production', 'Decreased Platelet Aggregation' ], 'EPC': [ 'Nonsteroidal Anti-inflammatory Drug', 'Platelet Aggregation Inhibitor' ], 'MoA': ['Cyclooxygenase Inhibitors'] } self.assertDictEqual(pharm_classes, expected_mappings)
def read(input): f = open(input, 'r') conf = [int(x) for x in f.readline().replace('\n', '').split(' ')] video_sizes = [int(x) for x in f.readline().replace('\n', '').split(' ')] endpoints = [] for i in range(0, conf[INDEX_NUMBER_OF_ENDPOINTS]): endpoint_raw = [int(x) for x in f.readline().replace('\n', '').split(' ')] endpoint = Endpoint(i, endpoint_raw[0]) for j in range(0, endpoint_raw[1]): cache_raw = [int(x) for x in f.readline().replace('\n', '').split(' ')] endpoint.add_cache(cache_raw[0], cache_raw[1]) endpoints.append(endpoint) for i in range(0, int(conf[INDEX_NUMBER_OF_REQUESTS])): request_raw = [int(x) for x in f.readline().replace('\n', '').split(' ')] endpoints[request_raw[1]].add_request(request_raw[0], request_raw[2]) f.close() return conf, video_sizes, endpoints
def get_show_cts_role_based_sgtmaps_all(self): self.ise.get_sgts() self.sgts = self.ise.sgts net_connect = ConnectHandler(**self.cisco_switch) for vrf in self.vrfs: command = 'show cts role-based sgt-map vrf ' + vrf + ' all' cts_sgt_maps_output = net_connect.send_command(command) f = open( os.path.join( os.path.dirname(os.path.dirname( os.path.abspath(__file__))), 'templates/cts_role_based_sgt_map_all.templ'), 'r') template = textfsm.TextFSM(f) output = template.ParseText(cts_sgt_maps_output) for o in output: e = Endpoint(self.arp[o[0]]) e.set_ip(o[0]) e.set_vrf(vrf) e.set_sgt(self.sgts[int(o[1])]) self.endpoints[self.arp[o[0]]] = e