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