servicehandler/src/main/java/org/opendaylight/transportpce/servicehandler/MappingAndSendingPCRequest.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
   9 package org.opendaylight.transportpce.servicehandler;
  10
  11 import com.google.common.util.concurrent.ListenableFuture;
  12 import com.google.common.util.concurrent.ListeningExecutorService;
  13 import com.google.common.util.concurrent.MoreExecutors;
  14
  15 import java.util.concurrent.Callable;
  16 import java.util.concurrent.CancellationException;
  17 import java.util.concurrent.ExecutionException;
  18 import java.util.concurrent.Executors;
  19 import java.util.concurrent.Future;
  20
  21 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  22 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.CancelResourceReserveInput;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.CancelResourceReserveInputBuilder;
  24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.CancelResourceReserveOutput;
  25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.PathComputationRequestInput;
  26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.PathComputationRequestInputBuilder;
  27 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.PathComputationRequestOutput;
  28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.StubpceService;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.path.computation.request.input.ServiceAEnd;
  30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.path.computation.request.input.ServiceAEndBuilder;
  31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.path.computation.request.input.ServiceZEnd;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.stubpce.rev170426.path.computation.request.input.ServiceZEndBuilder;
  33 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.RpcActions;
  34 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.ServiceEndpoint;
  35 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.sdnc.request.header.SdncRequestHeader;
  36 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev161014.sdnc.request.header.SdncRequestHeaderBuilder;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.ServiceCreateInput;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.ServiceFeasibilityCheckInput;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.ServiceReconfigureInput;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev161014.service.list.Services;
  41 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.RoutingConstraintsSp.PceMetric;
  42 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.routing.constraints.sp.HardConstraints;
  43 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.routing.constraints.sp.SoftConstraints;
  44 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.service.endpoint.sp.RxDirection;
  45 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.service.endpoint.sp.RxDirectionBuilder;
  46 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.service.endpoint.sp.TxDirection;
  47 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.service.endpoint.sp.TxDirectionBuilder;
  48 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev170426.service.handler.header.ServiceHandlerHeaderBuilder;
  49 import org.opendaylight.yangtools.yang.common.RpcResult;
  50
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 /**
  55  * class for Mapping and Sending PCE requests : - path-computation-request -
  56  * cancel-resource-reserve.
  57  *
  58  * @author <a href="mailto:martial.coulibaly@gfi.com">Martial Coulibaly</a> on behalf of Orange
  59  *
  60  */
  61 public class MappingAndSendingPCRequest {
  62     /** Logging. */
  63     private static final Logger LOG = LoggerFactory.getLogger(MappingAndSendingPCRequest.class);
  64     /** Permit to call PCE RPCs. */
  65     private StubpceService service;
  66     /** define procedure success (or not ). */
  67     private Boolean success;
  68     /** permit to call bundle service (PCE, Renderer, Servicehandler. */
  69     private RpcProviderRegistry rpcRegistry;
  70     PathComputationRequestInput pathComputationRequestInput = null;
  71     CancelResourceReserveInput cancelResourceReserveInput = null;
  72     HardConstraints hard = null;
  73     SoftConstraints soft = null;
  74     private ServiceAEnd serviceAEndSp;
  75     private ServiceZEnd serviceZEndSp;
  76     /** store all error messages. */
  77     private String error;
  78     private final ListeningExecutorService executor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
  79
  80     /**
  81      * MappingAndSendingPCRequest Class constructor for RPC serviceReconfigure.
  82      *
  83      * @param rpcRegistry
  84      *            RpcProviderRegistry
  85      * @param serviceReconfigureInput
  86      *            serviceReconfigureInput
  87      * @param resvResource
  88      *            Boolean to define resource reserve
  89      */
  90     public MappingAndSendingPCRequest(RpcProviderRegistry rpcRegistry, ServiceReconfigureInput serviceReconfigureInput,
  91             Boolean resvResource) {
  92         this.setRpcRegistry(rpcRegistry);
  93         if (rpcRegistry != null) {
  94             service = rpcRegistry.getRpcService(StubpceService.class);
  95         }
  96         endpointToEndpointStubpce(serviceReconfigureInput.getServiceAEnd(), serviceReconfigureInput.getServiceZEnd());
  97         SdncRequestHeader head = new SdncRequestHeaderBuilder()
  98                 .setRequestId("reconfigure_" + serviceReconfigureInput.getServiceName())
  99                 .setRpcAction(RpcActions.ServiceReconfigure)
 100                 .build();
 101         MappingConstraints map = new MappingConstraints(serviceReconfigureInput.getHardConstraints(),
 102                 serviceReconfigureInput.getSoftConstraints());
 103         map.serviceToServicePathConstarints();
 104         /**
 105          * mappingPCRequest(serviceReconfigureInput.getNewServiceName(),
 106          * serviceReconfigureInput.getHardConstraints(),
 107          * serviceReconfigureInput.getSoftConstraints(),head ,resvResource);
 108          */
 109         mappingPCRequest(serviceReconfigureInput.getNewServiceName(),serviceAEndSp, serviceZEndSp,
 110                 map.getServicePathHardConstraints(), map.getServicePathSoftConstraints(), head, resvResource);
 111         setSuccess(false);
 112         setError("");
 113     }
 114
 115     /**
 116      * MappingAndSendingPCRequest Class constructor for RPC
 117      * serviceFeasibilityCheck.
 118      *
 119      * @param rpcRegistry
 120      *            RpcProviderRegistry
 121      * @param serviceFeasibilityCheckInput
 122      *            ServiceFeasibilityCheckInput
 123      * @param resvResource
 124      *            Boolean to reserve resource
 125      */
 126     public MappingAndSendingPCRequest(RpcProviderRegistry rpcRegistry,
 127             ServiceFeasibilityCheckInput serviceFeasibilityCheckInput, Boolean resvResource) {
 128         this.setRpcRegistry(rpcRegistry);
 129         if (rpcRegistry != null) {
 130             service = rpcRegistry.getRpcService(StubpceService.class);
 131         }
 132         endpointToEndpointStubpce(serviceFeasibilityCheckInput.getServiceAEnd(),
 133                 serviceFeasibilityCheckInput.getServiceZEnd());
 134         MappingConstraints map = new MappingConstraints(serviceFeasibilityCheckInput.getHardConstraints(),
 135                 serviceFeasibilityCheckInput.getSoftConstraints());
 136         map.serviceToServicePathConstarints();
 137         mappingPCRequest("no name",serviceAEndSp, serviceZEndSp, map.getServicePathHardConstraints(),
 138                 map.getServicePathSoftConstraints(), serviceFeasibilityCheckInput.getSdncRequestHeader(),
 139                 resvResource);
 140         setSuccess(false);
 141         setError("");
 142     }
 143
 144     /**
 145      * MappingAndSendingPCRequest Class constructor for RPC serviceCreate.
 146      *
 147      * @param rpcRegistry
 148      *            RpcProviderRegistry
 149      * @param serviceCreateInput
 150      *            ServiceCreateInput
 151      * @param resvResource
 152      *            Boolean to reserve resource
 153      */
 154     public MappingAndSendingPCRequest(RpcProviderRegistry rpcRegistry, ServiceCreateInput serviceCreateInput,
 155             Boolean resvResource) {
 156         this.setRpcRegistry(rpcRegistry);
 157         if (rpcRegistry != null) {
 158             service = rpcRegistry.getRpcService(StubpceService.class);
 159         }
 160         endpointToEndpointStubpce(serviceCreateInput.getServiceAEnd(), serviceCreateInput.getServiceZEnd());
 161         MappingConstraints map = new MappingConstraints(serviceCreateInput.getHardConstraints(),
 162                 serviceCreateInput.getSoftConstraints());
 163         map.serviceToServicePathConstarints();
 164         mappingPCRequest(serviceCreateInput.getServiceName(),serviceAEndSp, serviceZEndSp,
 165                 map.getServicePathHardConstraints(), map.getServicePathSoftConstraints(),
 166                 serviceCreateInput.getSdncRequestHeader(), resvResource);
 167         setSuccess(false);
 168         setError("");
 169     }
 170
 171     /**
 172      * MappingAndSendingPCRequest Class constructor for modify Service in ODL
 173      * Datastore.
 174      *
 175      * @param rpcRegistry
 176      *            RpcProviderRegistry
 177      * @param input
 178      *            Services
 179      * @param resvResource
 180      *            Boolean to reserve resource
 181      */
 182     public MappingAndSendingPCRequest(RpcProviderRegistry rpcRegistry, Services input, Boolean resvResource) {
 183         this.setRpcRegistry(rpcRegistry);
 184         if (rpcRegistry != null) {
 185             service = rpcRegistry.getRpcService(StubpceService.class);
 186         }
 187         endpointToEndpointStubpce(input.getServiceAEnd(), input.getServiceZEnd());
 188         MappingConstraints map = new MappingConstraints(input.getHardConstraints(), input.getSoftConstraints());
 189         map.serviceToServicePathConstarints();
 190         mappingPCRequest(input.getServiceName(),serviceAEndSp, serviceZEndSp, map.getServicePathHardConstraints(),
 191                 map.getServicePathSoftConstraints(), input.getSdncRequestHeader(), resvResource);
 192         setSuccess(false);
 193         setError("");
 194     }
 195
 196
 197     public void endpointToEndpointStubpce(ServiceEndpoint serviceAEnd, ServiceEndpoint serviceZEnd) {
 198         LOG.info("Mapping Service Endpoint to Service Endpoint Stubpce");
 199         TxDirection txDirection = null;
 200         RxDirection rxDirection = null;
 201         if (serviceAEnd != null && serviceZEnd != null) {
 202             txDirection = new TxDirectionBuilder()
 203                     .setPort(serviceAEnd.getTxDirection().getPort())
 204                     .build();
 205             rxDirection = new RxDirectionBuilder()
 206                     .setPort(serviceAEnd.getRxDirection().getPort())
 207                     .build();
 208             serviceAEndSp = new ServiceAEndBuilder()
 209                     .setClli(serviceAEnd.getClli())
 210                     .setNodeId(serviceAEnd.getNodeId())
 211                     .setServiceFormat(serviceAEnd.getServiceFormat())
 212                     .setServiceRate(serviceAEnd.getServiceRate())
 213                     .setTxDirection(txDirection)
 214                     .setRxDirection(rxDirection)
 215                     .build();
 216
 217             txDirection = new TxDirectionBuilder()
 218                     .setPort(serviceZEnd.getTxDirection().getPort())
 219                     .build();
 220             rxDirection = new RxDirectionBuilder()
 221                     .setPort(serviceZEnd.getRxDirection().getPort())
 222                     .build();
 223             serviceZEndSp = new ServiceZEndBuilder()
 224                     .setClli(serviceZEnd.getClli())
 225                     .setNodeId(serviceZEnd.getNodeId())
 226                     .setServiceFormat(serviceZEnd.getServiceFormat())
 227                     .setServiceRate(serviceZEnd.getServiceRate())
 228                     .setTxDirection(txDirection)
 229                     .setRxDirection(rxDirection)
 230                     .build();
 231         }
 232     }
 233
 234     /**
 235      * Build pathComputationRequestInput or cancelResourceReserveInput with
 236      * input parameters (serviceReconfigureInput or serviceFeasibilityCheckInput.
 237      *
 238      * @param String
 239      *            serviceName
 240      * @param zend Service ZEnd
 241      * @param aend Service AEnd
 242      * @param HardConstraints
 243      *            hardConstraints
 244      * @param SoftConstraints
 245      *            softConstraints
 246      * @param SdncRequestHeader
 247      *            sdncRequestHeader
 248      * @param Boolean
 249      *            resvResource
 250      */
 251     private void mappingPCRequest(String serviceName, ServiceAEnd aend, ServiceZEnd zend,
 252             HardConstraints hardConstraints, SoftConstraints softConstraints, org.opendaylight.yang.gen.v1.http.org
 253             .openroadm.common.service.types.rev161014.sdnc.request.header.SdncRequestHeader sdncRequestHeader,
 254             Boolean resvResource) {
 255
 256         LOG.info("Mapping ServiceCreateInput or ServiceFeasibilityCheckInput or serviceReconfigureInput "
 257                 + "to PCE requests");
 258
 259         HardConstraints serviceCreateHard = hardConstraints;
 260         SoftConstraints serviceCreateSoft = softConstraints;
 261         org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.routing
 262             .constraints.sp.HardConstraints pceHardConstraints = null;
 263         org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.routing.constraints.rev170426.routing
 264             .constraints.sp.SoftConstraints pceSoftConstraints = null;
 265         if (serviceCreateHard != null) {
 266             pceHardConstraints = serviceCreateHard;
 267         }
 268         if (serviceCreateSoft != null) {
 269             pceSoftConstraints = serviceCreateSoft;
 270         }
 271
 272         ServiceHandlerHeaderBuilder serviceHandlerHeader = new ServiceHandlerHeaderBuilder();
 273         if (sdncRequestHeader != null) {
 274             serviceHandlerHeader.setRequestId(sdncRequestHeader.getRequestId());
 275         }
 276
 277         /** PathComputationRequestInput build */
 278         pathComputationRequestInput = new PathComputationRequestInputBuilder()
 279                 .setServiceName(serviceName)
 280                 .setResourceReserve(resvResource)
 281                 .setServiceHandlerHeader(serviceHandlerHeader.build())
 282                 .setServiceAEnd(aend)
 283                 .setServiceZEnd(zend)
 284                 .setHardConstraints(pceHardConstraints)
 285                 .setSoftConstraints(pceSoftConstraints)
 286                 .setPceMetric(PceMetric.TEMetric).build();
 287
 288         /** CancelResourceReserveInput build */
 289         cancelResourceReserveInput = new CancelResourceReserveInputBuilder().setServiceName(serviceName)
 290                 .setServiceHandlerHeader(serviceHandlerHeader.build()).build();
 291     }
 292
 293
 294     /**
 295      * Send cancelResourceReserve request to PCE.
 296      *
 297      * @return Boolean true if success, false else
 298      */
 299     public ListenableFuture<Boolean> cancelResourceReserve() {
 300         setSuccess(false);
 301         return executor.submit(new Callable<Boolean>() {
 302             @Override
 303             public Boolean call() throws Exception {
 304                 Boolean output = false;
 305                 if (cancelResourceReserveInput != null) {
 306                     RpcResult<CancelResourceReserveOutput> pceOutputResult = null;
 307                     Future<RpcResult<CancelResourceReserveOutput>> pceOutputFuture = service
 308                             .cancelResourceReserve(cancelResourceReserveInput);
 309                     try {
 310                         pceOutputResult = pceOutputFuture.get();
 311                     } catch (InterruptedException | CancellationException | ExecutionException e) {
 312                         setError("Did not receive the expected response from pce to cancelResourceReserve RPC "
 313                                 + e.toString());
 314                         LOG.error(error);
 315                         pceOutputFuture.cancel(true);
 316                     }
 317
 318                     if (pceOutputResult != null && pceOutputResult.isSuccessful()) {
 319                         LOG.info("PCE replied to CancelResource request !");
 320                         output = true;
 321                         setSuccess(true);
 322                     }
 323                 } else {
 324                     LOG.info("cancelResourceReserveInput parameter not valid !");
 325                 }
 326                 return output;
 327             }
 328         });
 329
 330     }
 331
 332     /**
 333      * Send pathComputationRequest request to PCE.
 334      *
 335      * @return Boolean true if success, false else
 336      */
 337     public ListenableFuture<Boolean> pathComputationRequest() {
 338         LOG.info("In pathComputationRequest ...");
 339         setSuccess(false);
 340         return executor.submit(new Callable<Boolean>() {
 341             @Override
 342             public Boolean call() throws Exception {
 343                 RpcResult<PathComputationRequestOutput> pceOutputResult = null;
 344                 Boolean output = false;
 345                 if (pathComputationRequestInput != null) {
 346                     LOG.info("pathComputationRequestInput : {}", pathComputationRequestInput.toString());
 347                     Future<RpcResult<PathComputationRequestOutput>> pceOutputFuture = service
 348                             .pathComputationRequest(pathComputationRequestInput);
 349                     try {
 350                         pceOutputResult = pceOutputFuture.get();
 351                     } catch (InterruptedException | CancellationException | ExecutionException e) {
 352                         setError("Did not receive the expected response from pce to pathComputationRequest RPC "
 353                                 + e.toString());
 354                         LOG.error(error);
 355                         pceOutputFuture.cancel(true);
 356                     }
 357                     if (pceOutputResult != null && pceOutputResult.isSuccessful()) {
 358                         setSuccess(true);
 359                         output = true;
 360                         LOG.info("PCE replied to pathComputation request !");
 361                     }
 362                 } else {
 363                     LOG.info("pathComputationRequestInput parameter not valid !");
 364                 }
 365                 return output;
 366             }
 367         });
 368     }
 369
 370     public Boolean getSuccess() {
 371         return success;
 372     }
 373
 374     public void setSuccess(Boolean success) {
 375         this.success = success;
 376     }
 377
 378     public String getError() {
 379         return error;
 380     }
 381
 382     public void setError(String error) {
 383         this.error = error;
 384     }
 385
 386     public RpcProviderRegistry getRpcRegistry() {
 387         return rpcRegistry;
 388     }
 389
 390     public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
 391         this.rpcRegistry = rpcRegistry;
 392     }
 393
 394     public ServiceAEnd getServiceAEndSp() {
 395         return serviceAEndSp;
 396     }
 397
 398     public void setServiceAEndSp(ServiceAEnd serviceAEndSp) {
 399         this.serviceAEndSp = serviceAEndSp;
 400     }
 401
 402     public ServiceZEnd getServiceZEndSp() {
 403         return serviceZEndSp;
 404     }
 405
 406     public void setServiceZEndSp(ServiceZEnd serviceZEndSp) {
 407         this.serviceZEndSp = serviceZEndSp;
 408     }
 409 }