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