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