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)
