2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Copyright (C) 2017 Amdocs
8 * =============================================================================
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
13 * http://www.apache.org/licenses/LICENSE-2.0
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
21 * ECOMP is a trademark and service mark of AT&T Intellectual Property.
22 * ============LICENSE_END=========================================================
25 package org.openecomp.appc.provider;
27 import com.att.eelf.configuration.EELFLogger;
28 import com.att.eelf.configuration.EELFManager;
29 import com.att.eelf.i18n.EELFResourceManager;
30 import com.google.common.util.concurrent.Futures;
31 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
32 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
33 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
34 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
35 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.AppcProviderLcmService;
36 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.AuditInput;
37 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.AuditOutput;
38 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.AuditOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.CheckLockInput;
40 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.CheckLockOutput;
41 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.CheckLockOutputBuilder;
42 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigBackupDeleteInput;
43 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigBackupDeleteOutput;
44 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigBackupDeleteOutputBuilder;
45 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigBackupInput;
46 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigBackupOutput;
47 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigBackupOutputBuilder;
48 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigExportInput;
49 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigExportOutput;
50 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigExportOutputBuilder;
51 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigModifyInput;
52 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigModifyOutput;
53 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigModifyOutputBuilder;
54 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigRestoreInput;
55 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigRestoreOutput;
56 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigRestoreOutputBuilder;
57 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigScaleoutInput;
58 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigScaleoutOutput;
59 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigScaleoutOutputBuilder;
60 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigureInput;
61 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigureOutput;
62 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.ConfigureOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.EvacuateInput;
64 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.EvacuateOutput;
65 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.EvacuateOutputBuilder;
66 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.HealthCheckInput;
67 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.HealthCheckOutput;
68 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.HealthCheckOutputBuilder;
69 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.LiveUpgradeInput;
70 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.LiveUpgradeOutput;
71 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.LiveUpgradeOutputBuilder;
72 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.LockInput;
73 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.LockOutput;
74 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.LockOutputBuilder;
75 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.MigrateInput;
76 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.MigrateOutput;
77 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.MigrateOutputBuilder;
78 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RebuildInput;
79 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RebuildOutput;
80 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RebuildOutputBuilder;
81 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RestartInput;
82 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RestartOutput;
83 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RestartOutputBuilder;
84 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RollbackInput;
85 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RollbackOutput;
86 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.RollbackOutputBuilder;
87 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SnapshotInput;
88 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SnapshotOutput;
89 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SnapshotOutputBuilder;
90 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SoftwareUploadInput;
91 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SoftwareUploadOutput;
92 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SoftwareUploadOutputBuilder;
93 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StartInput;
94 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StartOutput;
95 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StartOutputBuilder;
96 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StopInput;
97 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StopOutput;
98 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StopOutputBuilder;
99 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SyncInput;
100 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SyncOutput;
101 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.SyncOutputBuilder;
102 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.TerminateInput;
103 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.TerminateOutput;
104 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.TerminateOutputBuilder;
105 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.TestInput;
106 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.TestOutput;
107 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.TestOutputBuilder;
108 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.UnlockInput;
109 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.UnlockOutput;
110 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.UnlockOutputBuilder;
111 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StartApplicationOutput;
112 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StartApplicationOutputBuilder;
113 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StartApplicationInput;
114 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StopApplicationOutput;
115 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StopApplicationOutputBuilder;
116 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.StopApplicationInput;
117 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.status.Status;
118 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.status.StatusBuilder;
119 import org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.Action;
120 import org.opendaylight.yangtools.yang.common.RpcResult;
121 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
122 import org.openecomp.appc.Constants;
123 import org.openecomp.appc.configuration.Configuration;
124 import org.openecomp.appc.configuration.ConfigurationFactory;
125 import org.openecomp.appc.domainmodel.lcm.ResponseContext;
126 import org.openecomp.appc.exceptions.APPCException;
127 import org.openecomp.appc.executor.objects.LCMCommandStatus;
128 import org.openecomp.appc.executor.objects.Params;
129 import org.openecomp.appc.i18n.Msg;
130 import org.openecomp.appc.logging.LoggingConstants;
131 import org.openecomp.appc.logging.LoggingUtils;
132 import org.openecomp.appc.provider.lcm.util.RequestInputBuilder;
133 import org.openecomp.appc.provider.lcm.util.ValidationService;
134 import org.openecomp.appc.requesthandler.RequestHandler;
135 import org.openecomp.appc.requesthandler.objects.RequestHandlerInput;
136 import org.openecomp.appc.requesthandler.objects.RequestHandlerOutput;
137 import org.osgi.framework.BundleContext;
138 import org.osgi.framework.FrameworkUtil;
139 import org.osgi.framework.ServiceReference;
141 import java.text.ParseException;
142 import java.util.concurrent.ExecutorService;
143 import java.util.concurrent.Executors;
144 import java.util.concurrent.Future;
146 public class AppcProviderLcm implements AutoCloseable, AppcProviderLcmService {
148 private Configuration configuration = ConfigurationFactory.getConfiguration();
149 private final EELFLogger logger = EELFManager.getInstance().getLogger(AppcProviderLcm.class);
151 private final ExecutorService executor;
153 private final String COMMON_ERROR_MESSAGE_TEMPLATE = "Error processing %s input : %s";
156 * The ODL data store broker. Provides access to a conceptual data tree store and also provides the ability to
157 * subscribe for changes to data under a given branch of the tree.
159 protected DataBroker dataBroker;
162 * ODL Notification Service that provides publish/subscribe capabilities for YANG modeled notifications.
164 protected NotificationProviderService notificationService;
167 * Provides a registry for Remote Procedure Call (RPC) service implementations. The RPCs are defined in YANG models.
169 protected RpcProviderRegistry rpcRegistry;
172 * Represents our RPC implementation registration
174 protected BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
179 * @param notificationProviderService
180 * @param rpcProviderRegistry
185 public AppcProviderLcm(DataBroker dataBroker, NotificationProviderService notificationProviderService,
186 RpcProviderRegistry rpcProviderRegistry) {
188 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
189 logger.info(Msg.COMPONENT_INITIALIZING, appName, "provider-lcm");
191 executor = Executors.newFixedThreadPool(1);
192 this.dataBroker = dataBroker;
193 this.notificationService = notificationProviderService;
194 this.rpcRegistry = rpcProviderRegistry;
196 if (this.rpcRegistry != null) {
197 rpcRegistration = rpcRegistry.addRpcImplementation(AppcProviderLcmService.class, this);
200 logger.info(Msg.COMPONENT_INITIALIZED, appName, "provider");
204 * Implements the close of the service
206 * @see java.lang.AutoCloseable#close()
208 @SuppressWarnings("nls")
210 public void close() throws Exception {
211 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
212 logger.info(Msg.COMPONENT_TERMINATING, appName, "provider");
214 if (rpcRegistration != null) {
215 rpcRegistration.close();
217 logger.info(Msg.COMPONENT_TERMINATED, appName, "provider");
222 * Rebuilds a specific VNF
224 * @see AppcProviderLcmService#rebuild(RebuildInput)
227 public Future<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
228 logger.debug("Input received : " + input.toString());
230 RebuildOutputBuilder outputBuilder = new RebuildOutputBuilder();
231 String action = Action.Rebuild.toString() ;
232 String rpcName = Action.Rebuild.name().toLowerCase();
234 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
237 RequestHandlerInput request = new RequestInputBuilder().requestContext()
238 .commonHeader(input.getCommonHeader())
239 .actionIdentifiers(input.getActionIdentifiers())
240 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
241 status = buildStatusWithDispatcherOutput(executeRequest(request));
242 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
243 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
244 } catch (ParseException e) {
245 status = buildParsingErrorStatus(e);
247 LoggingUtils.logErrorMessage(
248 LoggingConstants.TargetNames.APPC_PROVIDER,
249 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
250 this.getClass().getName());
254 outputBuilder.setCommonHeader(input.getCommonHeader());
255 outputBuilder.setStatus(status);
256 RpcResult<RebuildOutput> result = RpcResultBuilder.<RebuildOutput> status(true).withResult(outputBuilder.build()).build();
257 return Futures.immediateFuture(result);
261 * Restarts a specific VNF
263 * @see org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.AppcProviderLcmService#restart(RestartInput)
266 public Future<RpcResult<RestartOutput>> restart(RestartInput input) {
267 logger.debug("Input received : " + input.toString());
269 RestartOutputBuilder outputBuilder = new RestartOutputBuilder();
270 String action = Action.Restart.toString() ;
271 String rpcName = Action.Restart.name().toLowerCase();
273 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
276 RequestHandlerInput request = new RequestInputBuilder().requestContext()
277 .commonHeader(input.getCommonHeader())
278 .actionIdentifiers(input.getActionIdentifiers())
279 .payload(input.getPayload())
284 status = buildStatusWithDispatcherOutput(executeRequest(request));
285 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
286 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
287 } catch (ParseException e) {
288 status = buildParsingErrorStatus(e);
290 LoggingUtils.logErrorMessage(
291 LoggingConstants.TargetNames.APPC_PROVIDER,
292 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
293 this.getClass().getName());
297 outputBuilder.setCommonHeader(input.getCommonHeader());
298 outputBuilder.setStatus(status);
299 RpcResult<RestartOutput> result = RpcResultBuilder.<RestartOutput> status(true).withResult(outputBuilder.build()).build();
300 return Futures.immediateFuture(result);
304 * Migrates a specific VNF
306 * @see AppcProviderLcmService#migrate(MigrateInput)
309 public Future<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
310 logger.debug("Input received : " + input.toString());
312 MigrateOutputBuilder outputBuilder = new MigrateOutputBuilder();
313 String action = Action.Migrate.toString() ;
314 String rpcName = Action.Migrate.name().toLowerCase();
316 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
319 RequestHandlerInput request = new RequestInputBuilder().requestContext()
320 .commonHeader(input.getCommonHeader())
321 .actionIdentifiers(input.getActionIdentifiers())
322 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
323 status = buildStatusWithDispatcherOutput(executeRequest(request));
324 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
325 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
326 } catch (ParseException e) {
327 status = buildParsingErrorStatus(e);
329 LoggingUtils.logErrorMessage(
330 LoggingConstants.TargetNames.APPC_PROVIDER,
331 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
332 this.getClass().getName());
336 outputBuilder.setCommonHeader(input.getCommonHeader());
337 outputBuilder.setStatus(status);
338 RpcResult<MigrateOutput> result = RpcResultBuilder.<MigrateOutput> status(true).withResult(outputBuilder.build()).build();
339 return Futures.immediateFuture(result);
343 * Evacuates a specific VNF
345 * @see AppcProviderLcmService#evacuate(EvacuateInput)
348 public Future<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
349 logger.debug("Input received : " + input.toString());
351 EvacuateOutputBuilder outputBuilder = new EvacuateOutputBuilder();
352 String action = Action.Evacuate.toString() ;
353 String rpcName = Action.Evacuate.name().toLowerCase();
354 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
357 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
358 status = buildStatusWithDispatcherOutput(executeRequest(request));
359 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
360 } catch (ParseException e) {
361 status = buildParsingErrorStatus(e);
363 LoggingUtils.logErrorMessage(
364 LoggingConstants.TargetNames.APPC_PROVIDER,
365 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
366 this.getClass().getName());
370 outputBuilder.setCommonHeader(input.getCommonHeader());
371 outputBuilder.setStatus(status);
372 RpcResult<EvacuateOutput> result = RpcResultBuilder.<EvacuateOutput> status(true).withResult(outputBuilder.build()).build();
373 return Futures.immediateFuture(result);
378 * Evacuates a specific VNF
380 * @see AppcProviderLcmService#snapshot(SnapshotInput)
383 public Future<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
384 logger.debug("Input received : " + input.toString());
386 SnapshotOutputBuilder outputBuilder = new SnapshotOutputBuilder();
387 String action = Action.Snapshot.toString() ;
388 String rpcName = Action.Snapshot.name().toLowerCase();
390 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
391 String identityUrl = input.getIdentityUrl();
394 RequestHandlerInput request = new RequestInputBuilder().requestContext()
395 .commonHeader(input.getCommonHeader())
396 .actionIdentifiers(input.getActionIdentifiers())
397 .payload(input.getPayload()).action(action).rpcName(rpcName)
398 .additionalContext("identity-url", identityUrl).build();
399 status = buildStatusWithDispatcherOutput(executeRequest(request));
400 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
401 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
402 } catch (ParseException e) {
403 status = buildParsingErrorStatus(e);
405 LoggingUtils.logErrorMessage(
406 LoggingConstants.TargetNames.APPC_PROVIDER,
407 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
408 this.getClass().getName());
411 outputBuilder.setCommonHeader(input.getCommonHeader());
412 outputBuilder.setStatus(status);
413 RpcResult<SnapshotOutput> result = RpcResultBuilder.<SnapshotOutput> status(true).withResult(outputBuilder.build()).build();
414 return Futures.immediateFuture(result);
418 public Future<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
419 logger.debug("Input received : " + input.toString());
421 RollbackOutputBuilder outputBuilder = new RollbackOutputBuilder();
422 String rpcName = Action.Rollback.toString() ;
424 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), rpcName);
425 String identityUrl = input.getIdentityUrl();
426 String snapshotId = input.getSnapshotId();
429 RequestHandlerInput request = new RequestInputBuilder().requestContext()
430 .commonHeader(input.getCommonHeader())
431 .actionIdentifiers(input.getActionIdentifiers())
432 .payload(input.getPayload()).additionalContext("identity-url", identityUrl)
433 .additionalContext("snapshot-id", snapshotId).action(rpcName).build();
434 status = buildStatusWithDispatcherOutput(executeRequest(request));
435 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
436 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
437 } catch (ParseException e) {
438 status = buildParsingErrorStatus(e);
440 LoggingUtils.logErrorMessage(
441 LoggingConstants.TargetNames.APPC_PROVIDER,
442 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, rpcName, e.getMessage()),
443 this.getClass().getName());
447 outputBuilder.setCommonHeader(input.getCommonHeader());
448 outputBuilder.setStatus(status);
449 RpcResult<RollbackOutput> result = RpcResultBuilder.<RollbackOutput> status(true).withResult(outputBuilder.build()).build();
450 return Futures.immediateFuture(result);
454 public Future<RpcResult<SyncOutput>> sync(SyncInput input) {
455 logger.debug("Input received : " + input.toString());
456 SyncOutputBuilder outputBuilder = new SyncOutputBuilder();
457 String action = Action.Sync.toString() ;
458 String rpcName = Action.Sync.name().toLowerCase();
460 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
463 RequestHandlerInput request = new RequestInputBuilder().requestContext()
464 .commonHeader(input.getCommonHeader())
465 .actionIdentifiers(input.getActionIdentifiers())
466 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
467 status = buildStatusWithDispatcherOutput(executeRequest(request));
468 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
469 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
470 } catch (ParseException e) {
471 status = buildParsingErrorStatus(e);
473 LoggingUtils.logErrorMessage(
474 LoggingConstants.TargetNames.APPC_PROVIDER,
475 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
476 this.getClass().getName());
480 outputBuilder.setCommonHeader(input.getCommonHeader());
481 outputBuilder.setStatus(status);
482 RpcResult<SyncOutput> result = RpcResultBuilder.<SyncOutput> status(true).withResult(outputBuilder.build()).build();
483 return Futures.immediateFuture(result);
486 private Status buildParsingErrorStatus(ParseException e){
487 LCMCommandStatus requestParsingFailure = LCMCommandStatus.REQUEST_PARSING_FAILED;
488 String errorMessage = e.getMessage() != null ? e.getMessage() : e.toString();
489 Params params = new Params().addParam("errorMsg", errorMessage);
490 return buildStatus(requestParsingFailure.getResponseCode(), requestParsingFailure.getFormattedMessage(params));
493 private Status buildStatus(Integer code,String message){
494 StatusBuilder status = new StatusBuilder();
495 status.setCode(code);
496 status.setMessage(message);
497 return status.build();
500 private Status buildStatusWithDispatcherOutput(RequestHandlerOutput requestHandlerOutput){
501 Integer statusCode = requestHandlerOutput.getResponseContext().getStatus().getCode();
502 String statusMessage = requestHandlerOutput.getResponseContext().getStatus().getMessage();
503 return buildStatus(statusCode, statusMessage);
506 private RequestHandlerOutput createErrorRequestHandlerObj(RequestHandlerInput request,
507 LCMCommandStatus cmdStatus,
510 final String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
511 final String reason = EELFResourceManager.format(msg, e,
512 appName, e.getClass().getSimpleName(), "", e.getMessage());
514 RequestHandlerOutput requestHandlerOutput = new RequestHandlerOutput();
515 final ResponseContext responseContext = new ResponseContext();
516 requestHandlerOutput.setResponseContext(responseContext);
517 responseContext.setCommonHeader(request.getRequestContext().getCommonHeader());
519 String errorMessage = e.getMessage() != null ? e.getMessage() : e.toString();
520 Params params = new Params().addParam("errorMsg", errorMessage);
521 responseContext.setStatus(cmdStatus.toStatus(params));
523 LoggingUtils.logErrorMessage(
524 LoggingConstants.TargetNames.APPC_PROVIDER,
526 this.getClass().getName());
528 return requestHandlerOutput;
531 private RequestHandler getRequestHandler(){
532 final BundleContext context = FrameworkUtil.getBundle(RequestHandler.class).getBundleContext();
533 if (context == null) {
537 final ServiceReference reference = context.getServiceReference(RequestHandler.class.getName());
538 if (reference == null) {
539 logger.error("Cannot find service reference for " + RequestHandler.class.getName());
540 throw new RuntimeException();
543 return (RequestHandler) context.getService(reference);
547 public Future<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
548 logger.debug("Input received : " + input.toString());
549 TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
550 String action = Action.Terminate.toString() ;
551 String rpcName = Action.Terminate.name().toLowerCase();
553 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
556 RequestHandlerInput request = new RequestInputBuilder().requestContext()
557 .commonHeader(input.getCommonHeader())
558 .actionIdentifiers(input.getActionIdentifiers())
559 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
560 status = buildStatusWithDispatcherOutput(executeRequest(request));
561 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
562 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
563 } catch (ParseException e) {
565 status = buildParsingErrorStatus(e);
567 LoggingUtils.logErrorMessage(
568 LoggingConstants.TargetNames.APPC_PROVIDER,
569 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
570 this.getClass().getName());
575 outputBuilder.setCommonHeader(input.getCommonHeader());
576 outputBuilder.setStatus(status);
577 RpcResult<TerminateOutput> result =
578 RpcResultBuilder.<TerminateOutput> status(true).withResult(outputBuilder.build()).build();
579 return Futures.immediateFuture(result);
583 public Future<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
584 logger.debug("Input received : " + input.toString());
585 ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
586 String action = Action.Configure.toString() ;
587 String rpcName = "configure";
589 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
592 RequestHandlerInput request = new RequestInputBuilder().requestContext()
593 .commonHeader(input.getCommonHeader())
594 .actionIdentifiers(input.getActionIdentifiers())
595 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
596 status = buildStatusWithDispatcherOutput(executeRequest(request));
597 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
598 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
599 } catch (ParseException e) {
600 status = buildParsingErrorStatus(e);
602 LoggingUtils.logErrorMessage(
603 LoggingConstants.TargetNames.APPC_PROVIDER,
604 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
605 this.getClass().getName());
609 outputBuilder.setCommonHeader(input.getCommonHeader());
610 outputBuilder.setStatus(status);
611 RpcResult<ConfigureOutput> result =
612 RpcResultBuilder.<ConfigureOutput> status(true).withResult(outputBuilder.build()).build();
613 return Futures.immediateFuture(result);
617 public Future<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
618 logger.debug("Input received : " + input.toString());
619 ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
620 String action = Action.ConfigModify.toString() ;
621 String rpcName = "config-modify";
623 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
626 RequestHandlerInput request = new RequestInputBuilder().requestContext()
627 .commonHeader(input.getCommonHeader())
628 .actionIdentifiers(input.getActionIdentifiers())
629 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
630 status = buildStatusWithDispatcherOutput(executeRequest(request));
631 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
632 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
633 } catch (ParseException e) {
634 status = buildParsingErrorStatus(e);
636 LoggingUtils.logErrorMessage(
637 LoggingConstants.TargetNames.APPC_PROVIDER,
638 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
639 this.getClass().getName());
643 outputBuilder.setCommonHeader(input.getCommonHeader());
644 outputBuilder.setStatus(status);
645 RpcResult<ConfigModifyOutput> result =
646 RpcResultBuilder.<ConfigModifyOutput> status(true).withResult(outputBuilder.build()).build();
647 return Futures.immediateFuture(result);
651 public Future<RpcResult<ConfigScaleoutOutput>> configScaleout(ConfigScaleoutInput input) {
652 logger.debug("Input received : " + input.toString());
653 ConfigScaleoutOutputBuilder outputBuilder = new ConfigScaleoutOutputBuilder();
654 String action = Action.ConfigScaleOut.toString() ;
655 String rpcName = "config-scaleout";
657 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
660 RequestHandlerInput request = new RequestInputBuilder().requestContext()
661 .commonHeader(input.getCommonHeader())
662 .actionIdentifiers(input.getActionIdentifiers())
663 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
664 status = buildStatusWithDispatcherOutput(executeRequest(request));
665 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
666 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
667 } catch (ParseException e) {
668 status = buildParsingErrorStatus(e);
670 LoggingUtils.logErrorMessage(
671 LoggingConstants.TargetNames.APPC_PROVIDER,
672 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
673 this.getClass().getName());
677 outputBuilder.setCommonHeader(input.getCommonHeader());
678 outputBuilder.setStatus(status);
679 RpcResult<ConfigScaleoutOutput> result =
680 RpcResultBuilder.<ConfigScaleoutOutput> status(true).withResult(outputBuilder.build()).build();
681 return Futures.immediateFuture(result);
685 public Future<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
686 logger.debug("Input received : " + input.toString());
687 ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
688 String action = Action.ConfigRestore.toString() ;
689 String rpcName = "config-restore";
691 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
694 RequestHandlerInput request = new RequestInputBuilder().requestContext()
695 .commonHeader(input.getCommonHeader())
696 .actionIdentifiers(input.getActionIdentifiers())
697 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
698 status = buildStatusWithDispatcherOutput(executeRequest(request));
699 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
700 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
701 } catch (ParseException e) {
702 status = buildParsingErrorStatus(e);
704 LoggingUtils.logErrorMessage(
705 LoggingConstants.TargetNames.APPC_PROVIDER,
706 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
707 this.getClass().getName());
711 outputBuilder.setCommonHeader(input.getCommonHeader());
712 outputBuilder.setStatus(status);
713 RpcResult<ConfigRestoreOutput> result =
714 RpcResultBuilder.<ConfigRestoreOutput> status(true).withResult(outputBuilder.build()).build();
715 return Futures.immediateFuture(result);
719 public Future<RpcResult<TestOutput>> test(TestInput input) {
720 logger.debug("Input received : " + input.toString());
721 TestOutputBuilder outputBuilder = new TestOutputBuilder();
722 String action = Action.Test.toString() ;
723 String rpcName = Action.Test.name().toLowerCase();
724 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
727 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
728 status = buildStatusWithDispatcherOutput(executeRequest(request));
729 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
730 } catch (ParseException e) {
731 status = buildParsingErrorStatus(e);
733 LoggingUtils.logErrorMessage(
734 LoggingConstants.TargetNames.APPC_PROVIDER,
735 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
736 this.getClass().getName());
740 outputBuilder.setCommonHeader(input.getCommonHeader());
741 outputBuilder.setStatus(status);
742 RpcResult<TestOutput> result = RpcResultBuilder.<TestOutput> status(true).withResult(outputBuilder.build()).build();
743 return Futures.immediateFuture(result);
748 public Future<RpcResult<StopOutput>> stop(StopInput input) {
749 logger.debug("Input received : " + input.toString());
750 StopOutputBuilder outputBuilder = new StopOutputBuilder();
751 String action = Action.Stop.toString() ;
752 String rpcName = Action.Stop.name().toLowerCase();
753 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
756 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
757 status = buildStatusWithDispatcherOutput(executeRequest(request));
758 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
759 } catch (ParseException e) {
760 status = buildParsingErrorStatus(e);
762 LoggingUtils.logErrorMessage(
763 LoggingConstants.TargetNames.APPC_PROVIDER,
764 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
765 this.getClass().getName());
769 outputBuilder.setCommonHeader(input.getCommonHeader());
770 outputBuilder.setStatus(status);
771 RpcResult<StopOutput> result = RpcResultBuilder.<StopOutput> status(true).withResult(outputBuilder.build()).build();
772 return Futures.immediateFuture(result);
776 * Starts a specific VNF
778 * @see AppcProviderLcmService#start(StartInput)
781 public Future<RpcResult<StartOutput>> start(StartInput input) {
782 logger.debug("Input received : " + input.toString());
784 StartOutputBuilder outputBuilder = new StartOutputBuilder();
785 String action = Action.Start.toString() ;
786 String rpcName = Action.Start.name().toLowerCase();
787 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
790 RequestHandlerInput request = new RequestInputBuilder().requestContext()
791 .commonHeader(input.getCommonHeader())
792 .actionIdentifiers(input.getActionIdentifiers())
793 .payload(input.getPayload())
795 .rpcName(rpcName).build();
796 status = buildStatusWithDispatcherOutput(executeRequest(request));
797 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
798 } catch (ParseException e) {
799 status = buildParsingErrorStatus(e);
801 LoggingUtils.logErrorMessage(
802 LoggingConstants.TargetNames.APPC_PROVIDER,
803 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
804 this.getClass().getName());
808 outputBuilder.setCommonHeader(input.getCommonHeader());
809 outputBuilder.setStatus(status);
810 RpcResult<StartOutput> result = RpcResultBuilder.<StartOutput> status(true).withResult(outputBuilder.build()).build();
811 return Futures.immediateFuture(result);
816 public Future<RpcResult<AuditOutput>> audit(AuditInput input) {
817 logger.debug("Input received : " + input.toString());
818 AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
819 String action = Action.Audit.toString();
820 String rpcName = Action.Audit.name().toLowerCase();
821 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
824 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
825 status = buildStatusWithDispatcherOutput(executeRequest(request));
826 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
827 } catch (ParseException e) {
828 status = buildParsingErrorStatus(e);
830 LoggingUtils.logErrorMessage(
831 LoggingConstants.TargetNames.APPC_PROVIDER,
832 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
833 this.getClass().getName());
837 outputBuilder.setCommonHeader(input.getCommonHeader());
838 outputBuilder.setStatus(status);
839 RpcResult<AuditOutput> result = RpcResultBuilder.<AuditOutput> status(true).withResult(outputBuilder.build()).build();
840 return Futures.immediateFuture(result);
844 public Future<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
845 logger.debug("Input received : " + input.toString());
846 SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
847 String action = Action.SoftwareUpload.toString() ;
848 String rpcName = convertActionNameToUrl(action);
849 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
852 RequestHandlerInput request = new RequestInputBuilder().
853 requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
854 status = buildStatusWithDispatcherOutput(executeRequest(request));
855 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
856 } catch (ParseException e) {
857 status = buildParsingErrorStatus(e);
859 LoggingUtils.logErrorMessage(
860 LoggingConstants.TargetNames.APPC_PROVIDER,
861 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
862 this.getClass().getName());
866 outputBuilder.setCommonHeader(input.getCommonHeader());
867 outputBuilder.setStatus(status);
868 RpcResult<SoftwareUploadOutput> result = RpcResultBuilder.<SoftwareUploadOutput> status(true).withResult(outputBuilder.build()).build();
869 return Futures.immediateFuture(result);
873 public Future<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
874 logger.debug("Input received : " + input.toString());
875 HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
876 String action = Action.HealthCheck.toString() ;
877 String rpcName = convertActionNameToUrl(action);
878 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
881 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
882 status = buildStatusWithDispatcherOutput(executeRequest(request));
883 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
884 } catch (ParseException e) {
885 status = buildParsingErrorStatus(e);
887 LoggingUtils.logErrorMessage(
888 LoggingConstants.TargetNames.APPC_PROVIDER,
889 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
890 this.getClass().getName());
894 outputBuilder.setCommonHeader(input.getCommonHeader());
895 outputBuilder.setStatus(status);
896 RpcResult<HealthCheckOutput> result = RpcResultBuilder.<HealthCheckOutput> status(true).withResult(outputBuilder.build()).build();
897 return Futures.immediateFuture(result);
901 public Future<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
902 logger.debug("Input received : " + input.toString());
903 LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
904 String action = Action.LiveUpgrade.toString() ;
905 String rpcName = convertActionNameToUrl(action);
906 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
909 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
910 status = buildStatusWithDispatcherOutput(executeRequest(request));
911 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
912 } catch (ParseException e) {
913 status = buildParsingErrorStatus(e);
915 LoggingUtils.logErrorMessage(
916 LoggingConstants.TargetNames.APPC_PROVIDER,
917 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
918 this.getClass().getName());
922 outputBuilder.setCommonHeader(input.getCommonHeader());
923 outputBuilder.setStatus(status);
924 RpcResult<LiveUpgradeOutput> result = RpcResultBuilder.<LiveUpgradeOutput> status(true).withResult(outputBuilder.build()).build();
925 return Futures.immediateFuture(result);
930 public Future<RpcResult<LockOutput>> lock(LockInput input) {
931 logger.debug("Input received : " + input.toString());
932 LockOutputBuilder outputBuilder = new LockOutputBuilder();
933 String action = Action.Lock.toString() ;
934 String rpcName = Action.Lock.name().toLowerCase();
935 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
938 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
939 status = buildStatusWithDispatcherOutput(executeRequest(request));
940 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
941 } catch (ParseException e) {
942 status = buildParsingErrorStatus(e);
944 LoggingUtils.logErrorMessage(
945 LoggingConstants.TargetNames.APPC_PROVIDER,
946 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
947 this.getClass().getName());
951 outputBuilder.setCommonHeader(input.getCommonHeader());
952 outputBuilder.setStatus(status);
953 RpcResult<LockOutput> result = RpcResultBuilder.<LockOutput> status(true).withResult(outputBuilder.build()).build();
954 return Futures.immediateFuture(result);
959 public Future<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
960 logger.debug("Input received : " + input.toString());
961 UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
962 String action = Action.Unlock.toString() ;
963 String rpcName = Action.Unlock.name().toLowerCase();
964 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
967 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
968 status = buildStatusWithDispatcherOutput(executeRequest(request));
969 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
970 } catch (ParseException e) {
971 status = buildParsingErrorStatus(e);
973 LoggingUtils.logErrorMessage(
974 LoggingConstants.TargetNames.APPC_PROVIDER,
975 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
976 this.getClass().getName());
980 outputBuilder.setCommonHeader(input.getCommonHeader());
981 outputBuilder.setStatus(status);
982 RpcResult<UnlockOutput> result = RpcResultBuilder.<UnlockOutput> status(true).withResult(outputBuilder.build()).build();
983 return Futures.immediateFuture(result);
987 public Future<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
988 logger.debug("Input received : " + input.toString());
989 CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
990 String action = Action.CheckLock.toString();
991 String rpcName = Action.CheckLock.name().toLowerCase();
992 RequestHandlerOutput requestHandlerOutput = null;
993 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(),
994 input.getAction(), action);
995 if (null == status) {
997 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input
998 .getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action)
999 .rpcName(rpcName).build();
1000 requestHandlerOutput = executeRequest(request);
1002 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1003 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1004 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1005 } catch (ParseException e) {
1006 status = buildParsingErrorStatus(e);
1008 LoggingUtils.logErrorMessage(
1009 LoggingConstants.TargetNames.APPC_PROVIDER,
1010 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1011 this.getClass().getName());
1015 outputBuilder.setCommonHeader(input.getCommonHeader());
1016 outputBuilder.setStatus(status);
1017 if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1018 outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(requestHandlerOutput.getResponseContext()
1019 .getAdditionalContext().get("locked").toUpperCase()));
1021 RpcResult<CheckLockOutput> result = RpcResultBuilder.<CheckLockOutput>status(true)
1022 .withResult(outputBuilder.build()).build();
1023 return Futures.immediateFuture(result);
1027 public Future<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1028 logger.debug("Input received : " + input.toString());
1029 ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1030 String action = Action.ConfigBackup.toString() ;
1031 String rpcName = Action.ConfigBackup.name().toLowerCase();
1032 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1033 if(null == status) {
1035 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1036 status = buildStatusWithDispatcherOutput(executeRequest(request));
1037 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1038 } catch (ParseException e) {
1039 status = buildParsingErrorStatus(e);
1041 LoggingUtils.logErrorMessage(
1042 LoggingConstants.TargetNames.APPC_PROVIDER,
1043 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1044 this.getClass().getName());
1048 outputBuilder.setCommonHeader(input.getCommonHeader());
1049 outputBuilder.setStatus(status);
1050 RpcResult<ConfigBackupOutput> result = RpcResultBuilder.<ConfigBackupOutput> status(true).withResult(outputBuilder.build()).build();
1051 return Futures.immediateFuture(result);
1056 public Future<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1057 logger.debug("Input received : " + input.toString());
1058 ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1059 String action = Action.ConfigBackupDelete.toString() ;
1060 String rpcName = Action.ConfigBackupDelete.name().toLowerCase();
1061 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1062 if(null == status) {
1064 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1065 status = buildStatusWithDispatcherOutput(executeRequest(request));
1066 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1067 } catch (ParseException e) {
1068 status = buildParsingErrorStatus(e);
1070 LoggingUtils.logErrorMessage(
1071 LoggingConstants.TargetNames.APPC_PROVIDER,
1072 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1073 this.getClass().getName());
1077 outputBuilder.setCommonHeader(input.getCommonHeader());
1078 outputBuilder.setStatus(status);
1079 RpcResult<ConfigBackupDeleteOutput> result = RpcResultBuilder.<ConfigBackupDeleteOutput> status(true).withResult(outputBuilder.build()).build();
1080 return Futures.immediateFuture(result);
1085 public Future<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1086 logger.debug("Input received : " + input.toString());
1087 ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1088 String action = Action.ConfigExport.toString() ;
1089 String rpcName = Action.ConfigExport.name().toLowerCase();
1090 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1091 if(null == status) {
1093 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1094 status = buildStatusWithDispatcherOutput(executeRequest(request));
1095 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1096 } catch (ParseException e) {
1097 status = buildParsingErrorStatus(e);
1099 LoggingUtils.logErrorMessage(
1100 LoggingConstants.TargetNames.APPC_PROVIDER,
1101 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1102 this.getClass().getName());
1106 outputBuilder.setCommonHeader(input.getCommonHeader());
1107 outputBuilder.setStatus(status);
1108 RpcResult<ConfigExportOutput> result = RpcResultBuilder.<ConfigExportOutput> status(true).withResult(outputBuilder.build()).build();
1109 return Futures.immediateFuture(result);
1112 public Future<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
1113 logger.debug("Input received : " + input.toString());
1115 StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
1116 String action = Action.StartApplication.toString() ;
1117 String rpcName = Action.StartApplication.name().toLowerCase();
1118 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1119 if(null == status) {
1121 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1122 .commonHeader(input.getCommonHeader())
1123 .actionIdentifiers(input.getActionIdentifiers())
1124 .payload(input.getPayload())
1129 status = buildStatusWithDispatcherOutput(executeRequest(request));
1130 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1131 } catch (ParseException e) {
1132 status = buildParsingErrorStatus(e);
1134 LoggingUtils.logErrorMessage(
1135 LoggingConstants.TargetNames.APPC_PROVIDER,
1136 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1137 this.getClass().getName());
1141 outputBuilder.setCommonHeader(input.getCommonHeader());
1142 outputBuilder.setStatus(status);
1143 RpcResult<StartApplicationOutput> result = RpcResultBuilder.<StartApplicationOutput> status(true).withResult(outputBuilder.build()).build();
1144 return Futures.immediateFuture(result);
1147 public Future<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input){
1148 logger.debug("Input received : " + input.toString());
1149 StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1150 String action = Action.StopApplication.toString() ;
1151 String rpcName = Action.StopApplication.name().toLowerCase();
1152 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1153 if(null == status) {
1155 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1156 status = buildStatusWithDispatcherOutput(executeRequest(request));
1157 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1158 } catch (ParseException e) {
1159 status = buildParsingErrorStatus(e);
1161 LoggingUtils.logErrorMessage(
1162 LoggingConstants.TargetNames.APPC_PROVIDER,
1163 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1164 this.getClass().getName());
1168 outputBuilder.setCommonHeader(input.getCommonHeader());
1169 outputBuilder.setStatus(status);
1170 RpcResult<StopApplicationOutput> result = RpcResultBuilder.<StopApplicationOutput> status(true).withResult(outputBuilder.build()).build();
1171 return Futures.immediateFuture(result);
1174 private String convertActionNameToUrl(String action) {
1175 String regex = "([a-z])([A-Z]+)";
1176 String replacement = "$1-$2";
1177 return action.replaceAll(regex, replacement)
1181 RequestHandlerOutput executeRequest(RequestHandlerInput request){
1182 RequestHandler handler = getRequestHandler();
1183 RequestHandlerOutput requestHandlerOutput;
1184 if (handler != null) {
1186 requestHandlerOutput = handler.handleRequest(request);
1187 } catch (Exception e) {
1188 logger.info("UNEXPECTED FAILURE while executing " + request.getRequestContext().getAction().name());
1189 requestHandlerOutput = createErrorRequestHandlerObj(request,
1190 LCMCommandStatus.UNEXPECTED_ERROR, Msg.EXCEPTION_CALLING_DG, e);
1193 String errorMsg = "LCM request cannot be processed at the moment because APPC isn't running";
1194 requestHandlerOutput = createErrorRequestHandlerObj(request,
1195 LCMCommandStatus.REJECTED, Msg.REQUEST_HANDLER_UNAVAILABLE, new APPCException(errorMsg));
1197 return requestHandlerOutput;