servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/listeners/RendererListenerImpl.java

   1 /*
   2  * Copyright © 2017 Orange, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.transportpce.servicehandler.listeners;
   9
  10 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  11 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  12 import org.opendaylight.transportpce.common.OperationResult;
  13 import org.opendaylight.transportpce.common.StringConstants;
  14 import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
  15 import org.opendaylight.transportpce.pce.service.PathComputationService;
  16 import org.opendaylight.transportpce.servicehandler.ServiceInput;
  17 import org.opendaylight.transportpce.servicehandler.service.PCEServiceWrapper;
  18 import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
  19 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.RendererRpcResultSp;
  20 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.TransportpceRendererListener;
  21 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.renderer.rpc.result.sp.Link;
  22 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultSh;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultShBuilder;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ServiceNotificationTypes;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  27 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
  28 import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
  29 import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.PublishNotificationService;
  30 import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.PublishNotificationServiceBuilder;
  31 import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.notification.service.ServiceAEndBuilder;
  32 import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.notification.service.ServiceZEndBuilder;
  33 import org.opendaylight.yangtools.yang.common.Uint32;
  34 import org.slf4j.Logger;
  35 import org.slf4j.LoggerFactory;
  36
  37 /**
  38  * Calls to listen to Renderer notifications.
  39  *
  40  * @author Martial Coulibaly ( martial.coulibaly@gfi.com ) on behalf of Orange
  41  *
  42  */
  43 public class RendererListenerImpl implements TransportpceRendererListener {
  44
  45     private static final String TOPIC = "RendererListener";
  46     private static final Logger LOG = LoggerFactory.getLogger(RendererListenerImpl.class);
  47     private RendererRpcResultSp serviceRpcResultSp;
  48     private ServiceDataStoreOperations serviceDataStoreOperations;
  49     private ServiceInput input;
  50     private PCEServiceWrapper pceServiceWrapper;
  51     private Boolean tempService;
  52     private NotificationPublishService notificationPublishService;
  53     private final NetworkModelService networkModelService;
  54
  55
  56     public RendererListenerImpl(PathComputationService pathComputationService,
  57             NotificationPublishService notificationPublishService, NetworkModelService networkModelService) {
  58         this.pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService);
  59         setServiceInput(null);
  60         setTempService(false);
  61         this.notificationPublishService = notificationPublishService;
  62         this.networkModelService = networkModelService;
  63     }
  64
  65     @Override
  66     public void onRendererRpcResultSp(RendererRpcResultSp notification) {
  67         if (compareServiceRpcResultSp(notification)) {
  68             LOG.warn("ServiceRpcResultSp already wired !");
  69             return;
  70         }
  71         serviceRpcResultSp = notification;
  72         int notifType = serviceRpcResultSp.getNotificationType().getIntValue();
  73         LOG.info("Renderer '{}' Notification received : {}", serviceRpcResultSp.getNotificationType().getName(),
  74                 notification);
  75         switch (notifType) {
  76             /* service-implementation-request. */
  77             case 3:
  78                 onServiceImplementationResult(notification);
  79                 break;
  80             /* service-delete. */
  81             case 4:
  82                 onServiceDeleteResult(notification);
  83                 break;
  84             default:
  85                 break;
  86         }
  87     }
  88
  89     /**
  90      * Process service delete result for serviceName.
  91      * @param notification RendererRpcResultSp
  92      */
  93     private void onServiceDeleteResult(RendererRpcResultSp notification) {
  94         switch (serviceRpcResultSp.getStatus()) {
  95             case Successful:
  96                 String serviceType = notification.getServiceType();
  97                 switch (serviceType) {
  98                     case StringConstants.SERVICE_TYPE_1GE:
  99                     case StringConstants.SERVICE_TYPE_10GE:
 100                     case StringConstants.SERVICE_TYPE_100GE_M:
 101                         Short tribPort = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
 102                             .split("\\.")[0]);
 103                         Short minTribSlot = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
 104                             .split("\\.")[1]);
 105                         Short maxTribSlot = Short.valueOf(notification.getAToZDirection().getMaxTribSlot().getValue()
 106                             .split("\\.")[1]);
 107                         updateOtnTopology(notification.getLink(), true, notification.getServiceType(),
 108                             notification.getAToZDirection().getRate(), tribPort, minTribSlot, maxTribSlot);
 109                         break;
 110                     case StringConstants.SERVICE_TYPE_OTU4:
 111                     case StringConstants.SERVICE_TYPE_OTUC4:
 112                     case StringConstants.SERVICE_TYPE_ODU4:
 113                     case StringConstants.SERVICE_TYPE_ODUC4:
 114                         updateOtnTopology(notification.getLink(), true, notification.getServiceType(), null, null,
 115                             null, null);
 116                         break;
 117                     default:
 118                         break;
 119                 }
 120                 break;
 121             case Failed:
 122                 LOG.error("Renderer service delete failed !");
 123                 Services service = serviceDataStoreOperations.getService(input.getServiceName()).get();
 124                 sendNbiNotification(new PublishNotificationServiceBuilder()
 125                         .setServiceName(service.getServiceName())
 126                         .setServiceAEnd(new ServiceAEndBuilder(service.getServiceAEnd()).build())
 127                         .setServiceZEnd(new ServiceZEndBuilder(service.getServiceZEnd()).build())
 128                         .setCommonId(service.getCommonId())
 129                         .setConnectionType(service.getConnectionType())
 130                         .setResponseFailed("Renderer service delete failed !")
 131                         .setMessage("ServiceDelete request failed ...")
 132                         .setOperationalState(service.getOperationalState())
 133                         .setTopic(TOPIC)
 134                         .build());
 135                 return;
 136             case Pending:
 137                 LOG.warn("Renderer service delete returned a Pending RpcStatusEx code!");
 138                 return;
 139             default:
 140                 LOG.error("Renderer service delete returned an unknown RpcStatusEx code!");
 141                 return;
 142         }
 143         LOG.info("Service '{}' deleted !", notification.getServiceName());
 144         if (this.input == null) {
 145             LOG.error("ServiceInput parameter is null !");
 146             return;
 147         }
 148         LOG.info("sending PCE cancel resource reserve for '{}'", this.input.getServiceName());
 149         this.pceServiceWrapper.cancelPCEResource(this.input.getServiceName(),
 150                 ServiceNotificationTypes.ServiceDeleteResult);
 151         sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceDeleteResult);
 152     }
 153
 154     /**
 155      * Process service implementation result for serviceName.
 156      * @param notification RendererRpcResultSp
 157      */
 158     private void onServiceImplementationResult(RendererRpcResultSp notification) {
 159         switch (serviceRpcResultSp.getStatus()) {
 160             case Successful:
 161                 onSuccededServiceImplementation(notification);
 162                 break;
 163             case Failed:
 164                 onFailedServiceImplementation(notification.getServiceName());
 165                 break;
 166             case Pending:
 167                 LOG.warn("Service Implementation still pending according to RpcStatusEx");
 168                 break;
 169             default:
 170                 LOG.warn("Service Implementation has an unknown RpcStatusEx code");
 171                 break;
 172         }
 173     }
 174
 175     /**
 176      * Process succeeded service implementation for service.
 177      * @param notification RendererRpcResultSp
 178      */
 179     private void onSuccededServiceImplementation(RendererRpcResultSp notification) {
 180         LOG.info("Service implemented !");
 181         if (serviceDataStoreOperations == null) {
 182             LOG.debug("serviceDataStoreOperations is null");
 183             return;
 184         }
 185         String serviceType = notification.getServiceType();
 186         switch (serviceType) {
 187             case StringConstants.SERVICE_TYPE_1GE:
 188             case StringConstants.SERVICE_TYPE_10GE:
 189             case StringConstants.SERVICE_TYPE_100GE_M:
 190                 Short tribPort = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
 191                     .split("\\.")[0]);
 192                 Short minTribSlot = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
 193                     .split("\\.")[1]);
 194                 Short maxTribSlot = Short.valueOf(notification.getAToZDirection().getMaxTribSlot().getValue()
 195                     .split("\\.")[1]);
 196                 updateOtnTopology(notification.getLink(), false, notification.getServiceType(),
 197                     notification.getAToZDirection().getRate(), tribPort, minTribSlot, maxTribSlot);
 198                 break;
 199             case StringConstants.SERVICE_TYPE_OTU4:
 200             case StringConstants.SERVICE_TYPE_OTUC4:
 201             case StringConstants.SERVICE_TYPE_ODU4:
 202             case StringConstants.SERVICE_TYPE_ODUC4:
 203                 updateOtnTopology(notification.getLink(), false, notification.getServiceType(), null, null, null, null);
 204                 break;
 205             default:
 206                 break;
 207         }
 208         PublishNotificationServiceBuilder nbiNotificationBuilder = new PublishNotificationServiceBuilder()
 209                 .setServiceName(input.getServiceName())
 210                 .setServiceAEnd(new ServiceAEndBuilder(input.getServiceAEnd()).build())
 211                 .setServiceZEnd(new ServiceZEndBuilder(input.getServiceZEnd()).build())
 212                 .setCommonId(input.getCommonId()).setConnectionType(input.getConnectionType())
 213                 .setTopic(TOPIC);
 214         OperationResult operationResult;
 215         String serviceTemp = "";
 216         if (tempService) {
 217             operationResult = this.serviceDataStoreOperations.modifyTempService(
 218                     serviceRpcResultSp.getServiceName(), State.InService, AdminStates.InService);
 219             serviceTemp = "Temp ";
 220         } else {
 221             operationResult = this.serviceDataStoreOperations.modifyService(
 222                     serviceRpcResultSp.getServiceName(), State.InService, AdminStates.InService);
 223         }
 224         if (operationResult.isSuccess()) {
 225             sendNbiNotification(nbiNotificationBuilder
 226                     .setResponseFailed("")
 227                     .setMessage("Service implemented !")
 228                     .setOperationalState(org.opendaylight.yang.gen.v1.http
 229                             .org.openroadm.common.state.types.rev181130.State.InService)
 230                     .build());
 231             if (!tempService) {
 232                 sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceCreateResult);
 233             }
 234         } else {
 235             LOG.warn("{}Service status not updated in datastore !", serviceTemp);
 236             sendNbiNotification(nbiNotificationBuilder
 237                     .setResponseFailed(serviceTemp + "Service status not updated in datastore !")
 238                     .setMessage("ServiceCreate request failed ...")
 239                     .setOperationalState(org.opendaylight.yang.gen.v1.http
 240                             .org.openroadm.common.state.types.rev181130.State.OutOfService)
 241                     .build());
 242         }
 243     }
 244
 245     /**
 246      * Create and send service handler notification.
 247      * @param notification RendererRpcResultSp
 248      * @param type ServiceNotificationTypes
 249      */
 250     private void sendServiceHandlerNotification(RendererRpcResultSp notification, ServiceNotificationTypes type) {
 251         try {
 252             ServiceRpcResultSh serviceHandlerNotification = new ServiceRpcResultShBuilder()
 253                     .setAToZDirection(notification.getAToZDirection())
 254                     .setZToADirection(notification.getZToADirection())
 255                     .setServiceName(notification.getServiceName())
 256                     .setStatus(notification.getStatus())
 257                     .setStatusMessage(notification.getStatusMessage())
 258                     .setNotificationType(type)
 259                     .build();
 260             LOG.debug("Service update in datastore OK, sending notification {}", serviceHandlerNotification);
 261             notificationPublishService.putNotification(
 262                     serviceHandlerNotification);
 263         } catch (InterruptedException e) {
 264             LOG.warn("Something went wrong while sending notification for service {}",
 265                     serviceRpcResultSp.getServiceName(), e);
 266             Thread.currentThread().interrupt();
 267         }
 268     }
 269
 270     /**
 271      * Process failed service implementation for serviceName.
 272      * @param serviceName String
 273      */
 274     private void onFailedServiceImplementation(String serviceName) {
 275         LOG.error("Renderer implementation failed !");
 276         Services service = serviceDataStoreOperations.getService(input.getServiceName()).get();
 277         sendNbiNotification(new PublishNotificationServiceBuilder()
 278                 .setServiceName(service.getServiceName())
 279                 .setServiceAEnd(new ServiceAEndBuilder(service.getServiceAEnd()).build())
 280                 .setServiceZEnd(new ServiceZEndBuilder(service.getServiceZEnd()).build())
 281                 .setCommonId(service.getCommonId())
 282                 .setConnectionType(service.getConnectionType())
 283                 .setResponseFailed("Renderer implementation failed !")
 284                 .setMessage("ServiceCreate request failed ...")
 285                 .setOperationalState(service.getOperationalState())
 286                 .setTopic(TOPIC)
 287                 .build());
 288         OperationResult deleteServicePathOperationResult =
 289                 this.serviceDataStoreOperations.deleteServicePath(serviceName);
 290         if (!deleteServicePathOperationResult.isSuccess()) {
 291             LOG.warn("Service path was not removed from datastore!");
 292         }
 293         OperationResult deleteServiceOperationResult;
 294         String serviceType = "";
 295         if (tempService) {
 296             deleteServiceOperationResult = this.serviceDataStoreOperations.deleteTempService(serviceName);
 297             serviceType = "Temp ";
 298         } else {
 299             deleteServiceOperationResult = this.serviceDataStoreOperations.deleteService(serviceName);
 300         }
 301         if (deleteServiceOperationResult.isSuccess()) {
 302             LOG.warn("{}Service was not removed from datastore!", serviceType);
 303         }
 304     }
 305
 306     @SuppressFBWarnings(
 307         value = "ES_COMPARING_STRINGS_WITH_EQ",
 308         justification = "false positives, not strings but real object references comparisons")
 309     private Boolean compareServiceRpcResultSp(RendererRpcResultSp notification) {
 310         if (serviceRpcResultSp == null) {
 311             return false;
 312         }
 313         if (serviceRpcResultSp.getNotificationType() != notification.getNotificationType()) {
 314             return false;
 315         }
 316         if (serviceRpcResultSp.getServiceName() != notification.getServiceName()) {
 317             return false;
 318         }
 319         if (serviceRpcResultSp.getStatus() != notification.getStatus()) {
 320             return false;
 321         }
 322         if (serviceRpcResultSp.getStatusMessage() != notification.getStatusMessage()) {
 323             return false;
 324         }
 325         return true;
 326     }
 327
 328     public void setServiceInput(ServiceInput serviceInput) {
 329         this.input = serviceInput;
 330     }
 331
 332     public void setserviceDataStoreOperations(ServiceDataStoreOperations serviceData) {
 333         this.serviceDataStoreOperations = serviceData;
 334     }
 335
 336     public void setTempService(Boolean tempService) {
 337         this.tempService = tempService;
 338     }
 339
 340     /**
 341      * Send notification to NBI notification in order to publish message.
 342      * @param service PublishNotificationService
 343      */
 344     private void sendNbiNotification(PublishNotificationService service) {
 345         try {
 346             notificationPublishService.putNotification(service);
 347         } catch (InterruptedException e) {
 348             LOG.warn("Cannot send notification to nbi", e);
 349             Thread.currentThread().interrupt();
 350         }
 351     }
 352
 353     private void updateOtnTopology(Link link, boolean isDeletion, String serviceType, Uint32 rate, Short portNb,
 354             Short minSlotNb, Short maxSlotNb) {
 355         if (link == null) {
 356             return;
 357         }
 358         OtnLinkType otnLinkType;
 359         switch (serviceType) {
 360             case StringConstants.SERVICE_TYPE_OTU4:
 361                 otnLinkType = OtnLinkType.OTU4;
 362                 break;
 363             case StringConstants.SERVICE_TYPE_OTUC4:
 364                 otnLinkType = OtnLinkType.OTUC4;
 365                 break;
 366             case StringConstants.SERVICE_TYPE_ODU4:
 367                 otnLinkType = OtnLinkType.ODTU4;
 368                 break;
 369             case StringConstants.SERVICE_TYPE_ODUC4:
 370                 otnLinkType = OtnLinkType.ODUC4;
 371                 break;
 372             default:
 373                 otnLinkType = null;
 374                 LOG.warn("No otn-link-type corresponds to service-type {}", serviceType);
 375                 break;
 376         }
 377         switch (serviceType) {
 378             case StringConstants.SERVICE_TYPE_OTU4:
 379             case StringConstants.SERVICE_TYPE_OTUC4:
 380             case StringConstants.SERVICE_TYPE_ODU4:
 381             case StringConstants.SERVICE_TYPE_ODUC4:
 382                 if (isDeletion) {
 383                     LOG.info("updating otn-topology removing links");
 384                     this.networkModelService.deleteOtnLinks(link.getATermination().getNodeId(),
 385                         link.getATermination().getTpId(), link.getZTermination().getNodeId(),
 386                         link.getZTermination().getTpId(), otnLinkType);
 387                 } else {
 388                     LOG.info("updating otn-topology adding links");
 389                     this.networkModelService.createOtnLinks(link.getATermination().getNodeId(),
 390                         link.getATermination().getTpId(), link.getZTermination().getNodeId(),
 391                         link.getZTermination().getTpId(), otnLinkType);
 392                 }
 393                 break;
 394             case StringConstants.SERVICE_TYPE_1GE:
 395             case StringConstants.SERVICE_TYPE_10GE:
 396             case StringConstants.SERVICE_TYPE_100GE_M:
 397                 LOG.info("updating otn-topology node tps -tps and tpn pools");
 398                 this.networkModelService.updateOtnLinks(link, rate, portNb, minSlotNb, maxSlotNb, isDeletion);
 399                 break;
 400             default:
 401                 break;
 402         }
 403     }
 404
 405 }