def test_register_metadata(self):
# TODO more testing is needed
results = open(self.PATH + 'hls_snmp.xml').read()
results_set = ResultSet.parse_result(results)
services = parse_lookup_service_result(results_set)
self.assertEqual(len(services), 2)
self.assertEqual(len(services[0]['data']), 8)
self.assertEqual(len(services[1]['data']), 5)
for psservice in services:
serviceType = psservice['service'].serviceType
serviceName = psservice['service'].serviceName
accessPoint = psservice['service'].accessPoint
serviceDescription = psservice['service'].serviceDescription
service = create_psservice(serviceName,
accessPoint,
serviceType,
serviceDescription,
psservice['event_types'])
for data in psservice['data']:
obj = register_metadata(service, data.data)
# check if all data elements were registered
watch = psServiceWatchList.objects.filter(service=service, network_object=obj)
self.assertTrue(watch.count() > 0)
def aggregate_query(self, queries, \
message_type=Message.SETUP_DATA_REQUEST, \
parse_result=True):
"""
Send multiple queries to the same service to save round trip
time.
Arguments:
queries: list of queries either objects of type Query or
XML strings.
message_type: perfSONAR message types, possible values are
defined in Message
parse_results: If False return raw XML string
"""
if not isinstance(queries, list):
raise ValueError("queries should be a list.")
message = self.make_aggregate_query(queries, message_type)
xml = message.to_xml()
result = self.soap_client.send_request(xml, parse=parse_result)
if parse_result is True:
return ResultSet.parse_result(result)
else:
return result
def test_interface_to_port(self):
# TODO test with create port is False
results = open(self.PATH + 'hls_snmp.xml').read()
results_set = ResultSet.parse_result(results)
services = parse_lookup_service_result(results_set)
for psservice in services:
for data in psservice['data']:
port = interface_to_port(data.subject.contents)
self.assertIsInstance(port, Port)
def query_psservice(client, query, message_type=None, parse_result=True):
"""
Sends query to perfSONAR service and returns the result.
@param client: perfSONAR service client
@type client: L{psapi.client.ServiceClient}
@param query: Query to be sent
@type query: L{psapi.query.Query} or XML string, or list of them.
@param parse_result: if B{False} results will not be parsed.
@type parse_result: boolean
@returns: L{psapi.client.ResultSet} if I{parse_result}, XML string otherwise
"""
if not isinstance(client, ServiceClient):
raise ValueError("Client must be of type psapi.client.ServiceClient")
logger.info("Sending query to: '%s'" % client.access_point)
if PRINT_XML_QUERIES:
print "Sending query to", client.access_point, ":", PRINT_XML_QUERIES
if isinstance(query, list):
print client.make_aggregate_query(query, message_type).to_xml()
else:
print query.to_xml(message_type=message_type)
parse_query_result = parse_result
if PRINT_XML_RESULTS:
parse_query_result = False
if isinstance(query, list):
results = client.aggregate_query(query,
message_type=message_type, parse_result=parse_query_result)
else:
results = client.query(query,
message_type=message_type, parse_result=parse_query_result)
if PRINT_XML_RESULTS:
print "Received result from", client.access_point, ":"
print results
if parse_result and not parse_query_result:
results = ResultSet.parse_result(results)
logger.info("Received result from: '%s'" % client.access_point)
return results
def test_parse_lookup_service_result(self):
results = open(self.PATH + 'hls_snmp.xml').read()
results_set = ResultSet.parse_result(results)
services = parse_lookup_service_result(results_set)
self.assertEqual(len(services), 2)
self.assertEqual(len(services[0]['data']), 8)
self.assertEqual(len(services[1]['data']), 5)
event_types = [ events.NET_ERROR,
events.NET_DISCARD,
events.NET_UTILIZATION
]
for service in services:
for data in service['data']:
self.assertIsNotNone(data)
for event in event_types:
self.assertTrue(event in service['event_types'])
def query(self, query, message_type=None, parse_result=True):
"""
Send One query to perfSONAR service
Arguments:
query: either objects of type Query or XML strings
message_type: perfSONAR message types, possible values are
defined in Message
parse_results: If False return raw XML string
"""
result = None
if hasattr(query, 'to_xml'):
result = self.soap_client.send_request(\
query.to_xml(message_type=message_type),
parse=parse_result)
elif isinstance(query, str):
result = self.soap_client.send_request(query)
else:
raise ValueError("Query should be Query instance.")
if parse_result is True:
return ResultSet.parse_result(result)
else:
return result
