def test_type1(self): """Tests format of the type key in response, soon to be deprecated.""" with mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get' ) as request_mock: self.resp["type"] = {"id": 8, "name": "dns", "af": 4} request_mock.return_value = True, self.resp measurement = Measurement(id=1) self.assertEqual(measurement.type, "DNS") self.resp["type"] = {} request_mock.return_value = True, self.resp measurement = Measurement(id=1) self.assertEqual(measurement.type, "")
def test_fields(self): with mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get' ) as request_mock: request_mock.return_value = True, {} Measurement(id=1, fields=["probes"]) self.assertEqual(request_mock.call_args[1], {"fields": "probes"}) Measurement(id=1, fields=["probes", "data"]) self.assertEqual(request_mock.call_args[1], {"fields": "probes,data"}) Measurement(id=1, fields="probes,data") self.assertEqual(request_mock.call_args[1], {"fields": "probes,data"}) Measurement(id=1, fields=1) self.assertEqual(request_mock.call_args[1], {})
def test_user_agent(self): paths = { "fetch": "ripe.atlas.cousteau.Measurement._fetch_meta_data", "populate": "ripe.atlas.cousteau.Measurement._populate_data", } with mock.patch(paths["fetch"]) as fetch: fetch.return_value = True with mock.patch(paths["populate"]): self.assertEqual(Measurement(id=1)._user_agent, None) self.assertEqual( Measurement(id=1, user_agent=None)._user_agent, None) self.assertEqual( Measurement(id=1, user_agent="w00t")._user_agent, "w00t")
def test_sane_response(self): with mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get' ) as request_mock: request_mock.return_value = True, self.resp measurement = Measurement(id=1) self.assertEqual(measurement.meta_data, self.resp) self.assertEqual(measurement.protocol, 4) self.assertEqual(measurement.target_ip, "202.73.56.70") self.assertEqual(measurement.target_asn, 9255) self.assertEqual(measurement.target, "blaaaah") self.assertEqual(measurement.description, "Blaaaaaaaaaah") self.assertEqual(measurement.is_oneoff, True) self.assertEqual(measurement.is_public, True) self.assertEqual(measurement.interval, 1800) self.assertEqual(measurement.status, "Stopped") self.assertEqual( measurement.creation_time, datetime.utcfromtimestamp(1439379910).replace(tzinfo=tzutc())) self.assertEqual( measurement.start_time, datetime.utcfromtimestamp(1439379910).replace(tzinfo=tzutc())) self.assertEqual( measurement.stop_time, datetime.utcfromtimestamp(1439380502).replace(tzinfo=tzutc())) self.assertEqual(measurement.type, "HTTP") self.assertEqual(measurement.result_url, "/api/v1/measurement/2310448/result/")
def setup(self): # TODO: implement the actual measurement creation self._measurement = Measurement( id=self._config.get("measurement_id", HARDCODED_MEASUREMENT_ID)) self._logger.info("Using measurement with ID %s", self._measurement.id) self._rtt_tolerance = self._config.get("rtt_tolerance", RIPEAtlasPolling._rtt_tolerance)
def _load_msm(id=None, key=None): try: return Measurement(id=id, key=key) except (CousteauGenericError, APIResponseError) as e: raise MeasurementProcessingError( "Error while retrieving measurement details: {}".format( repr(e)))
def run(self): try: measurement = Measurement(id=self.arguments.measurement_id, user_agent=self.user_agent) except APIResponseError: raise RipeAtlasToolsException("That measurement does not exist") renderer = Renderer.get_renderer(self.arguments.renderer, measurement.type.lower())() results = self._get_request().get()[1] if not results: raise RipeAtlasToolsException( "There aren't any results available for that measurement") results = SaganSet(iterable=results, probes=self.arguments.probes) if self.arguments.probe_asns: asn_filters = set([]) for asn in self.arguments.probe_asns: asn_filters.add(FilterFactory.create("asn", asn)) results = filter_results(asn_filters, list(results)) if self.arguments.aggregate_by: results = aggregate(results, self.get_aggregators()) Rendering(renderer=renderer, payload=results).render()
def format_results_for_testbed(results): formatted_results = dict() for req_id, responses in results.items(): # Note: This loop body is taken from Arunesh's code # Create the local per subdomain dict probe_dict = dict() subdomain_dict = dict() i = 1 # Setup variables measurement = Measurement(id=req_id) if measurement.type == 'ping': subdomain = measurement.target measurement_class = PingResult else: subdomain = measurement.meta_data['query_argument'].strip('.') measurement_class = DnsResult if measurement.type != 'dns': logger.error('Some error here') for resp in responses: logger.debug('Data Frame ' + str(resp)) probe_id = resp["prb_id"] probe_dict[probe_id] = measurement_class(resp) logger.debug("Iteration Num- " + str(i)) i += 1 subdomain_dict[subdomain] = probe_dict domain_name = tld.extract(subdomain).domain if domain_name not in formatted_results: formatted_results[domain_name] = [] formatted_results[domain_name].append(subdomain_dict) return formatted_results
def test_type2(self): """Tests new format of the type key in response, soon to be enabled.""" with mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get' ) as request_mock: self.resp["type"] = "dns" request_mock.return_value = True, self.resp measurement = Measurement(id=1) self.assertEqual(measurement.type, "dns")
def main(): print "#prb dst af tcp10 icmp10 diff tcpvalcount icmpvalcount tcpcount icmpcount" with open(sys.argv[1]) as inf: for line in inf: d = json.loads(line) if 'response' in d: if 'measurements' in d['response']: if len(d['response']['measurements']) == 1: ## OK we had success, now record the original msm dst = d['original']['target'] af = d['original']['af'] tcp_msm_id = d['response']['measurements'][0] icmp_msm_id = d['original']['id'] # load measurement data tmeta = Measurement(id=tcp_msm_id) imeta = Measurement(id=icmp_msm_id) print >> sys.stderr, "tcp:%s icmp:%s" % (tcp_msm_id, icmp_msm_id) res = {} get_tcp_stats(tcp_msm_id, d['start'], d['stop'], res) #print res get_icmp_stats(icmp_msm_id, d['start'], d['stop'], res) #print res for prb, info in res.iteritems(): if 'tcp' in info and 'icmp' in info: tvals = filter(lambda x: x != None, info['tcp']) ivals = filter(lambda x: x != None, info['icmp']) tcp10 = None icmp10 = None if len(tvals) > 0: tcp10 = np.percentile(tvals, 10) if len(ivals) > 0: icmp10 = np.percentile(ivals, 10) diff = None if icmp10 != None and tcp10 != None: diff = 100.0 * (tcp10 - icmp10) / min( tcp10, icmp10) ## tcp=10ms icmp=20ms -> (10-20)/10 = -100% <- minus = tcp is faster ## tcp=20ms icmp=10ms -> (20-10)/10 = +100% <- plus = icmp is faster print "%s %s %s %s %s %s %s %s %s %s" % ( prb, dst, af, tcp10, icmp10, diff, len(tvals), len(ivals), len( info['tcp']), len(info['icmp'])) print >> sys.stderr, "line done: %s" % (line)
def check_msm(msm_id, asn): try: msm_meta = Measurement(id=msm_id) except Exception as e: debug('{}'.format(e)) flash('{}'.format(e), 'error') return False if msm_meta.type != 'traceroute': flash('measurement {} is {} not traceroute'.format( msm_id, msm_meta.type), 'error') return False msm_meta.target_asn = Lookup().lookup(msm_meta.target_ip) if int(msm_meta.target_asn) != int(asn): flash('measurement {} target is in AS{} not AS{}'.format( msm_id, msm_meta.target_asn, asn), 'error') return False return msm_meta
def test_populate_times(self): with mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get' ) as request_mock: del self.resp["stop_time"] del self.resp["creation_time"] del self.resp["start_time"] request_mock.return_value = True, self.resp measurement = Measurement(id=1) self.assertEqual(measurement.stop_time, None) self.assertEqual(measurement.start_time, None) self.assertEqual(measurement.creation_time, None)
def run(self): try: measurement = Measurement(id=self.arguments.id, user_agent=self.user_agent) except APIResponseError: raise RipeAtlasToolsException( "That measurement does not appear to exist") self.render_basic(measurement) getattr(self, "render_{}".format(measurement.type.lower()))(measurement)
def run(self): try: measurement = Measurement(id=self.arguments.measurement_id) except APIResponseError: raise RipeAtlasToolsException("That measurement does not exist") try: Stream(capture_limit=self.arguments.limit).stream( self.arguments.renderer, measurement.type.lower(), self.arguments.measurement_id) except (KeyboardInterrupt, CaptureLimitExceeded): self.ok("Disconnecting from the stream")
def run(self): try: measurement = Measurement(id=self.arguments.measurement_id, user_agent=self.user_agent, key=self._get_request_auth) except APIResponseError as e: raise RipeAtlasToolsException(e.args[0]) try: Stream(capture_limit=self.arguments.limit).stream( self.arguments.renderer, measurement.type.lower(), self.arguments.measurement_id) except (KeyboardInterrupt, CaptureLimitExceeded): self.ok("Disconnecting from the stream")
def wait_on_measurement(measurement_id): kwargs = {"msm_id": int(measurement_id)} log_message("Checking measurement status...") # Wait to get a result i = 0 num_checks = 50 while True: is_success, results = AtlasResultsRequest(**kwargs).create() m = Measurement(id=measurement_id) if "No suitable probes" in m.status: log_message("No suitable probes found") return None, True # Return first (and should be only) result for this ID if is_success and len(results) != 0: return results[0], False if not is_success: log_message("Failed results: {}".format(results)) if results is not None: if len(results) == 0: log_message( "ATLAS ResultsRequest returned unsuccessful and results array is empty for try {}" .format(i)) return None, True time.sleep(20) i += 1 if i == num_checks: log_message( "ATLAS measurement did not finish after {} checks over {} seconds with status: {}" .format(str(num_checks), str(num_checks * 10), m.status)) return None, True
def run(self): try: measurement = Measurement(id=self.arguments.measurement_id) except APIResponseError: raise RipeAtlasToolsException("That measurement does not exist") renderer = Renderer.get_renderer(self.arguments.renderer, measurement.type.lower())() results = self._get_request().get()[1] if not results: raise RipeAtlasToolsException( "There aren't any results available for that measurement") results = SaganSet(iterable=results, probes=self.arguments.probes) if self.arguments.aggregate_by: results = aggregate(results, self.get_aggregators()) Rendering(renderer=renderer, header=self._get_header(measurement), payload=results).render()
def test_measurement_repr_request(self): """Unittest for Measurement representation request""" if self.server == "": raise SkipTest Measurement(id=1000032, server=self.server, verify=False)
def test_error_response(self): with mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get' ) as request_mock: request_mock.return_value = False, {} self.assertRaises(APIResponseError, lambda: Measurement(id=1))
def test_measurement_repr_request(self): """Unittest for Measurement representation request""" if self.server == "": pytest.skip("No ATLAS_SERVER defined") Measurement(id=1000032, server=self.server, verify=False)
probes_measurement_id = 28380424 filename = 'measurements/south_africa_measurements.json' from datetime import datetime import json import os # Gets the required measuremnt from RIPE ATLAS and creates the initial dictionary file # info from https://ripe-atlas-cousteau.readthedocs.io/_/downloads/en/latest/pdf/ from ripe.atlas.cousteau import Ping, Traceroute, AtlasSource, AtlasRequest, AtlasCreateRequest, AtlasLatestRequest, Probe, Measurement # Sagans sole purpose is to make RIPE Atlas measurements manageable from within Python. # https://ripe-atlas-sagan.readthedocs.io/en/latest/use.html#how-to-use-this-library # Attributes and Methods at https://ripe-atlas-sagan.readthedocs.io/en/latest/types.html measurement = Measurement(id=28380424) from ripe.atlas.sagan import Result, TracerouteResult # Opensource Geocoder from geopy.geocoders import Nominatim geolocator = Nominatim(user_agent="aswindow") # A Python library to gather IP address details (ASN, prefix, resource holder, reverse DNS) using the RIPEStat API, # with a basic cache to avoid flood of requests and to enhance performances. https://pypi.org/project/ipdetailscache/ #from pierky.ipdetailscache import IPDetailsCache #cache = IPDetailsCache() #cache.UseIXPs() #r = cache.GetIPInformation( "193.0.6.139" ) # example use #print (r) # target_address = "90 Oxford Street, Randburg" # sample target address # Discover the geo cordinates of the target location #location = geolocator.geocode(target_address)
def query_msm_meta(msm_id): return Measurement(id=msm_id)
#from html_create import Html_Create # Load the Measurements and target probe id's with open("measurements/anchors.json") as file: measurements_file = json.load(file) # convert the list into a dictionary measurements_dict = Convert(measurements_file) traceroute_dict = {} # initialis the measuretments dictionary # measurements_list = [28380424,] # this was the initial South Africa measurement, the list of probes from this are used in further measurements # read in each measurment for measurement in measurements_dict: # for each measurement # get the measurement ID print('Measurement', measurement, 'Probe ', measurements_dict[measurement]) m = Measurement(id=measurement) # get metadata for this measurement p = Probe( id=measurements_dict[measurement] ) # Get all the properties of the individual probe used in this individual measurement coords = p.geometry['coordinates'] coords_str = ','.join([str(elem) for elem in coords]) print(coords_str) # Create a list of Coordinates # Discover the physical address of the target location try: location = geolocator.reverse(coords_str) except: location = "unknown" print(location)