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             String errorMessage = e.getMessage() != null ? e.getMessage() : e.toString();
 466             Params params = new Params().addParam("errorMsg", errorMessage);
 467             responseContext.setStatus(LCMCommandStatus.UNEXPECTED_ERROR.toStatus(params));
 468
 469             LoggingUtils.logErrorMessage(
 470                     LoggingConstants.TargetNames.APPC_PROVIDER,
 471                     reason,
 472                     this.getClass().getName());
 473
 474
 475         }
 476         return requestHandlerOutput;
 477     }
 478
 479     private RequestHandler getRequestHandler(){
 480         RequestHandler handler ;
 481         final BundleContext context = FrameworkUtil.getBundle(RequestHandler.class).getBundleContext();
 482         final ServiceReference reference = context.getServiceReference(RequestHandler.class.getName());
 483
 484         if (reference != null) {
 485             handler = (RequestHandler) context.getService(reference);
 486         } else {
 487             logger.error("Cannot find service reference for " + RequestHandler.class.getName());
 488             throw new RuntimeException();
 489         }
 490         return  handler ;
 491     }
 492
 493
 494     @Override
 495     public Future<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
 496         logger.debug("Input received : " + input.toString());
 497         TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
 498         String action = Action.Terminate.toString() ;
 499         String rpcName = Action.Terminate.name().toLowerCase();
 500         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 501         if(null == status) {
 502             try {
 503                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 504                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 505                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 506             } catch (ParseException e) {
 507
 508                 status = buildParsingErrorStatus(e);
 509
 510                 LoggingUtils.logErrorMessage(
 511                         LoggingConstants.TargetNames.APPC_PROVIDER,
 512                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 513                         this.getClass().getName());
 514
 515             }
 516
 517         }
 518         outputBuilder.setCommonHeader(input.getCommonHeader());
 519         outputBuilder.setStatus(status);
 520         RpcResult<TerminateOutput> result = RpcResultBuilder.<TerminateOutput> status(true).withResult(outputBuilder.build()).build();
 521         return Futures.immediateFuture(result);
 522     }
 523
 524
 525
 526     @Override
 527     public Future<RpcResult<ModifyConfigOutput>> modifyConfig(ModifyConfigInput input) {
 528         logger.debug("Input received : " + input.toString());
 529         ModifyConfigOutputBuilder outputBuilder = new ModifyConfigOutputBuilder();
 530         String action = Action.ModifyConfig.toString() ;
 531         String rpcName = "modify-config";
 532         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 533         if(null == status) {
 534             try {
 535                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 536                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 537                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 538             } catch (ParseException e) {
 539                 status = buildParsingErrorStatus(e);
 540
 541                 LoggingUtils.logErrorMessage(
 542                         LoggingConstants.TargetNames.APPC_PROVIDER,
 543                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 544                         this.getClass().getName());
 545
 546             }
 547         }
 548         outputBuilder.setCommonHeader(input.getCommonHeader());
 549         outputBuilder.setStatus(status);
 550         RpcResult<ModifyConfigOutput> result = RpcResultBuilder.<ModifyConfigOutput> status(true).withResult(outputBuilder.build()).build();
 551         return Futures.immediateFuture(result);
 552     }
 553
 554     @Override
 555     public Future<RpcResult<TestOutput>> test(TestInput input) {
 556         logger.debug("Input received : " + input.toString());
 557         TestOutputBuilder outputBuilder = new TestOutputBuilder();
 558         String action = Action.Test.toString() ;
 559         String rpcName = Action.Test.name().toLowerCase();
 560         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 561         if(null == status) {
 562             try {
 563                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 564                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 565                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 566             } catch (ParseException e) {
 567                 status = buildParsingErrorStatus(e);
 568
 569                 LoggingUtils.logErrorMessage(
 570                         LoggingConstants.TargetNames.APPC_PROVIDER,
 571                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 572                         this.getClass().getName());
 573
 574             }
 575         }
 576         outputBuilder.setCommonHeader(input.getCommonHeader());
 577         outputBuilder.setStatus(status);
 578         RpcResult<TestOutput> result = RpcResultBuilder.<TestOutput> status(true).withResult(outputBuilder.build()).build();
 579         return Futures.immediateFuture(result);
 580     }
 581
 582
 583     @Override
 584     public Future<RpcResult<StopOutput>> stop(StopInput input) {
 585         logger.debug("Input received : " + input.toString());
 586         StopOutputBuilder outputBuilder = new StopOutputBuilder();
 587         String action = Action.Stop.toString() ;
 588         String rpcName = Action.Stop.name().toLowerCase();
 589         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 590         if(null == status) {
 591             try {
 592                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 593                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 594                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 595             } catch (ParseException e) {
 596                 status = buildParsingErrorStatus(e);
 597
 598                 LoggingUtils.logErrorMessage(
 599                         LoggingConstants.TargetNames.APPC_PROVIDER,
 600                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 601                         this.getClass().getName());
 602
 603             }
 604         }
 605         outputBuilder.setCommonHeader(input.getCommonHeader());
 606         outputBuilder.setStatus(status);
 607         RpcResult<StopOutput> result = RpcResultBuilder.<StopOutput> status(true).withResult(outputBuilder.build()).build();
 608         return Futures.immediateFuture(result);
 609     }
 610
 611     @Override
 612     public Future<RpcResult<AuditOutput>> audit(AuditInput input) {
 613         logger.debug("Input received : " + input.toString());
 614         AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
 615         String action = Action.Audit.toString();
 616         String rpcName = Action.Audit.name().toLowerCase();
 617         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 618         if(null == status) {
 619             try {
 620                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
 621                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 622                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 623             } catch (ParseException e) {
 624                 status = buildParsingErrorStatus(e);
 625
 626                 LoggingUtils.logErrorMessage(
 627                         LoggingConstants.TargetNames.APPC_PROVIDER,
 628                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 629                         this.getClass().getName());
 630
 631             }
 632         }
 633         outputBuilder.setCommonHeader(input.getCommonHeader());
 634         outputBuilder.setStatus(status);
 635         RpcResult<AuditOutput> result = RpcResultBuilder.<AuditOutput> status(true).withResult(outputBuilder.build()).build();
 636         return Futures.immediateFuture(result);
 637     }
 638
 639     @Override
 640     public Future<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
 641         logger.debug("Input received : " + input.toString());
 642         SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
 643         String action = Action.SoftwareUpload.toString() ;
 644         String rpcName = convertActionNameToUrl(action);
 645         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 646         if(null == status) {
 647             try {
 648                 RequestHandlerInput request = new RequestInputBuilder().
 649                         requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 650                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 651                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 652             } catch (ParseException e) {
 653                 status = buildParsingErrorStatus(e);
 654
 655                 LoggingUtils.logErrorMessage(
 656                         LoggingConstants.TargetNames.APPC_PROVIDER,
 657                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 658                         this.getClass().getName());
 659
 660             }
 661         }
 662         outputBuilder.setCommonHeader(input.getCommonHeader());
 663         outputBuilder.setStatus(status);
 664         RpcResult<SoftwareUploadOutput> result = RpcResultBuilder.<SoftwareUploadOutput> status(true).withResult(outputBuilder.build()).build();
 665         return Futures.immediateFuture(result);
 666     }
 667
 668     @Override
 669     public Future<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
 670         logger.debug("Input received : " + input.toString());
 671         HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
 672         String action = Action.HealthCheck.toString() ;
 673         String rpcName = convertActionNameToUrl(action);
 674         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 675         if(null == status) {
 676             try {
 677                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).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<HealthCheckOutput> result = RpcResultBuilder.<HealthCheckOutput> status(true).withResult(outputBuilder.build()).build();
 693         return Futures.immediateFuture(result);
 694     }
 695
 696     @Override
 697     public Future<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
 698         logger.debug("Input received : " + input.toString());
 699         LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
 700         String action = Action.LiveUpgrade.toString() ;
 701         String rpcName = convertActionNameToUrl(action);
 702         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 703         if(null == status) {
 704             try {
 705                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 706                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 707                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 708             } catch (ParseException e) {
 709                 status = buildParsingErrorStatus(e);
 710
 711                 LoggingUtils.logErrorMessage(
 712                         LoggingConstants.TargetNames.APPC_PROVIDER,
 713                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 714                         this.getClass().getName());
 715
 716             }
 717         }
 718         outputBuilder.setCommonHeader(input.getCommonHeader());
 719         outputBuilder.setStatus(status);
 720         RpcResult<LiveUpgradeOutput> result = RpcResultBuilder.<LiveUpgradeOutput> status(true).withResult(outputBuilder.build()).build();
 721         return Futures.immediateFuture(result);
 722     }
 723
 724
 725     @Override
 726     public Future<RpcResult<LockOutput>> lock(LockInput input) {
 727         logger.debug("Input received : " + input.toString());
 728         LockOutputBuilder outputBuilder = new LockOutputBuilder();
 729         String action = Action.Lock.toString() ;
 730         String rpcName = Action.Lock.name().toLowerCase();
 731         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 732         if(null == status) {
 733             try {
 734                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
 735                 status = buildStatusWithDispatcherOutput(executeRequest(request));
 736                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 737             } catch (ParseException e) {
 738                 status = buildParsingErrorStatus(e);
 739
 740                 LoggingUtils.logErrorMessage(
 741                         LoggingConstants.TargetNames.APPC_PROVIDER,
 742                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 743                         this.getClass().getName());
 744
 745             }
 746         }
 747         outputBuilder.setCommonHeader(input.getCommonHeader());
 748         outputBuilder.setStatus(status);
 749         RpcResult<LockOutput> result = RpcResultBuilder.<LockOutput> status(true).withResult(outputBuilder.build()).build();
 750         return Futures.immediateFuture(result);
 751     }
 752
 753
 754     @Override
 755     public Future<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
 756         logger.debug("Input received : " + input.toString());
 757         UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
 758         String action = Action.Unlock.toString() ;
 759         String rpcName = Action.Unlock.name().toLowerCase();
 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<UnlockOutput> result = RpcResultBuilder.<UnlockOutput> status(true).withResult(outputBuilder.build()).build();
 779         return Futures.immediateFuture(result);
 780     }
 781
 782     @Override
 783     public Future<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
 784         logger.debug("Input received : " + input.toString());
 785         CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
 786         String action = Action.CheckLock.toString() ;
 787         String rpcName = Action.CheckLock.name().toLowerCase();
 788         RequestHandlerOutput requestHandlerOutput=null;
 789         Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
 790         if(null == status) {
 791             try {
 792                 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
 793                 requestHandlerOutput=executeRequest(request);
 794
 795                 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
 796                 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
 797             } catch (ParseException e) {
 798                 status = buildParsingErrorStatus(e);
 799
 800                 LoggingUtils.logErrorMessage(
 801                         LoggingConstants.TargetNames.APPC_PROVIDER,
 802                         String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
 803                         this.getClass().getName());
 804
 805             }
 806         }
 807         outputBuilder.setCommonHeader(input.getCommonHeader());
 808         outputBuilder.setStatus(status);
 809         if(requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
 810             outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(requestHandlerOutput.getResponseContext().getAdditionalContext().get("locked").toUpperCase()));
 811         }
 812         RpcResult<CheckLockOutput> result = RpcResultBuilder.<CheckLockOutput> status(true).withResult(outputBuilder.build()).build();
 813         return Futures.immediateFuture(result);
 814     }
 815
 816     private String convertActionNameToUrl(String action) {
 817         String regex = "([a-z])([A-Z]+)";
 818         String replacement = "$1-$2";
 819         return action.replaceAll(regex, replacement)
 820                 .toLowerCase();
 821     }
 822
 823
 824 }