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