def testReserveTimeout(self): # these need to be constructed such that there is only one label option source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) dest_stp = nsa.STP(self.network, self.dest_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer self.clock.advance(self.backend.TPC_TIMEOUT + 1) header, cid, notification_id, timestamp, timeout_value, org_cid, org_nsa = yield self.requester.reserve_timeout_defer self.failUnlessEquals(cid, acid) self.requester.reserve_defer = defer.Deferred() # new criteria start_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=2) end_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=6) schedule = nsa.Schedule(start_time, end_time) criteria = nsa.Criteria(0, schedule, nsa.Point2PointService(source_stp, dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) ) # try to reserve the same resources acid2 = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer
def testNoStartEndTimeAndAdditionalReservation(self): schedule = nsa.Schedule(None, None) criteria = nsa.Criteria(0, schedule, nsa.Point2PointService(self.source_stp, self.dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sc = yield self.requester.reserve_defer self.failUnlessEqual(cid, acid) yield self.provider.reserveCommit(self.header, acid) cid = yield self.requester.reserve_commit_defer # second reservation self.header.newCorrelationId() self.requester.reserve_defer = defer.Deferred() self.requester.reserve_commit_defer = defer.Deferred() schedule = nsa.Schedule(None, None) criteria = nsa.Criteria(0, schedule, nsa.Point2PointService(self.source_stp, self.dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) acid2 = yield self.provider.reserve(header, None, None, None, criteria) _ = yield self.requester.reserve_defer yield self.provider.reserveCommit(self.header, acid2) cid = yield self.requester.reserve_commit_defer
def testReserveFailAndLabelSwapEnabled(self): # When you try to reserve a circuit using a labelSwap enabled backend and the dest_stp appers to be in use, # the src stp reservation never gets removed from the calendar self.assertTrue(self.backend.connection_manager.canSwapLabel(cnt.ETHERNET_VLAN),"DUD is not able to swapLabels") # Construct a valid circuit source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) dest_stp = nsa.STP(self.network, self.dest_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) #We shouldn't have reservations in the calendar right now self.assertEquals(len(self.backend.calendar.reservations), 0, "Reservations size is %s should be 0" % len(self.backend.calendar.reservations)) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer # reset deferred for reservation self.requester.reserve_defer = defer.Deferred() # 2 reservations, for source_stp and dest_stp self.assertEquals(len(self.backend.calendar.reservations), 2, "Reservations size is %s should be 2" % len(self.backend.calendar.reservations)) #Construct a second circuit, with the same dest_stp source_stp2 = nsa.STP(self.network,self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1781')) criteria2 = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp2, dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() try: acid2 = yield self.provider.reserve(self.header, None, None, None, criteria2) header2, cid2, gid2, desc2, sp2 = yield self.requester.reserve_defer except error.STPUnavailableError as e: pass # reset deferred for reservation self.requester.reserve_defer = defer.Deferred() # The second reserve request failed, so we should have the original 2 reservations in the calendar self.assertEquals(len(self.backend.calendar.reservations), 2, "Reservations size is %s should be 2" % len(self.backend.calendar.reservations)) # terminate the connection yield self.provider.terminate(self.header, cid) yield self.requester.terminate_defer for stp in [source_stp2,dest_stp,source_stp]: try: res = self.backend.connection_manager.getResource(stp.port, stp.label) resource_is_available = self.backend.calendar.checkReservation(res, self.schedule.start_time,self.schedule.end_time) except error.STPUnavailableError as e: self.fail("STP %s should be available" % res)
def testLabelRangeMultiReservation(self): source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1781-1783')) dest_stp = nsa.STP(self.network, self.dest_port, nsa.Label(cnt.ETHERNET_VLAN, '1781-1783')) criteria = nsa.Criteria( 0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 100, 'Bidirectional', False, None)) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) yield self.requester.reserve_defer self.header.newCorrelationId() yield self.provider.reserveCommit(self.header, acid) yield self.requester.reserve_commit_defer self.requester.reserve_defer = defer.Deferred() self.requester.reserve_commit_defer = defer.Deferred() self.header.newCorrelationId() acid2 = yield self.provider.reserve(self.header, None, None, None, criteria) yield self.requester.reserve_defer self.header.newCorrelationId() yield self.provider.reserveCommit(self.header, acid2) yield self.requester.reserve_commit_defer
def reserveConfirmed(self, soap_data, request_info): header, reservation = helper.parseRequest(soap_data) criteria = reservation.criteria # Create DTOs - this overlaps heavily with the parsing done in providerservice - unify sometime start_time = xmlhelper.parseXMLTimestamp(criteria.schedule.startTime) if criteria.schedule.startTime is not None else None end_time = xmlhelper.parseXMLTimestamp(criteria.schedule.endTime) if criteria.schedule.endTime is not None else None schedule = nsa.Schedule(start_time, end_time) # check for service type sometime p2ps = criteria.serviceDefinition if type(p2ps) is not p2pservices.P2PServiceBaseType: raise ValueError('Only P2P service supported.') # (ERO missing) src_stp = helper.createSTP(p2ps.sourceSTP) dst_stp = helper.createSTP(p2ps.destSTP) if p2ps.ero: print('ERO parsing in reserveConfirmed not implemented yet, full path will not be available') sd = nsa.Point2PointService(src_stp, dst_stp, p2ps.capacity, p2ps.directionality, p2ps.symmetricPath, None) crt = nsa.Criteria(criteria.version, schedule, sd) self.requester.reserveConfirmed(header, reservation.connectionId, reservation.globalReservationId, reservation.description, crt) return helper.createGenericRequesterAcknowledgement(header)
def _createP2PS(src, dst, capacity, ero): src_stp = _createSTP(src) dst_stp = _createSTP(dst) ordered_stp = _createSTPList(ero) return nsa.Point2PointService(src_stp, dst_stp, capacity, cnt.BIDIRECTIONAL, False, ordered_stp, None)
def testPortSTPs(self): source_stp = nsa.STP(self.network, 'eth1', None) dest_stp = nsa.STP(self.network, 'eth2', None) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sc = yield self.requester.reserve_defer self.failUnlessEqual(cid, acid) yield self.provider.reserveCommit(self.header, acid) cid = yield self.requester.reserve_commit_defer yield self.provider.provision(self.header, acid) cid = yield self.requester.provision_defer self.clock.advance(3) header, cid, nid, timestamp, dps = yield self.requester.data_plane_change_defer active, version, consistent = dps self.requester.data_plane_change_defer = defer.Deferred() # need a new one for deactivate self.failUnlessEqual(cid, acid) self.failUnlessEqual(active, True) self.failUnlessEqual(consistent, True) #yield self.provider.release(self.header, cid) #cid = yield self.requester.release_defer yield self.provider.terminate(self.header, acid) cid = yield self.requester.terminate_defer
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() db.setupDatabase() # 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
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)
def testReserveAbort(self): # these need to be constructed such that there is only one label option source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1782')) dest_stp = nsa.STP(self.network, self.dest_port, nsa.Label(cnt.ETHERNET_VLAN, '1782')) criteria = nsa.Criteria( 0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 200, cnt.BIDIRECTIONAL, False, None)) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer yield self.provider.reserveAbort(self.header, acid) header, cid = yield self.requester.reserve_abort_defer self.requester.reserve_defer = defer.Deferred() # try to reserve the same resources acid2 = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer
def testProvisionReleaseNoStartEndTime(self): schedule = nsa.Schedule(None, None) criteria = nsa.Criteria(0, schedule, nsa.Point2PointService(self.source_stp, self.dest_stp, 200, 'Bidirectional', False, None) ) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) yield self.requester.reserve_defer yield self.provider.reserveCommit(self.header, acid) yield self.requester.reserve_commit_defer yield self.provider.provision(self.header, acid) yield self.requester.provision_defer self.clock.advance(3) header, cid, nid, timestamp, dps = yield self.requester.data_plane_change_defer active, version, consistent = dps self.failUnlessEquals(active, True) self.requester.data_plane_change_defer = defer.Deferred() yield self.provider.release(self.header, acid) yield self.requester.release_defer header, cid, nid, timestamp, dps = yield self.requester.data_plane_change_defer active, version, consistent = dps self.failUnlessEquals(active, False) yield self.provider.terminate(self.header, cid) yield self.requester.terminate_defer
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)
def testSlowActivate(self): # key here is that end time is passed when activation is done start_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=2) end_time = datetime.datetime.utcnow() + datetime.timedelta(seconds=4) schedule = nsa.Schedule(start_time, end_time) source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1780')) dest_stp = nsa.STP(self.network, self.dest_port, nsa.Label(cnt.ETHERNET_VLAN, '1780')) criteria = nsa.Criteria( 0, schedule, nsa.Point2PointService(source_stp, dest_stp, 200, cnt.BIDIRECTIONAL, False, None)) def setupLink(connection_id, src, dst, bandwidth): d = defer.Deferred() reactor.callLater(2, d.callback, None) return d # make activation fail via monkey patching self.backend.connection_manager.setupLink = setupLink self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer self.failUnlessEqual(cid, acid) yield self.provider.reserveCommit(self.header, cid) yield self.requester.reserve_commit_defer yield self.provider.provision(self.header, cid) yield self.requester.provision_defer self.clock.advance(3) header, cid, nid, timestamp, dps = yield self.requester.data_plane_change_defer active, version, consistent = dps self.failUnlessEqual(cid, acid) self.failUnlessEqual(active, True) self.failUnlessEqual(consistent, True) self.requester.data_plane_change_defer = defer.Deferred() self.clock.advance(2) header, cid, nid, timestamp, dps = yield self.requester.data_plane_change_defer active, version, consistent = dps self.failUnlessEqual(cid, acid) self.failUnlessEqual(active, False) yield self.provider.terminate(self.header, cid) yield self.requester.terminate_defer
def testInvalidRewrite(self): source_stp = nsa.STP(self.network, 'eth1', None) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, self.dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() try: acid = yield self.provider.reserve(self.header, None, None, None, criteria) self.fail("Should have gotten topology error ") except error.NSIError: pass # expected
def testInvalidNetworkReservation(self): source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) dest_stp = nsa.STP('NoSuchNetwork:topology', 'whatever', nsa.Label(cnt.ETHERNET_VLAN, '1782') ) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 200, 'Bidirectional', False, None) ) self.header.newCorrelationId() try: yield self.provider.reserve(self.header, None, None, None, criteria) self.fail('Should have raised TopologyError') except (error.ConnectionCreateError, error.STPResolutionError): # we raise ConnectionCreateError in backends, and STPResolutionError in aggregator pass # expected
def testIdenticalPortSTPs(self): source_stp = nsa.STP(self.network, 'eth1', None) dest_stp = nsa.STP(self.network, 'eth1', None) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() try: acid = yield self.provider.reserve(self.header, None, None, None, criteria) self.fail("Should have gotten service error for identical ports") except error.ServiceError: pass # expected
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)
def buildServiceDefinition(service_definition): if service_definition is None: log.msg('Did not get any service definitions, cannot build service definition', system=LOG_SYSTEM) return None if type(service_definition) is p2pservices.P2PServiceBaseType: sd = service_definition source_stp = helper.createSTP(sd.sourceSTP) dest_stp = helper.createSTP(sd.destSTP) return nsa.Point2PointService(source_stp, dest_stp, sd.capacity, sd.directionality, sd.symmetricPath, None) else: log.msg('Got %s service definition, can only build for P2PService' % str(service_definition), system=LOG_SYSTEM) return None
def testHairpinConnection(self): 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: yield self.provider.reserve(self.header, None, None, None, criteria) self.fail('Should have raised ServceError / TopologyError') except error.ServiceError: pass # expected - hairpin except error.TopologyError: pass # expected - double vlan assignment
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 testDoubleReserve(self): source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1781') ) p2p = nsa.Point2PointService(source_stp, self.dest_stp, self.bandwidth, cnt.BIDIRECTIONAL, False, None) criteria = nsa.Criteria(0, self.schedule, p2p) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer self.requester.reserve_defer = defer.Deferred() # new defer for new reserve request try: acid2 = yield self.provider.reserve(self.header, None, None, None, criteria) self.fail('Should have raised STPUnavailableError') except error.STPUnavailableError: pass # we expect this
def _query(self, header, connection_ids, global_reservation_ids, request_info=None): # generic query mechanism for summary and recursive # TODO: Match stps/ports that can be used with credentials and return connections using these STPs if connection_ids: conns = yield GenericBackendConnections.find(where=[ 'source_network = ? AND dest_network = ? AND requester_nsa = ? AND connection_id IN ?', self.network, self.network, header.requester_nsa, tuple(connection_ids) ]) elif global_reservation_ids: conns = yield GenericBackendConnections.find(where=[ 'source_network = ? AND dest_network = ? AND requester_nsa = ? AND global_reservation_ids IN ?', self.network, self.network, header.requester_nsa, tuple(global_reservation_ids) ]) else: raise error.MissingParameterError( 'Must specify connectionId or globalReservationId') reservations = [] for c in conns: source_stp = nsa.STP(c.source_network, c.source_port, c.source_label) dest_stp = nsa.STP(c.dest_network, c.dest_port, c.dest_label) schedule = nsa.Schedule(c.start_time, c.end_time) sd = nsa.Point2PointService(source_stp, dest_stp, c.bandwidth, cnt.BIDIRECTIONAL, False, None) criteria = nsa.QueryCriteria(c.revision, schedule, sd) data_plane_status = (c.data_plane_active, c.revision, True) states = (c.reservation_state, c.provision_state, c.lifecycle_state, data_plane_status) notification_id = self.getNotificationId() result_id = notification_id # whatever provider_nsa = cnt.URN_OGF_PREFIX + self.network.replace( 'topology', 'nsa') # hack on reservations.append( nsa.ConnectionInfo(c.connection_id, c.global_reservation_id, c.description, cnt.EVTS_AGOLE, [criteria], provider_nsa, c.requester_nsa, states, notification_id, result_id)) defer.returnValue(reservations)
def _doReserve(self, conn, correlation_id): # we have already checked resource availability, so can progress directly through checking state.reserveMultiSwitch(conn, state.RESERVE_CHECKING, state.RESERVE_HELD) yield conn.save() self.logStateUpdate(conn, 'RESERVE CHECKING/HELD') # schedule 2PC timeout if self.scheduler.hasScheduledCall(conn.connection_id): # this means that the build scheduler made a call while we yielded self.scheduler.cancelCall(conn.connection_id) now = datetime.datetime.utcnow() timeout_time = min(now + datetime.timedelta(seconds=self.TPC_TIMEOUT), conn.end_time) self.scheduler.scheduleCall(conn.connection_id, timeout_time, self._doReserveTimeout, conn) td = timeout_time - datetime.datetime.utcnow() log.msg( 'Connection %s: reserve abort scheduled for %s UTC (%i seconds)' % (conn.connection_id, timeout_time.replace(microsecond=0), td.total_seconds()), system=self.log_system) schedule = nsa.Schedule(conn.start_time, conn.end_time) sc_source_stp = nsa.STP(conn.source_network, conn.source_port, conn.source_label) sc_dest_stp = nsa.STP(conn.dest_network, conn.dest_port, conn.dest_label) sd = nsa.Point2PointService( sc_source_stp, sc_dest_stp, conn.bandwidth, cnt.BIDIRECTIONAL, False, None) # we fake some things due to db limitations crit = nsa.Criteria(conn.revision, schedule, sd) header = nsa.NSIHeader( conn.requester_nsa, conn.requester_nsa, correlation_id=correlation_id ) # The NSA is both requester and provider in the backend, but this might be problematic without aggregator yield self.parent_requester.reserveConfirmed( header, conn.connection_id, conn.global_reservation_id, conn.description, crit)
def testReserveTerminateReReserve(self): # Tamas Varga found a bug where calendar isn't probably cleanup up on reserve+terminate # This reproduces the the issue # these need to be constructed such that there is only one label option source_stp = nsa.STP(self.network, self.source_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) dest_stp = nsa.STP(self.network, self.dest_port, nsa.Label(cnt.ETHERNET_VLAN, '1782') ) criteria = nsa.Criteria(0, self.schedule, nsa.Point2PointService(source_stp, dest_stp, 200, cnt.BIDIRECTIONAL, False, None) ) self.header.newCorrelationId() acid = yield self.provider.reserve(self.header, None, None, None, criteria) header, cid, gid, desc, sp = yield self.requester.reserve_defer # reset deferred for reservation self.requester.reserve_defer = defer.Deferred() # terminate the connection yield self.provider.terminate(self.header, cid) yield self.requester.terminate_defer # try to reserve the same resources acid2 = yield self.provider.reserve(self.header, None, None, None, criteria) yield self.requester.reserve_defer
def _createP2PS(src, dst, capacity): src_stp = _createSTP(src) dst_stp = _createSTP(dst) return nsa.Point2PointService(src_stp, dst_stp, capacity)
def reserve(self, soap_data): t_start = time.time() header, reservation = helper.parseRequest(soap_data) # do some checking here # print header.protocolVersion # print header.correlationId # print header.requesterNSA # print header.providerNSA # print header.replyTo criteria = reservation.criteria #version = criteria.version # not used at the moment service_type = criteria.serviceType # right now we just ignore this, either we know the service type or not p2ps = criteria.serviceDefinition # if len(service_defs) == 0: # err = failure.Failure ( error.PayloadError('No service definition element in message') ) # return self._createSOAPFault(err, header.provider_nsa, service_type=service_type) # if len(service_defs) != 1: # err = failure.Failure ( error.PayloadError('Only one service definition allowed') ) # return self._createSOAPFault(err, header.provider_nsa, service_type=service_type) if type(p2ps) is not p2pservices.P2PServiceBaseType: err = failure.Failure( error.PayloadError( 'Only supports Point2PointService service for now.')) return self._createSOAPFault(err, header.provider_nsa, service_type=service_type) if p2ps.directionality in (None, ''): err = failure.Failure( error.MissingParameterError( 'Directionality parameter not defined')) return self._createSOAPFault(err, header.provider_nsa) # create DTOs (EROs not supported yet) start_time = xmlhelper.parseXMLTimestamp( criteria.schedule.startTime ) if criteria.schedule.startTime is not None else None end_time = xmlhelper.parseXMLTimestamp(criteria.schedule.endTime) schedule = nsa.Schedule(start_time, end_time) src_stp = helper.createSTP(p2ps.sourceSTP) dst_stp = helper.createSTP(p2ps.destSTP) if p2ps.ero: err = failure.Failure( error.PayloadError('ERO not supported, go away.')) return self._createSOAPFault(err, header.provider_nsa) # if p2ps.parameter: # p = p2ps.parameter[0] # err = failure.Failure ( error.UnsupportedParameter('Unsupported parameter: %s/%s' % (p.type_, p.value) ) ) # return self._createSOAPFault(err, header.provider_nsa) params = [(p.type_, p.value) for p in p2ps.parameter] if p2ps.parameter else None symmetric = p2ps.symmetricPath or False # the p2p service specifies default behaviour as false, but doesn't specify default sd = nsa.Point2PointService(src_stp, dst_stp, p2ps.capacity, p2ps.directionality, symmetric, None, params) crt = nsa.Criteria(criteria.version, schedule, sd) t_delta = time.time() - t_start log.msg('Profile: Reserve request parse time: %s' % round(t_delta, 3), profile=True, system=LOG_SYSTEM) d = self.provider.reserve(header, reservation.connectionId, reservation.globalReservationId, reservation.description, crt) def createReserveAcknowledgement(connection_id): # no reply to / security attrs / trace soap_header_element = helper.createProviderHeader( header.requester_nsa, header.provider_nsa, None, header.correlation_id) reserve_response = nsiconnection.ReserveResponseType(connection_id) reserve_response_element = reserve_response.xml( nsiconnection.reserveResponse) payload = minisoap.createSoapPayload(reserve_response_element, soap_header_element) return payload d.addCallbacks(createReserveAcknowledgement, self._createSOAPFault, errbackArgs=(header.provider_nsa, )) return d
def render_POST(self, request): allowed, msg, request_info = requestauthz.checkAuthz( request, self.allowed_hosts) if not allowed: payload = msg + RN return _requestResponse(request, 401, payload) # Not Authorized payload = request.content.read() if len(payload) == 0: log.msg('No data received in request', system=LOG_SYSTEM) payload = 'No data received in request' + RN return _requestResponse(request, 400, payload) # Bad Request if len(payload) > 32 * 1024: log.msg('Rejecting request, payload too large. Length %i' % len(payload), system=LOG_SYSTEM) payload = 'Requests too large' + RN return _requestResponse(request, 413, payload) # Payload Too Large try: data = json.loads(payload) except ValueError: log.msg('Invalid JSON data received, returning 400', system=LOG_SYSTEM) payload = 'Invalid JSON data' + RN return _requestResponse(request, 400, payload) # Bad Request def createResponse(connection_id): payload = 'Connection created' + RN header = {'location': self.base_path + '/' + connection_id} _finishRequest(request, 201, payload, header) # Created return connection_id # extract stuffs try: source = data['source'] if not source.startswith(cnt.URN_OGF_PREFIX): source = cnt.URN_OGF_PREFIX + source destination = data['destination'] if not destination.startswith(cnt.URN_OGF_PREFIX): destination = cnt.URN_OGF_PREFIX + destination source_stp = helper.createSTP(str(source)) destination_stp = helper.createSTP(str(destination)) start_time = xmlhelper.parseXMLTimestamp( data[START_TIME]) if START_TIME in data else None end_time = xmlhelper.parseXMLTimestamp( data[END_TIME]) if END_TIME in data else None capacity = data[ 'capacity'] if 'capacity' in data else 0 # Maybe None should just be best effort # auto commit (default true) and auto provision (defult false) auto_commit = False if 'auto_commit' in data and not data[ 'auto_commit'] else True auto_provision = True if 'auto_provision' in data and data[ 'auto_provision'] else False if auto_provision and not auto_commit: msg = 'Cannot have auto-provision without auto-commit' log.msg('Rejecting request: ' + msg, system=LOG_SYSTEM) return _requestResponse(request, 400, msg + RN) # Bad Request # fillers, we don't really do this in this api symmetric = False ero = None params = None version = 0 service_def = nsa.Point2PointService(source_stp, destination_stp, capacity, cnt.BIDIRECTIONAL, symmetric, ero, params) schedule = nsa.Schedule(start_time, end_time) criteria = nsa.Criteria(version, schedule, service_def) header = nsa.NSIHeader( 'rest-dud-requester', 'rest-dud-provider') # completely bogus header d = self.provider.reserve( header, None, None, None, criteria, request_info ) # nones are connection_id, global resv id, description d.addCallbacks(createResponse, _createErrorResponse, errbackArgs=(request, )) if auto_commit: @defer.inlineCallbacks def connectionCreated(conn_id): if conn_id is None: # error creating connection # not exactly optimal code flow here, but chainining the callback correctly for this is tricky return conn = yield self.provider.getConnection(conn_id) def stateUpdate(): log.msg( 'stateUpdate reservation_state: %s, provision_state: %s' % (str(conn.reservation_state), str(conn.provision_state)), debug=True, system=LOG_SYSTEM) if conn.reservation_state == state.RESERVE_HELD: self.provider.reserveCommit( header, conn_id, request_info) if conn.reservation_state == state.RESERVE_START and conn.provision_state == state.RELEASED and auto_provision: self.provider.provision(header, conn_id, request_info) if conn.provision_state == state.PROVISIONED: state.desubscribe(conn_id, stateUpdate) state.subscribe(conn_id, stateUpdate) d.addCallback(connectionCreated) return server.NOT_DONE_YET except Exception as e: #log.err(e, system=LOG_SYSTEM) log.msg('Error creating connection: %s' % str(e), system=LOG_SYSTEM) error_code = _errorCode(e) return _requestResponse(request, error_code, str(e))
def setUp(self): from twisted.web import resource, server from twisted.application import internet from opennsa.protocols import nsi2 from opennsa.protocols.shared import resource as soapresource from opennsa.protocols.nsi2 import requesterservice, requesterclient 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, None, {}) # we set the parent later 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.aggregator = aggregator.Aggregator(self.network, self.provider_agent, network_topology, route_vectors, 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)