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