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 createErrorRequestHandlerObj(RequestHandlerInput request,
 507                                                               LCMCommandStatus cmdStatus,
 508                                                               Msg msg,
 509                                                               Exception e) {
 510         final String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
 511         final String reason = EELFResourceManager.format(msg, e,
 512                 appName, e.getClass().getSimpleName(), "", e.getMessage());
 513
 514         RequestHandlerOutput requestHandlerOutput = new RequestHandlerOutput();
 515         final ResponseContext responseContext = new ResponseContext();
 516         requestHandlerOutput.setResponseContext(responseContext);
 517         responseContext.setCommonHeader(request.getRequestContext().getCommonHeader());
 518
 519         String errorMessage = e.getMessage() != null ? e.getMessage() : e.toString();
 520         Params params = new Params().addParam("errorMsg", errorMessage);
 521         responseContext.setStatus(cmdStatus.toStatus(params));
 522
 523         LoggingUtils.logErrorMessage(
 524                 LoggingConstants.TargetNames.APPC_PROVIDER,
 525                 reason,
 526                 this.getClass().getName());
 527
 528         return requestHandlerOutput;
 529     }
 530
 531     private RequestHandler getRequestHandler(){
 532         final BundleContext context = FrameworkUtil.getBundle(RequestHandler.class).getBundleContext();
 533         if (context == null) {
 534             return null;
 535         }
 536
 537         final ServiceReference reference = context.getServiceReference(RequestHandler.class.getName());
 538         if (reference == null) {
 539             logger.error("Cannot find service reference for " + RequestHandler.class.getName());
 540             throw new RuntimeException();
 541         }
 542
 543         return (RequestHandler) context.getService(reference);
 544     }
 545
 546     @Override
 547     public Future<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
 548         logger.debug("Input received : " + input.toString());
 549         TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
 550         String action = Action.Terminate.toString() ;
 551         String rpcName = Action.Terminate.name().toLowerCase();
 552         Status status =
 553                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 554         if(null == status) {
 555             try {
 556                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 557                         .commonHeader(input.getCommonHeader())
 558                         .actionIdentifiers(input.getActionIdentifiers())
 559                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 560                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 561                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 562                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 563             } catch (ParseException e) {
 564
 565                 status = buildParsingErrorStatus(e);
 566
 567                 LoggingUtils.logErrorMessage(
 568                         LoggingConstants.TargetNames.APPC_PROVIDER,
 569                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 570                         this.getClass().getName());
 571
 572             }
 573
 574         }
 575         outputBuilder.setCommonHeader(input.getCommonHeader());
 576         outputBuilder.setStatus(status);
 577         RpcResult<TerminateOutput> result =
 578                 RpcResultBuilder.<TerminateOutput> status(true).withResult(outputBuilder.build()).build();
 579         return Futures.immediateFuture(result);
 580     }
 581
 582     @Override
 583     public Future<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
 584         logger.debug("Input received : " + input.toString());
 585         ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
 586         String action = Action.Configure.toString() ;
 587         String rpcName = "configure";
 588         Status status =
 589                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 590         if(null == status) {
 591             try {
 592                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 593                         .commonHeader(input.getCommonHeader())
 594                         .actionIdentifiers(input.getActionIdentifiers())
 595                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 596                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 597                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 598                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 599             } catch (ParseException e) {
 600                 status = buildParsingErrorStatus(e);
 601
 602                 LoggingUtils.logErrorMessage(
 603                         LoggingConstants.TargetNames.APPC_PROVIDER,
 604                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 605                         this.getClass().getName());
 606
 607             }
 608         }
 609         outputBuilder.setCommonHeader(input.getCommonHeader());
 610         outputBuilder.setStatus(status);
 611         RpcResult<ConfigureOutput> result =
 612                 RpcResultBuilder.<ConfigureOutput> status(true).withResult(outputBuilder.build()).build();
 613         return Futures.immediateFuture(result);
 614     }
 615
 616     @Override
 617     public Future<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
 618         logger.debug("Input received : " + input.toString());
 619         ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
 620         String action = Action.ConfigModify.toString() ;
 621         String rpcName = "config-modify";
 622         Status status =
 623                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 624         if(null == status) {
 625             try {
 626                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 627                         .commonHeader(input.getCommonHeader())
 628                         .actionIdentifiers(input.getActionIdentifiers())
 629                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 630                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 631                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 632                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 633             } catch (ParseException e) {
 634                 status = buildParsingErrorStatus(e);
 635
 636                 LoggingUtils.logErrorMessage(
 637                         LoggingConstants.TargetNames.APPC_PROVIDER,
 638                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 639                         this.getClass().getName());
 640
 641             }
 642         }
 643         outputBuilder.setCommonHeader(input.getCommonHeader());
 644         outputBuilder.setStatus(status);
 645         RpcResult<ConfigModifyOutput> result =
 646                 RpcResultBuilder.<ConfigModifyOutput> status(true).withResult(outputBuilder.build()).build();
 647         return Futures.immediateFuture(result);
 648     }
 649
 650     @Override
 651     public Future<RpcResult<ConfigScaleoutOutput>> configScaleout(ConfigScaleoutInput input) {
 652         logger.debug("Input received : " + input.toString());
 653         ConfigScaleoutOutputBuilder outputBuilder = new ConfigScaleoutOutputBuilder();
 654         String action = Action.ConfigScaleOut.toString() ;
 655         String rpcName = "config-scaleout";
 656         Status status =
 657                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 658         if(null == status) {
 659             try {
 660                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 661                         .commonHeader(input.getCommonHeader())
 662                         .actionIdentifiers(input.getActionIdentifiers())
 663                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 664                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 665                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 666                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 667             } catch (ParseException e) {
 668                 status = buildParsingErrorStatus(e);
 669
 670                 LoggingUtils.logErrorMessage(
 671                         LoggingConstants.TargetNames.APPC_PROVIDER,
 672                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 673                         this.getClass().getName());
 674
 675             }
 676         }
 677         outputBuilder.setCommonHeader(input.getCommonHeader());
 678         outputBuilder.setStatus(status);
 679         RpcResult<ConfigScaleoutOutput> result =
 680                 RpcResultBuilder.<ConfigScaleoutOutput> status(true).withResult(outputBuilder.build()).build();
 681         return Futures.immediateFuture(result);
 682     }
 683
 684     @Override
 685     public Future<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
 686         logger.debug("Input received : " + input.toString());
 687         ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
 688         String action = Action.ConfigRestore.toString() ;
 689         String rpcName = "config-restore";
 690         Status status =
 691                 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 692         if(null == status) {
 693             try {
 694                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 695                         .commonHeader(input.getCommonHeader())
 696                         .actionIdentifiers(input.getActionIdentifiers())
 697                         .payload(input.getPayload()).action(action).rpcName(rpcName).build();
 698                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 699                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
 700                         input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 701             } catch (ParseException e) {
 702                 status = buildParsingErrorStatus(e);
 703
 704                 LoggingUtils.logErrorMessage(
 705                         LoggingConstants.TargetNames.APPC_PROVIDER,
 706                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 707                         this.getClass().getName());
 708
 709             }
 710         }
 711         outputBuilder.setCommonHeader(input.getCommonHeader());
 712         outputBuilder.setStatus(status);
 713         RpcResult<ConfigRestoreOutput> result =
 714                 RpcResultBuilder.<ConfigRestoreOutput> status(true).withResult(outputBuilder.build()).build();
 715         return Futures.immediateFuture(result);
 716     }
 717
 718     @Override
 719     public Future<RpcResult<TestOutput>> test(TestInput input) {
 720         logger.debug("Input received : " + input.toString());
 721         TestOutputBuilder outputBuilder = new TestOutputBuilder();
 722         String action = Action.Test.toString() ;
 723         String rpcName = Action.Test.name().toLowerCase();
 724         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 725         if(null == status) {
 726             try {
 727                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 728                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 729                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 730             } catch (ParseException e) {
 731                 status = buildParsingErrorStatus(e);
 732
 733                 LoggingUtils.logErrorMessage(
 734                         LoggingConstants.TargetNames.APPC_PROVIDER,
 735                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 736                         this.getClass().getName());
 737
 738             }
 739         }
 740         outputBuilder.setCommonHeader(input.getCommonHeader());
 741         outputBuilder.setStatus(status);
 742         RpcResult<TestOutput> result = RpcResultBuilder.<TestOutput> status(true).withResult(outputBuilder.build()).build();
 743         return Futures.immediateFuture(result);
 744     }
 745
 746
 747     @Override
 748     public Future<RpcResult<StopOutput>> stop(StopInput input) {
 749         logger.debug("Input received : " + input.toString());
 750         StopOutputBuilder outputBuilder = new StopOutputBuilder();
 751         String action = Action.Stop.toString() ;
 752         String rpcName = Action.Stop.name().toLowerCase();
 753         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 754         if(null == status) {
 755             try {
 756                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 757                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 758                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 759             } catch (ParseException e) {
 760                 status = buildParsingErrorStatus(e);
 761
 762                 LoggingUtils.logErrorMessage(
 763                         LoggingConstants.TargetNames.APPC_PROVIDER,
 764                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 765                         this.getClass().getName());
 766
 767             }
 768         }
 769         outputBuilder.setCommonHeader(input.getCommonHeader());
 770         outputBuilder.setStatus(status);
 771         RpcResult<StopOutput> result = RpcResultBuilder.<StopOutput> status(true).withResult(outputBuilder.build()).build();
 772         return Futures.immediateFuture(result);
 773     }
 774
 775     /**
 776      * Starts a specific VNF
 777      *
 778      * @see AppcProviderLcmService#start(StartInput)
 779      */
 780     @Override
 781     public Future<RpcResult<StartOutput>> start(StartInput input) {
 782         logger.debug("Input received : " + input.toString());
 783
 784         StartOutputBuilder outputBuilder = new StartOutputBuilder();
 785         String action = Action.Start.toString() ;
 786         String rpcName = Action.Start.name().toLowerCase();
 787         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 788         if(null == status) {
 789             try {
 790                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
 791                         .commonHeader(input.getCommonHeader())
 792                         .actionIdentifiers(input.getActionIdentifiers())
 793                         .payload(input.getPayload())
 794                         .action(action)
 795                         .rpcName(rpcName).build();
 796                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 797                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 798             } catch (ParseException e) {
 799                 status = buildParsingErrorStatus(e);
 800
 801                 LoggingUtils.logErrorMessage(
 802                         LoggingConstants.TargetNames.APPC_PROVIDER,
 803                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 804                         this.getClass().getName());
 805
 806             }
 807         }
 808         outputBuilder.setCommonHeader(input.getCommonHeader());
 809         outputBuilder.setStatus(status);
 810         RpcResult<StartOutput> result = RpcResultBuilder.<StartOutput> status(true).withResult(outputBuilder.build()).build();
 811         return Futures.immediateFuture(result);
 812     }
 813
 814
 815     @Override
 816     public Future<RpcResult<AuditOutput>> audit(AuditInput input) {
 817         logger.debug("Input received : " + input.toString());
 818         AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
 819         String action = Action.Audit.toString();
 820         String rpcName = Action.Audit.name().toLowerCase();
 821         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 822         if(null == status) {
 823             try {
 824                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 825                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 826                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 827             } catch (ParseException e) {
 828                 status = buildParsingErrorStatus(e);
 829
 830                 LoggingUtils.logErrorMessage(
 831                         LoggingConstants.TargetNames.APPC_PROVIDER,
 832                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 833                         this.getClass().getName());
 834
 835             }
 836         }
 837         outputBuilder.setCommonHeader(input.getCommonHeader());
 838         outputBuilder.setStatus(status);
 839         RpcResult<AuditOutput> result = RpcResultBuilder.<AuditOutput> status(true).withResult(outputBuilder.build()).build();
 840         return Futures.immediateFuture(result);
 841     }
 842
 843     @Override
 844     public Future<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
 845         logger.debug("Input received : " + input.toString());
 846         SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
 847         String action = Action.SoftwareUpload.toString() ;
 848         String rpcName = convertActionNameToUrl(action);
 849         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 850         if(null == status) {
 851             try {
 852                 RequestHandlerInput request = new RequestInputBuilder().
 853                         requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 854                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 855                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 856             } catch (ParseException e) {
 857                 status = buildParsingErrorStatus(e);
 858
 859                 LoggingUtils.logErrorMessage(
 860                         LoggingConstants.TargetNames.APPC_PROVIDER,
 861                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 862                         this.getClass().getName());
 863
 864             }
 865         }
 866         outputBuilder.setCommonHeader(input.getCommonHeader());
 867         outputBuilder.setStatus(status);
 868         RpcResult<SoftwareUploadOutput> result = RpcResultBuilder.<SoftwareUploadOutput> status(true).withResult(outputBuilder.build()).build();
 869         return Futures.immediateFuture(result);
 870     }
 871
 872     @Override
 873     public Future<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
 874         logger.debug("Input received : " + input.toString());
 875         HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
 876         String action = Action.HealthCheck.toString() ;
 877         String rpcName = convertActionNameToUrl(action);
 878         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 879         if(null == status) {
 880             try {
 881                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 882                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 883                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 884             } catch (ParseException e) {
 885                 status = buildParsingErrorStatus(e);
 886
 887                 LoggingUtils.logErrorMessage(
 888                         LoggingConstants.TargetNames.APPC_PROVIDER,
 889                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 890                         this.getClass().getName());
 891
 892             }
 893         }
 894         outputBuilder.setCommonHeader(input.getCommonHeader());
 895         outputBuilder.setStatus(status);
 896         RpcResult<HealthCheckOutput> result = RpcResultBuilder.<HealthCheckOutput> status(true).withResult(outputBuilder.build()).build();
 897         return Futures.immediateFuture(result);
 898     }
 899
 900     @Override
 901     public Future<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
 902         logger.debug("Input received : " + input.toString());
 903         LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
 904         String action = Action.LiveUpgrade.toString() ;
 905         String rpcName = convertActionNameToUrl(action);
 906         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 907         if(null == status) {
 908             try {
 909                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 910                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 911                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 912             } catch (ParseException e) {
 913                 status = buildParsingErrorStatus(e);
 914
 915                 LoggingUtils.logErrorMessage(
 916                         LoggingConstants.TargetNames.APPC_PROVIDER,
 917                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 918                         this.getClass().getName());
 919
 920             }
 921         }
 922         outputBuilder.setCommonHeader(input.getCommonHeader());
 923         outputBuilder.setStatus(status);
 924         RpcResult<LiveUpgradeOutput> result = RpcResultBuilder.<LiveUpgradeOutput> status(true).withResult(outputBuilder.build()).build();
 925         return Futures.immediateFuture(result);
 926     }
 927
 928
 929     @Override
 930     public Future<RpcResult<LockOutput>> lock(LockInput input) {
 931         logger.debug("Input received : " + input.toString());
 932         LockOutputBuilder outputBuilder = new LockOutputBuilder();
 933         String action = Action.Lock.toString() ;
 934         String rpcName = Action.Lock.name().toLowerCase();
 935         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 936         if(null == status) {
 937             try {
 938                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 939                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 940                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 941             } catch (ParseException e) {
 942                 status = buildParsingErrorStatus(e);
 943
 944                 LoggingUtils.logErrorMessage(
 945                         LoggingConstants.TargetNames.APPC_PROVIDER,
 946                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 947                         this.getClass().getName());
 948
 949             }
 950         }
 951         outputBuilder.setCommonHeader(input.getCommonHeader());
 952         outputBuilder.setStatus(status);
 953         RpcResult<LockOutput> result = RpcResultBuilder.<LockOutput> status(true).withResult(outputBuilder.build()).build();
 954         return Futures.immediateFuture(result);
 955     }
 956
 957
 958     @Override
 959     public Future<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
 960         logger.debug("Input received : " + input.toString());
 961         UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
 962         String action = Action.Unlock.toString() ;
 963         String rpcName = Action.Unlock.name().toLowerCase();
 964         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 965         if(null == status) {
 966             try {
 967                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 968                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 969                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 970             } catch (ParseException e) {
 971                 status = buildParsingErrorStatus(e);
 972
 973                 LoggingUtils.logErrorMessage(
 974                         LoggingConstants.TargetNames.APPC_PROVIDER,
 975                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 976                         this.getClass().getName());
 977
 978             }
 979         }
 980         outputBuilder.setCommonHeader(input.getCommonHeader());
 981         outputBuilder.setStatus(status);
 982         RpcResult<UnlockOutput> result = RpcResultBuilder.<UnlockOutput> status(true).withResult(outputBuilder.build()).build();
 983         return Futures.immediateFuture(result);
 984     }
 985
 986     @Override
 987     public Future<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
 988         logger.debug("Input received : " + input.toString());
 989         CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
 990         String action = Action.CheckLock.toString();
 991         String rpcName = Action.CheckLock.name().toLowerCase();
 992         RequestHandlerOutput requestHandlerOutput = null;
 993         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(),
 994             input.getAction(), action);
 995         if (null == status) {
 996             try {
 997                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input
 998                     .getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action)
 999                     .rpcName(rpcName).build();
1000                 requestHandlerOutput = executeRequest(request);
1001
1002                 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1003                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1004                     input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1005             } catch (ParseException e) {
1006                 status = buildParsingErrorStatus(e);
1007
1008                 LoggingUtils.logErrorMessage(
1009                     LoggingConstants.TargetNames.APPC_PROVIDER,
1010                     String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1011                     this.getClass().getName());
1012
1013             }
1014         }
1015         outputBuilder.setCommonHeader(input.getCommonHeader());
1016         outputBuilder.setStatus(status);
1017         if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1018             outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(requestHandlerOutput.getResponseContext()
1019                 .getAdditionalContext().get("locked").toUpperCase()));
1020         }
1021         RpcResult<CheckLockOutput> result = RpcResultBuilder.<CheckLockOutput>status(true)
1022             .withResult(outputBuilder.build()).build();
1023         return Futures.immediateFuture(result);
1024     }
1025
1026     @Override
1027     public Future<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1028         logger.debug("Input received : " + input.toString());
1029         ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1030         String action = Action.ConfigBackup.toString() ;
1031         String rpcName = Action.ConfigBackup.name().toLowerCase();
1032         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1033         if(null == status) {
1034             try {
1035                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1036                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1037                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1038             } catch (ParseException e) {
1039                 status = buildParsingErrorStatus(e);
1040
1041                 LoggingUtils.logErrorMessage(
1042                         LoggingConstants.TargetNames.APPC_PROVIDER,
1043                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1044                         this.getClass().getName());
1045
1046             }
1047         }
1048         outputBuilder.setCommonHeader(input.getCommonHeader());
1049         outputBuilder.setStatus(status);
1050         RpcResult<ConfigBackupOutput> result = RpcResultBuilder.<ConfigBackupOutput> status(true).withResult(outputBuilder.build()).build();
1051         return Futures.immediateFuture(result);
1052     }
1053
1054
1055     @Override
1056     public Future<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1057         logger.debug("Input received : " + input.toString());
1058         ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1059         String action = Action.ConfigBackupDelete.toString() ;
1060         String rpcName = Action.ConfigBackupDelete.name().toLowerCase();
1061         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1062         if(null == status) {
1063             try {
1064                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1065                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1066                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1067             } catch (ParseException e) {
1068                 status = buildParsingErrorStatus(e);
1069
1070                 LoggingUtils.logErrorMessage(
1071                         LoggingConstants.TargetNames.APPC_PROVIDER,
1072                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1073                         this.getClass().getName());
1074
1075             }
1076         }
1077         outputBuilder.setCommonHeader(input.getCommonHeader());
1078         outputBuilder.setStatus(status);
1079         RpcResult<ConfigBackupDeleteOutput> result = RpcResultBuilder.<ConfigBackupDeleteOutput> status(true).withResult(outputBuilder.build()).build();
1080         return Futures.immediateFuture(result);
1081     }
1082
1083
1084     @Override
1085     public Future<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1086         logger.debug("Input received : " + input.toString());
1087         ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1088         String action = Action.ConfigExport.toString() ;
1089         String rpcName = Action.ConfigExport.name().toLowerCase();
1090         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1091         if(null == status) {
1092             try {
1093                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1094                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1095                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1096             } catch (ParseException e) {
1097                 status = buildParsingErrorStatus(e);
1098
1099                 LoggingUtils.logErrorMessage(
1100                         LoggingConstants.TargetNames.APPC_PROVIDER,
1101                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1102                         this.getClass().getName());
1103
1104             }
1105         }
1106         outputBuilder.setCommonHeader(input.getCommonHeader());
1107         outputBuilder.setStatus(status);
1108         RpcResult<ConfigExportOutput> result = RpcResultBuilder.<ConfigExportOutput> status(true).withResult(outputBuilder.build()).build();
1109         return Futures.immediateFuture(result);
1110     }
1111     @Override
1112     public Future<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
1113         logger.debug("Input received : " + input.toString());
1114
1115         StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
1116         String action = Action.StartApplication.toString() ;
1117         String rpcName = Action.StartApplication.name().toLowerCase();
1118         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1119         if(null == status) {
1120             try {
1121                 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1122                         .commonHeader(input.getCommonHeader())
1123                         .actionIdentifiers(input.getActionIdentifiers())
1124                         .payload(input.getPayload())
1125                         .action(action)
1126                         .rpcName(rpcName)
1127                         .build();
1128
1129                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1130                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1131             } catch (ParseException e) {
1132                 status = buildParsingErrorStatus(e);
1133
1134                 LoggingUtils.logErrorMessage(
1135                         LoggingConstants.TargetNames.APPC_PROVIDER,
1136                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1137                         this.getClass().getName());
1138
1139             }
1140         }
1141         outputBuilder.setCommonHeader(input.getCommonHeader());
1142         outputBuilder.setStatus(status);
1143         RpcResult<StartApplicationOutput> result = RpcResultBuilder.<StartApplicationOutput> status(true).withResult(outputBuilder.build()).build();
1144         return Futures.immediateFuture(result);
1145     }
1146     @Override
1147     public Future<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input){
1148         logger.debug("Input received : " + input.toString());
1149         StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1150         String action = Action.StopApplication.toString() ;
1151         String rpcName = Action.StopApplication.name().toLowerCase();
1152         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1153         if(null == status) {
1154             try {
1155                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
1156                 status = buildStatusWithDispatcherOutput(executeRequest(request));
1157                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1158             } catch (ParseException e) {
1159                 status = buildParsingErrorStatus(e);
1160
1161                 LoggingUtils.logErrorMessage(
1162                         LoggingConstants.TargetNames.APPC_PROVIDER,
1163                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1164                         this.getClass().getName());
1165
1166             }
1167         }
1168         outputBuilder.setCommonHeader(input.getCommonHeader());
1169         outputBuilder.setStatus(status);
1170         RpcResult<StopApplicationOutput> result = RpcResultBuilder.<StopApplicationOutput> status(true).withResult(outputBuilder.build()).build();
1171         return Futures.immediateFuture(result);
1172     }
1173
1174     private String convertActionNameToUrl(String action) {
1175         String regex = "([a-z])([A-Z]+)";
1176         String replacement = "$1-$2";
1177         return action.replaceAll(regex, replacement)
1178                 .toLowerCase();
1179     }
1180
1181     RequestHandlerOutput executeRequest(RequestHandlerInput request){
1182         RequestHandler handler = getRequestHandler();
1183         RequestHandlerOutput requestHandlerOutput;
1184         if (handler != null) {
1185             try {
1186                 requestHandlerOutput = handler.handleRequest(request);
1187             } catch (Exception e) {
1188                 logger.info("UNEXPECTED FAILURE while executing " + request.getRequestContext().getAction().name());
1189                 requestHandlerOutput = createErrorRequestHandlerObj(request,
1190                     LCMCommandStatus.UNEXPECTED_ERROR, Msg.EXCEPTION_CALLING_DG, e);
1191             }
1192         } else {
1193             String errorMsg = "LCM request cannot be processed at the moment because APPC isn't running";
1194             requestHandlerOutput = createErrorRequestHandlerObj(request,
1195                 LCMCommandStatus.REJECTED, Msg.REQUEST_HANDLER_UNAVAILABLE, new APPCException(errorMsg));
1196         }
1197         return requestHandlerOutput;
1198     }
1199 }