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