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 querySummarySync(self, soap_data):
def gotReservations(reservations, header):
# do reply inline
soap_header_element = helper.createProviderHeader(
header.requester_nsa,
header.provider_nsa,
correlation_id=header.correlation_id)
qs_reservations = queryhelper.buildQuerySummaryResultType(
reservations)
qsct = nsiconnection.QuerySummaryConfirmedType(qs_reservations)
payload = minisoap.createSoapPayload(
qsct.xml(nsiconnection.querySummarySyncConfirmed),
soap_header_element)
return payload
header, query = helper.parseRequest(soap_data)
d = self.provider.querySummarySync(header, query.connectionId,
query.globalReservationId)
d.addCallbacks(gotReservations,
self._createSOAPFault,
callbackArgs=(header, ),
errbackArgs=(header.provider_nsa, ))
return d
def reserveTimeout(self, soap_data):
header, reserve_timeout = helper.parseRequest(soap_data)
rt = reserve_timeout
self.requester.reserveTimeout(header, rt.connectionId, rt.notificationId, rt.timeStamp, rt.timeoutValue, rt.originatingConnectionId, rt.originatingNSA)
return helper.createGenericRequesterAcknowledgement(header)
def reserveConfirmed(self, soap_data):
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)
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 release(self, soap_data):
header, request = helper.parseRequest(soap_data)
d = self.provider.release(header, request.connectionId)
d.addCallbacks(
lambda _: helper.createGenericProviderAcknowledgement(header),
self._createSOAPFault,
errbackArgs=(header.provider_nsa, request.connectionId))
return d
def gotReply(soap_data):
header, query_confirmed = helper.parseRequest(soap_data)
if query_confirmed is None:
return []
elif type(query_confirmed) is list:
return [ helper.buildQuerySummaryResult(qc) for qc in query_confirmed ]
else:
return [ helper.buildQuerySummaryResult(query_confirmed) ]
def reserveCommit(self, soap_data, request_info):
header, confirm = helper.parseRequest(soap_data)
d = self.provider.reserveCommit(header, confirm.connectionId,
request_info)
d.addCallbacks(
lambda _: helper.createGenericProviderAcknowledgement(header),
self._createSOAPFault,
errbackArgs=(header.provider_nsa, confirm.connectionId))
return d
def reserveTimeout(self, soap_data, request_info):
header, reserve_timeout = helper.parseRequest(soap_data)
rt = reserve_timeout
timestamp = xmlhelper.parseXMLTimestamp(rt.timeStamp)
self.requester.reserveTimeout(header, rt.connectionId, rt.notificationId, timestamp, rt.timeoutValue, rt.originatingConnectionId, rt.originatingNSA)
return helper.createGenericRequesterAcknowledgement(header)
def queryRecursiveConfirmed(self, soap_data, request_info):
header, query_result = helper.parseRequest(soap_data)
reservations = [ queryhelper.buildQueryResult(res, header.provider_nsa, include_children=True) for res in query_result.reservations ]
self.requester.queryRecursiveConfirmed(header, reservations)
return helper.createGenericRequesterAcknowledgement(header)
def queryRecursiveConfirmed(self, soap_data):
header, query_result = helper.parseRequest(soap_data)
reservations = [ queryhelper.buildQueryResult(res, header.provider_nsa, include_children=True) for res in query_result.reservations ]
self.requester.queryRecursiveConfirmed(header, reservations)
return helper.createGenericRequesterAcknowledgement(header)
def querySummaryConfirmed(self, soap_data, request_info):
header, query_result = helper.parseRequest(soap_data)
reservations = [ queryhelper.buildQueryResult(res, header.provider_nsa) for res in query_result.reservations ]
self.requester.querySummaryConfirmed(header, reservations)
return helper.createGenericRequesterAcknowledgement(header)
def dataPlaneStateChange(self, soap_data, request_info):
header, data_plane_state_change = helper.parseRequest(soap_data)
dpsc = data_plane_state_change
dps = dpsc.dataPlaneStatus
self.requester.dataPlaneStateChange(header, dpsc.connectionId, dpsc.notificationId, dpsc.timeStamp, (dps.active, dps.version, dps.versionConsistent) )
return helper.createGenericRequesterAcknowledgement(header)
def queryRecursive(self, soap_data):
header, query = helper.parseRequest(soap_data)
d = self.provider.queryRecursive(header, query.connectionId,
query.globalReservationId)
d.addCallbacks(
lambda _: helper.createGenericProviderAcknowledgement(header),
self._createSOAPFault,
errbackArgs=(header.provider_nsa, ))
return d
def dataPlaneStateChange(self, soap_data):
header, data_plane_state_change = helper.parseRequest(soap_data)
dpsc = data_plane_state_change
dps = dpsc.dataPlaneStatus
self.requester.dataPlaneStateChange(header, dpsc.connectionId, dpsc.notificationId, dpsc.timeStamp, (dps.active, dps.version, dps.versionConsistent) )
return helper.createGenericRequesterAcknowledgement(header)
def _parseGenericFailure(self, soap_data):
header, generic_failure = helper.parseRequest(soap_data)
rc = generic_failure.connectionStates
rd = rc.dataPlaneStatus
dps = (rd.active, rd.version, rd.versionConsistent)
cs = (rc.reservationState, rc.provisionState, rc.lifecycleState, dps)
ex = helper.createException(generic_failure.serviceException, header.provider_nsa)
return header, generic_failure.connectionId, cs, ex
def querySummaryConfirmed(self, soap_data):
header, query_result = helper.parseRequest(soap_data)
reservations = [
queryhelper.buildQueryResult(res, header.provider_nsa)
for res in query_result.reservations
]
self.requester.querySummaryConfirmed(header, reservations)
return helper.createGenericRequesterAcknowledgement(header)
def _parseGenericFailure(self, soap_data):
header, generic_failure = helper.parseRequest(soap_data)
rc = generic_failure.connectionStates
rd = rc.dataPlaneStatus
dps = (rd.active, rd.version, rd.versionConsistent)
cs = (rc.reservationState, rc.provisionState, rc.lifecycleState, dps)
ex = helper.createException(generic_failure.serviceException, header.provider_nsa)
return header, generic_failure.connectionId, cs, ex
def errorEvent(self, soap_data):
header, error_event = helper.parseRequest(soap_data)
#connection_id, notification_id, timestamp, event, info, service_ex =
ee = error_event
if ee.serviceException:
se = ee.serviceException
service_ex = (se.nsaId, se.connectionId, se.errorId, se.text, se.variables, se.childException)
else:
service_ex = None
self.requester.errorEvent(header, ee.connectionId, ee.notificationId, ee.timeStamp, ee.event, ee.additionalInfo, service_ex)
return helper.createGenericRequesterAcknowledgement(header)
def errorEvent(self, soap_data, request_info):
header, error_event = helper.parseRequest(soap_data)
#connection_id, notification_id, timestamp, event, info, service_ex =
ee = error_event
if ee.serviceException:
se = ee.serviceException
service_ex = (se.nsaId, se.connectionId, se.errorId, se.text, se.variables, se.childException)
else:
service_ex = None
self.requester.errorEvent(header, ee.connectionId, ee.notificationId, ee.timeStamp, ee.event, ee.additionalInfo, service_ex)
return helper.createGenericRequesterAcknowledgement(header)
def querySummarySync(self, soap_data, request_info):
def gotReservations(reservations, header):
# do reply inline
soap_header_element = helper.createProviderHeader(header.requester_nsa, header.provider_nsa, correlation_id=header.correlation_id)
qs_reservations = queryhelper.buildQuerySummaryResultType(reservations)
qsct = nsiconnection.QuerySummaryConfirmedType(qs_reservations)
payload = minisoap.createSoapPayload(qsct.xml(nsiconnection.querySummarySyncConfirmed), soap_header_element)
return payload
header, query = helper.parseRequest(soap_data)
d = self.provider.querySummarySync(header, query.connectionId, query.globalReservationId, request_info)
d.addCallbacks(gotReservations, self._createSOAPFault, callbackArgs=(header,), errbackArgs=(header.provider_nsa,))
return d
def querySummarySync(self, soap_data):
def gotReservations(reservations):
# do reply inline
soap_header = nsiframework.CommonHeaderType(cnt.CS2_SERVICE_TYPE, header.correlation_id, header.requester_nsa, header.provider_nsa, None, header.session_security_attrs)
soap_header_element = soap_header.xml(nsiframework.nsiHeader)
query_summary_result = helper.buildQuerySummaryResultType(reservations)
qsr_elements = [ qsr.xml(nsiconnection.reservation) for qsr in query_summary_result ]
payload = minisoap.createSoapPayload(qsr_elements, soap_header_element)
return payload
header, query = helper.parseRequest(soap_data)
d = self.provider.querySummarySync(header, query.connectionId, query.globalReservationId)
d.addCallbacks(gotReservations, self._createSOAPFault, errbackArgs=(header.provider_nsa,))
return d
def error(self, soap_data):
header, error = helper.parseRequest(soap_data)
se = error.serviceException
# service exception fields, we are not quite there yet...
# nsaId # NsaIdType -> anyURI
# connectionId # ConnectionIdType -> string
# serviceType # string
# errorId # string
# text # string
# variables # [ TypeValuePairType ]
# childException # [ ServiceException ]
variables = [ (tvp.type, tvp.value) for tvp in se.variables ]
child_ex = None
self.requester.error(header, se.nsaId, se.connectionId, se.serviceType, se.errorId, se.text, variables, child_ex)
return helper.createGenericRequesterAcknowledgement(header)
def error(self, soap_data, request_info):
header, error = helper.parseRequest(soap_data)
se = error.serviceException
# service exception fields, we are not quite there yet...
# nsaId # NsaIdType -> anyURI
# connectionId # ConnectionIdType -> string
# serviceType # string
# errorId # string
# text # string
# variables # [ TypeValuePairType ]
# childException # [ ServiceException ]
variables = [ (tvp.type, tvp.value) for tvp in se.variables ]
child_ex = None
self.requester.error(header, se.nsaId, se.connectionId, se.serviceType, se.errorId, se.text, variables, child_ex)
return helper.createGenericRequesterAcknowledgement(header)
def gotReply(soap_data):
header, query_confirmed = helper.parseRequest(soap_data)
return [queryhelper.buildQueryResult(resv, header.provider_nsa) for resv in query_confirmed.reservations]
def _handleAck(soap_data):
header, ack = helper.parseRequest(soap_data)
return ack.connectionId
def reserveCommit(self, soap_data):
header, confirm = helper.parseRequest(soap_data)
d = self.provider.reserveCommit(header, confirm.connectionId)
d.addCallbacks(lambda _ : helper.createGenericProviderAcknowledgement(header), self._createSOAPFault, errbackArgs=(header.provider_nsa, confirm.connectionId))
return d
def terminateConfirmed(self, soap_data):
header, generic_confirm = helper.parseRequest(soap_data)
self.requester.terminateConfirmed(header, generic_confirm.connectionId)
return helper.createGenericRequesterAcknowledgement(header)
def provisionConfirmed(self, soap_data, request_info):
header, generic_confirm = helper.parseRequest(soap_data)
self.requester.provisionConfirmed(header, generic_confirm.connectionId)
return helper.createGenericRequesterAcknowledgement(header)
def terminate(self, soap_data, request_info):
header, request = helper.parseRequest(soap_data)
d = self.provider.terminate(header, request.connectionId, request_info)
d.addCallbacks(lambda _ : helper.createGenericProviderAcknowledgement(header), self._createSOAPFault, errbackArgs=(header.provider_nsa, request.connectionId))
return d
def queryRecursive(self, soap_data, request_info):
header, query = helper.parseRequest(soap_data)
d = self.provider.queryRecursive(header, query.connectionId, query.globalReservationId, request_info)
d.addCallbacks(lambda _ : helper.createGenericProviderAcknowledgement(header), self._createSOAPFault, errbackArgs=(header.provider_nsa,))
return d
def reserve(self, soap_data, request_info):
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) if criteria.schedule.endTime is not None else None
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, request_info)
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 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 terminateConfirmed(self, soap_data):
header, generic_confirm = helper.parseRequest(soap_data)
self.requester.terminateConfirmed(header, generic_confirm.connectionId)
return helper.createGenericRequesterAcknowledgement(header)
def provisionConfirmed(self, soap_data, request_info):
header, generic_confirm = helper.parseRequest(soap_data)
self.requester.provisionConfirmed(header, generic_confirm.connectionId)
return helper.createGenericRequesterAcknowledgement(header)
def gotReply(soap_data):
header, query_confirmed = helper.parseRequest(soap_data)
return [ queryhelper.buildQueryResult(resv, header.provider_nsa) for resv in query_confirmed.reservations ]
def _handleAck(soap_data):
header, ack = helper.parseRequest(soap_data)
return ack.connectionId
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 support EthernetVlanType service for now.') )
return self._createSOAPFault(err, header.provider_nsa, service_type=service_type)
# create DTOs (EROs not supported yet)
start_time = helper.parseXMLTimestamp(criteria.schedule.startTime)
end_time = helper.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)
sd = nsa.Point2PointService(src_stp, dst_stp, p2ps.capacity, p2ps.directionality, p2ps.symmetricPath, None)
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):
soap_header = nsiframework.CommonHeaderType(cnt.CS2_SERVICE_TYPE, header.correlation_id, header.requester_nsa, header.provider_nsa, None, header.session_security_attrs)
soap_header_element = soap_header.xml(nsiframework.nsiHeader)
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
