def add_traceroute_measurement(self, target_ip, protocol="ICMP"):
# add a RIPE traceroute measurement with given destination ip and protocol
if len(target_ip.split('.')) == 4:
# IPv4
self.measurements.append(
Traceroute(
af=4, # IPv4
target=target_ip,
description="Traceroute Target %s %s" %
(target_ip, str(datetime.now())),
max_hops=30,
timeout=4000,
paris=16, # use Paris Traceroute to avoid load balancing
protocol=protocol,
is_public=False,
resolve_on_probe=True # use probe's locally assigned DNS
))
else:
# IPv6
self.measurements.append(
Traceroute(
af=6, # IPv6
target=target_ip,
description="Traceroute Target %s %s" %
(target_ip, str(datetime.now())),
max_hops=30,
timeout=4000,
paris=16, # use Paris Traceroute to avoid load balancing
protocol=protocol,
is_public=False,
resolve_on_probe=True # use probe's locally assigned DNS
))
def create_measurements(probes, target):
'''
Create two new ICMP traceroute measurements, one for the IPv4 target address
and one for the IPv6.
'''
probes.remove(target['id']) # Don't waste credits tracerouting to itself
num_probes = len(probes)
sources = AtlasSource(
type='probes',
value=','.join(str(x) for x in random.sample(probes, num_probes)),
requested=num_probes)
tr4 = Traceroute(af=4,
target=target['address_v4'],
description='Transient tr4 test',
protocol='ICMP')
tr6 = Traceroute(af=6,
target=target['address_v6'],
description='Transient tr6 test',
protocol='ICMP')
atlas_request = AtlasCreateRequest(key=API_KEY,
measurements=[tr4, tr6],
sources=[sources],
is_oneoff=True)
if dry_run:
response = False
else:
response = atlas_request.create()
return response
def main():
try:
target = sys.argv[1]
except:
print('Please provide a host to traceroute')
exit(1)
probes = load_json()
sources = AtlasSource(
type='probes',
value=','.join(str(x) for x in random.sample(probes, num_probes)),
requested=num_probes)
tr4 = Traceroute(af=4,
target=target,
description='Transient tr4 test',
protocol='ICMP')
tr6 = Traceroute(af=6,
target=target,
description='Transient tr6 test',
protocol='ICMP')
atlas_request = AtlasCreateRequest(key=API_KEY,
measurements=[tr4, tr6],
sources=[sources],
is_oneoff=True)
response = atlas_request.create()
print(response)
def atlas_api_call():
#ATLAS_API_KEY = ""
q = Target.objects.all().last()
if (q.specification.one_off is True):
traceroute = Traceroute(
af=4,
target=str(q.target),
description=str(q.description),
protocol=str(q.specification.protocol),
)
else:
traceroute = Traceroute(
af=4,
target=str(q.target),
description=str(q.description),
protocol=str(q.specification.protocol),
interval=int(q.specification.interval),
)
source = []
for i in range(0, q.probes.all().count()):
l = q.probes.all()[i]
#new[i]='source'+i
source.append(
AtlasSource(type="country",
value=str(l.country),
requested=int(l.number),
tags={"exclude": ["system-anchor"]}))
if (q.specification.one_off is True):
atlas_request = AtlasCreateRequest(start_time=int(time.time()),
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=source,
is_oneoff=q.specification.one_off)
else:
atlas_request = AtlasCreateRequest(
start_time=int(time.time()),
stop_time=int(time.mktime(q.specification.stop_time.timetuple())),
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=source,
is_oneoff=q.specification.one_off)
(is_success, response) = atlas_request.create()
print response
return response
def create_ripe_measurement(prefix_list):
measurement_count = 0
measurement_limit = 10
ATLAS_API_KEY = "secret"
for prefix, ip_list in prefix_list.iteritems():
for ip in ip_list:
ipAddr = ip
count = 0
descr = "Prefix: " + prefix + "Flapped " + str(count) + " times"
ping = Ping(af=4, target=ipAddr, description=descr)
traceroute = Traceroute(
af=4,
target=ipAddr,
description=descr,
protocol="ICMP",
)
source = AtlasSource(type="area", value="WW", requested=5)
atlas_request = AtlasCreateRequest(
start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[ping, traceroute],
sources=[source],
is_oneoff=True
)
(is_success, response) = atlas_request.create()
measurement_count += 1
if measurement_count > measurement_limit:
break
def main():
our_as_with_own_probe = '7922'
client_as_list = ('42610', '3320', '3215') # '2856')
source_list = []
# add Philipp's probe as a source
source = AtlasSource(type="probes", value='11090', requested=1)
source_list.append(source)
# add British one separate for AS 2856
# because the one it uses doesn't work
source = AtlasSource(type="probes", value='14274', requested=1)
source_list.append(source)
# the rest
for cli_as in client_as_list:
source = AtlasSource(type="asn", value="AS" + cli_as, requested=1)
source_list.append(source)
tor_default_port = 9001 # useless now because not doing TCP traceroutes anymore
limit = 85
tr_list = []
count = 0
# Need to do traceroutes to all IPs
for ip_line in sys.stdin:
ip_str = ip_line.rstrip()
traceroute = Traceroute(target=ip_str,
af=4,
timeout=4000,
description='Traceroute from client AS to ' +
ip_str,
protocol="UDP",
resolve_on_probe=False,
packets=3,
size=48,
first_hop=1,
max_hops=32,
port=tor_default_port,
paris=16,
destination_option_size=0,
hop_by_hop_option_size=0,
dont_fragment=False,
skip_dns_check=False)
tr_list.append(traceroute)
count += 1
create_measurement(tr_list, source_list)
# reset the tr_list
tr_list = []
if count == limit:
# sleep for 15 minutes
# 60 seconds * 15
time.sleep(900)
# reset the count
count = 0
def startTraceroute(self, query_params):
# localhost:8080/api/v1/traceroute?dest=X.X.X.X&desc=description&proto=TCP
dest = query_params["dest"][0]
desc = query_params["desc"][0]
proto = query_params["proto"][0]
traceroute = Traceroute(
af=4,
target=dest,
description=desc,
protocol=proto,
)
source = AtlasSource(type="area",
value="WW",
requested=5,
tags={"include": ["system-ipv4-works"]})
start_time = datetime.utcnow() + timedelta(0, 2)
atlas_request = AtlasCreateRequest(start_time=start_time,
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
print(response)
print("Success ", is_success)
self.wfile.write(json.dumps(response, ensure_ascii=False).encode())
def submit_traceroute(asn):
traceroute_time = int(time.time())
traceroute = Traceroute(
af=4,
target="208.45.214.0",
description="{}_{}".format(asn, traceroute_time),
protocol="ICMP",
)
source = AtlasSource(type="asn", value=asn, requested=1)
atlas_request = AtlasCreateRequest(start_time=datetime.datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if not is_success:
return None, traceroute_time
measurement_id = response["measurements"][0]
log_message(
"Measurement ID of {} for ongoing traceroute".format(measurement_id))
return measurement_id, traceroute_time
def create_measurement(cc):
"""
Creates DNS and Traceroute measurements for given country code
@param cc: Two characters (ISO) country code
@type cc: str
@return: tuple of measurement ids
@rtype: tuple
"""
global API_CREATE_KEY
traceroute = Traceroute(af=4, target="193.0.14.129", protocol="ICMP",
description="Traceroute from %s to K Root" % cc)
dns = Dns(af=4, target="193.0.14.129", query_argument="com.", query_type="NS", query_class="IN",
description="DNS Response time fromt %s to K Root" % cc)
source = AtlasSource(value=cc,
requested=50,
type="country",
action="add")
request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=API_CREATE_KEY,
measurements=[traceroute, dns],
sources=[source],
is_oneoff=True)
(is_success, response) = request.create()
if is_success:
print("- Created measurement for %s" % cc)
return list(response['measurements'])
else:
print("- Failed to create measurement for %s: %s" % (cc, response))
return None
def create_traceroute(self, target, packets=1):
trace = Traceroute(af=self.af,
target=target,
description="Trace for %s" % target,
protocol=self.protocol,
packets=packets,
skip_dns_check=True)
return trace
def send_ripe_measurement_request(website, ATLAS_API_KEY):
traceroute1 = Traceroute(
af=4,
target=website,
description="testing",
protocol="ICMP",
)
source1 = AtlasSource(
type="country",
value="CA", #, canada "CA", "PL", "AU", "AR"],
requested=3,
tags={"include": ["system-ipv4-works"]})
source2 = AtlasSource(
type="country",
value="ZA", #, South Africa "CA", "PL", "AU", "AR"],
requested=3,
tags={"include": ["system-ipv4-works"]})
source3 = AtlasSource(
type="country",
value="DE", #, Germany "CA", "PL", "AU", "AR"],
requested=3,
tags={"include": ["system-ipv4-works"]})
source4 = AtlasSource(
type="country",
value="NG", #, Nigeria "CA", "PL", "AU", "AR"],
requested=3,
tags={"include": ["system-ipv4-works"]})
source5 = AtlasSource(
type="country",
value="BR", #, Brazil "CA", "PL", "AU", "AR"],
requested=3,
tags={"include": ["system-ipv4-works"]})
atlas_request = AtlasCreateRequest(
start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[traceroute1],
sources=[source1, source2, source3, source4, source5],
is_oneoff=True)
is_success, response = atlas_request.create()
result_id = []
if is_success:
result_id = response['measurements']
print("Measurement for", website, "sent. Result ID is", result_id[0])
return result_id
else:
print("Measurement not successful")
return []
def measure(msm_spec):
traceroute = Traceroute(**msm_spec['definitions'])
source = AtlasSource(**msm_spec['probes'])
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
return response['measurements'][0]
def getTracerouteResults(self, query_params):
dest = query_params["dest"][0]
myresults = getMyResults()
id = 0
for result in myresults["results"]:
target = result["target"]
if target == dest:
id = result["id"]
if id == 0:
# start a new measurement
traceroute = Traceroute(
af=4,
target=dest,
description="auto traceroute to %s" % dest,
protocol="TCP",
)
source = AtlasSource(type="area",
value="WW",
requested=5,
tags={"include": ["system-ipv4-works"]})
start_time = datetime.utcnow() + timedelta(0, 1)
atlas_request = AtlasCreateRequest(start_time=start_time,
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if is_success:
id = response['measurements'][0]
# {'measurements': [23976423, 23976424]}
print("Run traceroute back for id %d" % id)
rt = RunReverseTraceroute(id)
rt.start()
rt.join(timeout=60)
responses = get_json(id)
# source = "https://atlas.ripe.net/api/v2/measurements/%d/results/"%id
# responses = requests.get(source).json()
# for i in responses:
# dst_addr = i['dst_addr']
# i['dst_addr'] = self.getCity(dst_addr)
# i['from'] = self.getCity(i['from'])
# results = i['result']
# for j in results:
# for k in j['result']:
# if k.get('from'):
# k['from'] = self.getCity(k['from'])
self.wfile.write(json.dumps(responses, ensure_ascii=False).encode())
def oneofftrace(probes_def, dst, **kwargs):
probe_list = []
if isinstance(probes_def, int):
probe_list.append(probes_def)
elif isinstance(probes_def, list):
probe_list = probes_def
else:
raise ValueError(
"Probes definition needs to be of type int or list, not %s" %
(type(probes_def)))
default_defs = {
'target': dst,
'type': 'traceroute',
'protocol': 'ICMP',
'resolve_on_probe': True,
'is_oneoff': True
}
defs = dict(default_defs.items() + kwargs.items())
# handle 'af'
if not 'af' in defs:
if ':' in dst:
defs['af'] = 6
else: #default to 4
defs['af'] = 4
# handle 'descr'
if not 'description' in defs:
defs['description'] = 'trace to %s (IPv%d)' % (dst, defs['af'])
data = {
'definitions': defs,
'probes': {
'requested': len(probe_list),
'type': 'probes',
'value': ','.join(map(str, probe_list))
}
}
traceroute = Traceroute(**data['definitions'])
source = AtlasSource(**data['probes'])
atlas_request = AtlasCreateRequest(
# start_time = datetime.utcnow(), # this was generating "Measurements must have the start time in future"
key=KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if 'measurements' in response:
return response['measurements'][0]
else:
print >> sys.stderr, response
def submit_traceroute(asn):
global PREFIX
global PEERING
traceroute_time = int(time.time())
prefix_no_subnet = str(PREFIX.split('/')[0])
if PEERING:
split_prefix = prefix_no_subnet.split('.')
prefix_no_subnet = "{}.{}.{}.1".format(split_prefix[0],
split_prefix[1],
split_prefix[2])
traceroute = Traceroute(af=4,
target=prefix_no_subnet,
description="{}_{}_{}".format(
asn, traceroute_time,
"{}".format(prefix_no_subnet)),
protocol="ICMP",
max_hops=255)
source = AtlasSource(
type="asn",
value=str(asn),
requested=1,
tags={"include": ["system-ipv4-works", "system-ipv4-stable-1d"]})
atlas_request = AtlasCreateRequest(start_time=datetime.datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if not is_success:
response = str(response)
log_message("Traceroute failed: {}".format(response))
# Handle probe not found in ASN
if "Your selected ASN is not covered by our network." in response:
return -1, traceroute_time
# Handle all other cases
else:
return None, traceroute_time
measurement_id = response["measurements"][0]
log_message(
"Measurement ID of {} for ongoing traceroute".format(measurement_id))
return measurement_id, traceroute_time
def create_measurement(self, kwargs):
'''
Creates the request for a measurement to ripe.
Input:
a) kwargs: The user input arguments in a dictionary.
Output:
a) response: The response from ripe.
'''
default_defs = {
'target': 'www.inspire.edu.gr',
'type': 'traceroute',
'protocol': 'ICMP',
'resolve_on_probe': True,
'af': 4,
'description': 'traIXroute (IPv4)'
}
default_probes = {'type': 'probes', 'value': '23385', 'requested': 1}
default_defs.update(kwargs[0].items())
default_probes.update(kwargs[1].items())
if (default_defs['type'] != 'traceroute' or default_defs['af'] != 4):
print(
'TraIXroute only supports Traceroute and IPv4 measurements. Exiting.'
)
traceroute = Traceroute(**default_defs)
source = AtlasSource(**default_probes)
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=self.ripe_key,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if (is_success):
print(
'Please wait for ripe to complete the measurements and run traIXroute again with: ripe -r \'{\"msm_id\":'
+ str(response['measurements'][0]) + '}\'')
else:
print(
'Please revise the arguments you have given. Ripe does not accept these arguments or it may be unavailable at this time.'
)
sys.exit(0)
def main():
# Handle command-line arguments
exit_as_set_pickle_fname = sys.argv[1]
with open(exit_as_set_pickle_fname, 'rb') as f:
exit_as_set = pickle.load(f)
source_list = []
for asn in exit_as_set:
source = AtlasSource(type='asn', value='AS' + str(asn), requested=1)
source_list.append(source)
#print len(source_list)
#print len(exit_as_set)
#exit()
the_port = 53
tr_list = []
for ip_line in sys.stdin:
the_ip = ip_line.rstrip()
traceroute = Traceroute(
target=the_ip,
af=4,
timeout=4000,
description='UDP Traceroute from exit ASes to ' + the_ip,
protocol='UDP',
resolve_on_probe=False,
packets=3,
size=48,
first_hop=1,
max_hops=32,
port=the_port,
paris=16,
destination_option_size=0,
hop_by_hop_option_size=0,
dont_fragment=False,
skip_dns_check=False)
tr_list.append(traceroute)
#print tr_list
create_measurement(tr_list, source_list)
def measure_from_template( template_file, template_vars ):
env = Environment()
template = env.get_template( template_file )
msm_spec = template.render(**{template_vars})
traceroute = Traceroute( ** msm_spec['definitions'] )
source = AtlasSource( ** msm_spec['probes'] )
atlas_request = AtlasCreateRequest(
start_time = datetime.utcnow(),
key = KEY,
measurements = [traceroute],
sources = [source],
is_oneoff = True
)
(is_success, response) = atlas_request.create()
return response['measurements'][0]
def submit_traceroute(asn, probe):
global PREFIX
traceroute_time = int(time.time())
prefix_no_subnet = str(PREFIX.split('/')[0])
o1, o2, o3, o4 = prefix_no_subnet.split('.')
prefix_loopback = "{}.{}.{}.1".format(o1, o2, o3)
traceroute = Traceroute(af=4,
target=prefix_loopback,
description="{}_{}_{}".format(
asn, traceroute_time,
"{}".format(prefix_no_subnet)),
protocol="TCP",
port=39876,
max_hops=60)
source = AtlasSource(type="probes", value=str(probe), requested=1)
atlas_request = AtlasCreateRequest(start_time=datetime.datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if not is_success:
response = str(response)
log_message("Traceroute failed: {}".format(response))
# Handle probe not found in ASN
if "Your selected ASN is not covered by our network." in response:
return -1, traceroute_time
# Handle all other cases
else:
return None, traceroute_time
measurement_id = response["measurements"][0]
log_message(
"Measurement ID of {} for ongoing traceroute".format(measurement_id))
return measurement_id, traceroute_time
def run_measurement(tgt):
m = [
Traceroute(af=4,
target=addr,
description="ROV tgt %d" % mid,
protocol="UDP") for (mid, addr) in enumerate(tgt)
]
source = AtlasSource(type="area", value="WW", requested=1000)
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=m,
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
print "tgt=%s is_success=%s response=%s" % (str(tgt), str(is_success),
str(response))
def test_traceroute(self):
"""Unittest for Traceroute class"""
post_body = Traceroute(
**{
"af": 4,
"target": 'www.ripe.net',
"description": 'testing',
"protocol": "ICMP",
"prefer_anchors": True,
}).build_api_struct()
expected_output = {
'protocol': 'ICMP',
'description': 'testing',
'prefer_anchors': True,
'af': 4,
'type': 'traceroute',
'target': 'www.ripe.net'
}
self.assertEqual(post_body, expected_output)
def measure(port, hostname, afs):
for af in afs:
if (hostname, port, af) in msm_state:
msm_state[(hostname, port, af)]['state'] = 'active'
else:
# the mapping between API and cousteau drives me nuts!
msm_def['definitions'][0]['port'] = port
msm_def['definitions'][0]['target'] = hostname
msm_def['definitions'][0]['af'] = af
traceroute = Traceroute(**msm_def['definitions'][0])
source = AtlasSource(**msm_def['probes'][0])
start = int(time.time()) + 60
atlas_request = AtlasCreateRequest(key=KEY,
measurements=[traceroute],
sources=[source],
start_time=start)
(is_success, response) = atlas_request.create()
msm_id = None
if is_success:
msm_id = response['measurements'][0]
json.dump(
{
'hostname': hostname,
'port': port,
'af': af,
'action': 'started',
'ts': start,
'msm_id': msm_id
}, log_fh)
log_fh.write("\n")
msm_state[(hostname, port, af)] = {
'msm_id': msm_id,
'state': 'new'
}
print("new msm created for %s %s %s (id: %s)" %
(hostname, port, af, msm_id),
file=sys.stderr)
else:
print("msm start failed for %s %s %s: %s" %
(hostname, port, af, response),
file=sys.stderr)
def schedule_measurement(dest, probes, tag, stage):
msm_status = defaultdict(list)
traceroute = Traceroute(
af=4,
target=dest,
description="%s_%s: Traceroute to %s" % (tag, stage, dest),
protocol="ICMP",
is_public=True,
paris=16,
can_visualize=False,
)
trace_origin = AtlasSource(requested=len(probes),
type="probes",
value=",".join(probes))
try:
atlas_req = AtlasCreateRequest(start_time=datetime.utcnow(),
key=authkey,
measurements=[traceroute],
sources=[trace_origin],
is_oneoff=True)
(is_success, response) = atlas_req.create()
# Check if we got a positive result
if is_success:
print response
for m in response['measurements']:
msm_status['list'].append(m)
else:
msm_status['failed'].append(dest)
# This sleep is important to give time to the scheduled measurements to complete before trying more.
time.sleep(3)
except (urllib2.HTTPError, urllib2.URLError) as e:
# Other kind of error
msm_status['failed'].append(dest)
print "Fatal Error: %s " % e
return msm_status
def create_measurement(self):
traceroute = Traceroute(
af=4,
target=self.local_host,
protocol=self.protocol.upper(),
description=self.description,
paris=32,
timeout=4000,
packets=4,
)
source = AtlasSource(type="probes",
value=",".join(self.probe_ids),
requested=len(self.probe_ids))
# add 1 second to ensure starttime in the request is not in the past
atlas_request = AtlasCreateRequest(key=ATLAS_API_KEY,
measurements=[traceroute],
sources=[source],
is_oneoff=True,
start_time=datetime.utcnow() +
timedelta(seconds=1))
return atlas_request.create()
#!/usr/bin/python3
from datetime import datetime,timedelta
from ripe.atlas.cousteau import (
Ping,
Traceroute,
AtlasSource,
AtlasCreateRequest
)
ATLAS_API_KEY = "ba0ea367-df59-4cfb-8e50-3fc8a2fd9243"
ping = Ping(af=4, target="220.247.159.10", description="Test ping to APRICOT 2020")
traceroute = Traceroute(
af=4,
target="220.247.159.10",
description="Test traceroute to APRICOT 2020",
protocol="TCP",
)
source = AtlasSource(
type="area",
value="WW",
requested=5,
tags={"include":["system-ipv4-works"]}
)
source1 = AtlasSource(
type="country",
value="NL",
requested=50,
tags={"exclude": ["system-anchor"]}
)
def getMeasurementList(c, one, two):
msmnts = []
p1 = Ping(af=4, target="www.uct.ac.za", description="intra ping 1 - " + c)
p2 = Ping(af=4, target="www.uwc.ac.za", description="intra ping 2 - " + c)
p3 = Ping(af=4,
target="www.aucegypt.edu",
description="intra ping 3 - " + c)
p4 = Ping(af=4, target="www.cu.edu.eg", description="intra ping 4 - " + c)
p5 = Ping(af=4, target="www.abu.edu.ng", description="intra ping 5 - " + c)
p6 = Ping(af=4,
target="www.unilag.edu.ng",
description="intra ping 6 - " + c)
p7 = Ping(af=4,
target="www.uonbi.ac.ke",
description="intra ping 7 - " + c)
p8 = Ping(af=4, target="www.ku.ac.ke", description="intra ping 8 - " + c)
p9 = Ping(af=4, target="www.ucad.sn", description="intra ping 9 - " + c)
p10 = Ping(af=4, target="www.ugb.sn", description="intra ping 10 - " + c)
p11 = Ping(af=4, target="www.uaq.ma", description="intra ping 11 - " + c)
p12 = Ping(af=4, target="www.uca.ma", description="intra ping 12 - " + c)
p13 = Ping(af=4,
target="www.univ-tlemcen.dz",
description="intra ping 13 - " + c)
p14 = Ping(af=4,
target="www.univ-bejaia.dz",
description="intra ping 14 - " + c)
p15 = Ping(af=4,
target="www.ug.edu.gh",
description="intra ping 15 - " + c)
p16 = Ping(af=4,
target="www.knust.edu.gh",
description="intra ping 16 - " + c)
p17 = Ping(af=4, target="www.uem.mz", description="intra ping 17 - " + c)
p18 = Ping(af=4, target="www.up.ac.mz", description="intra ping 18 - " + c)
p19 = Ping(af=4,
target="www.udsm.ac.tz",
description="intra ping 19 - " + c)
p20 = Ping(af=4,
target="www.sua.ac.tz",
description="intra ping 20 - " + c)
# ============================================================================
tr1 = Traceroute(af=4,
target="www.uct.ac.za",
description="intra traceroute 1 - " + c,
protocol="ICMP")
tr2 = Traceroute(af=4,
target="www.uwc.ac.za",
description="intra traceroute 2 - " + c,
protocol="ICMP")
tr3 = Traceroute(af=4,
target="www.aucegypt.edu",
description="intra traceroute 3 - " + c,
protocol="ICMP")
tr4 = Traceroute(af=4,
target="www.cu.edu.eg",
description="intra traceroute 4 - " + c,
protocol="ICMP")
tr5 = Traceroute(af=4,
target="www.abu.edu.ng",
description="intra traceroute 5 - " + c,
protocol="ICMP")
tr6 = Traceroute(af=4,
target="www.unilag.edu.ng",
description="intra traceroute 6 - " + c,
protocol="ICMP")
tr7 = Traceroute(af=4,
target="www.uonbi.ac.ke",
description="intra traceroute 7 - " + c,
protocol="ICMP")
tr8 = Traceroute(af=4,
target="www.ku.ac.ke",
description="intra traceroute 8 - " + c,
protocol="ICMP")
tr9 = Traceroute(af=4,
target="www.ucad.sn",
description="intra traceroute 9 - " + c,
protocol="ICMP")
tr10 = Traceroute(af=4,
target="www.ugb.sn",
description="intra traceroute 10 - " + c,
protocol="ICMP")
tr11 = Traceroute(af=4,
target="www.uaq.ma",
description="intra traceroute 11 - " + c,
protocol="ICMP")
tr12 = Traceroute(af=4,
target="www.uca.ma",
description="intra traceroute 12 - " + c,
protocol="ICMP")
tr13 = Traceroute(af=4,
target="www.univ-tlemcen.dz",
description="intra traceroute 13 - " + c,
protocol="ICMP")
tr14 = Traceroute(af=4,
target="www.univ-bejaia.dz",
description="intra traceroute 14 - " + c,
protocol="ICMP")
tr15 = Traceroute(af=4,
target="www.ug.edu.gh",
description="intra traceroute 15 - " + c,
protocol="ICMP")
tr16 = Traceroute(af=4,
target="www.knust.edu.gh",
description="intra traceroute 16 - " + c,
protocol="ICMP")
tr17 = Traceroute(af=4,
target="www.uem.mz",
description="intra traceroute 17 - " + c,
protocol="ICMP")
tr18 = Traceroute(af=4,
target="www.up.ac.mz",
description="intra traceroute 18 - " + c,
protocol="ICMP")
tr19 = Traceroute(af=4,
target="www.udsm.ac.tz",
description="intra traceroute 19 - " + c,
protocol="ICMP")
tr20 = Traceroute(af=4,
target="www.sua.ac.tz",
description="intra traceroute 20 - " + c,
protocol="ICMP")
msmnts = [
p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16,
p17, p18, p19, p20, tr1, tr2, tr3, tr4, tr5, tr6, tr7, tr8, tr9, tr10,
tr11, tr12, tr13, tr14, tr15, tr16, tr17, tr18, tr19, tr20
]
del msmnts[one:two]
del msmnts[(18 + one):(18 + two)]
#for i in range(36):
#print(msmnts[i].description)
return (msmnts)
for destination_network, measurements in data.items():
measurement_dict[destination_network] = []
for elt in measurements[:]:
if elt['is_success'] is False:
measurements.remove(elt)
ping = Ping(af=4,
target=elt['host'],
description="From {} to {}".format(
source_country_code, destination_network),
interval=10800,
tags=["retry-test-code-esib"])
traceroute = Traceroute(af=4,
target=elt['host'],
description="From {} to {}".format(
source_country_code,
destination_network),
protocol="ICMP",
interval=10800,
tags=["retry-test-code-esib"])
source = AtlasSource(type="country",
value=source_country_code,
requested=3)
atlas_request = AtlasCreateRequest(
start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[ping, traceroute],
sources=[source],
is_oneoff=False)
(is_success, response) = atlas_request.create()
if is_success:
measurement_dict[destination_network].append({
from datetime import datetime
from ripe.atlas.cousteau import (
Ping,
Traceroute,
AtlasSource,
AtlasCreateRequest
)
ATLAS_API_KEY = "faf17fcb-bbc2-450f-8a68-a600d293f8c9"
ping = Ping(af=4, target="cdn.ampproject.org", description="testing new wrapper")
traceroute = Traceroute(
af=4,
target="cdn.ampproject.org",
description="amp cdn",
protocol="ICMP",
)
source1 = AtlasSource(
type="country",
value="KE",
requested=5,
tags={"exclude": ["system-anchor"]}
)
source2 = AtlasSource(
type="country",
value="TZ",
requested=5,
tags={"exclude": ["system-anchor"]}
# while source_asns:
# source_asn = source_asns[0]
# print "Source ASN", source_asn
# probes = probes_per_asn[int(source_asn)]
# if not probes: pdb.set_trace()
# msm_id = run_oneofftrace(random.choice(probes), pref)
# if msm_id:
# msms.append(msm_id)
# source_asns.pop(0)
# random.shuffle(source_asns)
print "Traceroute from %s sources" % len(sources)
now = datetime.now().strftime("%b-%d-%Y")
traceroute = Traceroute(
af=4,
target=pref,
description="RSALGO %s %s traceroute to %s" % (now, dest_typ, pref),
protocol="ICMP")
is_success = False
while not is_success:
atlas_request = AtlasCreateRequest(
start_time=datetime.utcnow(),
key=api_key,
measurements=[traceroute],
sources=sources,
is_oneoff=True)
print "issuing measurement req to", pref
(is_success, response) = atlas_request.create()
print response
if 'error' in response:
if 'detail' in response['error'] and 'Invalid target' in response['error']['detail']:
from ripe.atlas.cousteau import ProbeRequest
from datetime import datetime
from ripe.atlas.cousteau import (Traceroute, AtlasCreateRequest, AtlasSource)
from ripe.atlas.cousteau import AtlasResultsRequest
import requests
ATLAS_API_KEY = "df5d3613-6c53-43be-bdad-cb921ffd20cf"
traceroute16 = Traceroute(af=4,
target="fr-bod-as198985.anchors.atlas.ripe.net",
interval=36000,
description="traceroute v4 to France",
protocol="ICMP")
source_LB_1 = AtlasSource(type="asn",
value="9051",
requested=1,
tags={"include": ["system-ipv6-works"]})
atlas_request = AtlasCreateRequest(
#start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[traceroute16],
sources=[source_LB_1],
is_oneoff=False,
start_time=1525348200,
stop_time=1525693800)
(is_success, response) = atlas_request.create()
print(is_success)
print(response)
msm_id = response['measurements'][0]
print(msm_id)
