X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=servicehandler%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fservicehandler%2Flisteners%2FPceListenerImpl.java;h=1f147942cb6ca1d872b14720ccb087855efb8f35;hb=refs%2Fchanges%2F44%2F94544%2F5;hp=d5a831f4dfe86f1d5463e37bb5df1138275054f5;hpb=82610815f1b706e2f9b5e5578474f3a8205c41aa;p=transportpce.git diff --git a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/listeners/PceListenerImpl.java b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/listeners/PceListenerImpl.java index d5a831f4d..1f147942c 100644 --- a/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/listeners/PceListenerImpl.java +++ b/servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/listeners/PceListenerImpl.java @@ -7,68 +7,225 @@ */ package org.opendaylight.transportpce.servicehandler.listeners; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev170426.ServicePathRpcResult; -import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev170426.TransportpcePceListener; -import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.RpcStatusEx; -import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.ServicePathNotificationTypes; +import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; +import org.opendaylight.mdsal.binding.api.NotificationPublishService; +import org.opendaylight.transportpce.common.OperationResult; +import org.opendaylight.transportpce.pce.service.PathComputationService; +import org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations; +import org.opendaylight.transportpce.servicehandler.ModelMappingUtils; +import org.opendaylight.transportpce.servicehandler.ServiceInput; +import org.opendaylight.transportpce.servicehandler.service.PCEServiceWrapper; +import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.PathComputationRequestOutput; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.PathComputationRequestOutputBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.ServicePathRpcResult; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.TransportpcePceListener; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.service.path.rpc.result.PathDescription; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.service.path.rpc.result.PathDescriptionBuilder; +import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestInput; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.RpcStatusEx; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.response.parameters.sp.ResponseParameters; +import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.response.parameters.sp.ResponseParametersBuilder; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -@Deprecated public class PceListenerImpl implements TransportpcePceListener { private static final Logger LOG = LoggerFactory.getLogger(PceListenerImpl.class); - private ServicePathRpcResult servicePathRpcResult = null; + private ServicePathRpcResult servicePathRpcResult; + private RendererServiceOperations rendererServiceOperations; + private ServiceDataStoreOperations serviceDataStoreOperations; + private PCEServiceWrapper pceServiceWrapper; + private ServiceInput input; + private Boolean serviceReconfigure; + private Boolean tempService; + private Boolean serviceFeasiblity; + + public PceListenerImpl(RendererServiceOperations rendererServiceOperations, + PathComputationService pathComputationService, NotificationPublishService notificationPublishService, + ServiceDataStoreOperations serviceDataStoreOperations) { + this.rendererServiceOperations = rendererServiceOperations; + this.pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService); + this.serviceDataStoreOperations = serviceDataStoreOperations; + setServiceReconfigure(false); + setInput(null); + setTempService(false); + setServiceFeasiblity(false); + } @Override public void onServicePathRpcResult(ServicePathRpcResult notification) { if (!compareServicePathRpcResult(notification)) { servicePathRpcResult = notification; - StringBuilder build = new StringBuilder(); - build.append( - "Received '" + notification.getNotificationType() + "' StubPce notification " + "from service '" - + notification.getServiceName() + "' " + "with status '" + notification.getStatus() + "'"); - build.append(" with StatusMessage '" + notification.getStatusMessage() + "'"); - if ((notification.getStatus() == RpcStatusEx.Successful) && (notification.getNotificationType() - .getIntValue() == ServicePathNotificationTypes.PathComputationRequest.getIntValue())) { - build.append(" PathDescription : " + notification.getPathDescription().toString()); - /* - * switch (action.getIntValue()) { case 1: //service-create case - * 3: //service-delete case 8: //service-reconfigure case 9: - * //service-restoration case 10://service-reversion case - * 11://service-reroute break; - * - * default: break; } - */ + switch (servicePathRpcResult.getNotificationType().getIntValue()) { + /* path-computation-request. */ + case 1: + onPathComputationResult(notification); + break; + /* cancel-resource-reserve. */ + case 2: + onCancelResourceResult(); + break; + default: + break; } - - LOG.info(build.toString()); } else { - LOG.info("ServicePathRpcResult already wired !"); + LOG.warn("ServicePathRpcResult already wired !"); } } - @Deprecated - private Boolean compareServicePathRpcResult(ServicePathRpcResult notification) { - Boolean result = true; - if (servicePathRpcResult == null) { - result = false; - } else { - if (servicePathRpcResult.getNotificationType() != notification.getNotificationType()) { - result = false; + /** + * Process path computation request result. + * @param notification the result notification. + */ + private void onPathComputationResult(ServicePathRpcResult notification) { + LOG.info("PCE '{}' Notification received : {}",servicePathRpcResult.getNotificationType().getName(), + notification); + if (servicePathRpcResult.getStatus() == RpcStatusEx.Failed) { + LOG.error("PCE path computation failed !"); + return; + } else if (servicePathRpcResult.getStatus() == RpcStatusEx.Pending) { + LOG.warn("PCE path computation returned a Penging RpcStatusEx code!"); + return; + } else if (servicePathRpcResult.getStatus() != RpcStatusEx.Successful) { + LOG.error("PCE path computation returned an unknown RpcStatusEx code!"); + return; + } + + LOG.info("PCE calculation done OK !"); + if (servicePathRpcResult.getPathDescription() == null) { + LOG.error("'PathDescription' parameter is null "); + return; + } + PathDescription pathDescription = new PathDescriptionBuilder() + .setAToZDirection(servicePathRpcResult.getPathDescription().getAToZDirection()) + .setZToADirection(servicePathRpcResult.getPathDescription().getZToADirection()) + .build(); + LOG.info("PathDescription gets : {}", pathDescription); + if (serviceFeasiblity) { + LOG.warn("service-feasibility-check RPC "); + return; + } + if (input == null) { + LOG.error("Input is null !"); + return; + } + OperationResult operationResult = null; + if (tempService) { + operationResult = this.serviceDataStoreOperations.createTempService(input.getTempServiceCreateInput()); + if (!operationResult.isSuccess()) { + LOG.error("Temp Service not created in datastore !"); } - if (servicePathRpcResult.getServiceName() != notification.getServiceName()) { - result = false; + } else { + operationResult = this.serviceDataStoreOperations.createService(input.getServiceCreateInput()); + if (!operationResult.isSuccess()) { + LOG.error("Service not created in datastore !"); } - if (servicePathRpcResult.getStatus() != notification.getStatus()) { - result = false; + } + ResponseParameters responseParameters = new ResponseParametersBuilder() + .setPathDescription(new org.opendaylight.yang.gen.v1.http.org + .transportpce.b.c._interface.service.types.rev200128 + .response.parameters.sp.response.parameters + .PathDescriptionBuilder(pathDescription).build()) + .build(); + PathComputationRequestOutput pceResponse = new PathComputationRequestOutputBuilder() + .setResponseParameters(responseParameters).build(); + OperationResult operationServicePathSaveResult = this.serviceDataStoreOperations + .createServicePath(input, pceResponse); + if (!operationServicePathSaveResult.isSuccess()) { + LOG.error("Service Path not created in datastore !"); + } + ServiceImplementationRequestInput serviceImplementationRequest = ModelMappingUtils + .createServiceImplementationRequest(input, pathDescription); + LOG.info("Sending serviceImplementation request : {}", serviceImplementationRequest); + this.rendererServiceOperations.serviceImplementation(serviceImplementationRequest); + } + + /** + * Process cancel resource result. + */ + private void onCancelResourceResult() { + if (servicePathRpcResult.getStatus() == RpcStatusEx.Failed) { + LOG.info("PCE cancel resource failed !"); + return; + } else if (servicePathRpcResult.getStatus() == RpcStatusEx.Pending) { + LOG.warn("PCE cancel returned a Penging RpcStatusEx code!"); + return; + } else if (servicePathRpcResult.getStatus() != RpcStatusEx.Successful) { + LOG.error("PCE cancel returned an unknown RpcStatusEx code!"); + return; + } + LOG.info("PCE cancel resource done OK !"); + OperationResult deleteServicePathOperationResult = + this.serviceDataStoreOperations.deleteServicePath(input.getServiceName()); + if (!deleteServicePathOperationResult.isSuccess()) { + LOG.warn("Service path was not removed from datastore!"); + } + OperationResult deleteServiceOperationResult = null; + if (tempService) { + deleteServiceOperationResult = + this.serviceDataStoreOperations.deleteTempService(input.getServiceName()); + if (!deleteServiceOperationResult.isSuccess()) { + LOG.warn("Temp Service was not removed from datastore!"); } - if (servicePathRpcResult.getStatusMessage() != notification.getStatusMessage()) { - result = false; + } else { + deleteServiceOperationResult = + this.serviceDataStoreOperations.deleteService(input.getServiceName()); + if (!deleteServiceOperationResult.isSuccess()) { + LOG.warn("Service was not removed from datastore!"); } } - return result; + /** + * if it was an RPC serviceReconfigure, re-launch PCR. + */ + if (this.serviceReconfigure) { + LOG.info("cancel resource reserve done, relaunching PCE path computation ..."); + this.pceServiceWrapper.performPCE(input.getServiceCreateInput(), true); + this.serviceReconfigure = false; + } + } + + @SuppressFBWarnings( + value = "ES_COMPARING_STRINGS_WITH_EQ", + justification = "false positives, not strings but real object references comparisons") + private Boolean compareServicePathRpcResult(ServicePathRpcResult notification) { + if (servicePathRpcResult == null) { + return false; + } + if (servicePathRpcResult.getNotificationType() != notification.getNotificationType()) { + return false; + } + if (servicePathRpcResult.getServiceName() != notification.getServiceName()) { + return false; + } + if (servicePathRpcResult.getStatus() != notification.getStatus()) { + return false; + } + if (servicePathRpcResult.getStatusMessage() != notification.getStatusMessage()) { + return false; + } + return true; + } + + public void setInput(ServiceInput serviceInput) { + this.input = serviceInput; + } + + public void setServiceReconfigure(Boolean serv) { + this.serviceReconfigure = serv; + } + + public void setserviceDataStoreOperations(ServiceDataStoreOperations serviceData) { + this.serviceDataStoreOperations = serviceData; + } + + public void setTempService(Boolean tempService) { + this.tempService = tempService; + } + + public void setServiceFeasiblity(Boolean serviceFeasiblity) { + this.serviceFeasiblity = serviceFeasiblity; } }