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