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