gerrit.onap Code Review - ccsdk/features.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                      reserved.
   7  *      Modifications Copyright © 2018 IBM.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.ccsdk.features.sdnr.northbound.ranSlice;
  24
  25 import java.text.SimpleDateFormat;
  26 import java.util.Date;
  27 import java.util.Properties;
  28 import java.util.concurrent.ExecutorService;
  29 import java.util.concurrent.Executors;
  30 import org.onap.ccsdk.sli.core.sli.provider.MdsalHelper;
  31 import org.opendaylight.mdsal.binding.api.DataBroker;
  32 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  33 import org.opendaylight.mdsal.binding.api.RpcProviderService;
  34 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  35 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.rev200806.*;
  36 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.rev200806.common.header.CommonHeaderBuilder;
  37 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.rev200806.status.StatusBuilder;
  38 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  39 import org.opendaylight.yangtools.yang.common.RpcResult;
  40 import org.opendaylight.yangtools.yang.common.Uint16;
  41 import org.slf4j.Logger;
  42
  43 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 import com.google.common.util.concurrent.Futures;
  48 import com.google.common.util.concurrent.ListenableFuture;
  49
  50 /**
  51  * Defines a base implementation for your provider. This class extends from a
  52  * helper class which provides storage for the most commonly used components of
  53  * the MD-SAL. Additionally the base class provides some basic logging and
  54  * initialization / clean up methods.
  55  *
  56  */
  57 public class RANSliceProvider implements AutoCloseable, RanSliceApiService {
  58
  59         private class CommonRANSliceFields {
  60                 private StatusBuilder statusBuilder;
  61                 private CommonHeaderBuilder commonHeaderBuilder;
  62                 private Payload payload;
  63
  64                 public CommonRANSliceFields(StatusBuilder statusBuilder, CommonHeaderBuilder commonHeaderBuilder) {
  65                         this.statusBuilder = statusBuilder;
  66                         this.commonHeaderBuilder = commonHeaderBuilder;
  67                         this.payload = null;
  68                 }
  69
  70                 public CommonRANSliceFields(StatusBuilder statusBuilder, CommonHeaderBuilder commonHeaderBuilder, Payload payload) {
  71                         this.statusBuilder = statusBuilder;
  72                         this.commonHeaderBuilder = commonHeaderBuilder;
  73                         this.payload = payload;
  74                 }
  75
  76                 public StatusBuilder getStatusBuilder() {
  77                         return statusBuilder;
  78                 }
  79
  80                 public CommonHeaderBuilder getCommonHeaderBuilder() {
  81                         return commonHeaderBuilder;
  82                 }
  83
  84                 public Payload getPayload() {
  85                         return payload;
  86                 }
  87         }
  88
  89         private static final Logger LOG = LoggerFactory.getLogger(RANSliceProvider.class);
  90
  91         private static final String exceptionMessage = "Caught exception";
  92
  93         private static final String APPLICATION_NAME = "RANSlice";
  94
  95         private final ExecutorService executor;
  96         protected DataBroker dataBroker;
  97         protected DOMDataBroker domDataBroker;
  98         protected NotificationPublishService notificationService;
  99         protected RpcProviderService rpcProviderRegistry;
 100         private  RANSliceClient RANSliceClient;
 101
 102         private ObjectRegistration<RanSliceApiService> rpcRegistration;
 103
 104         public RANSliceProvider() {
 105
 106                 LOG.info("Creating provider for {}", APPLICATION_NAME);
 107                 executor = Executors.newFixedThreadPool(1);
 108                 this.dataBroker = null;
 109                 this.domDataBroker = null;
 110                 this.notificationService = null;
 111                 this.rpcProviderRegistry = null;
 112                 this.rpcRegistration = null;
 113                 this.RANSliceClient = null;
 114         }
 115
 116         public void setDataBroker(DataBroker dataBroker) {
 117                 this.dataBroker = dataBroker;
 118         }
 119
 120         public void setDomDataBroker(DOMDataBroker domDataBroker) {
 121                 this.domDataBroker = domDataBroker;
 122         }
 123
 124         public void setRpcProviderRegistry(RpcProviderService rpcProviderRegistry) {
 125                 this.rpcProviderRegistry = rpcProviderRegistry;
 126         }
 127
 128         public void setNotificationPublishService(NotificationPublishService notificationPublishService) {
 129                 this.notificationService = notificationPublishService;
 130         }
 131
 132         public void setClient(RANSliceClient client) {
 133                 this.RANSliceClient = client;
 134         }
 135
 136         public void init() {
 137                 LOG.info("Initializing {} for {}", this.getClass().getName(), APPLICATION_NAME);
 138
 139                 if (rpcRegistration == null) {
 140                         if (rpcProviderRegistry != null) {
 141                                 rpcRegistration = rpcProviderRegistry.registerRpcImplementation(RanSliceApiService.class, this);
 142                                 LOG.info("Initialization complete for {}", APPLICATION_NAME);
 143                         } else {
 144                                 LOG.warn("Error initializing {} : rpcRegistry unset", APPLICATION_NAME);
 145                         }
 146                 }
 147         }
 148
 149         @Override
 150         public void close() throws Exception {
 151                 LOG.info("Closing provider for " + APPLICATION_NAME);
 152                 executor.shutdown();
 153                 rpcRegistration.close();
 154                 LOG.info("Successfully closed provider for " + APPLICATION_NAME);
 155         }
 156
 157
 158 //RPC configureNearRTRIC
 159
 160         @Override
 161         public ListenableFuture<RpcResult<ConfigureNearRTRICOutput>> configureNearRTRIC(ConfigureNearRTRICInput input) {
 162                 ConfigureNearRTRICInputBuilder iBuilder = new ConfigureNearRTRICInputBuilder(input);
 163                 ConfigureNearRTRICOutputBuilder oBuilder = new ConfigureNearRTRICOutputBuilder();
 164
 165                 try {
 166                         CommonRANSliceFields retval = callDG("configureNearRTRIC", iBuilder.build());
 167                         oBuilder.setStatus(retval.getStatusBuilder().build());
 168                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 169                 } catch (RANSliceRpcInvocationException e) {
 170                         LOG.debug(exceptionMessage, e);
 171                         oBuilder.setCommonHeader(e.getCommonHeader());
 172                         oBuilder.setStatus(e.getStatus());
 173                 }
 174
 175                 RpcResult<ConfigureNearRTRICOutput> rpcResult =
 176                                 RpcResultBuilder.<ConfigureNearRTRICOutput> status(true).withResult(oBuilder.build()).build();
 177                 // return error
 178                 return Futures.immediateFuture(rpcResult);
 179
 180         }
 181
 182         //RPC instantiateRANSlice
 183
 184         @Override
 185         public ListenableFuture<RpcResult<InstantiateRANSliceOutput>> instantiateRANSlice(InstantiateRANSliceInput input) {
 186                 InstantiateRANSliceInputBuilder iBuilder = new InstantiateRANSliceInputBuilder(input);
 187                 InstantiateRANSliceOutputBuilder oBuilder = new InstantiateRANSliceOutputBuilder();
 188
 189                 try {
 190                         CommonRANSliceFields retval = callDG("instantiateRANSlice", iBuilder.build());
 191                         oBuilder.setStatus(retval.getStatusBuilder().build());
 192                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 193                 } catch (RANSliceRpcInvocationException e) {
 194                         LOG.debug(exceptionMessage, e);
 195                         oBuilder.setCommonHeader(e.getCommonHeader());
 196                         oBuilder.setStatus(e.getStatus());
 197                 }
 198
 199                 RpcResult<InstantiateRANSliceOutput> rpcResult =
 200                                 RpcResultBuilder.<InstantiateRANSliceOutput> status(true).withResult(oBuilder.build()).build();
 201                 // return error
 202                 return Futures.immediateFuture(rpcResult);
 203
 204         }
 205
 206
 207
 208         //RPC configureRANSliceInstance
 209
 210         @Override
 211         public ListenableFuture<RpcResult<ConfigureRANSliceInstanceOutput>> configureRANSliceInstance(ConfigureRANSliceInstanceInput input) {
 212                 ConfigureRANSliceInstanceInputBuilder iBuilder = new ConfigureRANSliceInstanceInputBuilder(input);
 213                 ConfigureRANSliceInstanceOutputBuilder oBuilder = new ConfigureRANSliceInstanceOutputBuilder();
 214
 215                 try {
 216                         CommonRANSliceFields retval = callDG("configureRANSliceInstance", iBuilder.build());
 217                         oBuilder.setStatus(retval.getStatusBuilder().build());
 218                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 219                 } catch (RANSliceRpcInvocationException e) {
 220                         LOG.debug(exceptionMessage, e);
 221                         oBuilder.setCommonHeader(e.getCommonHeader());
 222                         oBuilder.setStatus(e.getStatus());
 223                 }
 224
 225                 RpcResult<ConfigureRANSliceInstanceOutput> rpcResult =
 226                                 RpcResultBuilder.<ConfigureRANSliceInstanceOutput> status(true).withResult(oBuilder.build()).build();
 227                 // return error
 228                 return Futures.immediateFuture(rpcResult);
 229
 230         }
 231
 232         //RPC configureCU
 233
 234         @Override
 235         public ListenableFuture<RpcResult<ConfigureCUOutput>> configureCU(ConfigureCUInput input) {
 236                 ConfigureCUInputBuilder iBuilder = new ConfigureCUInputBuilder(input);
 237                 ConfigureCUOutputBuilder oBuilder = new ConfigureCUOutputBuilder();
 238
 239                 try {
 240                         CommonRANSliceFields retval = callDG("configureCU", iBuilder.build());
 241                         oBuilder.setStatus(retval.getStatusBuilder().build());
 242                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 243                 } catch (RANSliceRpcInvocationException e) {
 244                         LOG.debug(exceptionMessage, e);
 245                         oBuilder.setCommonHeader(e.getCommonHeader());
 246                         oBuilder.setStatus(e.getStatus());
 247                 }
 248
 249                 RpcResult<ConfigureCUOutput> rpcResult =
 250                                 RpcResultBuilder.<ConfigureCUOutput> status(true).withResult(oBuilder.build()).build();
 251                 // return error
 252                 return Futures.immediateFuture(rpcResult);
 253
 254         }
 255
 256         //RPC configureDU
 257
 258         @Override
 259         public ListenableFuture<RpcResult<ConfigureDUOutput>> configureDU(ConfigureDUInput input) {
 260                 ConfigureDUInputBuilder iBuilder = new ConfigureDUInputBuilder(input);
 261                 ConfigureDUOutputBuilder oBuilder = new ConfigureDUOutputBuilder();
 262
 263                 try {
 264                         CommonRANSliceFields retval = callDG("configureDU", iBuilder.build());
 265                         oBuilder.setStatus(retval.getStatusBuilder().build());
 266                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 267                 } catch (RANSliceRpcInvocationException e) {
 268                         LOG.debug(exceptionMessage, e);
 269                         oBuilder.setCommonHeader(e.getCommonHeader());
 270                         oBuilder.setStatus(e.getStatus());
 271                 }
 272
 273                 RpcResult<ConfigureDUOutput> rpcResult =
 274                                 RpcResultBuilder.<ConfigureDUOutput> status(true).withResult(oBuilder.build()).build();
 275                 // return error
 276                 return Futures.immediateFuture(rpcResult);
 277
 278         }
 279
 280         //RPC activateRANSliceInstance
 281
 282         @Override
 283         public ListenableFuture<RpcResult<ActivateRANSliceInstanceOutput>> activateRANSliceInstance(ActivateRANSliceInstanceInput input) {
 284                 ActivateRANSliceInstanceInputBuilder iBuilder = new ActivateRANSliceInstanceInputBuilder(input);
 285                 ActivateRANSliceInstanceOutputBuilder oBuilder = new ActivateRANSliceInstanceOutputBuilder();
 286
 287                 try {
 288                         CommonRANSliceFields retval = callDG("activateRANSliceInstance", iBuilder.build());
 289                         oBuilder.setStatus(retval.getStatusBuilder().build());
 290                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 291                 } catch (RANSliceRpcInvocationException e) {
 292                         LOG.debug(exceptionMessage, e);
 293                         oBuilder.setCommonHeader(e.getCommonHeader());
 294                         oBuilder.setStatus(e.getStatus());
 295                 }
 296
 297                 RpcResult<ActivateRANSliceInstanceOutput> rpcResult =
 298                                 RpcResultBuilder.<ActivateRANSliceInstanceOutput> status(true).withResult(oBuilder.build()).build();
 299                 // return error
 300                 return Futures.immediateFuture(rpcResult);
 301
 302         }
 303
 304
 305         //RPC deactivateRANSliceInstance
 306
 307         @Override
 308         public ListenableFuture<RpcResult<DeactivateRANSliceInstanceOutput>> deactivateRANSliceInstance(DeactivateRANSliceInstanceInput input) {
 309                 DeactivateRANSliceInstanceInputBuilder iBuilder = new DeactivateRANSliceInstanceInputBuilder(input);
 310                 DeactivateRANSliceInstanceOutputBuilder oBuilder = new DeactivateRANSliceInstanceOutputBuilder();
 311
 312                 try {
 313                         CommonRANSliceFields retval = callDG("deactivateRANSliceInstance", iBuilder.build());
 314                         oBuilder.setStatus(retval.getStatusBuilder().build());
 315                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 316                 } catch (RANSliceRpcInvocationException e) {
 317                         LOG.debug(exceptionMessage, e);
 318                         oBuilder.setCommonHeader(e.getCommonHeader());
 319                         oBuilder.setStatus(e.getStatus());
 320                 }
 321
 322                 RpcResult<DeactivateRANSliceInstanceOutput> rpcResult =
 323                                 RpcResultBuilder.<DeactivateRANSliceInstanceOutput> status(true).withResult(oBuilder.build()).build();
 324                 // return error
 325                 return Futures.immediateFuture(rpcResult);
 326
 327         }
 328
 329         //RPC terminateRANSliceInstance
 330
 331         @Override
 332         public ListenableFuture<RpcResult<TerminateRANSliceInstanceOutput>> terminateRANSliceInstance(TerminateRANSliceInstanceInput input) {
 333                 TerminateRANSliceInstanceInputBuilder iBuilder = new TerminateRANSliceInstanceInputBuilder(input);
 334                 TerminateRANSliceInstanceOutputBuilder oBuilder = new TerminateRANSliceInstanceOutputBuilder();
 335
 336                 try {
 337                         CommonRANSliceFields retval = callDG("terminateRANSliceInstance", iBuilder.build());
 338                         oBuilder.setStatus(retval.getStatusBuilder().build());
 339                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 340                 } catch (RANSliceRpcInvocationException e) {
 341                         LOG.debug(exceptionMessage, e);
 342                         oBuilder.setCommonHeader(e.getCommonHeader());
 343                         oBuilder.setStatus(e.getStatus());
 344                 }
 345
 346                 RpcResult<TerminateRANSliceInstanceOutput> rpcResult =
 347                                 RpcResultBuilder.<TerminateRANSliceInstanceOutput> status(true).withResult(oBuilder.build()).build();
 348                 // return error
 349                 return Futures.immediateFuture(rpcResult);
 350
 351         }
 352
 353         //RPC determineRANSliceResources
 354
 355         @Override
 356         public ListenableFuture<RpcResult<DetermineRANSliceResourcesOutput>> determineRANSliceResources(DetermineRANSliceResourcesInput input) {
 357                 DetermineRANSliceResourcesInputBuilder iBuilder = new DetermineRANSliceResourcesInputBuilder(input);
 358                 DetermineRANSliceResourcesOutputBuilder oBuilder = new DetermineRANSliceResourcesOutputBuilder();
 359
 360                 try {
 361                         CommonRANSliceFields retval = callDG("determineRANSliceResources", iBuilder.build());
 362                         oBuilder.setStatus(retval.getStatusBuilder().build());
 363                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 364                 } catch (RANSliceRpcInvocationException e) {
 365                         LOG.debug(exceptionMessage, e);
 366                         oBuilder.setCommonHeader(e.getCommonHeader());
 367                         oBuilder.setStatus(e.getStatus());
 368                 }
 369
 370                 RpcResult<DetermineRANSliceResourcesOutput> rpcResult =
 371                                 RpcResultBuilder.<DetermineRANSliceResourcesOutput> status(true).withResult(oBuilder.build()).build();
 372                 // return error
 373                 return Futures.immediateFuture(rpcResult);
 374
 375         }
 376
 377         //RPC cm-notify
 378
 379         @Override
 380         public ListenableFuture<RpcResult<ConfigNotificationOutput>> configNotification(ConfigNotificationInput input) {
 381
 382                 ConfigNotificationInputBuilder iBuilder = new ConfigNotificationInputBuilder(input);
 383                 ConfigNotificationOutputBuilder oBuilder = new ConfigNotificationOutputBuilder();
 384
 385                 try {
 386                         CommonRANSliceFields retval = callDG("configNotification", iBuilder.build());
 387                         oBuilder.setStatus(retval.getStatusBuilder().build());
 388                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 389                 } catch (RANSliceRpcInvocationException e) {
 390                         LOG.debug(exceptionMessage, e);
 391                         oBuilder.setCommonHeader(e.getCommonHeader());
 392                         oBuilder.setStatus(e.getStatus());
 393                 }
 394
 395                 RpcResult<ConfigNotificationOutput> rpcResult =
 396                                 RpcResultBuilder.<ConfigNotificationOutput> status(true).withResult(oBuilder.build()).build();
 397                 // return error
 398                 return Futures.immediateFuture(rpcResult);
 399
 400         }
 401
 402
 403         private CommonRANSliceFields callDG(String rpcName, Object input) throws RANSliceRpcInvocationException {
 404
 405                 StatusBuilder statusBuilder = new StatusBuilder();
 406
 407                 if (input == null) {
 408                         LOG.debug("Rejecting " +rpcName+ " because of invalid input");
 409                         statusBuilder.setCode(Uint16.valueOf(RANSliceResponseCode.REJECT_INVALID_INPUT.getValue()));
 410                         statusBuilder.setMessage("REJECT - INVALID INPUT.  Missing input");
 411                         CommonHeaderBuilder hBuilder = new CommonHeaderBuilder();
 412                         hBuilder.setApiVer("1");
 413                         hBuilder.setOriginatorId("unknown");
 414                         hBuilder.setRequestId("unset");
 415                         hBuilder.setTimestamp(new ZULU(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").format(new Date())));
 416                         throw new RANSliceRpcInvocationException(statusBuilder.build(), hBuilder.build());
 417                 }
 418
 419                 CommonHeaderBuilder hBuilder = new CommonHeaderBuilder(((CommonHeader)input).getCommonHeader());
 420
 421                 // add input to parms
 422                 LOG.info("Adding INPUT data for "+ rpcName +" input: " + input.toString());
 423                 Properties inputProps = new Properties();
 424                 MdsalHelper.toProperties(inputProps, input);
 425
 426                 LOG.info("Printing SLI parameters to be passed");
 427
 428         // iterate properties file to get key-value pairs
 429                 for (String key : inputProps.stringPropertyNames()) {
 430                         String value = inputProps.getProperty(key);
 431                         LOG.info("The SLI parameter in " + key + " is: " + value);
 432                 }
 433
 434                 Properties respProps = new Properties();
 435
 436                 // Call SLI sync method
 437                 try
 438                 {
 439                         if (RANSliceClient.hasGraph("ran-slice-api", rpcName , null, "sync"))
 440                         {
 441                                 try
 442                                 {
 443                                         respProps = RANSliceClient.execute("ran-slice-api", rpcName, null, "sync", inputProps, domDataBroker);
 444                                 }
 445                                 catch (Exception e)
 446                                 {
 447                                         LOG.error("Caught exception executing service logic for "+ rpcName, e);
 448                                         statusBuilder.setCode(Uint16.valueOf(RANSliceResponseCode.FAILURE_DG_FAILURE.getValue()));
 449                                         statusBuilder.setMessage("FAILURE - DG FAILURE ("+e.getMessage()+")");
 450                                         throw new RANSliceRpcInvocationException(statusBuilder.build(), hBuilder.build());
 451                                 }
 452                         } else {
 453                                 LOG.error("No service logic active for RANSlice: '" + rpcName + "'");
 454
 455                                 statusBuilder.setCode(Uint16.valueOf(RANSliceResponseCode.REJECT_DG_NOT_FOUND.getValue()));
 456                                 statusBuilder.setMessage("FAILURE - DG not found for action "+rpcName);
 457                                 throw new RANSliceRpcInvocationException(statusBuilder.build(), hBuilder.build());
 458                         }
 459                 }
 460                 catch (Exception e)
 461                 {
 462                         LOG.error("Caught exception looking for service logic", e);
 463
 464                         statusBuilder.setCode(Uint16.valueOf(RANSliceResponseCode.FAILURE_DG_FAILURE.getValue()));
 465                         statusBuilder.setMessage("FAILURE - Unexpected error looking for DG ("+e.getMessage()+")");
 466                         throw new RANSliceRpcInvocationException(statusBuilder.build(), hBuilder.build());
 467                 }
 468
 469
 470                 StatusBuilder sBuilder = new StatusBuilder();
 471                 MdsalHelper.toBuilder(respProps, sBuilder);
 472                 MdsalHelper.toBuilder(respProps, hBuilder);
 473
 474                 Payload payload = null;
 475                 String payloadValue = respProps.getProperty("payload");
 476                 if (payloadValue != null) {
 477                         payload = new Payload(payloadValue);
 478                 }
 479
 480                 String statusCode = sBuilder.getCode().toString();
 481
 482                 if (!"400".equals(statusCode)) {
 483                         LOG.error("Returned FAILED for "+rpcName+" error code: '" + statusCode + "'");
 484                 } else {
 485                         LOG.info("Returned SUCCESS for "+rpcName+" ");
 486                 }
 487
 488                 return new CommonRANSliceFields(sBuilder, hBuilder, payload);
 489
 490         }
 491
 492 }