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