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', system='opennsa.setup')
vc = self.vc
topology_sources = [ open(tf) for tf in vc[config.TOPOLOGY_FILE] ]
topology, internal_topology = gole.parseTopology(topology_sources, open(vc[config.NRM_MAP_FILE]) if vc[config.NRM_MAP_FILE] else None )
if vc[config.HOST] is None:
import socket
vc[config.HOST] = socket.getfqdn()
ctx_factory = None
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])
backend = setupBackend(vc['backend'], vc[config.NETWORK_NAME], internal_topology)
factory = createService(vc[config.NETWORK_NAME], backend, topology, vc[config.HOST], vc[config.PORT], vc[config.WSDL_DIRECTORY])
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')
def createSSLClient(self):
# Constructing the client NSA
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("gmail.com", 80))
host = s.getsockname()[0]
s.close()
from opennsa import ctxfactory
ctx_factory = ctxfactory.ContextFactory("./server.key",
"./server.crt",
".",
verify=False)
self.client, factory = opennsa.setup.createClient(
host, self.port, WSDL_DIR, True, ctx_factory)
self.client_nsa = opennsa.nsa.NetworkServiceAgent(
'AutoScheduler',
'http://%s:%s/NSI/services/ConnectionService' % (host, self.port))
reactor.listenSSL(self.port, factory, ctx_factory)
def setupTLSContext(vc):
# 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
return ctx_factory
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')