def create_measurement(monitoring_goal, target, query_type, direct, af,
use_probe_resolver, monitor_trust_chain):
"""Creates one single DNS measurement."""
if use_probe_resolver:
# Monitor Trust Chain
if monitor_trust_chain:
description = config['ROLLOVER'][
'ZONE'] + '_' + monitoring_goal + '_' + target + '_' + str(
int(time.time()))
dns = Dns(af=af,
use_probe_resolver=True,
query_class='IN',
query_type=query_type,
query_argument=target,
interval=int(config['TTLS']['ttl_dnskey']),
spread=int(config['TTLS']['ttl_dnskey']) - 20,
description=description)
# Monitor Propagation Delay
else:
description = config['ROLLOVER'][
'ZONE'] + '_' + monitoring_goal + '_' + query_type + '_use_probe_resolver_' + str(
int(time.time()))
interval = int(config['TTLS']['ttl_' + query_type])
dns = Dns(af=af,
use_probe_resolver=True,
query_class='IN',
query_type=query_type,
query_argument=config['ROLLOVER']['ZONE'],
interval=interval,
spread=interval - 20,
description=description)
# Monitor Publication Delay
else:
description = config['ROLLOVER'][
'ZONE'] + '_' + monitoring_goal + '_' + query_type + '_' + target + '_' + str(
int(time.time()))
dns = Dns(
af=af,
target=target,
query_class='IN',
query_type=query_type,
query_argument=config['ROLLOVER']['ZONE'],
interval=int(
config['MEASUREMENTS']['msm_frequency_publication_delay']),
spread=int(
config['MEASUREMENTS']['msm_frequency_publication_delay']) -
20,
description=description)
return dns
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 measure_ping_and_dns(api_key, domains, probe_type, probe_value,
probe_requested, probe_tags):
# Todo: Make this a parameter?
retrieve_measurements_timeout = 5 # Seconds
# Create the probe source
probe_source = [
AtlasSource(type=probe_type,
value=probe_value,
requested=int(probe_requested),
tags=probe_tags)
]
## Get the data
# Create ping measurements
logger.info('Creating ping measurements')
ping_measurements = [
Ping(af=4, target=domain, description='Ping to ' + domain)
for domain in domains
]
success, ping_request_ids, ping_results = measurements.run_measurements(
api_key, ping_measurements, probe_source,
retrieve_measurements_timeout)
# Create subsequent dns measurements
logger.info('Creating dns measurements')
dns_measurements = [
Dns(af=4,
query_class='IN',
query_argument=domain,
query_type='A',
use_probe_resolver=True,
include_abuf=True,
retry=5,
description='DNS A request for ' + domain) for domain in domains
]
success, dns_request_ids, dns_results = measurements.run_measurements(
api_key, dns_measurements, probe_source, retrieve_measurements_timeout)
return ping_request_ids, ping_results, dns_request_ids, dns_results
def test_dns(self):
"""Unittest for Dns class"""
post_body = Dns(
**{
"target": "k.root-servers.net",
"af": 4,
"description": "testing",
"query_type": "SOA",
"query_class": "IN",
"query_argument": "nl",
"retry": 6
}).build_api_struct()
expected_output = {
'query_class': 'IN',
'retry': 6,
'description': 'testing',
'af': 4,
'query_argument': 'nl',
'query_type': 'SOA',
'type': 'dns',
'target': 'k.root-servers.net'
}
self.assertEqual(post_body, expected_output)
def test_create_delete_request(self):
"""Unittest for Atlas create and delete request"""
if self.server == "":
raise SkipTest
source = AtlasSource(**{"type": "area", "value": "WW", "requested": 38})
ping = Ping(**{
"target": "www.ripe.net",
"af": 4,
"description": "Cousteau testing",
"prefer_anchors": True
})
traceroute = Traceroute(**{
"target": "www.google.fr",
"af": 4, "protocol": "UDP",
"description": "Cousteau testing",
"dont_fragment": True
})
dns = Dns(**{
"target": "k.root-servers.net", "af": 4,
"description": "Cousteau testing", "query_type": "SOA",
"query_class": "IN", "query_argument": "nl", "retry": 6
})
ntp = Ntp(**{
"target": "www.ripe.net",
"af": 4,
"description": "Cousteau testing",
"timeout": 1000
})
ssl = Sslcert(**{
"target": "www.ripe.net",
"af": 4,
"description": "Cousteau testing",
})
http = Http(**{
"target": "www.ripe.net",
"af": 4,
"description": "Cousteau testing",
})
stop = datetime.utcnow() + timedelta(minutes=220)
request = AtlasCreateRequest(
**{
"verify": False,
"stop_time": stop,
"key": self.create_key,
"server": self.server,
"measurements": [ping, traceroute, dns, ntp, ssl, http],
"sources": [source]
}
)
result = namedtuple('Result', 'success response')
(result.success, result.response) = request.create()
print(result.response)
self.assertTrue(result.success)
self.delete_msm = result.response["measurements"][0]
self.assertTrue(result.success)
# Unittest for Atlas delete request
if self.server == "":
raise SkipTest
kwargs = {"verify": False, "msm_id": self.delete_msm, "key": self.delete_key, "server": self.server}
request = AtlasStopRequest(**kwargs)
result = namedtuple('Result', 'success response')
(result.success, result.response) = request.create()
print(result.response)
self.assertTrue(result.success)
url = url.split('www.')[-1]
print url
if 'xvideo' in url:
print "I think this is inappropriate.. skipping"
continue
url = url.split(':')[0]
print url
if not url:
continue
if url in msms_old:
print "Already measured", url
continue
dns = Dns(query_class='IN',
description="Alexa top sites DNS lookup %s" % url,
query_type='A',
query_argument=url,
af=4,
use_probe_resolver=True,
set_rd_bit=True)
is_success = False
while not is_success:
atlas_request = AtlasCreateRequest(start_time=datetime.utcnow(),
key=ATLAS_API_KEY,
measurements=[dns],
sources=[source],
is_oneoff=True)
(is_success, response) = atlas_request.create()
if is_success:
msms.append(response['measurements'][0])
else:
print "Failed Measurement to", url
QUERY_TEMPLATE = '$r-$t-$p.{}.rootcanary.net'
PROBES = 100
# https://atlas.ripe.net/docs/deprecated/measurement-creation-api/
dns = Dns(
af=4, # IPv4 | IPv6
description="IPv4 DNS 1500 MTU test",
query_class='IN', # IN | CHAOS (TXT)
query_type='A', # A | AAAA | ...
query_argument=QUERY_TEMPLATE.format('1500-plus0.pmtu4'),
use_macros=True,
use_probe_resolver=True,
resolve_on_probe=False,
set_nsid_bit=False,
protocol='UDP',
udp_payload_size=4096,
retry=0,
spread=1,
skip_dns_check=True,
include_qbuf=True,
include_abuf=True,
prepend_probe_id=False,
set_rd_bit=True,
set_do_bit=False,
set_cd_bit=False,
timeout=5000,
)
# specify the probes, i.e. 5 worldwide
source = AtlasSource(type="area", value="WW", requested=PROBES)