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

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