appc-provider/appc-provider-bundle/src/main/java/org/openecomp/appc/provider/AppcProviderLcm.java

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