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

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