def listeprobecontroller(controller): #Store probes attached to the given controller
db = client.bdd1
collection = db.probes
i = 0
count=0
while i <= 18500:
request = AtlasRequest(**{"url_path": "/api/v1/probe/?limit=500&offset=" + str(i)})
result = namedtuple('Result', 'success response')
(is_success, response) = request.get()
for id in response["objects"]:
if id["status"] == 1 or id["status"] == 2:
request = AtlasRequest(**{"url_path": "/api/v1/measurement/7000/result/?start=" + str(id["status_since"]) + "&stop=" + str(id["status_since"]) + "&prb_id=" + str(id["id"])})
result = namedtuple('Result2', 'success response2')
(is_success2, response2) = request.get()
if len(response2) > 0 and response2[0]["controller"] == controller:
collection.insert_one(
{
"id" : id["id"],
"status" : id["status"],
"timestamp" : id["last_connected"],
"latitude" : id["latitude"],
"longitude" : id["longitude"],
"controller" : response2[0]["controller"],
"asn" : id["asn_v4"],
"country_code" : id["country_code"]
}
)
count+=1
print(str((count/response["meta"]["total_count"])*100) + " %")
def test_user_agent(self):
with mock.patch("ripe.atlas.cousteau.request.__version__", 999):
standard = "RIPE ATLAS Cousteau v999"
self.assertEqual(AtlasRequest().http_agent, standard)
self.assertEqual(
AtlasRequest(user_agent=None).http_agent, standard)
self.assertEqual(
AtlasRequest(user_agent="w00t").http_agent, "w00t")
def getAnchorMsmPage(page=1):
url_path = "/api/v2/anchor-measurements?page=%s" % page
request = AtlasRequest(**{"url_path": url_path})
(is_success, response) = request.get()
if not is_success:
print "Error could not get all anchors data!"
return []
else:
if response["next"] is None:
return response["results"], None
else:
return response["results"], page+1
def getAnchorMsmPage(page=1):
url_path = "/api/v2/anchor-measurements?page=%s" % page
request = AtlasRequest(**{"url_path": url_path})
(is_success, response) = request.get()
if not is_success:
print "Error could not get all anchors data!"
return []
else:
if response["next"] is None:
return response["results"], None
else:
return response["results"], page + 1
def test_get_request(self):
"""Unittest for Atlas get request"""
if self.server == "":
raise SkipTest
request = AtlasRequest(**{
"verify": False,
"url_path": "/api/v2/anchors"
})
result = namedtuple('Result', 'success response')
(result.success, result.response) = request.get()
print(result.success, result.response)
self.assertTrue(result.response["results"])
self.assertTrue(result.success)
def test_get_request():
"""Unittest for Atlas get request"""
raise SkipTest("Skip change request")
request = AtlasRequest(
**{
"server": "testing",
"url_path": (
"/api/v1/measurement/1019083/"
"?fields=probes&format=json"
)
}
)
result = namedtuple('Result', 'success response')
(result.success, result.response) = request.get()
assert (result.success)
def test_get_request(self):
"""Unittest for Atlas get request"""
if self.server == "":
raise SkipTest
request = AtlasRequest(
**{
"url_path": "/api/v2/anchors"
}
)
result = namedtuple('Result', 'success response')
(result.success, result.response) = request.get()
print result.success, result.response
self.assertTrue(result.response["results"])
self.assertTrue(result.success)
def getTraceroutes(self):
"""Get traceroute results for all the measurements found with self.msmsURL"""
for msm in self.msms:
resPath = "/api/v2/measurements/%s/results/" % (msm["id"], )
request = AtlasRequest(**{"url_path": resPath})
(is_success, response) = request.get()
if is_success:
self.traceroutes[msm["id"]] = response
else:
logging.warn(
"Something wrong happened while fetching traceroute results"
)
logging.warn(response)
def getMsmIds(self):
"""Get metadata for measurements corresponding to self.msmsURL"""
nextPath = self.msmsURL % (self.starttime, self.endtime)
while nextPath:
request = AtlasRequest(**{"url_path": nextPath})
(is_success, response) = request.get()
if not is_success:
logging.warn(
"Something wrong happened while fetching measurement descriptions"
)
self.msms.extend(response["results"])
if response["next"] is not None:
nextPath = response["next"].partition(
"https://atlas.ripe.net")[2]
else:
nextPath = False
logging.info(nextPath)
def storeTracerouteIds():
sys.stdout.write("Getting all anchoring measurement ids...\n")
allMsm = getAllAnchorMsm()
sys.stdout.write("%s anchoring measurements found!\n" % len(allMsm))
v4file = open("anchorMsmIdsv4.txt", "w")
v6file = open("anchorMsmIdsv6.txt", "w")
count = 0
sys.stdout.write("Filtering out traceroute measurements...\n")
# filters = {"type": "traceroute", "is_public": True}
# measurements = MeasurementRequest(**filters)
for m in allMsm:
request = AtlasRequest(
**{"url_path": m["measurement"][len(u"https://atlas.ripe.net"):]})
(is_success, response) = request.get()
if not is_success:
print "error cannot get the measurment details!?\n %s" % m
continue
if response["type"] != "traceroute":
continue
count += 1
sys.stdout.write("\r%s anchoring measurements found" % count)
sys.stdout.flush()
if response["af"] == 4:
v4file.write('"msm_id":%s\n' % response["id"])
v4file.flush()
elif response["af"] == 6:
v6file.write('"msm_id":%s\n' % response["id"])
v6file.flush()
else:
print "Unknown address family!! \n %s" % m
def storeTracerouteIds():
sys.stdout.write("Getting all anchoring measurement ids...\n")
allMsm = getAllAnchorMsm()
sys.stdout.write("%s anchoring measurements found!\n" % len(allMsm))
v4file = open("anchorMsmIdsv4.txt","w")
v6file = open("anchorMsmIdsv6.txt","w")
count = 0
sys.stdout.write("Filtering out traceroute measurements...\n")
# filters = {"type": "traceroute", "is_public": True}
# measurements = MeasurementRequest(**filters)
for m in allMsm:
request = AtlasRequest(**{"url_path": m["measurement"][len(u"https://atlas.ripe.net"):]})
(is_success, response) = request.get()
if not is_success:
print "error cannot get the measurment details!?\n %s" % m
continue
if response["type"] != "traceroute":
continue
count += 1
sys.stdout.write("\r%s anchoring measurements found" % count)
sys.stdout.flush()
if response["af"] == 4:
v4file.write('"msm_id":%s\n' % response["id"])
v4file.flush()
elif response["af"] == 6:
v6file.write('"msm_id":%s\n' % response["id"])
v6file.flush()
else:
print "Unknown address family!! \n %s" % m
def setUp(self):
self.request = AtlasRequest(**{
"key": "blaaaa",
"server": "test",
"url_path": "testing"
})
class TestAtlasRequest(TestCase):
def setUp(self):
self.request = AtlasRequest(**{
"key": "blaaaa",
"server": "test",
"url_path": "testing"
})
def test_headers(self):
"""Tests header fields of the request."""
expected_output = {
"User-Agent": "RIPE ATLAS Cousteau v{0}".format(__version__),
"Content-Type": "application/json",
"Accept": "application/json"
}
self.assertEqual(expected_output, self.request.get_headers())
def test_http_method_args(self):
"""Tests initial args that will be passed later to HTTP method."""
expected_output = {
"params": {"key": "blaaaa"},
"verify": True,
"headers": {
"User-Agent": "RIPE ATLAS Cousteau v{0}".format(__version__),
"Content-Type": "application/json",
"Accept": "application/json"
},
"proxies": {},
}
self.assertEqual(expected_output, self.request.http_method_args)
def test_get_method(self):
"""Tests GET reuest method"""
extra_params = {"bull": "shit", "cow": "shit", "horse": "shit"}
expected_args = {
"params": {
"key": "blaaaa", "bull": "shit",
"cow": "shit", "horse": "shit"
},
"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:
mock_get.return_value = True
self.request.get(**extra_params)
self.assertEqual(self.request.http_method_args, expected_args)
def test_url_build(self):
"""Tests build of the url of the request."""
self.request.build_url()
self.assertEqual(self.request.url, "https://testtesting")
def test_success_http_method(self):
"""Tests the main http method function of the request in case of success"""
with mock.patch("ripe.atlas.cousteau.AtlasRequest.get_http_method") as mock_get:
fake = FakeResponse(json_return={"blaaa": "b"})
mock_get.return_value = fake
self.assertEqual(
self.request.http_method("GET"),
(True, {"blaaa": "b"})
)
fake_error = FakeErrorResponse()
mock_get.return_value = fake_error
self.assertEqual(
self.request.http_method("GET"),
(True, "testing")
)
def test_not_success_http_method(self):
"""Tests the main http method function of the request in case of fail"""
with mock.patch("ripe.atlas.cousteau.AtlasRequest.get_http_method") as mock_get:
fake = FakeResponse(json_return={"blaaa": "b"}, ok=False)
mock_get.return_value = fake
self.assertEqual(
self.request.http_method("GET"),
(False, {"blaaa": "b"})
)
fake_error = FakeErrorResponse(ok=False)
mock_get.return_value = fake_error
self.assertEqual(
self.request.http_method("GET"),
(False, "testing")
)
def test_exception_http_method(self):
"""Tests the main http method function of the request in case of fail"""
with mock.patch("ripe.atlas.cousteau.AtlasRequest.get_http_method") as mock_get:
mock_get.side_effect = requests.exceptions.RequestException("excargs")
self.assertEqual(
self.request.http_method("GET"),
(False, ("excargs",))
)
def test_user_agent(self):
with mock.patch("ripe.atlas.cousteau.request.__version__", 999):
standard = "RIPE ATLAS Cousteau v999"
self.assertEqual(AtlasRequest().http_agent, standard)
self.assertEqual(AtlasRequest(user_agent=None).http_agent, standard)
self.assertEqual(AtlasRequest(user_agent="w00t").http_agent, "w00t")
prova = json.loads(elem)
if prova.get("id"):
MesId = prova["id"]
else:
MesId = prova["msm_id"]
print(MesId)
if prova["probes"] == None:
probe_id = prova['probes'][0]['id']
url_path = "/api/v2/measurements/" + str(
MesId) + "/latest/?probe_ids=" + str(probe_id)
else:
url_path = "/api/v2/measurements/" + str(MesId) + "/latest"
#url_path ="https://atlas.ripe.net/api/v2/measurements/"+ str(MesId) +"/results/?start=" + str(inizio) + "&?stop=" + str(fine);
request = AtlasRequest(**{
"url_path": url_path
}) #perchè possono essere più di uno i risult.
(is_success, results) = request.get()
#se è denied lo scheduling allora fa l'else
if results != []:
kwargs = {
"msm_id": MesId,
"start": results[0]["timestamp"],
"stop": results[0]["timestamp"],
"probe_ids": results[0]["prb_id"]
}
#print(kwargs)
is_success, results = AtlasResultsRequest(**kwargs).create()
#is_success, results = AtlasLatestRequest(**kwargs).create()
def setUp(self):
self.request = AtlasRequest(
**{"key": "default_api_key", "server": "test", "url_path": "testing"}
)
