def setUp(self): self.clock = task.Clock() tcf = os.path.expanduser('~/.opennsa-test.json') tc = json.load( open(tcf) ) ncs_config = { config.NCS_SERVICES_URL : tc['ncs-url'], config.NCS_USER : tc['ncs-user'], config.NCS_PASSWORD : tc['ncs-password'] } self.requester = common.DUDRequester() self.backend = ncsvpn.NCSVPNBackend('Test', self.sr, self.requester, ncs_config) self.backend.scheduler.clock = self.clock self.backend.startService() database.setupDatabase(tc['database'], tc['database-user'], tc['database-password'], host=tc['hostname']) self.requester_nsa = nsa.NetworkServiceAgent('test-requester', 'http://example.org/nsa-test-requester') self.provider_nsa = nsa.NetworkServiceAgent('test-provider', 'http://example.org/nsa-test-provider') source_stp = nsa.STP('ncs', 'hel:ge-1/0/1', labels=[ nsa.Label(nml.ETHERNET_VLAN, '100-102') ] ) dest_stp = nsa.STP('ncs', 'sto:ge-1/0/1', labels=[ nsa.Label(nml.ETHERNET_VLAN, '101-104') ] ) start_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=2) end_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=30) bandwidth = 200 self.service_params = nsa.ServiceParameters(start_time, end_time, source_stp, dest_stp, bandwidth)
class DUDBackendTest(GenericProviderTest, unittest.TestCase): requester_agent = nsa.NetworkServiceAgent('test-requester:nsa', 'dud_endpoint1') provider_agent = nsa.NetworkServiceAgent(GenericProviderTest.base + ':nsa', 'dud_endpoint2') header = nsa.NSIHeader(requester_agent.urn(), provider_agent.urn()) def setUp(self): self.clock = task.Clock() self.requester = common.DUDRequester() nrm_ports = nrm.parsePortSpec( StringIO.StringIO(topology.ARUBA_TOPOLOGY)) self.backend = dud.DUDNSIBackend(self.network, nrm_ports, self.requester, {}) self.provider = self.backend self.provider.scheduler.clock = self.clock self.provider.startService() tcf = os.path.expanduser('~/.opennsa-test.json') tc = json.load(open(tcf)) database.setupDatabase(tc['database'], tc['database-user'], tc['database-password']) # request stuff self.start_time = datetime.datetime.utcnow() + datetime.timedelta( seconds=2) self.end_time = datetime.datetime.utcnow() + datetime.timedelta( seconds=10) self.schedule = nsa.Schedule(self.start_time, self.end_time) self.sd = nsa.Point2PointService(self.source_stp, self.dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) self.criteria = nsa.Criteria(0, self.schedule, self.sd) return self.backend.restore_defer @defer.inlineCallbacks def tearDown(self): from opennsa.backends.common import genericbackend yield self.provider.stopService() # delete all connections from test database yield genericbackend.GenericBackendConnections.deleteAll() # close database connections, so we don't run out from twistar.registry import Registry Registry.DBPOOL.close()
def testInvalidNetworkReservation(self): provider = nsa.Network( 'Aruba', nsa.NetworkServiceAgent( 'Aruba-OpenNSA', 'http://localhost:9080/NSI/services/ConnectionService')) source_stp = nsa.STP('NoSuchNetwork', 'PS') dest_stp = nsa.STP('Aruba', 'A2') start_time = datetime.datetime.utcfromtimestamp(time.time() + 1.5) end_time = datetime.datetime.utcfromtimestamp(time.time() + 120) bwp = nsa.BandwidthParameters(200) service_params = nsa.ServiceParameters(start_time, end_time, source_stp, dest_stp, bandwidth=bwp) connection_id = 'conn-id1' try: yield self.client.reserve(self.client_nsa, provider.nsa, None, None, '', connection_id, service_params) self.fail('Reserve call should have failed') except error.ReserveError as e: self.failUnlessIn('No network named NoSuchNetwork', str(e)) errors = self.flushLoggedErrors(error.TopologyError) self.assertEqual(len(errors), 1)
def testConnectSTPToItself(self): provider = nsa.Network( 'Aruba', nsa.NetworkServiceAgent( 'Aruba-OpenNSA', 'http://localhost:9080/NSI/services/ConnectionService')) source_stp = nsa.STP('Aruba', 'A1') dest_stp = nsa.STP('Aruba', 'A1') start_time = datetime.datetime.utcfromtimestamp(time.time() + 2) end_time = datetime.datetime.utcfromtimestamp(time.time() + 40) bwp = nsa.BandwidthParameters(200) service_params = nsa.ServiceParameters(start_time, end_time, source_stp, dest_stp, bandwidth=bwp) connection_id = 'conn-id1' try: yield self.client.reserve(self.client_nsa, provider.nsa, None, None, '', connection_id, service_params) self.fail('Reserve call should have failed') except error.ReserveError as e: self.failUnlessIn('Cannot connect <STP Aruba:A1> to itself', str(e)) errors = self.flushLoggedErrors(error.ReserveError) self.assertEqual(len(errors), 1)
def parseGOLERDFTopology(topology_source): def stripURNPrefix(text): URN_PREFIX = 'urn:ogf:network:' assert text.startswith(URN_PREFIX), "%s does not conform" % text return text.split(':')[-1] OWL_NS = rdflib.namespace.Namespace("http://www.w3.org/2002/07/owl#") RDF_NS = rdflib.namespace.Namespace( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#') DTOX_NS = rdflib.namespace.Namespace( 'http://www.glif.is/working-groups/tech/dtox#') graph = rdflib.Graph() # TODO: Change this to some configurable option. # graph.open("/Users/jeroen/Projects/OpenNSA-UvA/opennsa/rdfdb") try: graph.parse(topology_source) except: raise error.TopologyError('Invalid topology source') topo = Topology() topo.graph = graph for nsnetwork in graph.subjects(RDF_NS['type'], DTOX_NS['NSNetwork']): # Setup the base network object, with NSA nsaId = graph.value(subject=nsnetwork, predicate=DTOX_NS['managedBy']) network_name = stripURNPrefix(str(nsnetwork)) network_nsa_ep = graph.value(subject=nsaId, predicate=DTOX_NS['csProviderEndpoint']) network_nsa = nsa.NetworkServiceAgent(stripURNPrefix(str(nsaId)), str(network_nsa_ep)) network = nsa.Network(network_name, network_nsa) loc = graph.value(subject=nsnetwork, predicate=DTOX_NS["locatedAt"]) network.location = (graph.value(subject=loc, predicate=DTOX_NS["lat"]), graph.value(subject=loc, predicate=DTOX_NS["long"])) # Add all the STPs and connections to the network for stp in graph.objects(nsnetwork, DTOX_NS['hasSTP']): stp_name = stripURNPrefix(str(stp)) dest_stp = graph.value(subject=stp, predicate=DTOX_NS['connectedTo']) # If there is a destination, add that, otherwise the value stays None. if dest_stp: dest_network = graph.value(predicate=DTOX_NS['hasSTP'], object=dest_stp) #print "adding %s for %s" % (dest_stp, dest_network) dest_stp = nsa.STP(stripURNPrefix(str(dest_network)), stripURNPrefix(str(dest_stp))) ep = nsa.NetworkEndpoint(network_name, stp_name, None, dest_stp, None, None) network.addEndpoint(ep) topo.addSTP(str(stp), ep) topo.addNetwork(network) return topo
def testRemovedNetwork(self): agent = nsa.NetworkServiceAgent('test', 'http://example.org/nsi', cnt.CS2_SERVICE_TYPE) self.pr.spawnProvider(agent, ['testnetwork', 'testnetwork2']) self.pr.spawnProvider(agent, ['testnetwork']) self.failUnlessRaises(error.STPResolutionError, self.pr.getProviderByNetwork, 'testnetwork2')
def testUpdatedNetwork(self): agent = nsa.NetworkServiceAgent('test', 'http://example.org/nsi', cnt.CS2_SERVICE_TYPE) self.pr.spawnProvider(agent, ['testnetwork']) self.pr.spawnProvider(agent, ['testnetwork', 'testnetwork2']) provider2 = self.pr.getProviderByNetwork('testnetwork2') self.failUnlessEqual(provider2, cnt.URN_OGF_PREFIX + 'test')
def testMultipleProviders(self): agent_a = nsa.NetworkServiceAgent('a', 'http://example.org/nsi-a', cnt.CS2_SERVICE_TYPE) agent_b = nsa.NetworkServiceAgent('b', 'http://example.org/nsi-b', cnt.CS2_SERVICE_TYPE) fake_provider_a1 = 'provider-a1' fake_provider_a2 = 'provider-a2' fake_provider_b = 'provider-b' self.pr.addProvider(agent_a.urn(), 'testnetwork_a1', fake_provider_a1) self.pr.addProvider(agent_a.urn(), 'testnetwork_a2', fake_provider_a2) self.pr.addProvider(agent_b.urn(), 'testnetwork_b', fake_provider_b) provider = self.pr.getProvider('testnetwork_a1') self.failUnlessEqual(provider, fake_provider_a1) provider = self.pr.getProvider('testnetwork_a2') self.failUnlessEqual(provider, fake_provider_a2)
def setUp(self): an, _ = nrm.parseTopologySpec(StringIO(topology.ARUBA_TOPOLOGY), ARUBA_NETWORK) bn, _ = nrm.parseTopologySpec(StringIO(topology.BONAIRE_TOPOLOGY), BONAIRE_NETWORK) cn, _ = nrm.parseTopologySpec(StringIO(topology.CURACAO_TOPOLOGY), CURACAO_NETWORK) dn, _ = nrm.parseTopologySpec(StringIO(topology.DOMINICA_TOPOLOGY), DOMINICA_NETWORK) a_nsa = nsa.NetworkServiceAgent('aruba:nsa', 'a-endpoint') b_nsa = nsa.NetworkServiceAgent('bonaire:nsa', 'b-endpoint') c_nsa = nsa.NetworkServiceAgent('curacao:nsa', 'c-endpoint') d_nsa = nsa.NetworkServiceAgent('dominica:nsa', 'd-endpoint') self.networks = [an, bn, cn, dn] self.nsas = [a_nsa, b_nsa, c_nsa, d_nsa] self.topology = nml.Topology() for network, nsi_agent in zip(self.networks, self.nsas): self.topology.addNetwork(network, nsi_agent)
def testGetProvider(self): agent = nsa.NetworkServiceAgent('test', 'http://example.org/nsi', cnt.CS2_SERVICE_TYPE) self.pr.spawnProvider(agent, 'testnetwork') self.pr.spawnProvider(agent, 'testnetwork2') provider1 = self.pr.getProvider( 'testnetwork') # cnt.URN_OGF_PREFIX + 'test') self.failUnlessEqual(provider1.urn(), cnt.URN_OGF_PREFIX + 'test') provider2 = self.pr.getProvider('testnetwork2') self.failUnlessEqual(provider2.urn(), cnt.URN_OGF_PREFIX + 'test')
def testMultipleNetworks(self): agent = nsa.NetworkServiceAgent('test', 'http://example.org/nsi', cnt.CS2_SERVICE_TYPE) fake_provider = 'provider123' self.pr.addProvider(agent.urn(), 'testnetwork', fake_provider) self.pr.addProvider(agent.urn(), 'testnetwork2', fake_provider) provider1 = self.pr.getProvider('testnetwork') self.failUnlessEqual(provider1, fake_provider) provider2 = self.pr.getProvider('testnetwork2') self.failUnlessEqual(provider2, fake_provider)
def gotDocument(self, result, peer): log.msg('Got NSA description from %s (%i bytes)' % (peer.url, len(result)), debug=True, system=LOG_SYSTEM) try: nsa_description = discovery.parse(result) nsa_id = nsa_description.id_ cs_service_url = None for i in nsa_description.interface: if i.type_ == cnt.CS2_PROVIDER: cs_service_url = i.href elif i.type_ == cnt.CS2_SERVICE_TYPE and cs_service_url is None: # compat, only overwrite if cs prov not specified cs_service_url = i.href if cs_service_url is None: log.msg('NSA description does not have CS interface url, discarding description', system=LOG_SYSTEM) return network_ids = [ _baseName(nid) for nid in nsa_description.networkId if nid.startswith(cnt.URN_OGF_PREFIX) ] # silent discard weird stuff nsi_agent = nsa.NetworkServiceAgent( _baseName(nsa_id), cs_service_url, cnt.CS2_SERVICE_TYPE) self.provider_registry.spawnProvider(nsi_agent, network_ids) # how to port ? vectors = {} if nsa_description.other is not None: for other in nsa_description.other: if other.topologyReachability: for tr in other.topologyReachability: if tr.uri.startswith(cnt.URN_OGF_PREFIX): # silent discard weird stuff vectors[_baseName(tr.uri)] = tr.cost + 1 for nid in network_ids: vectors[nid] = 1 if vectors: for np in self.nrm_ports: if np.remote_network in network_ids: # this may add the vectors to multiple ports (though not likely) self.link_vectors.updateVector(np.name, vectors ) # there is lots of other stuff in the nsa description but we don't really use it except Exception as e: log.msg('Error parsing NSA description from url %s. Reason %s' % (peer.url, str(e)), system=LOG_SYSTEM) import traceback traceback.print_exc()
def buildTopology(triples): getSubject = lambda pred, obj : [ t[0] for t in triples if t[1] == pred and t[2] == obj ] getObjects = lambda subj, pred : [ t[2] for t in triples if t[0] == subj and t[1] == pred ] topo = topology.Topology() networks = getSubject(RDF_TYPE, GLIF_NETWORK) for network in networks: nsas = getObjects(network, GLIF_MANAGED_BY) endpoints = getObjects(nsas[0], GLIF_PROVIDER_ENDPOINT) t_network_name = _stripPrefix(network, URN_NSNETWORK_PREFIX) t_nsa_name = _stripPrefix(nsas[0], URN_NSA_PREFIX) t_nsa_endpoint = endpoints[0] t_network_nsa = nsa.NetworkServiceAgent(t_nsa_name, t_nsa_endpoint) t_network = nsa.Network(t_network_name, t_network_nsa) stps = getObjects(network, GLIF_HAS_STP) for stp in stps: t_stp_name = _stripPrefix(stp, URN_STP_PREFIX).split(':')[-1] maps_to = getObjects(stp, GLIF_MAPS_TO) t_maps_to = _stripPrefix(maps_to[0], URN_NRM_PORT) if maps_to else None # this is for default/single backend to work, remove initial colon (backend seperator) if t_maps_to is not None and t_maps_to.startswith(':'): t_maps_to = t_maps_to[1:] dest_stps = getObjects(stp, GLIF_CONNECTED_TO) if dest_stps: dest_network, dest_port = _stripPrefix(dest_stps[0], URN_STP_PREFIX).split(':',1) t_dest_stp = nsa.STP(dest_network, dest_port) else: t_dest_stp = None ep = nsa.NetworkEndpoint(t_network_name, t_stp_name, t_maps_to, t_dest_stp, None, None) t_network.addEndpoint(ep) topo.addNetwork(t_network) return topo
def setUp(self): self.iports = [] HOST = 'localhost' WSDL_DIR = os.path.realpath( os.path.normpath(os.path.join(os.path.dirname(__file__), '../wsdl'))) #WSDL_DIR = os.path.join(os.getcwd(), '..', 'wsdl') # service SERVICES = [('Aruba', 9080), ('Bonaire', 9081), ('Curacao', 9082)] for network, port in SERVICES: topo_source = StringIO.StringIO(testtopology.TEST_TOPOLOGY) backend = dud.DUDNSIBackend(network) topo, _ = gole.parseTopology([topo_source]) factory = setup.createService(network, backend, topo, HOST, port, WSDL_DIR) iport = reactor.listenTCP(port, factory, interface='localhost') self.iports.append(iport) # client CLIENT_PORT = 7080 self.client, client_factory = setup.createClient( HOST, CLIENT_PORT, WSDL_DIR) self.client_nsa = nsa.NetworkServiceAgent( 'OpenNSA-Test-Client', 'http://localhost:%i/NSI/services/ConnectionService' % CLIENT_PORT) client_iport = reactor.listenTCP(CLIENT_PORT, client_factory) self.iports.append(client_iport)
def testDiscovery(self): aruba_discovery_service = 'http://localhost:4080/NSI/discovery.xml' bonaire_discovery_service = 'http://localhost:4080/NSI/discovery.xml' requester_agent = nsa.NetworkServiceAgent('test-requester:nsa', 'dud_endpoint1') d = httpclient.httpRequest(aruba_discovery_service.encode('utf-8'), b'', {}, b'GET', timeout=10) aruba_discovery_doc = yield d aruba_discovery = discovery.parse(aruba_discovery_doc) # basic tests self.failUnlessEqual('urn:ogf:network:aruba.net:nsa', aruba_discovery.id_, 'nsa id seems to be wrong') self.failUnlessEqual(2, len(aruba_discovery.networkId), 'should have two networks') self.failUnlessIn('urn:ogf:network:aruba.net:san', aruba_discovery.networkId, 'missing network in discovery') self.failUnlessIn('urn:ogf:network:aruba.net:san', aruba_discovery.networkId, 'missing network in discovery') cs_service_url = None nml_topologies = [] for intf in aruba_discovery.interface: if intf.type_ == constants.CS2_SERVICE_TYPE: cs_service_url = intf.href elif intf.type_ == constants.NML_SERVICE_TYPE: nml_topologies.append(intf.href) self.failIfEqual(cs_service_url, None, 'No service url found')
class RestInterfaceTest(unittest.TestCase): PORT = 8180 network = 'aruba:topology' provider_agent = nsa.NetworkServiceAgent('aruba:nsa', 'dud_endpoint2') def setUp(self): db.setupDatabase() self.requester = common.DUDRequester() self.clock = task.Clock() nrm_ports = nrm.parsePortSpec(StringIO(topology.ARUBA_TOPOLOGY)) network_topology = nml.createNMLNetwork(nrm_ports, self.network, self.network) self.backend = dud.DUDNSIBackend(self.network, nrm_ports, None, {}) # we set the parent later self.backend.scheduler.clock = self.clock link_vector = linkvector.LinkVector( [ self.network ] ) pl = plugin.BasePlugin() pl.init( { config.DOMAIN: self.network }, None ) pr = provreg.ProviderRegistry({}) pr.addProvider(self.provider_agent.urn(), self.network, self.backend) self.aggregator = aggregator.Aggregator(self.provider_agent, network_topology, link_vector, None, pr, [], pl) # we set the parent later self.backend.parent_requester = self.aggregator # provider protocol http_top_resource = resource.Resource() rest.setupService(self.aggregator, http_top_resource) # we need this for the aggregator not to blow up cs2_prov = nsi2.setupProvider(self.aggregator, http_top_resource) self.aggregator.parent_requester = cs2_prov provider_factory = server.Site(http_top_resource) self.provider_service = internet.TCPServer(self.PORT, provider_factory) # start engines! self.backend.startService() self.provider_service.startService() @defer.inlineCallbacks def tearDown(self): self.backend.stopService() self.provider_service.stopService() from opennsa.backends.common import genericbackend # keep it simple... yield genericbackend.GenericBackendConnections.deleteAll() yield database.SubConnection.deleteAll() yield database.ServiceConnection.deleteAll() # close database connections, so we don't run out from twistar.registry import Registry Registry.DBPOOL.close() @defer.inlineCallbacks def testInvalidNetwork(self): agent = Agent(reactor) header = Headers({'User-Agent': ['OpenNSA Test Client'], 'Host': ['localhost'] } ) #payload = '''{ "source" : "nordu.net:s1", "destination" : "surfnet.nl:ps", "end" : "2016-01-13T08:08:08Z" }''' payload = { "source" : "nordu.net:s1", "destination" : "surfnet.nl:ps", "end" : "2016-01-13T08:08:08Z" } create_url = 'http://localhost:{}{}'.format(self.PORT, rest.PATH).encode() payload_data = json.dumps(payload) producer = FileBodyProducer(BytesIO(payload_data.encode())) d = agent.request(b'POST', create_url, header, producer) resp = yield d self.failUnlessEqual(resp.code, 400, 'Service did not return request error') @defer.inlineCallbacks def testCreateCommitProvision(self): agent = Agent(reactor) header = Headers({'User-Agent': ['OpenNSA Test Client'], 'Host': ['localhost'] } ) payload = { "source" : "aruba:topology:ps?vlan=1783", "destination" : "aruba:topology:bon?vlan=1783", "auto_commit" : False } payload_data = json.dumps(payload) create_url = 'http://localhost:%i%s' % (self.PORT, rest.PATH) producer = FileBodyProducer(BytesIO(payload_data.encode())) resp = yield agent.request(b'POST', create_url.encode(), header, producer) self.failUnlessEqual(resp.code, 201, 'Service did not return created') if not resp.headers.hasHeader('location'): self.fail('No location header in create response') conn_url = 'http://localhost:{}{}'.format(self.PORT, resp.headers.getRawHeaders('location')[0]) # so... the connection will not necesarely have moved into reserveheld or all sub-connections might not even be in place yet # we cannot really commit until we are in created and ReserveHeld # the clock doesn't really do anything here (not scheduling related) yield task.deferLater(reactor, 0.15, self._createCommitProvisionCB, agent, conn_url, header) @defer.inlineCallbacks def testGetResources(self): agent = Agent(reactor) payload = { "source": "aruba:topology:ps?vlan=1783", "destination": "aruba:topology:bon?vlan=1783", "capacity": 1000, "auto_commit": True } payload_data = json.dumps(payload) create_url = 'http://localhost:{}{}'.format(self.PORT, rest.PATH).encode() producer = FileBodyProducer(BytesIO(payload_data.encode())) resp = yield agent.request(b'POST', create_url, None, producer) self.failUnlessEqual(resp.code, 201, 'Service did not return created') resp = yield task.deferLater(reactor, 0.15, agent.request, b'GET', create_url) self.failUnlessEquals(resp.headers.getRawHeaders('Content-Type'), ['application/json']) data = yield readBody(resp) connections = json.loads(data) conn_info = connections[0] self._checkResource(conn_info) @defer.inlineCallbacks def testGetResource(self): agent = Agent(reactor) payload = {"source": "aruba:topology:ps?vlan=1783", "destination": "aruba:topology:bon?vlan=1783", "capacity": 1000, "auto_commit": True } payload_data = json.dumps(payload) create_url = 'http://localhost:{}{}'.format(self.PORT, rest.PATH) producer = FileBodyProducer(BytesIO(payload_data.encode())) resp = yield agent.request(b'POST', create_url.encode(), None, producer) self.failUnlessEqual(resp.code, 201, 'Service did not return created') conn_url = 'http://localhost:{}{}'.format(self.PORT, resp.headers.getRawHeaders('location')[0]) resp = yield task.deferLater(reactor, 0.15, agent.request, b'GET', conn_url.encode()) self.failUnlessEquals(resp.headers.getRawHeaders('Content-Type'), ['application/json']) data = yield readBody(resp) conn_info = json.loads(data) self._checkResource(conn_info) def _checkResource(self, conn_info): self.failUnlessEquals(conn_info['source'], 'aruba:topology:ps?vlan=1783') self.failUnlessEquals(conn_info['destination'], 'aruba:topology:bon?vlan=1783') self.failUnlessEquals(conn_info['lifecycle_state'], 'Created') self.failUnlessEquals(conn_info['reservation_state'], 'ReserveStart') self.failUnlessEquals(conn_info['provision_state'], 'Released') self.failUnlessEquals(conn_info['capacity'], 1000) self.failUnlessEquals(conn_info['data_plane_active'], False) self.assertNotIn(conn_info['connection_id'], ['', None]) self.assertIsNone(conn_info['start_time']) self.assertIsNone(conn_info['end_time']) @defer.inlineCallbacks def _createCommitProvisionCB(self, agent, conn_url, header): c_resp = yield agent.request(b'GET', conn_url.encode(), header) body = yield readBody(c_resp) c_info = json.loads(body) self.failUnlessEquals(c_info['reservation_state'], 'ReserveHeld', 'State did not transit to held after creation') status_url = conn_url + '/status' # commit producer2 = FileBodyProducer(BytesIO(b'commit')) resp2 = yield agent.request(b'POST', status_url.encode(), header, producer2) self.failUnlessEqual(resp2.code, 200, 'Service did not return OK after commit') # should do new call here.. c_resp = yield agent.request(b'GET', conn_url.encode(), header) body = yield readBody(c_resp) c_info2 = json.loads(body) self.failUnlessEquals(c_info2['reservation_state'], 'ReserveStart', 'State did not transit after commit') # provision producer3 = FileBodyProducer(BytesIO(b'provision')) resp3 = yield agent.request(b'POST', status_url.encode(), header, producer3) self.failUnlessEqual(resp3.code, 200, 'Service did not return OK after provision') # give the provider a bit of time to switch yield task.deferLater(reactor, 0.15, self._createCommitProvisionCB2, agent, conn_url, header) @defer.inlineCallbacks def _createCommitProvisionCB2(self, agent, conn_url, header): resp = yield agent.request(b'GET', conn_url.encode(), header) data = yield readBody(resp) conn_info = json.loads(data) self.failUnlessEquals(conn_info['provision_state'], 'Provisioned', 'State did not transit to provisioned after provision')
def doMain(): print 'OpenNSA WS test client' wsdl_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'wsdl') client, factory = setup.createClient(HOST, PORT, wsdl_dir) reactor.listenTCP(PORT, factory) client_nsa = nsa.NetworkServiceAgent('OpenNSA-testclient', LOCAL_REQUESTER) provider_local_aruba = nsa.Network('Aruba', nsa.NetworkServiceAgent('Aruba-OpenNSA', LOCALHOST_SERVICE)) provider_orval_aruba = nsa.Network('Aruba', nsa.NetworkServiceAgent('Aruba-OpenNSA', OPENNSA_SERVICE)) provider_martinique = nsa.Network('Martinique', nsa.NetworkServiceAgent('Martinique-DynamicKL', DYNAMICKL_SERVICE)) provider = provider_local_aruba #provider = provider_orval_aruba #provider = provider_martinique source_stp = nsa.STP('Aruba', 'A1' ) #source_stp = nsa.STP('Aruba', 'Axel' ) #source_stp = nsa.STP('Martinique', 'M1') #dest_stp = nsa.STP('Aruba', 'A2') dest_stp = nsa.STP('Bonaire', 'B3') #dest_stp = nsa.STP('Curacao', 'C3') start_time = datetime.datetime.utcfromtimestamp(time.time() + 3 ) end_time = datetime.datetime.utcfromtimestamp(time.time() + 120 ) #start_time, end_time = end_time, start_time bandwidth = 200 #service_params = nsa.ServiceParameters('2011-09-01T08:56:00Z', '2011-10-01T08:56:00Z' , source_stp, dest_stp, bwp) service_params = nsa.ServiceParameters(start_time, end_time, source_stp, dest_stp, bandwidth) global_reservation_id = 'urn:uuid:' + str(uuid.uuid1()) connection_id = 'urn:uuid:' + str(uuid.uuid1()) print "Connection id", connection_id r = yield client.reserve(client_nsa, provider.nsa, None, global_reservation_id, 'Test Connection', connection_id, service_params) print "Reservation created. Connection ID:", connection_id qr = yield client.query(client_nsa, provider.nsa, None, "Summary", connection_ids = [ connection_id ] ) matchState(qr, 'Reserved') d = client.provision(client_nsa, provider.nsa, None, connection_id) qr = yield client.query(client_nsa, provider.nsa, None, "Summary", connection_ids = [ connection_id ] ) matchState(qr, 'Auto-Provision') yield d print "Connection provisioned" qr = yield client.query(client_nsa, provider.nsa, None, "Summary", connection_ids = [ connection_id ] ) matchState(qr, 'Provisioned') _ = yield client.release(client_nsa, provider.nsa, None, connection_id) print "Connection released" qr = yield client.query(client_nsa, provider.nsa, None, "Summary", connection_ids = [ connection_id ] ) matchState(qr, 'Scheduled') _ = yield client.terminate(client_nsa, provider.nsa, None, connection_id) print "Reservation terminated" qr = yield client.query(client_nsa, provider.nsa, None, "Summary", connection_ids = [ connection_id ] ) matchState(qr, 'Terminated')
class AggregatorTest(GenericProviderTest, unittest.TestCase): requester_agent = nsa.NetworkServiceAgent('test-requester:nsa', 'dud_endpoint1') provider_agent = nsa.NetworkServiceAgent(GenericProviderTest.base + ':nsa', 'dud_endpoint2') header = nsa.NSIHeader( requester_agent.urn(), provider_agent.urn(), connection_trace=[requester_agent.urn() + ':1'], security_attributes=[nsa.SecurityAttribute('user', 'testuser')]) def setUp(self): tcf = os.path.expanduser('~/.opennsa-test.json') tc = json.load(open(tcf)) database.setupDatabase(tc['database'], tc['database-user'], tc['database-password']) self.requester = common.DUDRequester() self.clock = task.Clock() nrm_ports = nrm.parsePortSpec( StringIO.StringIO(topology.ARUBA_TOPOLOGY)) network_topology = nml.createNMLNetwork(nrm_ports, self.network, self.network) self.backend = dud.DUDNSIBackend(self.network, nrm_ports, self.requester, {}) self.backend.scheduler.clock = self.clock route_vectors = gns.RouteVectors([cnt.URN_OGF_PREFIX + self.network]) route_vectors.updateVector(self.provider_agent.identity, 0, [self.network], {}) pl = plugin.BasePlugin() pl.init({config.NETWORK_NAME: self.network}, None) pr = provreg.ProviderRegistry( {self.provider_agent.urn(): self.backend}, {}) self.provider = aggregator.Aggregator(self.network, self.provider_agent, network_topology, route_vectors, self.requester, pr, [], pl) # set parent for backend, we need to create the aggregator before this can be done self.backend.parent_requester = self.provider self.backend.startService() # request stuff self.start_time = datetime.datetime.utcnow() + datetime.timedelta( seconds=2) self.end_time = datetime.datetime.utcnow() + datetime.timedelta( seconds=10) self.schedule = nsa.Schedule(self.start_time, self.end_time) self.sd = nsa.Point2PointService(self.source_stp, self.dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) self.criteria = nsa.Criteria(0, self.schedule, self.sd) @defer.inlineCallbacks def tearDown(self): from opennsa.backends.common import genericbackend # keep it simple... yield genericbackend.GenericBackendConnections.deleteAll() yield database.SubConnection.deleteAll() yield database.ServiceConnection.deleteAll() # close database connections, so we don't run out from twistar.registry import Registry Registry.DBPOOL.close()
class AggregatorTest(GenericProviderTest, unittest.TestCase): requester_agent = nsa.NetworkServiceAgent('test-requester:nsa', 'dud_endpoint1') provider_agent = nsa.NetworkServiceAgent(GenericProviderTest.base + ':nsa', 'dud_endpoint2') header = nsa.NSIHeader(requester_agent.urn(), provider_agent.urn(), connection_trace= [ requester_agent.urn() + ':1' ], security_attributes = [ nsa.SecurityAttribute('user', 'testuser') ] ) def setUp(self): db.setupDatabase() self.requester = common.DUDRequester() self.clock = task.Clock() nrm_map = StringIO.StringIO(topology.ARUBA_TOPOLOGY) nrm_ports, nml_network, link_vector = setup.setupTopology(nrm_map, self.network, 'aruba.net') self.backend = dud.DUDNSIBackend(self.network, nrm_ports, self.requester, {}) self.backend.scheduler.clock = self.clock pl = plugin.BasePlugin() pl.init( { config.NETWORK_NAME: self.network }, None ) pr = provreg.ProviderRegistry( { self.provider_agent.urn() : self.backend }, {} ) self.provider = aggregator.Aggregator(self.network, self.provider_agent, nml_network, link_vector, self.requester, pr, [], pl) # set parent for backend, we need to create the aggregator before this can be done self.backend.parent_requester = self.provider self.backend.startService() # request stuff self.start_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=2) self.end_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=10) self.schedule = nsa.Schedule(self.start_time, self.end_time) self.sd = nsa.Point2PointService(self.source_stp, self.dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) self.criteria = nsa.Criteria(0, self.schedule, self.sd) @defer.inlineCallbacks def tearDown(self): from opennsa.backends.common import genericbackend # keep it simple... yield genericbackend.GenericBackendConnections.deleteAll() yield database.SubConnection.deleteAll() yield database.ServiceConnection.deleteAll() # close database connections, so we don't run out from twistar.registry import Registry Registry.DBPOOL.close() @defer.inlineCallbacks def testHairpinConnectionAllowed(self): self.provider.policies.append(cnt.ALLOW_HAIRPIN) source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) dest_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1783') ) sd = nsa.Point2PointService(source_stp, dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) criteria = nsa.Criteria(0, self.schedule, sd) self.header.newCorrelationId() try: acid = yield self.provider.reserve(self.header, None, None, None, criteria) yield self.requester.reserve_defer except Exception as e: self.fail('Should not have raised exception: %s' % str(e))
def setupServiceFactory(self): """ This sets up the OpenNSA service and ties together everything in the initialization. There are a lot of things going on, but none of it it particular deep. """ log.msg('OpenNSA service initializing') vc = self.vc now = datetime.datetime.utcnow().replace(microsecond=0) if vc[config.HOST] is None: # guess name if not configured import socket vc[config.HOST] = socket.getfqdn() # database database.setupDatabase(vc[config.DATABASE], vc[config.DATABASE_USER], vc[config.DATABASE_PASSWORD], vc[config.DATABASE_HOST], vc[config.SERVICE_ID_START]) service_endpoints = [] # base names domain_name = vc[config.DOMAIN] # FIXME rename variable to domain nsa_name = domain_name + ':nsa' # base url base_protocol = 'https://' if vc[config.TLS] else 'http://' base_url = base_protocol + vc[config.HOST] + ':' + str(vc[config.PORT]) # nsi endpoint and agent provider_endpoint = base_url + '/NSI/services/CS2' # hardcode for now service_endpoints.append(('Provider', provider_endpoint)) ns_agent = nsa.NetworkServiceAgent(nsa_name, provider_endpoint, 'local') # ssl/tls context ctx_factory = setupTLSContext(vc) # May be None # plugin if vc[config.PLUGIN]: from twisted.python import reflect plugin = reflect.namedAny('opennsa.plugins.%s.plugin' % vc[config.PLUGIN]) else: from opennsa.plugin import BasePlugin plugin = BasePlugin() plugin.init(vc, ctx_factory) # the dance to setup dynamic providers right top_resource = resource.Resource() requester_creator = CS2RequesterCreator( top_resource, None, vc[config.HOST], vc[config.PORT], vc[config.TLS], ctx_factory) # set aggregator later provider_registry = provreg.ProviderRegistry( {cnt.CS2_SERVICE_TYPE: requester_creator.create}) link_vector = linkvector.LinkVector() networks = {} ports = {} # { network : { port : nrmport } } parent_requester = None # parent requester is set later aggr = aggregator.Aggregator(ns_agent, ports, link_vector, parent_requester, provider_registry, vc[config.POLICY], plugin) requester_creator.aggregator = aggr pc = nsi2.setupProvider(aggr, top_resource, ctx_factory=ctx_factory, allowed_hosts=vc.get(config.ALLOWED_HOSTS)) aggr.parent_requester = pc # setup backend(s) - for now we only support one backend_configs = vc['backend'] if len(backend_configs) == 0: log.msg('No backend specified. Running in aggregator-only mode') if not cnt.AGGREGATOR in vc[config.POLICY]: vc[config.POLICY].append(cnt.AGGREGATOR) else: # at least one backend # This is all temporary right now... clean up later for backend_name, b_cfg in backend_configs.items(): if backend_name is None or backend_name == '': raise config.ConfigurationError( 'You need to specify backend name, use [backend:name]') backend_network_name = '{}:{}'.format(domain_name, backend_name) if not config.NRM_MAP_FILE in b_cfg: # move to verify config raise config.ConfigurationError( 'No nrm map specified for backend') backend_nrm_map_file = b_cfg[config.NRM_MAP_FILE] if not os.path.exists( backend_nrm_map_file): # move to verify config raise config.ConfigError( 'nrm map file {} for backend {} does not exists'. format(backend_nrm_map_file, backend_name)) nrm_map = open(backend_nrm_map_file) backend_nrm_ports = nrm.parsePortSpec(nrm_map) link_vector.addLocalNetwork(backend_network_name) for np in backend_nrm_ports: if np.remote_network is not None: link_vector.updateVector( backend_network_name, np.name, {np.remote_network: 1}) # hack for network, cost in np.vectors.items(): link_vector.updateVector(np.name, {network: cost}) # build port map for aggreator to lookup ports.setdefault(backend_network_name, {})[np.name] = np backend_service = setupBackend(b_cfg, backend_network_name, backend_nrm_ports, aggr) networks[backend_network_name] = { 'backend': backend_service, 'nrm_ports': backend_nrm_ports } provider_registry.addProvider(ns_agent.urn(), backend_network_name, backend_service) # fetcher if vc[config.PEERS]: fetcher_service = fetcher.FetcherService(link_vector, networks, vc[config.PEERS], provider_registry, ctx_factory=ctx_factory) fetcher_service.setServiceParent(self) else: log.msg( 'No peers configured, will not be able to do outbound requests (UPA mode)' ) # discovery service opennsa_version = 'OpenNSA-' + version network_urns = [ '{}{}'.format(cnt.URN_OGF_PREFIX, network_name) for network_name in networks ] interfaces = [(cnt.CS2_PROVIDER, provider_endpoint, None), (cnt.CS2_SERVICE_TYPE, provider_endpoint, None)] features = [] if networks: features.append((cnt.FEATURE_UPA, None)) if vc[config.PEERS]: features.append((cnt.FEATURE_AGGREGATOR, None)) # view resource vr = viewresource.ConnectionListResource() top_resource.children[NSI_RESOURCE].putChild('connections', vr) # rest service if vc[config.REST]: rest_url = base_url + '/connections' rest.setupService(aggr, top_resource, vc.get(config.ALLOWED_HOSTS)) service_endpoints.append(('REST', rest_url)) interfaces.append((cnt.OPENNSA_REST, rest_url, None)) for backend_network_name, no in networks.items(): nml_resource_name = '{}.nml.xml'.format(backend_network_name) nml_url = '%s/NSI/%s' % (base_url, nml_resource_name) nml_network = nml.createNMLNetwork(no['nrm_ports'], backend_network_name, backend_network_name) can_swap_label = no['backend'].connection_manager.canSwapLabel( cnt.ETHERNET_VLAN) nml_service = nmlservice.NMLService(nml_network, can_swap_label) top_resource.children[NSI_RESOURCE].putChild( nml_resource_name.encode(), nml_service.resource()) service_endpoints.append(('NML Topology', nml_url)) interfaces.append((cnt.NML_SERVICE_TYPE, nml_url, None)) # discovery service discovery_resource_name = b'discovery.xml' discovery_url = '%s/NSI/%s' % (base_url, discovery_resource_name.decode()) ds = discoveryservice.DiscoveryService(ns_agent.urn(), now, domain_name, opennsa_version, now, network_urns, interfaces, features, provider_registry, link_vector) discovery_resource = ds.resource() top_resource.children[NSI_RESOURCE].putChild(discovery_resource_name, discovery_resource) link_vector.callOnUpdate( lambda: discovery_resource.updateResource(ds.xml())) service_endpoints.append(('Discovery', discovery_url)) # log service urls for service_name, url in service_endpoints: log.msg('{:<12} URL: {}'.format(service_name, url)) factory = server.Site(top_resource) factory.log = httplog.logRequest # default logging is weird, so we do our own return factory, ctx_factory
def testNetworkServiceAgent(self): agent = nsa.NetworkServiceAgent('id', 'http://localhost:8888') host, port = agent.getHostPort() self.failUnlessEqual(host, 'localhost') self.failUnlessEqual(port, 8888)
def testBasicConnectionLifeCycle(self): provider = nsa.Network( 'Aruba', nsa.NetworkServiceAgent( 'Aruba-OpenNSA', 'http://localhost:9080/NSI/services/ConnectionService')) source_stp = nsa.STP('Aruba', 'A1') dest_stp = nsa.STP('Aruba', 'A2') start_time = datetime.datetime.utcfromtimestamp(time.time() + 1.5) end_time = datetime.datetime.utcfromtimestamp(time.time() + 120) bwp = nsa.BandwidthParameters(200) service_params = nsa.ServiceParameters(start_time, end_time, source_stp, dest_stp, bandwidth=bwp) global_reservation_id = 'urn:uuid:' + str(uuid.uuid1()) connection_id = 'conn-id1' yield self.client.reserve(self.client_nsa, provider.nsa, None, global_reservation_id, 'Test Connection', connection_id, service_params) qr = yield self.client.query(self.client_nsa, provider.nsa, None, "Summary", connection_ids=[connection_id]) self.assertEquals(qr.reservationSummary[0].connectionState, 'Reserved') yield self.client.provision(self.client_nsa, provider.nsa, None, connection_id) qr = yield self.client.query(self.client_nsa, provider.nsa, None, "Summary", connection_ids=[connection_id]) self.assertEquals(qr.reservationSummary[0].connectionState, 'Provisioned') yield self.client.release(self.client_nsa, provider.nsa, None, connection_id) qr = yield self.client.query(self.client_nsa, provider.nsa, None, "Summary", connection_ids=[connection_id]) self.assertEquals(qr.reservationSummary[0].connectionState, 'Scheduled') yield self.client.terminate(self.client_nsa, provider.nsa, None, connection_id) qr = yield self.client.query(self.client_nsa, provider.nsa, None, "Summary", connection_ids=[connection_id]) self.assertEquals(qr.reservationSummary[0].connectionState, 'Terminated') # give the service side time to dump its connections # this prevents finishing the test with a dirty reactor from twisted.internet import task d = task.deferLater(reactor, 0.01, lambda: None) yield d
def startService(self): """ This sets up the OpenNSA service and ties together everything in the initialization. There are a lot of things going on, but none of it it particular deep. """ log.msg('OpenNSA service initializing') vc = self.vc now = datetime.datetime.utcnow().replace(microsecond=0) if vc[config.HOST] is None: # guess name if not configured import socket vc[config.HOST] = socket.getfqdn() # database database.setupDatabase(vc[config.DATABASE], vc[config.DATABASE_USER], vc[config.DATABASE_PASSWORD], vc[config.DATABASE_HOST], vc[config.SERVICE_ID_START]) service_endpoints = [] # base names base_name = vc[config.NETWORK_NAME] network_name = base_name + ':topology' # because we say so nsa_name = base_name + ':nsa' # base url base_protocol = 'https://' if vc[config.TLS] else 'http://' base_url = base_protocol + vc[config.HOST] + ':' + str(vc[config.PORT]) # nsi endpoint and agent provider_endpoint = base_url + '/NSI/services/CS2' # hardcode for now service_endpoints.append(('Provider', provider_endpoint)) ns_agent = nsa.NetworkServiceAgent(nsa_name, provider_endpoint, 'local') # topology nrm_map = open(vc[config.NRM_MAP_FILE]) if vc[ config.NRM_MAP_FILE] is not None else None nrm_ports, nml_network, link_vector = setupTopology( nrm_map, network_name, base_name) # ssl/tls context ctx_factory = setupTLSContext(vc) # May be None # plugin if vc[config.PLUGIN]: from twisted.python import reflect plugin = reflect.namedAny('opennsa.plugins.%s.plugin' % vc[config.PLUGIN]) else: from opennsa.plugin import BasePlugin plugin = BasePlugin() plugin.init(vc, ctx_factory) # the dance to setup dynamic providers right top_resource = resource.Resource() requester_creator = CS2RequesterCreator( top_resource, None, vc[config.HOST], vc[config.PORT], vc[config.TLS], ctx_factory) # set aggregator later provider_registry = provreg.ProviderRegistry( {}, {cnt.CS2_SERVICE_TYPE: requester_creator.create}) aggr = aggregator.Aggregator(network_name, ns_agent, nml_network, link_vector, None, provider_registry, vc[config.POLICY], plugin) # set parent requester later requester_creator.aggregator = aggr pc = nsi2.setupProvider(aggr, top_resource, ctx_factory=ctx_factory, allowed_hosts=vc.get(config.ALLOWED_HOSTS)) aggr.parent_requester = pc # setup backend(s) - for now we only support one backend_configs = vc['backend'] if len(backend_configs) == 0: log.msg('No backend specified. Running in aggregator-only mode') if not cnt.AGGREGATOR in vc[config.POLICY]: vc[config.POLICY].append(cnt.AGGREGATOR) elif len(backend_configs) > 1: raise config.ConfigurationError( 'Only one backend supported for now. Multiple will probably come later.' ) else: # 1 backend if not nrm_ports: raise config.ConfigurationError( 'No NRM Map file specified. Cannot configure a backend without port spec.' ) backend_cfg = backend_configs.values()[0] backend_service = setupBackend(backend_cfg, network_name, nrm_ports, aggr) backend_service.setServiceParent(self) can_swap_label = backend_service.connection_manager.canSwapLabel( cnt.ETHERNET_VLAN) provider_registry.addProvider(ns_agent.urn(), backend_service, [network_name]) # fetcher if vc[config.PEERS]: fetcher_service = fetcher.FetcherService(link_vector, nrm_ports, vc[config.PEERS], provider_registry, ctx_factory=ctx_factory) fetcher_service.setServiceParent(self) else: log.msg( 'No peers configured, will not be able to do outbound requests.' ) # discovery service name = base_name.split(':')[0] if ':' in base_name else base_name opennsa_version = 'OpenNSA-' + version networks = [cnt.URN_OGF_PREFIX + network_name] if nml_network is not None else [] interfaces = [(cnt.CS2_PROVIDER, provider_endpoint, None), (cnt.CS2_SERVICE_TYPE, provider_endpoint, None)] features = [] if nrm_ports: features.append((cnt.FEATURE_UPA, None)) if vc[config.PEERS]: features.append((cnt.FEATURE_AGGREGATOR, None)) # view resource vr = viewresource.ConnectionListResource() top_resource.children['NSI'].putChild('connections', vr) # rest service if vc[config.REST]: rest_url = base_url + '/connections' rest.setupService(aggr, top_resource, vc.get(config.ALLOWED_HOSTS)) service_endpoints.append(('REST', rest_url)) interfaces.append((cnt.OPENNSA_REST, rest_url, None)) # nml topology if nml_network is not None: nml_resource_name = base_name + '.nml.xml' nml_url = '%s/NSI/%s' % (base_url, nml_resource_name) nml_service = nmlservice.NMLService(nml_network, can_swap_label) top_resource.children['NSI'].putChild(nml_resource_name, nml_service.resource()) service_endpoints.append(('NML Topology', nml_url)) interfaces.append((cnt.NML_SERVICE_TYPE, nml_url, None)) # discovery service discovery_resource_name = 'discovery.xml' discovery_url = '%s/NSI/%s' % (base_url, discovery_resource_name) ds = discoveryservice.DiscoveryService(ns_agent.urn(), now, name, opennsa_version, now, networks, interfaces, features, provider_registry, link_vector) discovery_resource = ds.resource() top_resource.children['NSI'].putChild(discovery_resource_name, discovery_resource) link_vector.callOnUpdate( lambda: discovery_resource.updateResource(ds.xml())) service_endpoints.append(('Discovery', discovery_url)) # print service urls for service_name, url in service_endpoints: log.msg('{:<12} URL: {}'.format(service_name, url)) factory = server.Site(top_resource) factory.log = httplog.logRequest # default logging is weird, so we do our own if vc[config.TLS]: internet.SSLServer(vc[config.PORT], factory, ctx_factory).setServiceParent(self) else: internet.TCPServer(vc[config.PORT], factory).setServiceParent(self) # do not start sub-services until we have started this one twistedservice.MultiService.startService(self) log.msg('OpenNSA service started')
class RemoteProviderTest(GenericProviderTest, unittest.TestCase): PROVIDER_PORT = 8180 REQUESTER_PORT = 8280 requester_agent = nsa.NetworkServiceAgent('test-requester:nsa', 'http://localhost:%i/NSI/services/RequesterService2' % REQUESTER_PORT) provider_agent = nsa.NetworkServiceAgent(GenericProviderTest.base + ':nsa', 'http://localhost:%i/NSI/services/CS2' % PROVIDER_PORT) header = nsa.NSIHeader(requester_agent.urn(), provider_agent.urn(), reply_to=requester_agent.endpoint, connection_trace=[ requester_agent.urn() + ':1' ], security_attributes = [ nsa.SecurityAttribute('user', 'testuser') ] ) def setUp(self): from twisted.web import resource, server from twisted.application import internet from opennsa.protocols import nsi2 from opennsa.protocols.shared import soapresource from opennsa.protocols.nsi2 import requesterservice, requesterclient db.setupDatabase() self.requester = common.DUDRequester() self.clock = task.Clock() nrm_map = StringIO.StringIO(topology.ARUBA_TOPOLOGY) nrm_ports, nml_network, link_vector = setup.setupTopology(nrm_map, self.network, 'aruba.net') self.backend = dud.DUDNSIBackend(self.network, nrm_ports, None, {}) # we set the parent later self.backend.scheduler.clock = self.clock pl = plugin.BasePlugin() pl.init( { config.NETWORK_NAME: self.network }, None ) pr = provreg.ProviderRegistry( { self.provider_agent.urn() : self.backend }, {} ) self.aggregator = aggregator.Aggregator(self.network, self.provider_agent, nml_network, link_vector, None, pr, [], pl) # we set the parent later self.backend.parent_requester = self.aggregator # provider protocol http_top_resource = resource.Resource() cs2_prov = nsi2.setupProvider(self.aggregator, http_top_resource) self.aggregator.parent_requester = cs2_prov provider_factory = server.Site(http_top_resource) self.provider_service = internet.TCPServer(self.PROVIDER_PORT, provider_factory) # requester protocol requester_top_resource = resource.Resource() soap_resource = soapresource.setupSOAPResource(requester_top_resource, 'RequesterService2') self.provider = requesterclient.RequesterClient(self.provider_agent.endpoint, self.requester_agent.endpoint) requester_service = requesterservice.RequesterService(soap_resource, self.requester) # this is the important part requester_factory = server.Site(requester_top_resource, logPath='/dev/null') # start engines! self.backend.startService() self.provider_service.startService() self.requester_iport = reactor.listenTCP(self.REQUESTER_PORT, requester_factory) # request stuff self.start_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=2) self.end_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=10) self.schedule = nsa.Schedule(self.start_time, self.end_time) self.sd = nsa.Point2PointService(self.source_stp, self.dest_stp, self.bandwidth) self.criteria = nsa.Criteria(0, self.schedule, self.sd) @defer.inlineCallbacks def tearDown(self): self.backend.stopService() self.provider_service.stopService() self.requester_iport.stopListening() from opennsa.backends.common import genericbackend # keep it simple... yield genericbackend.GenericBackendConnections.deleteAll() yield database.SubConnection.deleteAll() yield database.ServiceConnection.deleteAll() # close database connections, so we don't run out from twistar.registry import Registry Registry.DBPOOL.close() @defer.inlineCallbacks def testQuerySummarySync(self): # sync is only available remotely self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, 'gid-123', 'desc2', self.criteria) yield self.requester.reserve_defer yield self.provider.reserveCommit(self.header, acid) yield self.requester.reserve_commit_defer reservations = yield self.provider.querySummarySync(self.header, connection_ids = [ acid ] ) self.failUnlessEquals(len(reservations), 1) ci = reservations[0] self.failUnlessEquals(ci.connection_id, acid) self.failUnlessEquals(ci.global_reservation_id, 'gid-123') self.failUnlessEquals(ci.description, 'desc2') self.failUnlessEquals(ci.requester_nsa, self.requester_agent.urn()) self.failUnlessEquals(len(ci.criterias), 1) crit = ci.criterias[0] sd = crit.service_def src_stp = sd.source_stp dst_stp = sd.dest_stp self.failUnlessEquals(src_stp.network, self.network) self.failUnlessEquals(src_stp.port, self.source_port) self.failUnlessEquals(src_stp.label.type_, cnt.ETHERNET_VLAN) self.failUnlessIn(src_stp.label.labelValue(), ('1781', '1782') ) self.failUnlessEquals(dst_stp.network, self.network) self.failUnlessEquals(dst_stp.port, self.dest_port) self.failUnlessEquals(dst_stp.label.type_, cnt.ETHERNET_VLAN) self.failUnlessIn(dst_stp.label.labelValue(), ('1782', '1783') ) self.failUnlessEqual(sd.capacity, self.bandwidth) self.failUnlessEqual(crit.revision, 0) from opennsa import state rsm, psm, lsm, dps = ci.states self.failUnlessEquals(rsm, state.RESERVE_START) self.failUnlessEquals(psm, state.RELEASED) self.failUnlessEquals(lsm, state.CREATED) self.failUnlessEquals(dps[:2], (False, 0) ) # we cannot really expect a consistent result for consistent here @defer.inlineCallbacks def testQueryRecursive(self): # only available on aggregator and remote, we just do remote for now self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, 'gid-123', 'desc2', self.criteria) yield self.requester.reserve_defer yield self.provider.reserveCommit(self.header, acid) yield self.requester.reserve_commit_defer self.header.newCorrelationId() yield self.provider.queryRecursive(self.header, connection_ids = [ acid ] ) header, reservations = yield self.requester.query_recursive_defer self.failUnlessEquals(len(reservations), 1) ci = reservations[0] self.failUnlessEquals(ci.connection_id, acid) self.failUnlessEquals(ci.global_reservation_id, 'gid-123') self.failUnlessEquals(ci.description, 'desc2') self.failUnlessEquals(ci.requester_nsa, self.requester_agent.urn()) self.failUnlessEquals(len(ci.criterias), 1) crit = ci.criterias[0] src_stp = crit.service_def.source_stp dst_stp = crit.service_def.dest_stp self.failUnlessEquals(src_stp.network, self.network) self.failUnlessEquals(src_stp.port, self.source_port) self.failUnlessEquals(src_stp.label.type_, cnt.ETHERNET_VLAN) self.failUnlessIn(src_stp.label.labelValue(), ('1781', '1782') ) self.failUnlessEquals(dst_stp.network, self.network) self.failUnlessEquals(dst_stp.port, self.dest_port) self.failUnlessEquals(dst_stp.label.type_, cnt.ETHERNET_VLAN) self.failUnlessIn(dst_stp.label.labelValue(), ('1782', '1783') ) self.failUnlessEqual(crit.service_def.capacity, self.bandwidth) self.failUnlessEqual(crit.revision, 0) from opennsa import state rsm, psm, lsm, dps = ci.states self.failUnlessEquals(rsm, state.RESERVE_START) self.failUnlessEquals(psm, state.RELEASED) self.failUnlessEquals(lsm, state.CREATED) self.failUnlessEquals(dps[:2], (False, 0) ) # we cannot really expect a consistent result for consistent here self.failUnlessEqual(len(crit.children), 1) child = crit.children[0] rsm, psm, lsm, dps = ci.states # overwrite self.failUnlessEquals(rsm, state.RESERVE_START) self.failUnlessEquals(psm, state.RELEASED) self.failUnlessEquals(lsm, state.CREATED) self.failUnlessEquals(dps[:2], (False, 0) ) # we cannot really expect a consistent result for consistent here @defer.inlineCallbacks def testQueryRecursiveNoStartTime(self): # only available on aggregator and remote, we just do remote for now start_time = None criteria = nsa.Criteria(0, nsa.Schedule(start_time, self.end_time), self.sd) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, 'gid-123', 'desc2', criteria) yield self.requester.reserve_defer yield self.provider.reserveCommit(self.header, acid) yield self.requester.reserve_commit_defer self.header.newCorrelationId() yield self.provider.queryRecursive(self.header, connection_ids = [ acid ] ) header, reservations = yield self.requester.query_recursive_defer self.failUnlessEquals(len(reservations), 1) ci = reservations[0] self.failUnlessEquals(ci.connection_id, acid) self.failUnlessEquals(ci.global_reservation_id, 'gid-123') self.failUnlessEquals(ci.description, 'desc2') self.failUnlessEquals(ci.requester_nsa, self.requester_agent.urn()) self.failUnlessEquals(len(ci.criterias), 1) crit = ci.criterias[0] src_stp = crit.service_def.source_stp dst_stp = crit.service_def.dest_stp self.failUnlessEquals(src_stp.network, self.network) self.failUnlessEquals(src_stp.port, self.source_port) self.failUnlessEquals(src_stp.label.type_, cnt.ETHERNET_VLAN) self.failUnlessIn(src_stp.label.labelValue(), ('1781', '1782') ) self.failUnlessEquals(dst_stp.network, self.network) self.failUnlessEquals(dst_stp.port, self.dest_port) self.failUnlessEquals(dst_stp.label.type_, cnt.ETHERNET_VLAN) self.failUnlessIn(dst_stp.label.labelValue(), ('1782', '1783') ) self.failUnlessEqual(crit.service_def.capacity, self.bandwidth) self.failUnlessEqual(crit.revision, 0) from opennsa import state rsm, psm, lsm, dps = ci.states self.failUnlessEquals(rsm, state.RESERVE_START) self.failUnlessEquals(psm, state.RELEASED) self.failUnlessEquals(lsm, state.CREATED) self.failUnlessEquals(dps[:2], (False, 0) ) # we cannot really expect a consistent result for consistent here self.failUnlessEqual(len(crit.children), 1) child = crit.children[0] rsm, psm, lsm, dps = ci.states # overwrite self.failUnlessEquals(rsm, state.RESERVE_START) self.failUnlessEquals(psm, state.RELEASED) self.failUnlessEquals(lsm, state.CREATED) self.failUnlessEquals(dps[:2], (False, 0) ) # we cannot really expect a consistent result for consistent here
def startService(self): """ This sets up the OpenNSA service and ties together everything in the initialization. There are a lot of things going on, but none of it it particular deep. """ log.msg('OpenNSA service initializing') vc = self.vc now = datetime.datetime.utcnow().replace(microsecond=0) if vc[config.HOST] is None: # guess name if not configured import socket vc[config.HOST] = socket.getfqdn() # database database.setupDatabase(vc[config.DATABASE], vc[config.DATABASE_USER], vc[config.DATABASE_PASSWORD]) # base names base_name = vc[config.NETWORK_NAME] network_name = base_name + ':topology' # because we say so nsa_name = base_name + ':nsa' # url stuffs base_protocol = 'https://' if vc[config.TLS] else 'http://' base_url = base_protocol + vc[config.HOST] + ':' + str(vc[config.PORT]) # nsi agent provider_endpoint = base_url + '/NSI/services/CS2' # hardcode for now ns_agent = nsa.NetworkServiceAgent(nsa_name, provider_endpoint, 'local') # topology nrm_ports = nrm.parsePortSpec( open( vc[config.NRM_MAP_FILE] ) ) network_topology = nml.createNMLNetwork(nrm_ports, network_name, base_name) # route vectors link_vector = linkvector.LinkVector( [ network_name ] ) # hack in link vectors manually, since we don't have a mechanism for updating them automatically for np in nrm_ports: if np.remote_network is not None: link_vector.updateVector(np.name, { np.remote_network : 1 } ) # hack for network, cost in np.vectors.items(): link_vector.updateVector(np.name, { network : cost }) # ssl/tls contxt if vc[config.TLS]: from opennsa import ctxfactory ctx_factory = ctxfactory.ContextFactory(vc[config.KEY], vc[config.CERTIFICATE], vc[config.CERTIFICATE_DIR], vc[config.VERIFY_CERT]) elif os.path.isdir(vc[config.CERTIFICATE_DIR]): # we can at least create a context from opennsa import ctxfactory ctx_factory = ctxfactory.RequestContextFactory(vc[config.CERTIFICATE_DIR], vc[config.VERIFY_CERT]) else: ctx_factory = None # plugin if vc[config.PLUGIN]: from twisted.python import reflect plugin = reflect.namedAny('opennsa.plugins.%s.plugin' % vc[config.PLUGIN]) else: from opennsa.plugin import BasePlugin plugin = BasePlugin() plugin.init(vc, ctx_factory) # the dance to setup dynamic providers right top_resource = resource.Resource() requester_creator = CS2RequesterCreator(top_resource, None, vc[config.HOST], vc[config.PORT], vc[config.TLS], ctx_factory) # set aggregator later provider_registry = provreg.ProviderRegistry({}, { cnt.CS2_SERVICE_TYPE : requester_creator.create } ) aggr = aggregator.Aggregator(network_topology.id_, ns_agent, network_topology, link_vector, None, provider_registry, vc[config.POLICY], plugin ) # set parent requester later requester_creator.aggregator = aggr pc = nsi2.setupProvider(aggr, top_resource, ctx_factory=ctx_factory, allowed_hosts=vc.get(config.ALLOWED_HOSTS)) aggr.parent_requester = pc # setup backend(s) - for now we only support one backend_configs = vc['backend'] if len(backend_configs) > 1: raise config.ConfigurationError('Only one backend supported for now. Multiple will probably come later.') backend_cfg = backend_configs.values()[0] backend_service = setupBackend(backend_cfg, network_topology.id_, nrm_ports, aggr) backend_service.setServiceParent(self) can_swap_label = backend_service.connection_manager.canSwapLabel(cnt.ETHERNET_VLAN) provider_registry.addProvider(ns_agent.urn(), backend_service, [ network_topology.id_ ] ) # fetcher if vc[config.PEERS]: fetcher_service = fetcher.FetcherService(link_vector, nrm_ports, vc[config.PEERS], provider_registry, ctx_factory=ctx_factory) fetcher_service.setServiceParent(self) # wire up the http stuff discovery_resource_name = 'discovery.xml' nml_resource_name = base_name + '.nml.xml' nml_resource_url = '%s/NSI/%s' % (base_url, nml_resource_name) # discovery service name = base_name.split(':')[0] if ':' in base_name else base_name opennsa_version = 'OpenNSA-' + version networks = [ cnt.URN_OGF_PREFIX + network_name ] interfaces = [ ( cnt.CS2_PROVIDER, provider_endpoint, None), ( cnt.CS2_SERVICE_TYPE, provider_endpoint, None), (cnt.NML_SERVICE_TYPE, nml_resource_url, None) ] features = [ (cnt.FEATURE_AGGREGATOR, None), (cnt.FEATURE_UPA, None) ] ds = discoveryservice.DiscoveryService(ns_agent.urn(), now, name, opennsa_version, now, networks, interfaces, features, provider_registry, link_vector) discovery_resource = ds.resource() top_resource.children['NSI'].putChild(discovery_resource_name, discovery_resource) link_vector.callOnUpdate( lambda : discovery_resource.updateResource ( ds.xml() )) # view resource vr = viewresource.ConnectionListResource(aggr) top_resource.children['NSI'].putChild('connections', vr) # topology nml_service = nmlservice.NMLService(network_topology, can_swap_label) top_resource.children['NSI'].putChild(nml_resource_name, nml_service.resource() ) log.msg('Provider URL: %s' % provider_endpoint ) log.msg('Discovery URL: %s/NSI/%s' % (base_url, discovery_resource_name) ) log.msg('Topology URL: %s' % (nml_resource_url) ) factory = server.Site(top_resource) factory.log = httplog.logRequest # default logging is weird, so we do our own if vc[config.TLS]: internet.SSLServer(vc[config.PORT], factory, ctx_factory).setServiceParent(self) else: internet.TCPServer(vc[config.PORT], factory).setServiceParent(self) # do not start sub-services until we have started this one twistedservice.MultiService.startService(self) log.msg('OpenNSA service started')