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

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