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

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