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')
