appc-provider/appc-provider-bundle/src/main/java/org/onap/appc/provider/AppcProviderLcm.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * ================================================================================
   9  * Modifications Copyright (C) 2018-2019 Orange
  10  * ================================================================================
  11  * Modifications Copyright (C) 2019 Ericsson
  12  * =============================================================================
  13  * Licensed under the Apache License, Version 2.0 (the "License");
  14  * you may not use this file except in compliance with the License.
  15  * You may obtain a copy of the License at
  16  *
  17  *      http://www.apache.org/licenses/LICENSE-2.0
  18  *
  19  * Unless required by applicable law or agreed to in writing, software
  20  * distributed under the License is distributed on an "AS IS" BASIS,
  21  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22  * See the License for the specific language governing permissions and
  23  * limitations under the License.
  24  *
  25  * ============LICENSE_END=========================================================
  26  */
  27
  28 package org.onap.appc.provider;
  29
  30 import java.text.ParseException;
  31 import java.util.concurrent.ExecutorService;
  32 import java.util.concurrent.Executors;
  33 import org.onap.appc.Constants;
  34 import org.onap.appc.configuration.Configuration;
  35 import org.onap.appc.configuration.ConfigurationFactory;
  36 import org.onap.appc.i18n.Msg;
  37 import org.onap.appc.logging.LoggingConstants;
  38 import org.onap.appc.logging.LoggingUtils;
  39 import org.onap.appc.provider.lcm.service.AbstractBaseUtils;
  40 import org.onap.appc.provider.lcm.service.ActionStatusService;
  41 import org.onap.appc.provider.lcm.service.QueryService;
  42 import org.onap.appc.provider.lcm.service.QuiesceTrafficService;
  43 import org.onap.appc.provider.lcm.service.RebootService;
  44 import org.onap.appc.provider.lcm.service.RequestExecutor;
  45 import org.onap.appc.provider.lcm.service.ResumeTrafficService;
  46 import org.onap.appc.provider.lcm.service.UpgradeService;
  47 import org.onap.appc.provider.lcm.service.VolumeService;
  48 import org.onap.appc.provider.lcm.service.ConfigScaleOutService;
  49 import org.onap.appc.provider.lcm.service.PreConfigure;
  50 import org.onap.appc.provider.lcm.service.PreRebuild;
  51 import org.onap.appc.provider.lcm.service.GetConfigService;
  52 import org.onap.appc.provider.lcm.service.PostRebuild;
  53 import org.onap.appc.provider.lcm.service.PostEvacuateService;
  54 import org.onap.appc.provider.lcm.service.PreMigrateService;
  55 import org.onap.appc.provider.lcm.service.PostMigrateService;
  56 import org.onap.appc.provider.lcm.service.DistributeTrafficService;
  57 import org.onap.appc.provider.lcm.service.DistributeTrafficCheckService;
  58 import org.onap.appc.provider.lcm.service.PreEvacuate;
  59 import org.onap.appc.provider.lcm.service.ProvisioningService;
  60 import org.onap.appc.provider.lcm.service.LicenseManagementService;
  61 import org.onap.appc.provider.lcm.service.StartTraffic;
  62 import org.onap.appc.provider.lcm.service.StatusTraffic;
  63 import org.onap.appc.provider.lcm.service.StopTraffic;
  64 import org.onap.appc.provider.lcm.service.ConfigScaleInService;
  65 import org.onap.appc.provider.lcm.service.DownloadNESw;
  66 import org.onap.appc.provider.lcm.service.ActivateNESw;
  67 import org.onap.appc.provider.lcm.util.RequestInputBuilder;
  68 import org.onap.appc.provider.lcm.util.ValidationService;
  69 import org.onap.appc.requesthandler.objects.RequestHandlerInput;
  70 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
  71 import org.opendaylight.mdsal.binding.api.DataBroker;
  72 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  73 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  74 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
  76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
  77 import org.opendaylight.yangtools.yang.common.RpcResult;
  78 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  79 import com.att.eelf.configuration.EELFLogger;
  80 import com.att.eelf.configuration.EELFManager;
  81 import com.google.common.util.concurrent.Futures;
  82 import com.google.common.util.concurrent.ListenableFuture;
  83
  84
  85 public class AppcProviderLcm extends AbstractBaseUtils implements AutoCloseable, AppcProviderLcmService {
  86
  87     private Configuration configuration = ConfigurationFactory.getConfiguration();
  88     private final EELFLogger logger = EELFManager.getInstance().getLogger(AppcProviderLcm.class);
  89
  90     private final ExecutorService executor;
  91
  92     /**
  93      * The ODL data store broker. Provides access to a conceptual data tree store and also provides the ability to
  94      * subscribe for changes to data under a given branch of the tree.
  95      */
  96     protected DataBroker dataBroker;
  97
  98     /**
  99      * ODL Notification Service that provides publish/subscribe capabilities for YANG modeled notifications.
 100      */
 101     protected NotificationPublishService notificationService;
 102
 103     /**
 104      * Provides a registry for Remote Procedure Call (RPC) service implementations. The RPCs are defined in YANG models.
 105      */
 106     protected RpcProviderRegistry rpcRegistry;
 107
 108     /**
 109      * Represents our RPC implementation registration
 110      */
 111     protected BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
 112
 113
 114     /**
 115      * @param dataBroker
 116      * @param notificationProviderService
 117      * @param rpcProviderRegistry
 118      */
 119     @SuppressWarnings({"javadoc", "nls"})
 120     public AppcProviderLcm(DataBroker dataBroker, NotificationPublishService notificationProviderService,
 121             RpcProviderRegistry rpcProviderRegistry) {
 122
 123         String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
 124         logger.info(Msg.COMPONENT_INITIALIZING, appName, "provider-lcm");
 125
 126         executor = Executors.newFixedThreadPool(1);
 127         this.dataBroker = dataBroker;
 128         this.notificationService = notificationProviderService;
 129         this.rpcRegistry = rpcProviderRegistry;
 130
 131         if (this.rpcRegistry != null) {
 132             rpcRegistration = rpcRegistry.addRpcImplementation(AppcProviderLcmService.class, this);
 133         }
 134         logger.info(Msg.COMPONENT_INITIALIZED, appName, "provider");
 135     }
 136
 137     /**
 138      * Implements the close of the service
 139      *
 140      * @see java.lang.AutoCloseable#close()
 141      */
 142     @SuppressWarnings("nls")
 143     @Override
 144     public void close() throws Exception {
 145         String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
 146         logger.info(Msg.COMPONENT_TERMINATING, appName, "provider");
 147         executor.shutdown();
 148         if (rpcRegistration != null) {
 149             rpcRegistration.close();
 150         }
 151         logger.info(Msg.COMPONENT_TERMINATED, appName, "provider");
 152     }
 153
 154
 155     /**
 156      * Rebuilds a specific VNF
 157      *
 158      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#rebuild(RebuildInput)
 159      */
 160     @Override
 161     public ListenableFuture<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
 162         logger.debug("Input received : " + input.toString());
 163
 164         RebuildOutputBuilder outputBuilder = new RebuildOutputBuilder();
 165         String action = Action.Rebuild.toString();
 166         String rpcName = Action.Rebuild.name().toLowerCase();
 167         Status status =
 168                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 169         if (null == status) {
 170             try {
 171                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 172                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 173                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 174                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 175                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 176                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 177             } catch (ParseException e) {
 178                 status = buildStatusWithParseException(e);
 179
 180                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 181                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 182                         this.getClass().getName());
 183
 184             }
 185         }
 186         outputBuilder.setCommonHeader(input.getCommonHeader());
 187         outputBuilder.setStatus(status);
 188         RpcResult<RebuildOutput> result =
 189                 RpcResultBuilder.<RebuildOutput>status(true).withResult(outputBuilder.build()).build();
 190         return Futures.immediateFuture(result);
 191
 192     }
 193
 194
 195     /**
 196      * Restarts a specific VNF
 197      *
 198      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#restart(RestartInput)
 199      */
 200     @Override
 201     public ListenableFuture<RpcResult<RestartOutput>> restart(RestartInput input) {
 202         logger.debug("Input received : " + input.toString());
 203
 204         RestartOutputBuilder outputBuilder = new RestartOutputBuilder();
 205         String action = Action.Restart.toString();
 206         String rpcName = Action.Restart.name().toLowerCase();
 207         Status status =
 208                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 209         if (null == status) {
 210             try {
 211                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 212                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 213                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 214
 215                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 216                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 217                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 218             } catch (ParseException e) {
 219                 status = buildStatusWithParseException(e);
 220
 221                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 222                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 223                         this.getClass().getName());
 224
 225             }
 226         }
 227         outputBuilder.setCommonHeader(input.getCommonHeader());
 228         outputBuilder.setStatus(status);
 229         RpcResult<RestartOutput> result =
 230                 RpcResultBuilder.<RestartOutput>status(true).withResult(outputBuilder.build()).build();
 231         return Futures.immediateFuture(result);
 232     }
 233
 234     /**
 235      * Start Application
 236      *
 237      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#startApplication(StartApplicationInput)
 238      */
 239     @Override
 240     public ListenableFuture<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
 241         logger.debug("Input received : " + input.toString());
 242
 243         StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
 244         String action = Action.StartApplication.toString();
 245         String rpcName = Action.StartApplication.name().toLowerCase();
 246         Status status =
 247                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 248         if (null == status) {
 249             try {
 250                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 251                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 252                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 253
 254                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 255                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 256                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 257             } catch (ParseException e) {
 258                 status = buildStatusWithParseException(e);
 259
 260                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 261                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 262                         this.getClass().getName());
 263
 264             }
 265         }
 266         outputBuilder.setCommonHeader(input.getCommonHeader());
 267         outputBuilder.setStatus(status);
 268         RpcResult<StartApplicationOutput> result =
 269                 RpcResultBuilder.<StartApplicationOutput>status(true).withResult(outputBuilder.build()).build();
 270         return Futures.immediateFuture(result);
 271     }
 272
 273     /**
 274      * Migrates a specific VNF
 275      *
 276      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#migrate(MigrateInput)
 277      */
 278     @Override
 279     public ListenableFuture<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
 280         logger.debug("Input received : " + input.toString());
 281
 282         MigrateOutputBuilder outputBuilder = new MigrateOutputBuilder();
 283         String action = Action.Migrate.toString();
 284         String rpcName = Action.Migrate.name().toLowerCase();
 285         Status status =
 286                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 287         if (null == status) {
 288             try {
 289                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 290                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 291                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 292                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 293                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 294                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 295             } catch (ParseException e) {
 296                 status = buildStatusWithParseException(e);
 297
 298                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 299                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 300                         this.getClass().getName());
 301
 302             }
 303         }
 304         outputBuilder.setCommonHeader(input.getCommonHeader());
 305         outputBuilder.setStatus(status);
 306         RpcResult<MigrateOutput> result =
 307                 RpcResultBuilder.<MigrateOutput>status(true).withResult(outputBuilder.build()).build();
 308         return Futures.immediateFuture(result);
 309     }
 310
 311
 312     /**
 313      * Evacuates a specific VNF
 314      *
 315      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#evacuate(EvacuateInput)
 316      */
 317     @Override
 318     public ListenableFuture<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
 319         logger.debug("Input received : " + input.toString());
 320
 321         EvacuateOutputBuilder outputBuilder = new EvacuateOutputBuilder();
 322         String action = Action.Evacuate.toString();
 323         String rpcName = Action.Evacuate.name().toLowerCase();
 324         Status status =
 325                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 326         if (null == status) {
 327             try {
 328                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 329                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 330                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 331                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 332                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 333                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 334             } catch (ParseException e) {
 335                 status = buildStatusWithParseException(e);
 336
 337                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 338                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 339                         this.getClass().getName());
 340
 341             }
 342         }
 343         outputBuilder.setCommonHeader(input.getCommonHeader());
 344         outputBuilder.setStatus(status);
 345         RpcResult<EvacuateOutput> result =
 346                 RpcResultBuilder.<EvacuateOutput>status(true).withResult(outputBuilder.build()).build();
 347         return Futures.immediateFuture(result);
 348     }
 349
 350
 351     /**
 352      * Evacuates a specific VNF
 353      *
 354      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#snapshot(SnapshotInput)
 355      */
 356     @Override
 357     public ListenableFuture<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
 358         logger.debug("Input received : " + input.toString());
 359
 360         SnapshotOutputBuilder outputBuilder = new SnapshotOutputBuilder();
 361         String action = Action.Snapshot.toString();
 362         String rpcName = Action.Snapshot.name().toLowerCase();
 363         Status status =
 364                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 365         String identityUrl = input.getIdentityUrl();
 366         if (null == status) {
 367             try {
 368                 RequestHandlerInput request =
 369                         new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader())
 370                                 .actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload())
 371                                 .action(action).rpcName(rpcName).additionalContext("identity-url", identityUrl).build();
 372                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 373                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 374                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 375             } catch (ParseException e) {
 376                 status = buildStatusWithParseException(e);
 377
 378                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 379                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 380                         this.getClass().getName());
 381             }
 382         }
 383         outputBuilder.setCommonHeader(input.getCommonHeader());
 384         outputBuilder.setStatus(status);
 385         RpcResult<SnapshotOutput> result =
 386                 RpcResultBuilder.<SnapshotOutput>status(true).withResult(outputBuilder.build()).build();
 387         return Futures.immediateFuture(result);
 388     }
 389
 390     @Override
 391     public ListenableFuture<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
 392         logger.debug("Input received : " + input.toString());
 393
 394         RollbackOutputBuilder outputBuilder = new RollbackOutputBuilder();
 395         String rpcName = Action.Rollback.toString();
 396         Status status =
 397                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), rpcName);
 398         String identityUrl = input.getIdentityUrl();
 399         String snapshotId = input.getSnapshotId();
 400         if (null == status) {
 401             try {
 402                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 403                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 404                         .payload(input.getPayload()).additionalContext("identity-url", identityUrl)
 405                         .additionalContext("snapshot-id", snapshotId).action(rpcName).build();
 406                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 407                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 408                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 409             } catch (ParseException e) {
 410                 status = buildStatusWithParseException(e);
 411
 412                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 413                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, rpcName, e.getMessage()),
 414                         this.getClass().getName());
 415
 416             }
 417         }
 418         outputBuilder.setCommonHeader(input.getCommonHeader());
 419         outputBuilder.setStatus(status);
 420         RpcResult<RollbackOutput> result =
 421                 RpcResultBuilder.<RollbackOutput>status(true).withResult(outputBuilder.build()).build();
 422         return Futures.immediateFuture(result);
 423     }
 424
 425     @Override
 426     public ListenableFuture<RpcResult<SyncOutput>> sync(SyncInput input) {
 427         logger.debug("Input received : " + input.toString());
 428         SyncOutputBuilder outputBuilder = new SyncOutputBuilder();
 429         String action = Action.Sync.toString();
 430         String rpcName = Action.Sync.name().toLowerCase();
 431         Status status =
 432                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 433         if (null == status) {
 434             try {
 435                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 436                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 437                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 438                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 439                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 440                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 441             } catch (ParseException e) {
 442                 status = buildStatusWithParseException(e);
 443
 444                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 445                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 446                         this.getClass().getName());
 447
 448             }
 449         }
 450         outputBuilder.setCommonHeader(input.getCommonHeader());
 451         outputBuilder.setStatus(status);
 452         RpcResult<SyncOutput> result =
 453                 RpcResultBuilder.<SyncOutput>status(true).withResult(outputBuilder.build()).build();
 454         return Futures.immediateFuture(result);
 455     }
 456
 457     @Override
 458     public ListenableFuture<RpcResult<QueryOutput>> query(QueryInput input) {
 459         logger.debug(String.format("LCM query received input: %s", input.toString()));
 460         QueryOutputBuilder outputBuilder = new QueryService().process(input);
 461         RpcResult<QueryOutput> result =
 462                 RpcResultBuilder.<QueryOutput>status(true).withResult(outputBuilder.build()).build();
 463         return Futures.immediateFuture(result);
 464     }
 465
 466     @Override
 467     public ListenableFuture<RpcResult<RebootOutput>> reboot(RebootInput input) {
 468         logger.debug(String.format("LCM reboot received input: %s", input.toString()));
 469         RebootOutputBuilder outputBuilder = new RebootService().reboot(input);
 470         RpcResult<RebootOutput> result =
 471                 RpcResultBuilder.<RebootOutput>status(true).withResult(outputBuilder.build()).build();
 472         return Futures.immediateFuture(result);
 473     }
 474
 475     @Override
 476     public ListenableFuture<RpcResult<AttachVolumeOutput>> attachVolume(AttachVolumeInput input) {
 477         logger.debug(String.format("LCM attachVolume received input: %s", input.toString()));
 478         AttachVolumeOutputBuilder outputBuilder = new VolumeService(true).attachVolume(input);
 479         RpcResult<AttachVolumeOutput> result =
 480                 RpcResultBuilder.<AttachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
 481         return Futures.immediateFuture(result);
 482     }
 483
 484     @Override
 485     public ListenableFuture<RpcResult<DetachVolumeOutput>> detachVolume(DetachVolumeInput input) {
 486         logger.debug(String.format("LCM detachVolume received input: %s", input.toString()));
 487         DetachVolumeOutputBuilder outputBuilder = new VolumeService(false).detachVolume(input);
 488         RpcResult<DetachVolumeOutput> result =
 489                 RpcResultBuilder.<DetachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
 490         return Futures.immediateFuture(result);
 491     }
 492
 493     @Override
 494     public ListenableFuture<RpcResult<QuiesceTrafficOutput>> quiesceTraffic(QuiesceTrafficInput input) {
 495         logger.debug(String.format("LCM quiesce received input: %s", input.toString()));
 496         QuiesceTrafficOutputBuilder outputBuilder = new QuiesceTrafficService().process(input);
 497         RpcResult<QuiesceTrafficOutput> result =
 498                 RpcResultBuilder.<QuiesceTrafficOutput>status(true).withResult(outputBuilder.build()).build();
 499         return Futures.immediateFuture(result);
 500     }
 501
 502     @Override
 503     public ListenableFuture<RpcResult<ResumeTrafficOutput>> resumeTraffic(ResumeTrafficInput input) {
 504         logger.debug(String.format("LCM resume received input: %s", input.toString()));
 505         ResumeTrafficOutputBuilder outputBuilder = new ResumeTrafficService().process(input);
 506         RpcResult<ResumeTrafficOutput> result =
 507                 RpcResultBuilder.<ResumeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
 508         return Futures.immediateFuture(result);
 509     }
 510
 511     @Override
 512     public ListenableFuture<RpcResult<DistributeTrafficOutput>> distributeTraffic(DistributeTrafficInput input) {
 513         logger.debug(String.format("LCM DistributeTraffic, received input: %s", input.toString()));
 514         DistributeTrafficOutputBuilder outputBuilder = new DistributeTrafficService().process(input);
 515         RpcResult<DistributeTrafficOutput> result =
 516                 RpcResultBuilder.<DistributeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
 517         return Futures.immediateFuture(result);
 518     }
 519
 520     @Override
 521     public ListenableFuture<RpcResult<DistributeTrafficCheckOutput>> distributeTrafficCheck(DistributeTrafficCheckInput input) {
 522         logger.debug(String.format("LCM DistributeTrafficCheck, received input: %s", input.toString()));
 523         DistributeTrafficCheckOutputBuilder outputBuilder = new DistributeTrafficCheckService().process(input);
 524         RpcResult<DistributeTrafficCheckOutput> result =
 525                 RpcResultBuilder.<DistributeTrafficCheckOutput>status(true).withResult(outputBuilder.build()).build();
 526         return Futures.immediateFuture(result);
 527     }
 528
 529     @Override
 530     public ListenableFuture<RpcResult<UpgradePreCheckOutput>> upgradePreCheck(UpgradePreCheckInput input) {
 531         logger.debug(String.format("LCM upgradeprecheck received input: %s", input.toString()));
 532         UpgradePreCheckOutputBuilder outputBuilder = new UpgradeService("upgradePre").upgradePreCheck(input);
 533         RpcResult<UpgradePreCheckOutput> result =
 534                 RpcResultBuilder.<UpgradePreCheckOutput>status(true).withResult(outputBuilder.build()).build();
 535         return Futures.immediateFuture(result);
 536     }
 537
 538     @Override
 539     public ListenableFuture<RpcResult<UpgradeSoftwareOutput>> upgradeSoftware(UpgradeSoftwareInput input) {
 540         logger.debug(String.format("LCM upgradesoftware received input: %s", input.toString()));
 541         UpgradeSoftwareOutputBuilder outputBuilder = new UpgradeService("upgradeSoft").upgradeSoftware(input);
 542         RpcResult<UpgradeSoftwareOutput> result =
 543                 RpcResultBuilder.<UpgradeSoftwareOutput>status(true).withResult(outputBuilder.build()).build();
 544         return Futures.immediateFuture(result);
 545     }
 546
 547     @Override
 548     public ListenableFuture<RpcResult<UpgradePostCheckOutput>> upgradePostCheck(UpgradePostCheckInput input) {
 549         logger.debug(String.format("LCM upgradepostcheck received input: %s", input.toString()));
 550         UpgradePostCheckOutputBuilder outputBuilder = new UpgradeService("upgradePost").upgradePostCheck(input);
 551         RpcResult<UpgradePostCheckOutput> result =
 552                 RpcResultBuilder.<UpgradePostCheckOutput>status(true).withResult(outputBuilder.build()).build();
 553         return Futures.immediateFuture(result);
 554     }
 555
 556     @Override
 557     public ListenableFuture<RpcResult<UpgradeBackupOutput>> upgradeBackup(UpgradeBackupInput input) {
 558         logger.debug(String.format("LCM backup received input: %s", input.toString()));
 559         UpgradeBackupOutputBuilder outputBuilder = new UpgradeService("upgradeBackup").upgradeBackup(input);
 560         RpcResult<UpgradeBackupOutput> result =
 561                 RpcResultBuilder.<UpgradeBackupOutput>status(true).withResult(outputBuilder.build()).build();
 562         return Futures.immediateFuture(result);
 563     }
 564
 565     @Override
 566     public ListenableFuture<RpcResult<UpgradeBackoutOutput>> upgradeBackout(UpgradeBackoutInput input) {
 567         logger.debug(String.format("LCM backout received input: %s", input.toString()));
 568         UpgradeBackoutOutputBuilder outputBuilder = new UpgradeService("upgradeBackout").upgradeBackout(input);
 569         RpcResult<UpgradeBackoutOutput> result =
 570                 RpcResultBuilder.<UpgradeBackoutOutput>status(true).withResult(outputBuilder.build()).build();
 571         return Futures.immediateFuture(result);
 572     }
 573
 574     @Override
 575     public ListenableFuture<RpcResult<PreConfigureOutput>> preConfigure(PreConfigureInput input) {
 576         logger.debug(String.format("LCM PreConfigure received input: %s", input.toString()));
 577         PreConfigureOutputBuilder outputBuilder = new PreConfigure().process(input);
 578         RpcResult<PreConfigureOutput> result =
 579                 RpcResultBuilder.<PreConfigureOutput>status(true).withResult(outputBuilder.build()).build();
 580         return Futures.immediateFuture(result);
 581     }
 582
 583     @Override
 584     public ListenableFuture<RpcResult<GetConfigOutput>> getConfig(GetConfigInput input) {
 585         logger.debug(String.format("LCM getConfig received input: %s", input.toString()));
 586         GetConfigOutputBuilder outputBuilder = new GetConfigService().process(input);
 587         RpcResult<GetConfigOutput> result =
 588                 RpcResultBuilder.<GetConfigOutput>status(true).withResult(outputBuilder.build()).build();
 589         return Futures.immediateFuture(result);
 590     }
 591
 592     @Override
 593     public ListenableFuture<RpcResult<PreRebuildOutput>> preRebuild(PreRebuildInput input) {
 594         logger.debug(String.format("LCM PreRebuild received input: %s", input.toString()));
 595         PreRebuildOutputBuilder outputBuilder = new PreRebuild().process(input);
 596         RpcResult<PreRebuildOutput> result =
 597                 RpcResultBuilder.<PreRebuildOutput>status(true).withResult(outputBuilder.build()).build();
 598         return Futures.immediateFuture(result);
 599     }
 600
 601     @Override
 602     public ListenableFuture<RpcResult<PostRebuildOutput>> postRebuild(PostRebuildInput input) {
 603         logger.debug(String.format("LCM PostRebuild received input: %s", input.toString()));
 604         PostRebuildOutputBuilder outputBuilder = new PostRebuild().process(input);
 605         RpcResult<PostRebuildOutput> result =
 606                 RpcResultBuilder.<PostRebuildOutput>status(true).withResult(outputBuilder.build()).build();
 607         return Futures.immediateFuture(result);
 608     }
 609
 610     @Override
 611     public ListenableFuture<RpcResult<PreEvacuateOutput>> preEvacuate(PreEvacuateInput input) {
 612         logger.debug(String.format("LCM PreEvacuate received input: %s", input.toString()));
 613         PreEvacuateOutputBuilder outputBuilder = new PreEvacuate().process(input);
 614         RpcResult<PreEvacuateOutput> result =
 615                 RpcResultBuilder.<PreEvacuateOutput>status(true).withResult(outputBuilder.build()).build();
 616         return Futures.immediateFuture(result);
 617     }
 618
 619     @Override
 620     public ListenableFuture<RpcResult<ProvisioningOutput>> provisioning(ProvisioningInput input) {
 621         logger.debug(String.format("LCM ProvisioningService received input: %s", input.toString()));
 622         ProvisioningOutputBuilder outputBuilder = new ProvisioningService().process(input);
 623         RpcResult<ProvisioningOutput> result =
 624                 RpcResultBuilder.<ProvisioningOutput>status(true).withResult(outputBuilder.build()).build();
 625         return Futures.immediateFuture(result);
 626     }
 627
 628  @Override
 629     public ListenableFuture<RpcResult<LicenseManagementOutput>> licenseManagement(LicenseManagementInput input) {
 630         logger.debug(String.format("LCM licensemangementService received input: %s", input.toString()));
 631         LicenseManagementOutputBuilder outputBuilder = new LicenseManagementService().process(input);
 632         RpcResult<LicenseManagementOutput> result =
 633                 RpcResultBuilder.<LicenseManagementOutput>status(true).withResult(outputBuilder.build()).build();
 634         return Futures.immediateFuture(result);
 635     }
 636
 637     @Override
 638     public ListenableFuture<RpcResult<StartTrafficOutput>> startTraffic(StartTrafficInput input) {
 639         logger.debug(String.format("LCM StartTraffic received input: %s", input.toString()));
 640         StartTrafficOutputBuilder outputBuilder = new StartTraffic().process(input);
 641         RpcResult<StartTrafficOutput> result =
 642                 RpcResultBuilder.<StartTrafficOutput>status(true).withResult(outputBuilder.build()).build();
 643         return Futures.immediateFuture(result);
 644     }
 645
 646     @Override
 647     public ListenableFuture<RpcResult<StatusTrafficOutput>> statusTraffic(StatusTrafficInput input) {
 648         logger.debug(String.format("LCM StatusTraffic received input: %s", input.toString()));
 649         StatusTrafficOutputBuilder outputBuilder = new StatusTraffic().process(input);
 650         RpcResult<StatusTrafficOutput> result =
 651                 RpcResultBuilder.<StatusTrafficOutput>status(true).withResult(outputBuilder.build()).build();
 652         return Futures.immediateFuture(result);
 653     }
 654
 655     @Override
 656     public ListenableFuture<RpcResult<StopTrafficOutput>> stopTraffic(StopTrafficInput input) {
 657         logger.debug(String.format("LCM StopTraffic received input: %s", input.toString()));
 658         StopTrafficOutputBuilder outputBuilder = new StopTraffic().process(input);
 659         RpcResult<StopTrafficOutput> result =
 660                 RpcResultBuilder.<StopTrafficOutput>status(true).withResult(outputBuilder.build()).build();
 661         return Futures.immediateFuture(result);
 662     }
 663
 664     @Override
 665     public ListenableFuture<RpcResult<DownloadNESwOutput>> downloadNESw(DownloadNESwInput input) {
 666         logger.debug(String.format("LCM DownloadNESw received input: %s", input.toString()));
 667         DownloadNESwOutputBuilder outputBuilder = new DownloadNESw().process(input);
 668         RpcResult<DownloadNESwOutput> result =
 669                 RpcResultBuilder.<DownloadNESwOutput>status(true).withResult(outputBuilder.build()).build();
 670         return Futures.immediateFuture(result);
 671     }
 672
 673     @Override
 674     public ListenableFuture<RpcResult<ActivateNESwOutput>> activateNESw(ActivateNESwInput input) {
 675         logger.debug(String.format("LCM ActivateNESw received input: %s", input.toString()));
 676         ActivateNESwOutputBuilder outputBuilder = new ActivateNESw().process(input);
 677         RpcResult<ActivateNESwOutput> result =
 678                 RpcResultBuilder.<ActivateNESwOutput>status(true).withResult(outputBuilder.build()).build();
 679         return Futures.immediateFuture(result);
 680     }
 681
 682     @Override
 683     public ListenableFuture<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
 684         logger.debug("Input received : " + input.toString());
 685         TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
 686         Action myAction = Action.Terminate;
 687         String action = myAction.toString();
 688         String rpcName = getRpcName(myAction);
 689         Status status =
 690                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 691         if (null == status) {
 692             try {
 693                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 694                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 695                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 696                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 697                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 698                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 699             } catch (ParseException e) {
 700
 701                 status = buildStatusWithParseException(e);
 702
 703                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 704                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 705                         this.getClass().getName());
 706
 707             }
 708
 709         }
 710         outputBuilder.setCommonHeader(input.getCommonHeader());
 711         outputBuilder.setStatus(status);
 712         RpcResult<TerminateOutput> result =
 713                 RpcResultBuilder.<TerminateOutput>status(true).withResult(outputBuilder.build()).build();
 714         return Futures.immediateFuture(result);
 715     }
 716
 717     @Override
 718     public ListenableFuture<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
 719         logger.debug("Input received : " + input.toString());
 720         ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
 721         Action myAction = Action.Configure;
 722         String action = myAction.toString();
 723         String rpcName = getRpcName(myAction);
 724         Status status =
 725                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 726         if (null == status) {
 727             try {
 728                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 729                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 730                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 731                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 732                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 733                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 734             } catch (ParseException e) {
 735                 status = buildStatusWithParseException(e);
 736
 737                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 738                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 739                         this.getClass().getName());
 740
 741             }
 742         }
 743         outputBuilder.setCommonHeader(input.getCommonHeader());
 744         outputBuilder.setStatus(status);
 745         RpcResult<ConfigureOutput> result =
 746                 RpcResultBuilder.<ConfigureOutput>status(true).withResult(outputBuilder.build()).build();
 747         return Futures.immediateFuture(result);
 748     }
 749
 750     @Override
 751     public ListenableFuture<RpcResult<ActionStatusOutput>> actionStatus(ActionStatusInput input) {
 752         logger.debug(String.format("Input received : %s", input.toString()));
 753         ActionStatusOutputBuilder outputBuilder = (new ActionStatusService()).queryStatus(input);
 754         RpcResult<ActionStatusOutput> result =
 755                 RpcResultBuilder.<ActionStatusOutput>status(true).withResult(outputBuilder.build()).build();
 756         return Futures.immediateFuture(result);
 757     }
 758
 759     @Override
 760     public ListenableFuture<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
 761         logger.debug("Input received : " + input.toString());
 762         ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
 763         Action myAction = Action.ConfigModify;
 764         String action = myAction.toString();
 765         String rpcName = getRpcName(myAction);
 766         Status status =
 767                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 768         if (null == status) {
 769             try {
 770                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 771                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 772                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 773                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 774                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 775                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 776             } catch (ParseException e) {
 777                 status = buildStatusWithParseException(e);
 778
 779                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 780                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 781                         this.getClass().getName());
 782
 783             }
 784         }
 785         outputBuilder.setCommonHeader(input.getCommonHeader());
 786         outputBuilder.setStatus(status);
 787         RpcResult<ConfigModifyOutput> result =
 788                 RpcResultBuilder.<ConfigModifyOutput>status(true).withResult(outputBuilder.build()).build();
 789         return Futures.immediateFuture(result);
 790     }
 791
 792     @Override
 793     public ListenableFuture<RpcResult<ConfigScaleOutOutput>> configScaleOut(ConfigScaleOutInput input) {
 794         logger.debug("Input received : " + input.toString());
 795         ConfigScaleOutOutputBuilder outputBuilder = new ConfigScaleOutService().process(input);
 796         RpcResult<ConfigScaleOutOutput> result = RpcResultBuilder.<ConfigScaleOutOutput> status(true).withResult(outputBuilder.build()).build();
 797         return Futures.immediateFuture(result);
 798     }
 799
 800     @Override
 801     public ListenableFuture<RpcResult<ConfigScaleInOutput>> configScaleIn(ConfigScaleInInput input) {
 802         logger.debug("Input received : " + input.toString());
 803         ConfigScaleInOutputBuilder outputBuilder = new ConfigScaleInService().process(input);
 804         RpcResult<ConfigScaleInOutput> result = RpcResultBuilder.<ConfigScaleInOutput> status(true).withResult(outputBuilder.build()).build();
 805         return Futures.immediateFuture(result);
 806     }
 807
 808     @Override
 809     public ListenableFuture<RpcResult<PostEvacuateOutput>> postEvacuate(PostEvacuateInput input) {
 810         logger.debug("Input received : " + input.toString());
 811         PostEvacuateOutputBuilder outputBuilder = new PostEvacuateService().process(input);
 812         RpcResult<PostEvacuateOutput> result = RpcResultBuilder.<PostEvacuateOutput> status(true).withResult(outputBuilder.build()).build();
 813         return Futures.immediateFuture(result);
 814     }
 815
 816    @Override
 817     public ListenableFuture<RpcResult<PreMigrateOutput>> preMigrate(PreMigrateInput input) {
 818         logger.debug("Input received : " + input.toString());
 819         PreMigrateOutputBuilder outputBuilder = new PreMigrateService().process(input);
 820         RpcResult<PreMigrateOutput> result = RpcResultBuilder.<PreMigrateOutput> status(true).withResult(outputBuilder.build()).build();
 821         return Futures.immediateFuture(result);
 822     }
 823
 824     @Override
 825     public ListenableFuture<RpcResult<PostMigrateOutput>> postMigrate(PostMigrateInput input) {
 826         logger.debug("Input received : " + input.toString());
 827         PostMigrateOutputBuilder outputBuilder = new PostMigrateService().process(input);
 828         RpcResult<PostMigrateOutput> result = RpcResultBuilder.<PostMigrateOutput> status(true).withResult(outputBuilder.build()).build();
 829         return Futures.immediateFuture(result);
 830     }
 831
 832     @Override
 833     public ListenableFuture<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
 834         logger.debug("Input received : " + input.toString());
 835         ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
 836         Action myAction = Action.ConfigRestore;
 837         String action = myAction.toString();
 838         String rpcName = getRpcName(myAction);
 839         Status status =
 840                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 841         if (null == status) {
 842             try {
 843                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 844                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 845                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 846                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 847                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 848                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 849             } catch (ParseException e) {
 850                 status = buildStatusWithParseException(e);
 851
 852                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 853                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 854                         this.getClass().getName());
 855
 856             }
 857         }
 858         outputBuilder.setCommonHeader(input.getCommonHeader());
 859         outputBuilder.setStatus(status);
 860         RpcResult<ConfigRestoreOutput> result =
 861                 RpcResultBuilder.<ConfigRestoreOutput>status(true).withResult(outputBuilder.build()).build();
 862         return Futures.immediateFuture(result);
 863     }
 864
 865     @Override
 866     public ListenableFuture<RpcResult<TestOutput>> test(TestInput input) {
 867         logger.debug("Input received : " + input.toString());
 868         TestOutputBuilder outputBuilder = new TestOutputBuilder();
 869         Action myAction = Action.Test;
 870         String action = myAction.toString();
 871         String rpcName = getRpcName(myAction);
 872         Status status =
 873                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 874         if (null == status) {
 875             try {
 876                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 877                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 878                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 879                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 880                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 881                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 882             } catch (ParseException e) {
 883                 status = buildStatusWithParseException(e);
 884
 885                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 886                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 887                         this.getClass().getName());
 888
 889             }
 890         }
 891         outputBuilder.setCommonHeader(input.getCommonHeader());
 892         outputBuilder.setStatus(status);
 893         RpcResult<TestOutput> result =
 894                 RpcResultBuilder.<TestOutput>status(true).withResult(outputBuilder.build()).build();
 895         return Futures.immediateFuture(result);
 896     }
 897
 898
 899     @Override
 900     public ListenableFuture<RpcResult<StopOutput>> stop(StopInput input) {
 901         logger.debug("Input received : " + input.toString());
 902         StopOutputBuilder outputBuilder = new StopOutputBuilder();
 903         Action myAction = Action.Stop;
 904         String action = myAction.toString();
 905         String rpcName = getRpcName(myAction);
 906         Status status =
 907                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 908         if (null == status) {
 909             try {
 910                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 911                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 912                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 913                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 914                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 915                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 916             } catch (ParseException e) {
 917                 status = buildStatusWithParseException(e);
 918
 919                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 920                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 921                         this.getClass().getName());
 922
 923             }
 924         }
 925         outputBuilder.setCommonHeader(input.getCommonHeader());
 926         outputBuilder.setStatus(status);
 927         RpcResult<StopOutput> result =
 928                 RpcResultBuilder.<StopOutput>status(true).withResult(outputBuilder.build()).build();
 929         return Futures.immediateFuture(result);
 930     }
 931
 932     /**
 933      * Starts a specific VNF
 934      *
 935      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#start(StartInput)
 936      */
 937     @Override
 938     public ListenableFuture<RpcResult<StartOutput>> start(StartInput input) {
 939         logger.debug("Input received : " + input.toString());
 940
 941         StartOutputBuilder outputBuilder = new StartOutputBuilder();
 942         Action myAction = Action.Start;
 943         String action = myAction.toString();
 944         String rpcName = getRpcName(myAction);
 945         Status status =
 946                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 947         if (null == status) {
 948             try {
 949                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 950                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 951                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 952                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 953                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 954                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 955             } catch (ParseException e) {
 956                 status = buildStatusWithParseException(e);
 957
 958                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 959                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 960                         this.getClass().getName());
 961
 962             }
 963         }
 964         outputBuilder.setCommonHeader(input.getCommonHeader());
 965         outputBuilder.setStatus(status);
 966         RpcResult<StartOutput> result =
 967                 RpcResultBuilder.<StartOutput>status(true).withResult(outputBuilder.build()).build();
 968         return Futures.immediateFuture(result);
 969     }
 970
 971
 972     @Override
 973     public ListenableFuture<RpcResult<AuditOutput>> audit(AuditInput input) {
 974         logger.debug("Input received : " + input.toString());
 975         AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
 976         Action myAction = Action.Audit;
 977         String action = myAction.toString();
 978         String rpcName = getRpcName(myAction);
 979         Status status =
 980                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 981         if (null == status) {
 982             try {
 983                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 984                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 985                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 986                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 987                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 988                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 989             } catch (ParseException e) {
 990                 status = buildStatusWithParseException(e);
 991
 992                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 993                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 994                         this.getClass().getName());
 995
 996             }
 997         }
 998         outputBuilder.setCommonHeader(input.getCommonHeader());
 999         outputBuilder.setStatus(status);
