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

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