import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.RendererRpcResultSp;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.TransportpceRendererListener;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultSh;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultShBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ServiceNotificationTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev181130.State;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev181130.AdminStates;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.RpcStatusEx;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private ServiceInput input;
private PCEServiceWrapper pceServiceWrapper;
private Boolean tempService;
+ private NotificationPublishService notificationPublishService;
public RendererListenerImpl(PathComputationService pathComputationService,
NotificationPublishService notificationPublishService) {
this.pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService);
setServiceInput(null);
setTempService(false);
+ this.notificationPublishService = notificationPublishService;
}
@Override
return;
}
serviceRpcResultSp = notification;
- String serviceName = serviceRpcResultSp.getServiceName();
int notifType = serviceRpcResultSp.getNotificationType().getIntValue();
LOG.info("Renderer '{}' Notification received : {}", serviceRpcResultSp.getNotificationType().getName(),
notification);
switch (notifType) {
/* service-implementation-request. */
case 3 :
- onServiceImplementationResult(serviceName);
+ onServiceImplementationResult(notification);
break;
/* service-delete. */
case 4 :
- onServiceDeleteResult(serviceName);
+ onServiceDeleteResult(notification);
break;
default:
break;
/**
* Process service delete result for serviceName.
- * @param serviceName String
+ * @param notification RendererRpcResultSp
*/
- private void onServiceDeleteResult(String serviceName) {
- if (serviceRpcResultSp.getStatus() == RpcStatusEx.Failed) {
- LOG.error("Renderer service delete failed !");
- return;
- } else if (serviceRpcResultSp.getStatus() == RpcStatusEx.Pending) {
- LOG.warn("Renderer service delete returned a Penging RpcStatusEx code!");
- return;
- } else if (serviceRpcResultSp.getStatus() != RpcStatusEx.Successful) {
- LOG.error("Renderer service delete returned an unknown RpcStatusEx code!");
- return;
+ private void onServiceDeleteResult(RendererRpcResultSp notification) {
+ switch (serviceRpcResultSp.getStatus()) {
+ case Successful:
+ LOG.info("Service '{}' deleted !", notification.getServiceName());
+ break;
+ case Failed:
+ LOG.error("Renderer service delete failed !");
+ return;
+ case Pending:
+ LOG.warn("Renderer service delete returned a Penging RpcStatusEx code!");
+ return;
+ default:
+ LOG.error("Renderer service delete returned an unknown RpcStatusEx code!");
+ return;
}
- LOG.info("Service '{}' deleted !", serviceName);
if (this.input == null) {
LOG.error("ServiceInput parameter is null !");
return;
LOG.info("sending PCE cancel resource reserve for '{}'", this.input.getServiceName());
this.pceServiceWrapper.cancelPCEResource(this.input.getServiceName(),
ServiceNotificationTypes.ServiceDeleteResult);
+ sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceDeleteResult);
}
/**
* Process service implementation result for serviceName.
- * @param serviceName String
- * @param serviceName String
+ * @param notification RendererRpcResultSp
*/
- private void onServiceImplementationResult(String serviceName) {
- if (serviceRpcResultSp.getStatus() == RpcStatusEx.Successful) {
- onSuccededServiceImplementation();
- } else if (serviceRpcResultSp.getStatus() == RpcStatusEx.Failed) {
- onFailedServiceImplementation(serviceName);
- } else if (serviceRpcResultSp.getStatus() == RpcStatusEx.Pending) {
- LOG.warn("Service Implementation still pending according to RpcStatusEx");
- } else {
- LOG.warn("Service Implementation has an unknown RpcStatusEx code");
+ private void onServiceImplementationResult(RendererRpcResultSp notification) {
+ switch (serviceRpcResultSp.getStatus()) {
+ case Successful:
+ onSuccededServiceImplementation(notification);
+ break;
+ case Failed:
+ onFailedServiceImplementation(notification.getServiceName());
+ break;
+ case Pending:
+ LOG.warn("Service Implementation still pending according to RpcStatusEx");
+ break;
+ default:
+ LOG.warn("Service Implementation has an unknown RpcStatusEx code");
+ break;
}
-
}
/**
* Process succeeded service implementation for service.
+ * @param notification RendererRpcResultSp
*/
- private void onSuccededServiceImplementation() {
+ private void onSuccededServiceImplementation(RendererRpcResultSp notification) {
LOG.info("Service implemented !");
if (serviceDataStoreOperations == null) {
LOG.debug("serviceDataStoreOperations is null");
AdminStates.InService);
if (!operationResult.isSuccess()) {
LOG.warn("Service status not updated in datastore !");
+ } else {
+ sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceCreateResult);
}
}
}
+ /**
+ * Create and send service handler notification.
+ * @param notification RendererRpcResultSp
+ * @param type ServiceNotificationTypes
+ */
+ private void sendServiceHandlerNotification(RendererRpcResultSp notification, ServiceNotificationTypes type) {
+ try {
+ ServiceRpcResultSh serviceHandlerNotification = new ServiceRpcResultShBuilder()
+ .setAToZDirection(notification.getAToZDirection())
+ .setZToADirection(notification.getZToADirection())
+ .setServiceName(notification.getServiceName())
+ .setStatus(notification.getStatus())
+ .setStatusMessage(notification.getStatusMessage())
+ .setNotificationType(type)
+ .build();
+ LOG.debug("Service update in datastore OK, sending notification {}", serviceHandlerNotification);
+ notificationPublishService.putNotification(
+ serviceHandlerNotification);
+ } catch (InterruptedException e) {
+ LOG.warn("Something went wrong while sending notification for sevice {}",
+ serviceRpcResultSp.getServiceName(), e);
+ Thread.currentThread().interrupt();
+ }
+ }
+
/**
* Process failed service implementation for serviceName.
* @param serviceName String