1000         RpcResult<AuditOutput> result =
1001                 RpcResultBuilder.<AuditOutput>status(true).withResult(outputBuilder.build()).build();
1002         return Futures.immediateFuture(result);
1003     }
1004
1005     @Override
1006     public ListenableFuture<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
1007         logger.debug("Input received : " + input.toString());
1008         SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
1009         Action myAction = Action.SoftwareUpload;
1010         String action = myAction.toString();
1011         String rpcName = getRpcName(myAction);
1012         Status status =
1013                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1014         if (null == status) {
1015             try {
1016                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1017                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1018                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1019                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1020                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1021                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1022             } catch (ParseException e) {
1023                 status = buildStatusWithParseException(e);
1024
1025                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1026                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1027                         this.getClass().getName());
1028
1029             }
1030         }
1031         outputBuilder.setCommonHeader(input.getCommonHeader());
1032         outputBuilder.setStatus(status);
1033         RpcResult<SoftwareUploadOutput> result =
1034                 RpcResultBuilder.<SoftwareUploadOutput>status(true).withResult(outputBuilder.build()).build();
1035         return Futures.immediateFuture(result);
1036     }
1037
1038     @Override
1039     public ListenableFuture<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
1040         logger.debug("Input received : " + input.toString());
1041         HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
1042         Action myAction = Action.HealthCheck;
1043         String action = myAction.toString();
1044         String rpcName = getRpcName(myAction);
1045         Status status =
1046                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1047         if (null == status) {
1048             try {
1049                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1050                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1051                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1052                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1053                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1054                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1055             } catch (ParseException e) {
1056                 status = buildStatusWithParseException(e);
1057
1058                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1059                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1060                         this.getClass().getName());
1061
1062             }
1063         }
1064         outputBuilder.setCommonHeader(input.getCommonHeader());
1065         outputBuilder.setStatus(status);
1066         RpcResult<HealthCheckOutput> result =
1067                 RpcResultBuilder.<HealthCheckOutput>status(true).withResult(outputBuilder.build()).build();
1068         return Futures.immediateFuture(result);
1069     }
1070
1071     @Override
1072     public ListenableFuture<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
1073         logger.debug("Input received : " + input.toString());
1074         LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
1075         Action myAction = Action.LiveUpgrade;
1076         String action = myAction.toString();
1077         String rpcName = getRpcName(myAction);
1078         Status status =
1079                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1080         if (null == status) {
1081             try {
1082                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1083                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1084                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1085                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1086                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1087                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1088             } catch (ParseException e) {
1089                 status = buildStatusWithParseException(e);
1090
1091                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1092                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1093                         this.getClass().getName());
1094
1095             }
1096         }
1097         outputBuilder.setCommonHeader(input.getCommonHeader());
1098         outputBuilder.setStatus(status);
1099         RpcResult<LiveUpgradeOutput> result =
1100                 RpcResultBuilder.<LiveUpgradeOutput>status(true).withResult(outputBuilder.build()).build();
1101         return Futures.immediateFuture(result);
1102     }
1103
1104
1105     @Override
1106     public ListenableFuture<RpcResult<LockOutput>> lock(LockInput input) {
1107         logger.debug("Input received : " + input.toString());
1108         LockOutputBuilder outputBuilder = new LockOutputBuilder();
1109         Action myAction = Action.Lock;
1110         String action = myAction.toString();
1111         String rpcName = getRpcName(myAction);
1112         Status status =
1113                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1114         if (null == status) {
1115             try {
1116                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1117                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1118                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1119                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1120                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1121                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1122             } catch (ParseException e) {
1123                 status = buildStatusWithParseException(e);
1124
1125                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1126                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1127                         this.getClass().getName());
1128
1129             }
1130         }
1131         outputBuilder.setCommonHeader(input.getCommonHeader());
1132         outputBuilder.setStatus(status);
1133         RpcResult<LockOutput> result =
1134                 RpcResultBuilder.<LockOutput>status(true).withResult(outputBuilder.build()).build();
1135         return Futures.immediateFuture(result);
1136     }
1137
1138
1139     @Override
1140     public ListenableFuture<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
1141         logger.debug("Input received : " + input.toString());
1142         UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
1143         Action myAction = Action.Unlock;
1144         String action = myAction.toString();
1145         String rpcName = getRpcName(myAction);
1146         Status status =
1147                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1148         if (null == status) {
1149             try {
1150                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1151                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1152                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1153                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1154                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1155                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1156             } catch (ParseException e) {
1157                 status = buildStatusWithParseException(e);
1158
1159                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1160                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1161                         this.getClass().getName());
1162
1163             }
1164         }
1165         outputBuilder.setCommonHeader(input.getCommonHeader());
1166         outputBuilder.setStatus(status);
1167         RpcResult<UnlockOutput> result =
1168                 RpcResultBuilder.<UnlockOutput>status(true).withResult(outputBuilder.build()).build();
1169         return Futures.immediateFuture(result);
1170     }
1171
1172     @Override
1173     public ListenableFuture<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
1174         logger.debug("Input received : " + input.toString());
1175         CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
1176         Action myAction = Action.CheckLock;
1177         String action = myAction.toString();
1178         String rpcName = getRpcName(myAction);
1179         RequestHandlerOutput requestHandlerOutput = null;
1180         Status status =
1181                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1182         if (null == status) {
1183             try {
1184                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1185                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1186                         .action(action).rpcName(rpcName).build();
1187                 requestHandlerOutput = executeRequest(request);
1188
1189                 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1190                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1191                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1192             } catch (ParseException e) {
1193                 status = buildStatusWithParseException(e);
1194
1195                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1196                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1197                         this.getClass().getName());
1198
1199             }
1200         }
1201
1202         outputBuilder.setCommonHeader(input.getCommonHeader());
1203         outputBuilder.setStatus(status);
1204         if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1205             outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(
1206                     requestHandlerOutput.getResponseContext().getAdditionalContext().get("locked").toUpperCase()));
1207         }
1208         RpcResult<CheckLockOutput> result =
1209                 RpcResultBuilder.<CheckLockOutput>status(true).withResult(outputBuilder.build()).build();
1210         return Futures.immediateFuture(result);
1211     }
1212
1213     @Override
1214     public ListenableFuture<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1215         logger.debug("Input received : " + input.toString());
1216         ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1217         Action myAction = Action.ConfigBackup;
1218         String action = myAction.toString();
1219         String rpcName = getRpcName(myAction);
1220         Status status =
1221                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1222         if (null == status) {
1223             try {
1224                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1225                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1226                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1227                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1228                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1229                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1230             } catch (ParseException e) {
1231                 status = buildStatusWithParseException(e);
1232
1233                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1234                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1235                         this.getClass().getName());
1236
1237             }
1238         }
1239         outputBuilder.setCommonHeader(input.getCommonHeader());
1240         outputBuilder.setStatus(status);
1241         RpcResult<ConfigBackupOutput> result =
1242                 RpcResultBuilder.<ConfigBackupOutput>status(true).withResult(outputBuilder.build()).build();
1243         return Futures.immediateFuture(result);
1244     }
1245
1246
1247     @Override
1248     public ListenableFuture<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1249         logger.debug("Input received : " + input.toString());
1250         ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1251         Action myAction = Action.ConfigBackupDelete;
1252         String action = myAction.toString();
1253         String rpcName = getRpcName(myAction);
1254         Status status =
1255                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1256         if (null == status) {
1257             try {
1258                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1259                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1260                         .action(action).rpcName(rpcName).build();
1261                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1262                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1263                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1264             } catch (ParseException e) {
1265                 status = buildStatusWithParseException(e);
1266
1267                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1268                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1269                         this.getClass().getName());
1270
1271             }
1272         }
1273         outputBuilder.setCommonHeader(input.getCommonHeader());
1274         outputBuilder.setStatus(status);
1275         RpcResult<ConfigBackupDeleteOutput> result =
1276                 RpcResultBuilder.<ConfigBackupDeleteOutput>status(true).withResult(outputBuilder.build()).build();
1277         return Futures.immediateFuture(result);
1278     }
1279
1280
1281     @Override
1282     public ListenableFuture<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1283         logger.debug("Input received : " + input.toString());
1284         ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1285         Action myAction = Action.ConfigExport;
1286         String action = myAction.toString();
1287         String rpcName = getRpcName(myAction);
1288         Status status =
1289                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1290         if (null == status) {
1291             try {
1292                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1293                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1294                         .action(action).rpcName(rpcName).build();
1295                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1296                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1297                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1298             } catch (ParseException e) {
1299                 status = buildStatusWithParseException(e);
1300
1301                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1302                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1303                         this.getClass().getName());
1304
1305             }
1306         }
1307         outputBuilder.setCommonHeader(input.getCommonHeader());
1308         outputBuilder.setStatus(status);
1309         RpcResult<ConfigExportOutput> result =
1310                 RpcResultBuilder.<ConfigExportOutput>status(true).withResult(outputBuilder.build()).build();
1311         return Futures.immediateFuture(result);
1312     }
1313
1314
1315     public ListenableFuture<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input) {
1316         logger.debug("Input received : " + input.toString());
1317         StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1318         Action myAction = Action.StopApplication;
1319         String action = myAction.toString();
1320         String rpcName = getRpcName(myAction);
1321         Status status =
1322                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1323         if (null == status) {
1324             try {
1325                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1326                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1327                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1328                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1329                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1330                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1331             } catch (ParseException e) {
1332                 status = buildStatusWithParseException(e);
1333
1334                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1335                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1336                         this.getClass().getName());
1337
1338             }
1339         }
1340         outputBuilder.setCommonHeader(input.getCommonHeader());
1341         outputBuilder.setStatus(status);
1342         RpcResult<StopApplicationOutput> result =
1343                 RpcResultBuilder.<StopApplicationOutput>status(true).withResult(outputBuilder.build()).build();
1344         return Futures.immediateFuture(result);
1345     }
1346
1347     RequestHandlerOutput executeRequest(RequestHandlerInput request) {
1348         return new RequestExecutor().executeRequest(request);
1349     }
1350 }