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_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_measurement_impl(self, target_probe):
args = self._args
log = self._log
probe = target_probe
if 'address_v4' not in probe:
log.error('probe has no ipv4 addr')
return None
target_id = probe['id']
target_ip = probe['address_v4']
log.notice('Creating measurement to probe', target_id, target_ip)
desc = '{} {} to {}'.format(args.test_name_prefix, args.src_probe,
target_id)
ping = Ping(af=4, target=target_ip, description=desc)
source = AtlasSource(type='probes',
value='{}'.format(args.src_probe),
requested=1)
req = AtlasCreateRequest(start_time=datetime.utcnow(),
key=args.api,
measurements=[ping],
sources=[source],
is_oneoff=True)
is_success, resp = req.create()
if not is_success:
log.warn('Error creating measurement:', str(resp))
return None
else:
msm_id = resp['measurements'][0]
return msm_id
log(is_success, resp)
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 test_post_method_with_bill_to(self):
"""Tests POST reuest method without any time specified"""
request = AtlasCreateRequest(**{
"key": "path_to_key",
"measurements": [self.measurement],
"sources": [self.create_source],
"bill_to": "billing@address"
})
self.maxDiff = None
expected_args = {
"json": {
"definitions": [{
"af": 6, "description": "testing",
"target": "testing", "type": "ping"
}],
"is_oneoff": False,
"probes": [{"requested": 3, "type": "area", "value": "WW"}],
"bill_to": "billing@address",
},
"params": {"key": "path_to_key"},
"verify": True,
"headers": {
"User-Agent": "RIPE ATLAS Cousteau v{0}".format(__version__),
"Content-Type": "application/json",
"Accept": "application/json"
},
"proxies": {},
}
with mock.patch("ripe.atlas.cousteau.request.AtlasRequest.http_method") as mock_get:
request._construct_post_data()
mock_get.return_value = True
request.post()
self.assertEqual(request.http_method_args, expected_args)
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 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 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_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 initRequest(country, source, m):
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(str(country) + ": " + str(response))
def create(self):
creation_class = self.CREATION_CLASSES[self.arguments.type]
return AtlasCreateRequest(
server=conf["ripe-ncc"]["endpoint"].replace("https://", ""),
key=self.arguments.auth,
measurements=[creation_class(**self._get_measurement_kwargs())],
sources=[AtlasSource(**self._get_source_kwargs())],
is_oneoff=self._is_oneoff).create()
def create_measurement(tr_list, source_list):
ATLAS_API_KEY = "e2bb393f-b198-4bd0-96e3-fb5a5bc7fa22"
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=tr_list,
sources=source_list,
is_oneoff=True)
(is_success, response) = atlas_request.create()
print is_success
print response
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(self):
creation_class = self.CREATION_CLASSES[self._type]
return AtlasCreateRequest(
server=conf["ripe-ncc"]["endpoint"].replace("https://", ""),
key=self.arguments.auth,
user_agent=self.user_agent,
measurements=[creation_class(**self._get_measurement_kwargs())],
sources=[AtlasSource(**self._get_source_kwargs())],
is_oneoff=self._is_oneoff,
start_time = conf["specification"]["times"]["start"],
stop_time = conf["specification"]["times"]["stop"]
).create()
def create_request(self,
measurements,
source,
is_oneoff=True,
packet_interval=5000):
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=self.atlas_api_key,
measurements=measurements,
sources=[source],
packet_interval=packet_interval,
is_oneoff=is_oneoff)
(is_success, response) = atlas_request.create()
return is_success, response
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 setUp(self):
self.create_source = AtlasSource(
**{"type": "area", "value": "WW", "requested": 3}
)
self.measurement = Ping(**{
"target": "testing", "af": 6,
"description": "testing"
})
self.request = AtlasCreateRequest(**{
"start_time": datetime(2015, 10, 16),
"stop_time": 1445040000,
"key": "path_to_key",
"measurements": [self.measurement],
"sources": [self.create_source],
"is_oneoff": True,
})
def run_measurement(tgt):
m = [
Ping(af=4, target=addr, description="ROV tgt %d" % mid)
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 submit(self, key):
# create the measurements
start_time = datetime.utcnow() + timedelta(0, 0, 0, 0,
1) # start in a minute
self.request = AtlasCreateRequest(
key=key,
measurements=self.measurements,
sources=self.probe_sources,
# start_time = start_time,
is_oneoff=self.is_oneoff)
(is_success, response) = self.request.create()
if is_success:
self.measurement_ids.extend(response["measurements"])
print("SUCCESS: measurement created: %s" %
response["measurements"])
else:
raise Exception("failed to create measurement: %s" % response)
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 ping(self, source):
ping = Ping(af=4, target=self.target, description="RTT measurement")
# add 1 second to make sure time in request is not in the past
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow() +
timedelta(seconds=1),
key=ATLAS_API_KEY,
measurements=[ping],
sources=[source],
is_oneoff=True)
is_success, response = atlas_request.create()
if not is_success:
logging.warning(response)
return [] # return empty list representing no results
msm_id = response['measurements'][0]
return self.wait_for_all_results(msm_id, source.requested)
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 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_measurements(api_key, measurements, sources):
success_list = []
request_ids = []
logger.info('Chunking measurements')
chunk_size = 100
measurement_chunks = [measurements[x:x+chunk_size] for x in range(0, len(measurements), chunk_size)]
for i, measurement_chunk in enumerate(measurement_chunks):
# Check if there are simultaneous (concurrently running) measurements before running the next chunk
concurrent_status = '1,2'
concurrent_measurements = [x['id'] for x in MyMeasurementRequest(**{'status': concurrent_status, 'key': api_key})]
while concurrent_measurements:
logger.info('Found ' + str(len(concurrent_measurements)) + ' concurrent measurements. Sleeping')
logger.debug(concurrent_measurements)
time.sleep(60)
concurrent_measurements = [x['id'] for x in MyMeasurementRequest(**{'status': concurrent_status, 'key': api_key})]
logger.info('-Creating measurements for measurement chunk ' + str(i))
for msm in measurement_chunk:
logger.debug('Creating: ' + str(msm))
atlas_request = AtlasCreateRequest(
start_time=datetime.utcnow(),
key=api_key,
is_oneoff=True,
measurements=[msm],
sources=sources,
)
success, response = atlas_request.create()
logger.debug('Creating success: ' + str(success))
logger.debug('Creating response: ' + str(response))
if not success:
logger.error('Unsuccessful creating measurements for ' + str(msm))
logger.error('Failure response:' + str(response))
# return False, request_ids
else:
request_ids.extend(response['measurements'])
success_list.append(msm)
return success_list, request_ids
def _create_measurement_impl(self, inmsm):
args = self._args
log = self._log
target_ip = inmsm.target
probes = [str(p) for p in inmsm.probes]
desc = '[real02] all-pairs ping {} (nonce={})'.format(
target_ip, random.randint(0, 1000000000))
log(desc)
ping = Ping(af=4, target=target_ip, description=desc)
source = AtlasSource(type='probes',
requested=len(probes),
value='{}'.format(','.join(probes)))
req = AtlasCreateRequest(start_time=datetime.utcnow(),
key=args.api,
measurements=[ping],
sources=[source],
is_oneoff=True)
success, resp = req.create()
if not success:
log.warn('Error creating measurement:', str(resp))
return None
msm_id = resp['measurements'][0]
return msm_id
