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-2018 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  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.appc.provider;
  25
  26 import java.text.ParseException;
  27 import java.util.concurrent.ExecutorService;
  28 import java.util.concurrent.Executors;
  29 import java.util.concurrent.Future;
  30 import org.onap.appc.Constants;
  31 import org.onap.appc.configuration.Configuration;
  32 import org.onap.appc.configuration.ConfigurationFactory;
  33 import org.onap.appc.i18n.Msg;
  34 import org.onap.appc.logging.LoggingConstants;
  35 import org.onap.appc.logging.LoggingUtils;
  36 import org.onap.appc.provider.lcm.service.AbstractBaseUtils;
  37 import org.onap.appc.provider.lcm.service.ActionStatusService;
  38 import org.onap.appc.provider.lcm.service.QueryService;
  39 import org.onap.appc.provider.lcm.service.QuiesceTrafficService;
  40 import org.onap.appc.provider.lcm.service.RebootService;
  41 import org.onap.appc.provider.lcm.service.RequestExecutor;
  42 import org.onap.appc.provider.lcm.service.ResumeTrafficService;
  43 import org.onap.appc.provider.lcm.service.UpgradeService;
  44 import org.onap.appc.provider.lcm.service.VolumeService;
  45 import org.onap.appc.provider.lcm.service.ConfigScaleOutService;
  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().reboot(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 ConfigScaleOutService().process(input);
 649         RpcResult<ConfigScaleOutOutput> result = RpcResultBuilder.<ConfigScaleOutOutput> status(true).withResult(outputBuilder.build()).build();
 650         return Futures.immediateFuture(result);
 651     }
 652
 653     @Override
 654     public Future<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
 655         logger.debug("Input received : " + input.toString());
 656         ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
 657         Action myAction = Action.ConfigRestore;
 658         String action = myAction.toString();
 659         String rpcName = getRpcName(myAction);
 660         Status status =
 661                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 662         if (null == status) {
 663             try {
 664                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 665                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 666                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 667                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 668                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 669                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 670             } catch (ParseException e) {
 671                 status = buildStatusWithParseException(e);
 672
 673                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 674                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 675                         this.getClass().getName());
 676
 677             }
 678         }
 679         outputBuilder.setCommonHeader(input.getCommonHeader());
 680         outputBuilder.setStatus(status);
 681         RpcResult<ConfigRestoreOutput> result =
 682                 RpcResultBuilder.<ConfigRestoreOutput>status(true).withResult(outputBuilder.build()).build();
 683         return Futures.immediateFuture(result);
 684     }
 685
 686     @Override
 687     public Future<RpcResult<TestOutput>> test(TestInput input) {
 688         logger.debug("Input received : " + input.toString());
 689         TestOutputBuilder outputBuilder = new TestOutputBuilder();
 690         Action myAction = Action.Test;
 691         String action = myAction.toString();
 692         String rpcName = getRpcName(myAction);
 693         Status status =
 694                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 695         if (null == status) {
 696             try {
 697                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 698                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 699                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 700                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 701                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 702                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 703             } catch (ParseException e) {
 704                 status = buildStatusWithParseException(e);
 705
 706                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 707                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 708                         this.getClass().getName());
 709
 710             }
 711         }
 712         outputBuilder.setCommonHeader(input.getCommonHeader());
 713         outputBuilder.setStatus(status);
 714         RpcResult<TestOutput> result =
 715                 RpcResultBuilder.<TestOutput>status(true).withResult(outputBuilder.build()).build();
 716         return Futures.immediateFuture(result);
 717     }
 718
 719
 720     @Override
 721     public Future<RpcResult<StopOutput>> stop(StopInput input) {
 722         logger.debug("Input received : " + input.toString());
 723         StopOutputBuilder outputBuilder = new StopOutputBuilder();
 724         Action myAction = Action.Stop;
 725         String action = myAction.toString();
 726         String rpcName = getRpcName(myAction);
 727         Status status =
 728                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 729         if (null == status) {
 730             try {
 731                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 732                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 733                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 734                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 735                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 736                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 737             } catch (ParseException e) {
 738                 status = buildStatusWithParseException(e);
 739
 740                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 741                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 742                         this.getClass().getName());
 743
 744             }
 745         }
 746         outputBuilder.setCommonHeader(input.getCommonHeader());
 747         outputBuilder.setStatus(status);
 748         RpcResult<StopOutput> result =
 749                 RpcResultBuilder.<StopOutput>status(true).withResult(outputBuilder.build()).build();
 750         return Futures.immediateFuture(result);
 751     }
 752
 753     /**
 754      * Starts a specific VNF
 755      *
 756      * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#start(StartInput)
 757      */
 758     @Override
 759     public Future<RpcResult<StartOutput>> start(StartInput input) {
 760         logger.debug("Input received : " + input.toString());
 761
 762         StartOutputBuilder outputBuilder = new StartOutputBuilder();
 763         Action myAction = Action.Start;
 764         String action = myAction.toString();
 765         String rpcName = getRpcName(myAction);
 766         Status status =
 767                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 768         if (null == status) {
 769             try {
 770                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 771                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 772                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 773                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 774                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 775                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 776             } catch (ParseException e) {
 777                 status = buildStatusWithParseException(e);
 778
 779                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 780                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 781                         this.getClass().getName());
 782
 783             }
 784         }
 785         outputBuilder.setCommonHeader(input.getCommonHeader());
 786         outputBuilder.setStatus(status);
 787         RpcResult<StartOutput> result =
 788                 RpcResultBuilder.<StartOutput>status(true).withResult(outputBuilder.build()).build();
 789         return Futures.immediateFuture(result);
 790     }
 791
 792
 793     @Override
 794     public Future<RpcResult<AuditOutput>> audit(AuditInput input) {
 795         logger.debug("Input received : " + input.toString());
 796         AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
 797         Action myAction = Action.Audit;
 798         String action = myAction.toString();
 799         String rpcName = getRpcName(myAction);
 800         Status status =
 801                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 802         if (null == status) {
 803             try {
 804                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 805                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 806                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 807                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 808                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 809                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 810             } catch (ParseException e) {
 811                 status = buildStatusWithParseException(e);
 812
 813                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 814                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 815                         this.getClass().getName());
 816
 817             }
 818         }
 819         outputBuilder.setCommonHeader(input.getCommonHeader());
 820         outputBuilder.setStatus(status);
 821         RpcResult<AuditOutput> result =
 822                 RpcResultBuilder.<AuditOutput>status(true).withResult(outputBuilder.build()).build();
 823         return Futures.immediateFuture(result);
 824     }
 825
 826     @Override
 827     public Future<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
 828         logger.debug("Input received : " + input.toString());
 829         SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
 830         Action myAction = Action.SoftwareUpload;
 831         String action = myAction.toString();
 832         String rpcName = getRpcName(myAction);
 833         Status status =
 834                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 835         if (null == status) {
 836             try {
 837                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 838                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 839                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 840                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 841                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 842                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 843             } catch (ParseException e) {
 844                 status = buildStatusWithParseException(e);
 845
 846                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 847                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 848                         this.getClass().getName());
 849
 850             }
 851         }
 852         outputBuilder.setCommonHeader(input.getCommonHeader());
 853         outputBuilder.setStatus(status);
 854         RpcResult<SoftwareUploadOutput> result =
 855                 RpcResultBuilder.<SoftwareUploadOutput>status(true).withResult(outputBuilder.build()).build();
 856         return Futures.immediateFuture(result);
 857     }
 858
 859     @Override
 860     public Future<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
 861         logger.debug("Input received : " + input.toString());
 862         HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
 863         Action myAction = Action.HealthCheck;
 864         String action = myAction.toString();
 865         String rpcName = getRpcName(myAction);
 866         Status status =
 867                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 868         if (null == status) {
 869             try {
 870                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 871                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 872                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 873                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 874                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 875                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 876             } catch (ParseException e) {
 877                 status = buildStatusWithParseException(e);
 878
 879                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 880                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 881                         this.getClass().getName());
 882
 883             }
 884         }
 885         outputBuilder.setCommonHeader(input.getCommonHeader());
 886         outputBuilder.setStatus(status);
 887         RpcResult<HealthCheckOutput> result =
 888                 RpcResultBuilder.<HealthCheckOutput>status(true).withResult(outputBuilder.build()).build();
 889         return Futures.immediateFuture(result);
 890     }
 891
 892     @Override
 893     public Future<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
 894         logger.debug("Input received : " + input.toString());
 895         LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
 896         Action myAction = Action.LiveUpgrade;
 897         String action = myAction.toString();
 898         String rpcName = getRpcName(myAction);
 899         Status status =
 900                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 901         if (null == status) {
 902             try {
 903                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 904                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 905                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 906                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 907                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 908                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 909             } catch (ParseException e) {
 910                 status = buildStatusWithParseException(e);
 911
 912                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 913                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 914                         this.getClass().getName());
 915
 916             }
 917         }
 918         outputBuilder.setCommonHeader(input.getCommonHeader());
 919         outputBuilder.setStatus(status);
 920         RpcResult<LiveUpgradeOutput> result =
 921                 RpcResultBuilder.<LiveUpgradeOutput>status(true).withResult(outputBuilder.build()).build();
 922         return Futures.immediateFuture(result);
 923     }
 924
 925
 926     @Override
 927     public Future<RpcResult<LockOutput>> lock(LockInput input) {
 928         logger.debug("Input received : " + input.toString());
 929         LockOutputBuilder outputBuilder = new LockOutputBuilder();
 930         Action myAction = Action.Lock;
 931         String action = myAction.toString();
 932         String rpcName = getRpcName(myAction);
 933         Status status =
 934                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 935         if (null == status) {
 936             try {
 937                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 938                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 939                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 940                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 941                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 942                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 943             } catch (ParseException e) {
 944                 status = buildStatusWithParseException(e);
 945
 946                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 947                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 948                         this.getClass().getName());
 949
 950             }
 951         }
 952         outputBuilder.setCommonHeader(input.getCommonHeader());
 953         outputBuilder.setStatus(status);
 954         RpcResult<LockOutput> result =
 955                 RpcResultBuilder.<LockOutput>status(true).withResult(outputBuilder.build()).build();
 956         return Futures.immediateFuture(result);
 957     }
 958
 959
 960     @Override
 961     public Future<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
 962         logger.debug("Input received : " + input.toString());
 963         UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
 964         Action myAction = Action.Unlock;
 965         String action = myAction.toString();
 966         String rpcName = getRpcName(myAction);
 967         Status status =
 968                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 969         if (null == status) {
 970             try {
 971                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 972                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
 973                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 974                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 975                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 976                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 977             } catch (ParseException e) {
 978                 status = buildStatusWithParseException(e);
 979
 980                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
 981                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 982                         this.getClass().getName());
 983
 984             }
 985         }
 986         outputBuilder.setCommonHeader(input.getCommonHeader());
 987         outputBuilder.setStatus(status);
 988         RpcResult<UnlockOutput> result =
 989                 RpcResultBuilder.<UnlockOutput>status(true).withResult(outputBuilder.build()).build();
 990         return Futures.immediateFuture(result);
 991     }
 992
 993     @Override
 994     public Future<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
 995         logger.debug("Input received : " + input.toString());
 996         CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
 997         Action myAction = Action.CheckLock;
 998         String action = myAction.toString();
 999         String rpcName = getRpcName(myAction);
