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