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.ActionLevel;
126 import org.openecomp.appc.domainmodel.lcm.ResponseContext;
127 import org.openecomp.appc.exceptions.APPCException;
128 import org.openecomp.appc.executor.objects.LCMCommandStatus;
129 import org.openecomp.appc.executor.objects.Params;
130 import org.openecomp.appc.i18n.Msg;
131 import org.openecomp.appc.logging.LoggingConstants;
132 import org.openecomp.appc.logging.LoggingUtils;
133 import org.openecomp.appc.provider.lcm.util.RequestInputBuilder;
134 import org.openecomp.appc.provider.lcm.util.ValidationService;
135 import org.openecomp.appc.requesthandler.RequestHandler;
136 import org.openecomp.appc.requesthandler.objects.RequestHandlerInput;
137 import org.openecomp.appc.requesthandler.objects.RequestHandlerOutput;
138 import org.osgi.framework.BundleContext;
139 import org.osgi.framework.FrameworkUtil;
140 import org.osgi.framework.InvalidSyntaxException;
141 import org.osgi.framework.ServiceReference;
143 import java.text.ParseException;
144 import java.util.concurrent.ExecutorService;
145 import java.util.concurrent.Executors;
146 import java.util.concurrent.Future;
147 import java.util.Collection;
149 public class AppcProviderLcm implements AutoCloseable, AppcProviderLcmService {
151 private Configuration configuration = ConfigurationFactory.getConfiguration();
152 private final EELFLogger logger = EELFManager.getInstance().getLogger(AppcProviderLcm.class);
154 private final ExecutorService executor;
156 private final String COMMON_ERROR_MESSAGE_TEMPLATE = "Error processing %s input : %s";
159 * The ODL data store broker. Provides access to a conceptual data tree store and also provides the ability to
160 * subscribe for changes to data under a given branch of the tree.
162 protected DataBroker dataBroker;
165 * ODL Notification Service that provides publish/subscribe capabilities for YANG modeled notifications.
167 protected NotificationProviderService notificationService;
170 * Provides a registry for Remote Procedure Call (RPC) service implementations. The RPCs are defined in YANG models.
172 protected RpcProviderRegistry rpcRegistry;
175 * Represents our RPC implementation registration
177 protected BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
182 * @param notificationProviderService
183 * @param rpcProviderRegistry
188 public AppcProviderLcm(DataBroker dataBroker, NotificationProviderService notificationProviderService,
189 RpcProviderRegistry rpcProviderRegistry) {
191 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
192 logger.info(Msg.COMPONENT_INITIALIZING, appName, "provider-lcm");
194 executor = Executors.newFixedThreadPool(1);
195 this.dataBroker = dataBroker;
196 this.notificationService = notificationProviderService;
197 this.rpcRegistry = rpcProviderRegistry;
199 if (this.rpcRegistry != null) {
200 rpcRegistration = rpcRegistry.addRpcImplementation(AppcProviderLcmService.class, this);
203 logger.info(Msg.COMPONENT_INITIALIZED, appName, "provider");
207 * Implements the close of the service
209 * @see java.lang.AutoCloseable#close()
211 @SuppressWarnings("nls")
213 public void close() throws Exception {
214 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
215 logger.info(Msg.COMPONENT_TERMINATING, appName, "provider");
217 if (rpcRegistration != null) {
218 rpcRegistration.close();
220 logger.info(Msg.COMPONENT_TERMINATED, appName, "provider");
225 * Rebuilds a specific VNF
227 * @see AppcProviderLcmService#rebuild(RebuildInput)
230 public Future<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
231 logger.debug("Input received : " + input.toString());
233 RebuildOutputBuilder outputBuilder = new RebuildOutputBuilder();
234 String action = Action.Rebuild.toString() ;
235 String rpcName = Action.Rebuild.name().toLowerCase();
237 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
240 RequestHandlerInput request = new RequestInputBuilder().requestContext()
241 .commonHeader(input.getCommonHeader())
242 .actionIdentifiers(input.getActionIdentifiers())
243 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
244 status = buildStatusWithDispatcherOutput(executeRequest(request));
245 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
246 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
247 } catch (ParseException e) {
248 status = buildParsingErrorStatus(e);
250 LoggingUtils.logErrorMessage(
251 LoggingConstants.TargetNames.APPC_PROVIDER,
252 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
253 this.getClass().getName());
257 outputBuilder.setCommonHeader(input.getCommonHeader());
258 outputBuilder.setStatus(status);
259 RpcResult<RebuildOutput> result = RpcResultBuilder.<RebuildOutput> status(true).withResult(outputBuilder.build()).build();
260 return Futures.immediateFuture(result);
264 * Restarts a specific VNF
266 * @see org.opendaylight.yang.gen.v1.org.openecomp.appc.lcm.rev160108.AppcProviderLcmService#restart(RestartInput)
269 public Future<RpcResult<RestartOutput>> restart(RestartInput input) {
270 logger.debug("Input received : " + input.toString());
272 RestartOutputBuilder outputBuilder = new RestartOutputBuilder();
273 String action = Action.Restart.toString() ;
274 String rpcName = Action.Restart.name().toLowerCase();
276 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
279 RequestHandlerInput request = new RequestInputBuilder().requestContext()
280 .commonHeader(input.getCommonHeader())
281 .actionIdentifiers(input.getActionIdentifiers())
282 .payload(input.getPayload())
287 status = buildStatusWithDispatcherOutput(executeRequest(request));
288 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
289 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
290 } catch (ParseException e) {
291 status = buildParsingErrorStatus(e);
293 LoggingUtils.logErrorMessage(
294 LoggingConstants.TargetNames.APPC_PROVIDER,
295 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
296 this.getClass().getName());
300 outputBuilder.setCommonHeader(input.getCommonHeader());
301 outputBuilder.setStatus(status);
302 RpcResult<RestartOutput> result = RpcResultBuilder.<RestartOutput> status(true).withResult(outputBuilder.build()).build();
303 return Futures.immediateFuture(result);
307 * Migrates a specific VNF
309 * @see AppcProviderLcmService#migrate(MigrateInput)
312 public Future<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
313 logger.debug("Input received : " + input.toString());
315 MigrateOutputBuilder outputBuilder = new MigrateOutputBuilder();
316 String action = Action.Migrate.toString() ;
317 String rpcName = Action.Migrate.name().toLowerCase();
319 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
322 RequestHandlerInput request = new RequestInputBuilder().requestContext()
323 .commonHeader(input.getCommonHeader())
324 .actionIdentifiers(input.getActionIdentifiers())
325 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
326 status = buildStatusWithDispatcherOutput(executeRequest(request));
327 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
328 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
329 } catch (ParseException e) {
330 status = buildParsingErrorStatus(e);
332 LoggingUtils.logErrorMessage(
333 LoggingConstants.TargetNames.APPC_PROVIDER,
334 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
335 this.getClass().getName());
339 outputBuilder.setCommonHeader(input.getCommonHeader());
340 outputBuilder.setStatus(status);
341 RpcResult<MigrateOutput> result = RpcResultBuilder.<MigrateOutput> status(true).withResult(outputBuilder.build()).build();
342 return Futures.immediateFuture(result);
346 * Evacuates a specific VNF
348 * @see AppcProviderLcmService#evacuate(EvacuateInput)
351 public Future<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
352 logger.debug("Input received : " + input.toString());
354 EvacuateOutputBuilder outputBuilder = new EvacuateOutputBuilder();
355 String action = Action.Evacuate.toString() ;
356 String rpcName = Action.Evacuate.name().toLowerCase();
357 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
360 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
361 status = buildStatusWithDispatcherOutput(executeRequest(request));
362 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
363 } catch (ParseException e) {
364 status = buildParsingErrorStatus(e);
366 LoggingUtils.logErrorMessage(
367 LoggingConstants.TargetNames.APPC_PROVIDER,
368 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
369 this.getClass().getName());
373 outputBuilder.setCommonHeader(input.getCommonHeader());
374 outputBuilder.setStatus(status);
375 RpcResult<EvacuateOutput> result = RpcResultBuilder.<EvacuateOutput> status(true).withResult(outputBuilder.build()).build();
376 return Futures.immediateFuture(result);
381 * Evacuates a specific VNF
383 * @see AppcProviderLcmService#snapshot(SnapshotInput)
386 public Future<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
387 logger.debug("Input received : " + input.toString());
389 SnapshotOutputBuilder outputBuilder = new SnapshotOutputBuilder();
390 String action = Action.Snapshot.toString() ;
391 String rpcName = Action.Snapshot.name().toLowerCase();
393 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
394 String identityUrl = input.getIdentityUrl();
397 RequestHandlerInput request = new RequestInputBuilder().requestContext()
398 .commonHeader(input.getCommonHeader())
399 .actionIdentifiers(input.getActionIdentifiers())
400 .payload(input.getPayload()).action(action).rpcName(rpcName)
401 .additionalContext("identity-url", identityUrl).build();
402 status = buildStatusWithDispatcherOutput(executeRequest(request));
403 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
404 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
405 } catch (ParseException e) {
406 status = buildParsingErrorStatus(e);
408 LoggingUtils.logErrorMessage(
409 LoggingConstants.TargetNames.APPC_PROVIDER,
410 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
411 this.getClass().getName());
414 outputBuilder.setCommonHeader(input.getCommonHeader());
415 outputBuilder.setStatus(status);
416 RpcResult<SnapshotOutput> result = RpcResultBuilder.<SnapshotOutput> status(true).withResult(outputBuilder.build()).build();
417 return Futures.immediateFuture(result);
421 public Future<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
422 logger.debug("Input received : " + input.toString());
424 RollbackOutputBuilder outputBuilder = new RollbackOutputBuilder();
425 String rpcName = Action.Rollback.toString() ;
427 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), rpcName);
428 String identityUrl = input.getIdentityUrl();
429 String snapshotId = input.getSnapshotId();
432 RequestHandlerInput request = new RequestInputBuilder().requestContext()
433 .commonHeader(input.getCommonHeader())
434 .actionIdentifiers(input.getActionIdentifiers())
435 .payload(input.getPayload()).additionalContext("identity-url", identityUrl)
436 .additionalContext("snapshot-id", snapshotId).action(rpcName).build();
437 status = buildStatusWithDispatcherOutput(executeRequest(request));
438 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
439 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
440 } catch (ParseException e) {
441 status = buildParsingErrorStatus(e);
443 LoggingUtils.logErrorMessage(
444 LoggingConstants.TargetNames.APPC_PROVIDER,
445 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, rpcName, e.getMessage()),
446 this.getClass().getName());
450 outputBuilder.setCommonHeader(input.getCommonHeader());
451 outputBuilder.setStatus(status);
452 RpcResult<RollbackOutput> result = RpcResultBuilder.<RollbackOutput> status(true).withResult(outputBuilder.build()).build();
453 return Futures.immediateFuture(result);
457 public Future<RpcResult<SyncOutput>> sync(SyncInput input) {
458 logger.debug("Input received : " + input.toString());
459 SyncOutputBuilder outputBuilder = new SyncOutputBuilder();
460 String action = Action.Sync.toString() ;
461 String rpcName = Action.Sync.name().toLowerCase();
463 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
466 RequestHandlerInput request = new RequestInputBuilder().requestContext()
467 .commonHeader(input.getCommonHeader())
468 .actionIdentifiers(input.getActionIdentifiers())
469 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
470 status = buildStatusWithDispatcherOutput(executeRequest(request));
471 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
472 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
473 } catch (ParseException e) {
474 status = buildParsingErrorStatus(e);
476 LoggingUtils.logErrorMessage(
477 LoggingConstants.TargetNames.APPC_PROVIDER,
478 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
479 this.getClass().getName());
483 outputBuilder.setCommonHeader(input.getCommonHeader());
484 outputBuilder.setStatus(status);
485 RpcResult<SyncOutput> result = RpcResultBuilder.<SyncOutput> status(true).withResult(outputBuilder.build()).build();
486 return Futures.immediateFuture(result);
489 private Status buildParsingErrorStatus(ParseException e){
490 LCMCommandStatus requestParsingFailure = LCMCommandStatus.REQUEST_PARSING_FAILED;
491 String errorMessage = e.getMessage() != null ? e.getMessage() : e.toString();
492 Params params = new Params().addParam("errorMsg", errorMessage);
493 return buildStatus(requestParsingFailure.getResponseCode(), requestParsingFailure.getFormattedMessage(params));
496 private Status buildStatus(Integer code,String message){
497 StatusBuilder status = new StatusBuilder();
498 status.setCode(code);
499 status.setMessage(message);
500 return status.build();
503 private Status buildStatusWithDispatcherOutput(RequestHandlerOutput requestHandlerOutput){
504 Integer statusCode = requestHandlerOutput.getResponseContext().getStatus().getCode();
505 String statusMessage = requestHandlerOutput.getResponseContext().getStatus().getMessage();
506 return buildStatus(statusCode, statusMessage);
509 private RequestHandlerOutput createErrorRequestHandlerObj(RequestHandlerInput request,
510 LCMCommandStatus cmdStatus,
513 final String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
514 final String reason = EELFResourceManager.format(msg, e,
515 appName, e.getClass().getSimpleName(), "", e.getMessage());
517 RequestHandlerOutput requestHandlerOutput = new RequestHandlerOutput();
518 final ResponseContext responseContext = new ResponseContext();
519 requestHandlerOutput.setResponseContext(responseContext);
520 responseContext.setCommonHeader(request.getRequestContext().getCommonHeader());
522 String errorMessage = e.getMessage() != null ? e.getMessage() : e.toString();
523 Params params = new Params().addParam("errorMsg", errorMessage);
524 responseContext.setStatus(cmdStatus.toStatus(params));
526 LoggingUtils.logErrorMessage(
527 LoggingConstants.TargetNames.APPC_PROVIDER,
529 this.getClass().getName());
531 return requestHandlerOutput;
534 private RequestHandler getRequestHandler(ActionLevel actionLevel){
535 final BundleContext context = FrameworkUtil.getBundle(RequestHandler.class).getBundleContext();
536 if (context != null) {
537 String filter = null;
539 filter = "(level=" + actionLevel.name() + ")";
540 Collection<ServiceReference<RequestHandler>> serviceReferences = context.getServiceReferences(RequestHandler.class, filter);
541 if (serviceReferences.size() != 1) {
542 logger.error("Cannot find service reference for " + RequestHandler.class.getName());
543 throw new RuntimeException();
545 ServiceReference<RequestHandler> serviceReference = serviceReferences.iterator().next();
546 return context.getService(serviceReference);
547 } catch (InvalidSyntaxException e) {
548 logger.error("Cannot find service reference for " + RequestHandler.class.getName() + ": Invalid Syntax " + filter, e);
549 throw new RuntimeException(e);
556 public Future<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
557 logger.debug("Input received : " + input.toString());
558 TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
559 String action = Action.Terminate.toString() ;
560 String rpcName = Action.Terminate.name().toLowerCase();
562 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
565 RequestHandlerInput request = new RequestInputBuilder().requestContext()
566 .commonHeader(input.getCommonHeader())
567 .actionIdentifiers(input.getActionIdentifiers())
568 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
569 status = buildStatusWithDispatcherOutput(executeRequest(request));
570 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
571 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
572 } catch (ParseException e) {
574 status = buildParsingErrorStatus(e);
576 LoggingUtils.logErrorMessage(
577 LoggingConstants.TargetNames.APPC_PROVIDER,
578 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
579 this.getClass().getName());
584 outputBuilder.setCommonHeader(input.getCommonHeader());
585 outputBuilder.setStatus(status);
586 RpcResult<TerminateOutput> result =
587 RpcResultBuilder.<TerminateOutput> status(true).withResult(outputBuilder.build()).build();
588 return Futures.immediateFuture(result);
592 public Future<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
593 logger.debug("Input received : " + input.toString());
594 ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
595 String action = Action.Configure.toString() ;
596 String rpcName = "configure";
598 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
601 RequestHandlerInput request = new RequestInputBuilder().requestContext()
602 .commonHeader(input.getCommonHeader())
603 .actionIdentifiers(input.getActionIdentifiers())
604 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
605 status = buildStatusWithDispatcherOutput(executeRequest(request));
606 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
607 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
608 } catch (ParseException e) {
609 status = buildParsingErrorStatus(e);
611 LoggingUtils.logErrorMessage(
612 LoggingConstants.TargetNames.APPC_PROVIDER,
613 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
614 this.getClass().getName());
618 outputBuilder.setCommonHeader(input.getCommonHeader());
619 outputBuilder.setStatus(status);
620 RpcResult<ConfigureOutput> result =
621 RpcResultBuilder.<ConfigureOutput> status(true).withResult(outputBuilder.build()).build();
622 return Futures.immediateFuture(result);
626 public Future<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
627 logger.debug("Input received : " + input.toString());
628 ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
629 String action = Action.ConfigModify.toString() ;
630 String rpcName = "config-modify";
632 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
635 RequestHandlerInput request = new RequestInputBuilder().requestContext()
636 .commonHeader(input.getCommonHeader())
637 .actionIdentifiers(input.getActionIdentifiers())
638 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
639 status = buildStatusWithDispatcherOutput(executeRequest(request));
640 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
641 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
642 } catch (ParseException e) {
643 status = buildParsingErrorStatus(e);
645 LoggingUtils.logErrorMessage(
646 LoggingConstants.TargetNames.APPC_PROVIDER,
647 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
648 this.getClass().getName());
652 outputBuilder.setCommonHeader(input.getCommonHeader());
653 outputBuilder.setStatus(status);
654 RpcResult<ConfigModifyOutput> result =
655 RpcResultBuilder.<ConfigModifyOutput> status(true).withResult(outputBuilder.build()).build();
656 return Futures.immediateFuture(result);
660 public Future<RpcResult<ConfigScaleoutOutput>> configScaleout(ConfigScaleoutInput input) {
661 logger.debug("Input received : " + input.toString());
662 ConfigScaleoutOutputBuilder outputBuilder = new ConfigScaleoutOutputBuilder();
663 String action = Action.ConfigScaleOut.toString() ;
664 String rpcName = "config-scaleout";
666 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
669 RequestHandlerInput request = new RequestInputBuilder().requestContext()
670 .commonHeader(input.getCommonHeader())
671 .actionIdentifiers(input.getActionIdentifiers())
672 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
673 status = buildStatusWithDispatcherOutput(executeRequest(request));
674 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
675 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
676 } catch (ParseException e) {
677 status = buildParsingErrorStatus(e);
679 LoggingUtils.logErrorMessage(
680 LoggingConstants.TargetNames.APPC_PROVIDER,
681 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
682 this.getClass().getName());
686 outputBuilder.setCommonHeader(input.getCommonHeader());
687 outputBuilder.setStatus(status);
688 RpcResult<ConfigScaleoutOutput> result =
689 RpcResultBuilder.<ConfigScaleoutOutput> status(true).withResult(outputBuilder.build()).build();
690 return Futures.immediateFuture(result);
694 public Future<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
695 logger.debug("Input received : " + input.toString());
696 ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
697 String action = Action.ConfigRestore.toString() ;
698 String rpcName = "config-restore";
700 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
703 RequestHandlerInput request = new RequestInputBuilder().requestContext()
704 .commonHeader(input.getCommonHeader())
705 .actionIdentifiers(input.getActionIdentifiers())
706 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
707 status = buildStatusWithDispatcherOutput(executeRequest(request));
708 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
709 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
710 } catch (ParseException e) {
711 status = buildParsingErrorStatus(e);
713 LoggingUtils.logErrorMessage(
714 LoggingConstants.TargetNames.APPC_PROVIDER,
715 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
716 this.getClass().getName());
720 outputBuilder.setCommonHeader(input.getCommonHeader());
721 outputBuilder.setStatus(status);
722 RpcResult<ConfigRestoreOutput> result =
723 RpcResultBuilder.<ConfigRestoreOutput> status(true).withResult(outputBuilder.build()).build();
724 return Futures.immediateFuture(result);
728 public Future<RpcResult<TestOutput>> test(TestInput input) {
729 logger.debug("Input received : " + input.toString());
730 TestOutputBuilder outputBuilder = new TestOutputBuilder();
731 String action = Action.Test.toString() ;
732 String rpcName = Action.Test.name().toLowerCase();
733 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
736 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
737 status = buildStatusWithDispatcherOutput(executeRequest(request));
738 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
739 } catch (ParseException e) {
740 status = buildParsingErrorStatus(e);
742 LoggingUtils.logErrorMessage(
743 LoggingConstants.TargetNames.APPC_PROVIDER,
744 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
745 this.getClass().getName());
749 outputBuilder.setCommonHeader(input.getCommonHeader());
750 outputBuilder.setStatus(status);
751 RpcResult<TestOutput> result = RpcResultBuilder.<TestOutput> status(true).withResult(outputBuilder.build()).build();
752 return Futures.immediateFuture(result);
757 public Future<RpcResult<StopOutput>> stop(StopInput input) {
758 logger.debug("Input received : " + input.toString());
759 StopOutputBuilder outputBuilder = new StopOutputBuilder();
760 String action = Action.Stop.toString() ;
761 String rpcName = Action.Stop.name().toLowerCase();
762 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
765 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
766 status = buildStatusWithDispatcherOutput(executeRequest(request));
767 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
768 } catch (ParseException e) {
769 status = buildParsingErrorStatus(e);
771 LoggingUtils.logErrorMessage(
772 LoggingConstants.TargetNames.APPC_PROVIDER,
773 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
774 this.getClass().getName());
778 outputBuilder.setCommonHeader(input.getCommonHeader());
779 outputBuilder.setStatus(status);
780 RpcResult<StopOutput> result = RpcResultBuilder.<StopOutput> status(true).withResult(outputBuilder.build()).build();
781 return Futures.immediateFuture(result);
785 * Starts a specific VNF
787 * @see AppcProviderLcmService#start(StartInput)
790 public Future<RpcResult<StartOutput>> start(StartInput input) {
791 logger.debug("Input received : " + input.toString());
793 StartOutputBuilder outputBuilder = new StartOutputBuilder();
794 String action = Action.Start.toString() ;
795 String rpcName = Action.Start.name().toLowerCase();
796 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
799 RequestHandlerInput request = new RequestInputBuilder().requestContext()
800 .commonHeader(input.getCommonHeader())
801 .actionIdentifiers(input.getActionIdentifiers())
802 .payload(input.getPayload())
804 .rpcName(rpcName).build();
805 status = buildStatusWithDispatcherOutput(executeRequest(request));
806 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
807 } catch (ParseException e) {
808 status = buildParsingErrorStatus(e);
810 LoggingUtils.logErrorMessage(
811 LoggingConstants.TargetNames.APPC_PROVIDER,
812 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
813 this.getClass().getName());
817 outputBuilder.setCommonHeader(input.getCommonHeader());
818 outputBuilder.setStatus(status);
819 RpcResult<StartOutput> result = RpcResultBuilder.<StartOutput> status(true).withResult(outputBuilder.build()).build();
820 return Futures.immediateFuture(result);
825 public Future<RpcResult<AuditOutput>> audit(AuditInput input) {
826 logger.debug("Input received : " + input.toString());
827 AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
828 String action = Action.Audit.toString();
829 String rpcName = Action.Audit.name().toLowerCase();
830 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
833 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
834 status = buildStatusWithDispatcherOutput(executeRequest(request));
835 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
836 } catch (ParseException e) {
837 status = buildParsingErrorStatus(e);
839 LoggingUtils.logErrorMessage(
840 LoggingConstants.TargetNames.APPC_PROVIDER,
841 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
842 this.getClass().getName());
846 outputBuilder.setCommonHeader(input.getCommonHeader());
847 outputBuilder.setStatus(status);
848 RpcResult<AuditOutput> result = RpcResultBuilder.<AuditOutput> status(true).withResult(outputBuilder.build()).build();
849 return Futures.immediateFuture(result);
853 public Future<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
854 logger.debug("Input received : " + input.toString());
855 SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
856 String action = Action.SoftwareUpload.toString() ;
857 String rpcName = convertActionNameToUrl(action);
858 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
861 RequestHandlerInput request = new RequestInputBuilder().
862 requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
863 status = buildStatusWithDispatcherOutput(executeRequest(request));
864 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
865 } catch (ParseException e) {
866 status = buildParsingErrorStatus(e);
868 LoggingUtils.logErrorMessage(
869 LoggingConstants.TargetNames.APPC_PROVIDER,
870 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
871 this.getClass().getName());
875 outputBuilder.setCommonHeader(input.getCommonHeader());
876 outputBuilder.setStatus(status);
877 RpcResult<SoftwareUploadOutput> result = RpcResultBuilder.<SoftwareUploadOutput> status(true).withResult(outputBuilder.build()).build();
878 return Futures.immediateFuture(result);
882 public Future<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
883 logger.debug("Input received : " + input.toString());
884 HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
885 String action = Action.HealthCheck.toString() ;
886 String rpcName = convertActionNameToUrl(action);
887 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
890 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
891 status = buildStatusWithDispatcherOutput(executeRequest(request));
892 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
893 } catch (ParseException e) {
894 status = buildParsingErrorStatus(e);
896 LoggingUtils.logErrorMessage(
897 LoggingConstants.TargetNames.APPC_PROVIDER,
898 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
899 this.getClass().getName());
903 outputBuilder.setCommonHeader(input.getCommonHeader());
904 outputBuilder.setStatus(status);
905 RpcResult<HealthCheckOutput> result = RpcResultBuilder.<HealthCheckOutput> status(true).withResult(outputBuilder.build()).build();
906 return Futures.immediateFuture(result);
910 public Future<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
911 logger.debug("Input received : " + input.toString());
912 LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
913 String action = Action.LiveUpgrade.toString() ;
914 String rpcName = convertActionNameToUrl(action);
915 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
918 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
919 status = buildStatusWithDispatcherOutput(executeRequest(request));
920 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
921 } catch (ParseException e) {
922 status = buildParsingErrorStatus(e);
924 LoggingUtils.logErrorMessage(
925 LoggingConstants.TargetNames.APPC_PROVIDER,
926 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
927 this.getClass().getName());
931 outputBuilder.setCommonHeader(input.getCommonHeader());
932 outputBuilder.setStatus(status);
933 RpcResult<LiveUpgradeOutput> result = RpcResultBuilder.<LiveUpgradeOutput> status(true).withResult(outputBuilder.build()).build();
934 return Futures.immediateFuture(result);
939 public Future<RpcResult<LockOutput>> lock(LockInput input) {
940 logger.debug("Input received : " + input.toString());
941 LockOutputBuilder outputBuilder = new LockOutputBuilder();
942 String action = Action.Lock.toString() ;
943 String rpcName = Action.Lock.name().toLowerCase();
944 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
947 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
948 status = buildStatusWithDispatcherOutput(executeRequest(request));
949 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
950 } catch (ParseException e) {
951 status = buildParsingErrorStatus(e);
953 LoggingUtils.logErrorMessage(
954 LoggingConstants.TargetNames.APPC_PROVIDER,
955 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
956 this.getClass().getName());
960 outputBuilder.setCommonHeader(input.getCommonHeader());
961 outputBuilder.setStatus(status);
962 RpcResult<LockOutput> result = RpcResultBuilder.<LockOutput> status(true).withResult(outputBuilder.build()).build();
963 return Futures.immediateFuture(result);
968 public Future<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
969 logger.debug("Input received : " + input.toString());
970 UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
971 String action = Action.Unlock.toString() ;
972 String rpcName = Action.Unlock.name().toLowerCase();
973 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
976 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
977 status = buildStatusWithDispatcherOutput(executeRequest(request));
978 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
979 } catch (ParseException e) {
980 status = buildParsingErrorStatus(e);
982 LoggingUtils.logErrorMessage(
983 LoggingConstants.TargetNames.APPC_PROVIDER,
984 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
985 this.getClass().getName());
989 outputBuilder.setCommonHeader(input.getCommonHeader());
990 outputBuilder.setStatus(status);
991 RpcResult<UnlockOutput> result = RpcResultBuilder.<UnlockOutput> status(true).withResult(outputBuilder.build()).build();
992 return Futures.immediateFuture(result);
996 public Future<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
997 logger.debug("Input received : " + input.toString());
998 CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
999 String action = Action.CheckLock.toString();
1000 String rpcName = Action.CheckLock.name().toLowerCase();
1001 RequestHandlerOutput requestHandlerOutput = null;
1002 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(),
1003 input.getAction(), action);
1004 if (null == status) {
1006 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input
1007 .getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action)
1008 .rpcName(rpcName).build();
1009 requestHandlerOutput = executeRequest(request);
1011 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1012 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1013 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1014 } catch (ParseException e) {
1015 status = buildParsingErrorStatus(e);
1017 LoggingUtils.logErrorMessage(
1018 LoggingConstants.TargetNames.APPC_PROVIDER,
1019 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1020 this.getClass().getName());
1024 outputBuilder.setCommonHeader(input.getCommonHeader());
1025 outputBuilder.setStatus(status);
1026 if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1027 outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(requestHandlerOutput.getResponseContext()
1028 .getAdditionalContext().get("locked").toUpperCase()));
1030 RpcResult<CheckLockOutput> result = RpcResultBuilder.<CheckLockOutput>status(true)
1031 .withResult(outputBuilder.build()).build();
1032 return Futures.immediateFuture(result);
1036 public Future<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1037 logger.debug("Input received : " + input.toString());
1038 ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1039 String action = Action.ConfigBackup.toString() ;
1040 String rpcName = Action.ConfigBackup.name().toLowerCase();
1041 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1042 if(null == status) {
1044 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1045 status = buildStatusWithDispatcherOutput(executeRequest(request));
1046 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1047 } catch (ParseException e) {
1048 status = buildParsingErrorStatus(e);
1050 LoggingUtils.logErrorMessage(
1051 LoggingConstants.TargetNames.APPC_PROVIDER,
1052 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1053 this.getClass().getName());
1057 outputBuilder.setCommonHeader(input.getCommonHeader());
1058 outputBuilder.setStatus(status);
1059 RpcResult<ConfigBackupOutput> result = RpcResultBuilder.<ConfigBackupOutput> status(true).withResult(outputBuilder.build()).build();
1060 return Futures.immediateFuture(result);
1065 public Future<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1066 logger.debug("Input received : " + input.toString());
1067 ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1068 String action = Action.ConfigBackupDelete.toString() ;
1069 String rpcName = Action.ConfigBackupDelete.name().toLowerCase();
1070 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1071 if(null == status) {
1073 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1074 status = buildStatusWithDispatcherOutput(executeRequest(request));
1075 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1076 } catch (ParseException e) {
1077 status = buildParsingErrorStatus(e);
1079 LoggingUtils.logErrorMessage(
1080 LoggingConstants.TargetNames.APPC_PROVIDER,
1081 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1082 this.getClass().getName());
1086 outputBuilder.setCommonHeader(input.getCommonHeader());
1087 outputBuilder.setStatus(status);
1088 RpcResult<ConfigBackupDeleteOutput> result = RpcResultBuilder.<ConfigBackupDeleteOutput> status(true).withResult(outputBuilder.build()).build();
1089 return Futures.immediateFuture(result);
1094 public Future<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1095 logger.debug("Input received : " + input.toString());
1096 ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1097 String action = Action.ConfigExport.toString() ;
1098 String rpcName = Action.ConfigExport.name().toLowerCase();
1099 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1100 if(null == status) {
1102 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).action(action).rpcName(rpcName).build();
1103 status = buildStatusWithDispatcherOutput(executeRequest(request));
1104 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1105 } catch (ParseException e) {
1106 status = buildParsingErrorStatus(e);
1108 LoggingUtils.logErrorMessage(
1109 LoggingConstants.TargetNames.APPC_PROVIDER,
1110 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1111 this.getClass().getName());
1115 outputBuilder.setCommonHeader(input.getCommonHeader());
1116 outputBuilder.setStatus(status);
1117 RpcResult<ConfigExportOutput> result = RpcResultBuilder.<ConfigExportOutput> status(true).withResult(outputBuilder.build()).build();
1118 return Futures.immediateFuture(result);
1121 public Future<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
1122 logger.debug("Input received : " + input.toString());
1124 StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
1125 String action = Action.StartApplication.toString() ;
1126 String rpcName = Action.StartApplication.name().toLowerCase();
1127 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1128 if(null == status) {
1130 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1131 .commonHeader(input.getCommonHeader())
1132 .actionIdentifiers(input.getActionIdentifiers())
1133 .payload(input.getPayload())
1138 status = buildStatusWithDispatcherOutput(executeRequest(request));
1139 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1140 } catch (ParseException e) {
1141 status = buildParsingErrorStatus(e);
1143 LoggingUtils.logErrorMessage(
1144 LoggingConstants.TargetNames.APPC_PROVIDER,
1145 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1146 this.getClass().getName());
1150 outputBuilder.setCommonHeader(input.getCommonHeader());
1151 outputBuilder.setStatus(status);
1152 RpcResult<StartApplicationOutput> result = RpcResultBuilder.<StartApplicationOutput> status(true).withResult(outputBuilder.build()).build();
1153 return Futures.immediateFuture(result);
1156 public Future<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input){
1157 logger.debug("Input received : " + input.toString());
1158 StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1159 String action = Action.StopApplication.toString() ;
1160 String rpcName = Action.StopApplication.name().toLowerCase();
1161 Status status = ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1162 if(null == status) {
1164 RequestHandlerInput request = new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload()).action(action).rpcName(rpcName).build();
1165 status = buildStatusWithDispatcherOutput(executeRequest(request));
1166 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s", input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1167 } catch (ParseException e) {
1168 status = buildParsingErrorStatus(e);
1170 LoggingUtils.logErrorMessage(
1171 LoggingConstants.TargetNames.APPC_PROVIDER,
1172 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1173 this.getClass().getName());
1177 outputBuilder.setCommonHeader(input.getCommonHeader());
1178 outputBuilder.setStatus(status);
1179 RpcResult<StopApplicationOutput> result = RpcResultBuilder.<StopApplicationOutput> status(true).withResult(outputBuilder.build()).build();
1180 return Futures.immediateFuture(result);
1183 private String convertActionNameToUrl(String action) {
1184 String regex = "([a-z])([A-Z]+)";
1185 String replacement = "$1-$2";
1186 return action.replaceAll(regex, replacement)
1190 RequestHandlerOutput executeRequest(RequestHandlerInput request){
1191 RequestHandler handler = getRequestHandler(request.getRequestContext().getActionLevel());
1192 RequestHandlerOutput requestHandlerOutput;
1193 if (handler != null) {
1195 requestHandlerOutput = handler.handleRequest(request);
1196 } catch (Exception e) {
1197 logger.info("UNEXPECTED FAILURE while executing " + request.getRequestContext().getAction().name());
1198 requestHandlerOutput = createErrorRequestHandlerObj(request,
1199 LCMCommandStatus.UNEXPECTED_ERROR, Msg.EXCEPTION_CALLING_DG, e);
1202 String errorMsg = "LCM request cannot be processed at the moment because APPC isn't running";
1203 requestHandlerOutput = createErrorRequestHandlerObj(request,
1204 LCMCommandStatus.REJECTED, Msg.REQUEST_HANDLER_UNAVAILABLE, new APPCException(errorMsg));
1206 return requestHandlerOutput;