1000         RequestHandlerOutput requestHandlerOutput = null;
1001         Status status =
1002                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1003         if (null == status) {
1004             try {
1005                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1006                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1007                         .action(action).rpcName(rpcName).build();
1008                 requestHandlerOutput = executeRequest(request);
1009
1010                 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1011                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1012                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1013             } catch (ParseException e) {
1014                 status = buildStatusWithParseException(e);
1015
1016                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1017                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1018                         this.getClass().getName());
1019
1020             }
1021         }
1022
1023         outputBuilder.setCommonHeader(input.getCommonHeader());
1024         outputBuilder.setStatus(status);
1025         if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1026             outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(
1027                     requestHandlerOutput.getResponseContext().getAdditionalContext().get("locked").toUpperCase()));
1028         }
1029         RpcResult<CheckLockOutput> result =
1030                 RpcResultBuilder.<CheckLockOutput>status(true).withResult(outputBuilder.build()).build();
1031         return Futures.immediateFuture(result);
1032     }
1033
1034     @Override
1035     public Future<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1036         logger.debug("Input received : " + input.toString());
1037         ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1038         Action myAction = Action.ConfigBackup;
1039         String action = myAction.toString();
1040         String rpcName = getRpcName(myAction);
1041         Status status =
1042                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1043         if (null == status) {
1044             try {
1045                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1046                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1047                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1048                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1049                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1050                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1051             } catch (ParseException e) {
1052                 status = buildStatusWithParseException(e);
1053
1054                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1055                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1056                         this.getClass().getName());
1057
1058             }
1059         }
1060         outputBuilder.setCommonHeader(input.getCommonHeader());
1061         outputBuilder.setStatus(status);
1062         RpcResult<ConfigBackupOutput> result =
1063                 RpcResultBuilder.<ConfigBackupOutput>status(true).withResult(outputBuilder.build()).build();
1064         return Futures.immediateFuture(result);
1065     }
1066
1067
1068     @Override
1069     public Future<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1070         logger.debug("Input received : " + input.toString());
1071         ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1072         Action myAction = Action.ConfigBackupDelete;
1073         String action = myAction.toString();
1074         String rpcName = getRpcName(myAction);
1075         Status status =
1076                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1077         if (null == status) {
1078             try {
1079                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1080                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1081                         .action(action).rpcName(rpcName).build();
1082                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1083                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1084                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1085             } catch (ParseException e) {
1086                 status = buildStatusWithParseException(e);
1087
1088                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1089                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1090                         this.getClass().getName());
1091
1092             }
1093         }
1094         outputBuilder.setCommonHeader(input.getCommonHeader());
1095         outputBuilder.setStatus(status);
1096         RpcResult<ConfigBackupDeleteOutput> result =
1097                 RpcResultBuilder.<ConfigBackupDeleteOutput>status(true).withResult(outputBuilder.build()).build();
1098         return Futures.immediateFuture(result);
1099     }
1100
1101
1102     @Override
1103     public Future<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1104         logger.debug("Input received : " + input.toString());
1105         ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1106         Action myAction = Action.ConfigExport;
1107         String action = myAction.toString();
1108         String rpcName = getRpcName(myAction);
1109         Status status =
1110                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1111         if (null == status) {
1112             try {
1113                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1114                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1115                         .action(action).rpcName(rpcName).build();
1116                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1117                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1118                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1119             } catch (ParseException e) {
1120                 status = buildStatusWithParseException(e);
1121
1122                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1123                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1124                         this.getClass().getName());
1125
1126             }
1127         }
1128         outputBuilder.setCommonHeader(input.getCommonHeader());
1129         outputBuilder.setStatus(status);
1130         RpcResult<ConfigExportOutput> result =
1131                 RpcResultBuilder.<ConfigExportOutput>status(true).withResult(outputBuilder.build()).build();
1132         return Futures.immediateFuture(result);
1133     }
1134
1135
1136     public Future<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input) {
1137         logger.debug("Input received : " + input.toString());
1138         StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1139         Action myAction = Action.StopApplication;
1140         String action = myAction.toString();
1141         String rpcName = getRpcName(myAction);
1142         Status status =
1143                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1144         if (null == status) {
1145             try {
1146                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1147                         .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1148                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1149                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1150                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1151                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1152             } catch (ParseException e) {
1153                 status = buildStatusWithParseException(e);
1154
1155                 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1156                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1157                         this.getClass().getName());
1158
1159             }
1160         }
1161         outputBuilder.setCommonHeader(input.getCommonHeader());
1162         outputBuilder.setStatus(status);
1163         RpcResult<StopApplicationOutput> result =
1164                 RpcResultBuilder.<StopApplicationOutput>status(true).withResult(outputBuilder.build()).build();
1165         return Futures.immediateFuture(result);
1166     }
1167
1168     RequestHandlerOutput executeRequest(RequestHandlerInput request) {
1169         return new RequestExecutor().executeRequest(request);
1170     }
1171 }