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