2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2018 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 * ============LICENSE_END=========================================================
24 package org.onap.appc.provider;
26 import java.text.ParseException;
27 import java.util.concurrent.ExecutorService;
28 import java.util.concurrent.Executors;
29 import java.util.concurrent.Future;
30 import org.onap.appc.Constants;
31 import org.onap.appc.configuration.Configuration;
32 import org.onap.appc.configuration.ConfigurationFactory;
33 import org.onap.appc.i18n.Msg;
34 import org.onap.appc.logging.LoggingConstants;
35 import org.onap.appc.logging.LoggingUtils;
36 import org.onap.appc.provider.lcm.service.AbstractBaseUtils;
37 import org.onap.appc.provider.lcm.service.ActionStatusService;
38 import org.onap.appc.provider.lcm.service.QueryService;
39 import org.onap.appc.provider.lcm.service.QuiesceTrafficService;
40 import org.onap.appc.provider.lcm.service.RebootService;
41 import org.onap.appc.provider.lcm.service.RequestExecutor;
42 import org.onap.appc.provider.lcm.service.ResumeTrafficService;
43 import org.onap.appc.provider.lcm.service.UpgradeService;
44 import org.onap.appc.provider.lcm.service.VolumeService;
45 import org.onap.appc.provider.lcm.service.ConfigScaleOutService;
46 import org.onap.appc.provider.lcm.util.RequestInputBuilder;
47 import org.onap.appc.provider.lcm.util.ValidationService;
48 import org.onap.appc.requesthandler.objects.RequestHandlerInput;
49 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
50 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
51 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
52 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
53 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
54 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
55 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
56 import org.opendaylight.yangtools.yang.common.RpcResult;
57 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
58 import com.att.eelf.configuration.EELFLogger;
59 import com.att.eelf.configuration.EELFManager;
60 import com.google.common.util.concurrent.Futures;
63 public class AppcProviderLcm extends AbstractBaseUtils implements AutoCloseable, AppcProviderLcmService {
65 private Configuration configuration = ConfigurationFactory.getConfiguration();
66 private final EELFLogger logger = EELFManager.getInstance().getLogger(AppcProviderLcm.class);
68 private final ExecutorService executor;
71 * The ODL data store broker. Provides access to a conceptual data tree store and also provides the ability to
72 * subscribe for changes to data under a given branch of the tree.
74 protected DataBroker dataBroker;
77 * ODL Notification Service that provides publish/subscribe capabilities for YANG modeled notifications.
79 protected NotificationProviderService notificationService;
82 * Provides a registry for Remote Procedure Call (RPC) service implementations. The RPCs are defined in YANG models.
84 protected RpcProviderRegistry rpcRegistry;
87 * Represents our RPC implementation registration
89 protected BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
94 * @param notificationProviderService
95 * @param rpcProviderRegistry
97 @SuppressWarnings({"javadoc", "nls"})
98 public AppcProviderLcm(DataBroker dataBroker, NotificationProviderService notificationProviderService,
99 RpcProviderRegistry rpcProviderRegistry) {
101 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
102 logger.info(Msg.COMPONENT_INITIALIZING, appName, "provider-lcm");
104 executor = Executors.newFixedThreadPool(1);
105 this.dataBroker = dataBroker;
106 this.notificationService = notificationProviderService;
107 this.rpcRegistry = rpcProviderRegistry;
109 if (this.rpcRegistry != null) {
110 rpcRegistration = rpcRegistry.addRpcImplementation(AppcProviderLcmService.class, this);
113 logger.info(Msg.COMPONENT_INITIALIZED, appName, "provider");
117 * Implements the close of the service
119 * @see java.lang.AutoCloseable#close()
121 @SuppressWarnings("nls")
123 public void close() throws Exception {
124 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
125 logger.info(Msg.COMPONENT_TERMINATING, appName, "provider");
127 if (rpcRegistration != null) {
128 rpcRegistration.close();
130 logger.info(Msg.COMPONENT_TERMINATED, appName, "provider");
135 * Rebuilds a specific VNF
137 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#rebuild(RebuildInput)
140 public Future<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
141 logger.debug("Input received : " + input.toString());
143 RebuildOutputBuilder outputBuilder = new RebuildOutputBuilder();
144 String action = Action.Rebuild.toString();
145 String rpcName = Action.Rebuild.name().toLowerCase();
147 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
148 if (null == status) {
150 RequestHandlerInput request = new RequestInputBuilder().requestContext()
151 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
152 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
153 status = buildStatusWithDispatcherOutput(executeRequest(request));
154 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
155 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
156 } catch (ParseException e) {
157 status = buildStatusWithParseException(e);
159 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
160 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
161 this.getClass().getName());
165 outputBuilder.setCommonHeader(input.getCommonHeader());
166 outputBuilder.setStatus(status);
167 RpcResult<RebuildOutput> result =
168 RpcResultBuilder.<RebuildOutput>status(true).withResult(outputBuilder.build()).build();
169 return Futures.immediateFuture(result);
175 * Restarts a specific VNF
177 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#restart(RestartInput)
180 public Future<RpcResult<RestartOutput>> restart(RestartInput input) {
181 logger.debug("Input received : " + input.toString());
183 RestartOutputBuilder outputBuilder = new RestartOutputBuilder();
184 String action = Action.Restart.toString();
185 String rpcName = Action.Restart.name().toLowerCase();
187 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
188 if (null == status) {
190 RequestHandlerInput request = new RequestInputBuilder().requestContext()
191 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
192 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
194 status = buildStatusWithDispatcherOutput(executeRequest(request));
195 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
196 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
197 } catch (ParseException e) {
198 status = buildStatusWithParseException(e);
200 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
201 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
202 this.getClass().getName());
206 outputBuilder.setCommonHeader(input.getCommonHeader());
207 outputBuilder.setStatus(status);
208 RpcResult<RestartOutput> result =
209 RpcResultBuilder.<RestartOutput>status(true).withResult(outputBuilder.build()).build();
210 return Futures.immediateFuture(result);
216 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#startApplication(StartApplicationInput)
219 public Future<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
220 logger.debug("Input received : " + input.toString());
222 StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
223 String action = Action.StartApplication.toString();
224 String rpcName = Action.StartApplication.name().toLowerCase();
226 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
227 if (null == status) {
229 RequestHandlerInput request = new RequestInputBuilder().requestContext()
230 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
231 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
233 status = buildStatusWithDispatcherOutput(executeRequest(request));
234 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
235 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
236 } catch (ParseException e) {
237 status = buildStatusWithParseException(e);
239 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
240 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
241 this.getClass().getName());
245 outputBuilder.setCommonHeader(input.getCommonHeader());
246 outputBuilder.setStatus(status);
247 RpcResult<StartApplicationOutput> result =
248 RpcResultBuilder.<StartApplicationOutput>status(true).withResult(outputBuilder.build()).build();
249 return Futures.immediateFuture(result);
253 * Migrates a specific VNF
255 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#migrate(MigrateInput)
258 public Future<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
259 logger.debug("Input received : " + input.toString());
261 MigrateOutputBuilder outputBuilder = new MigrateOutputBuilder();
262 String action = Action.Migrate.toString();
263 String rpcName = Action.Migrate.name().toLowerCase();
265 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
266 if (null == status) {
268 RequestHandlerInput request = new RequestInputBuilder().requestContext()
269 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
270 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
271 status = buildStatusWithDispatcherOutput(executeRequest(request));
272 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
273 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
274 } catch (ParseException e) {
275 status = buildStatusWithParseException(e);
277 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
278 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
279 this.getClass().getName());
283 outputBuilder.setCommonHeader(input.getCommonHeader());
284 outputBuilder.setStatus(status);
285 RpcResult<MigrateOutput> result =
286 RpcResultBuilder.<MigrateOutput>status(true).withResult(outputBuilder.build()).build();
287 return Futures.immediateFuture(result);
292 * Evacuates a specific VNF
294 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#evacuate(EvacuateInput)
297 public Future<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
298 logger.debug("Input received : " + input.toString());
300 EvacuateOutputBuilder outputBuilder = new EvacuateOutputBuilder();
301 String action = Action.Evacuate.toString();
302 String rpcName = Action.Evacuate.name().toLowerCase();
304 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
305 if (null == status) {
307 RequestHandlerInput request = new RequestInputBuilder().requestContext()
308 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
309 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
310 status = buildStatusWithDispatcherOutput(executeRequest(request));
311 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
312 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
313 } catch (ParseException e) {
314 status = buildStatusWithParseException(e);
316 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
317 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
318 this.getClass().getName());
322 outputBuilder.setCommonHeader(input.getCommonHeader());
323 outputBuilder.setStatus(status);
324 RpcResult<EvacuateOutput> result =
325 RpcResultBuilder.<EvacuateOutput>status(true).withResult(outputBuilder.build()).build();
326 return Futures.immediateFuture(result);
331 * Evacuates a specific VNF
333 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#snapshot(SnapshotInput)
336 public Future<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
337 logger.debug("Input received : " + input.toString());
339 SnapshotOutputBuilder outputBuilder = new SnapshotOutputBuilder();
340 String action = Action.Snapshot.toString();
341 String rpcName = Action.Snapshot.name().toLowerCase();
343 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
344 String identityUrl = input.getIdentityUrl();
345 if (null == status) {
347 RequestHandlerInput request =
348 new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader())
349 .actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload())
350 .action(action).rpcName(rpcName).additionalContext("identity-url", identityUrl).build();
351 status = buildStatusWithDispatcherOutput(executeRequest(request));
352 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
353 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
354 } catch (ParseException e) {
355 status = buildStatusWithParseException(e);
357 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
358 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
359 this.getClass().getName());
362 outputBuilder.setCommonHeader(input.getCommonHeader());
363 outputBuilder.setStatus(status);
364 RpcResult<SnapshotOutput> result =
365 RpcResultBuilder.<SnapshotOutput>status(true).withResult(outputBuilder.build()).build();
366 return Futures.immediateFuture(result);
370 public Future<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
371 logger.debug("Input received : " + input.toString());
373 RollbackOutputBuilder outputBuilder = new RollbackOutputBuilder();
374 String rpcName = Action.Rollback.toString();
376 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), rpcName);
377 String identityUrl = input.getIdentityUrl();
378 String snapshotId = input.getSnapshotId();
379 if (null == status) {
381 RequestHandlerInput request = new RequestInputBuilder().requestContext()
382 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
383 .payload(input.getPayload()).additionalContext("identity-url", identityUrl)
384 .additionalContext("snapshot-id", snapshotId).action(rpcName).build();
385 status = buildStatusWithDispatcherOutput(executeRequest(request));
386 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
387 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
388 } catch (ParseException e) {
389 status = buildStatusWithParseException(e);
391 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
392 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, rpcName, e.getMessage()),
393 this.getClass().getName());
397 outputBuilder.setCommonHeader(input.getCommonHeader());
398 outputBuilder.setStatus(status);
399 RpcResult<RollbackOutput> result =
400 RpcResultBuilder.<RollbackOutput>status(true).withResult(outputBuilder.build()).build();
401 return Futures.immediateFuture(result);
405 public Future<RpcResult<SyncOutput>> sync(SyncInput input) {
406 logger.debug("Input received : " + input.toString());
407 SyncOutputBuilder outputBuilder = new SyncOutputBuilder();
408 String action = Action.Sync.toString();
409 String rpcName = Action.Sync.name().toLowerCase();
411 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
412 if (null == status) {
414 RequestHandlerInput request = new RequestInputBuilder().requestContext()
415 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
416 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
417 status = buildStatusWithDispatcherOutput(executeRequest(request));
418 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
419 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
420 } catch (ParseException e) {
421 status = buildStatusWithParseException(e);
423 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
424 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
425 this.getClass().getName());
429 outputBuilder.setCommonHeader(input.getCommonHeader());
430 outputBuilder.setStatus(status);
431 RpcResult<SyncOutput> result =
432 RpcResultBuilder.<SyncOutput>status(true).withResult(outputBuilder.build()).build();
433 return Futures.immediateFuture(result);
437 public Future<RpcResult<QueryOutput>> query(QueryInput input) {
438 logger.debug(String.format("LCM query received input: %s", input.toString()));
439 QueryOutputBuilder outputBuilder = new QueryService().process(input);
440 RpcResult<QueryOutput> result =
441 RpcResultBuilder.<QueryOutput>status(true).withResult(outputBuilder.build()).build();
442 return Futures.immediateFuture(result);
446 public Future<RpcResult<RebootOutput>> reboot(RebootInput input) {
447 logger.debug(String.format("LCM reboot received input: %s", input.toString()));
448 RebootOutputBuilder outputBuilder = new RebootService().process(input);
449 RpcResult<RebootOutput> result =
450 RpcResultBuilder.<RebootOutput>status(true).withResult(outputBuilder.build()).build();
451 return Futures.immediateFuture(result);
455 public Future<RpcResult<AttachVolumeOutput>> attachVolume(AttachVolumeInput input) {
456 logger.debug(String.format("LCM attachVolume received input: %s", input.toString()));
457 AttachVolumeOutputBuilder outputBuilder = new VolumeService(true).attachVolume(input);
458 RpcResult<AttachVolumeOutput> result =
459 RpcResultBuilder.<AttachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
460 return Futures.immediateFuture(result);
464 public Future<RpcResult<DetachVolumeOutput>> detachVolume(DetachVolumeInput input) {
465 logger.debug(String.format("LCM detachVolume received input: %s", input.toString()));
466 DetachVolumeOutputBuilder outputBuilder = new VolumeService(false).detachVolume(input);
467 RpcResult<DetachVolumeOutput> result =
468 RpcResultBuilder.<DetachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
469 return Futures.immediateFuture(result);
473 public Future<RpcResult<QuiesceTrafficOutput>> quiesceTraffic(QuiesceTrafficInput input) {
474 logger.debug(String.format("LCM quiesce received input: %s", input.toString()));
475 QuiesceTrafficOutputBuilder outputBuilder = new QuiesceTrafficService().process(input);
476 RpcResult<QuiesceTrafficOutput> result =
477 RpcResultBuilder.<QuiesceTrafficOutput>status(true).withResult(outputBuilder.build()).build();
478 return Futures.immediateFuture(result);
482 public Future<RpcResult<ResumeTrafficOutput>> resumeTraffic(ResumeTrafficInput input) {
483 logger.debug(String.format("LCM resume received input: %s", input.toString()));
484 ResumeTrafficOutputBuilder outputBuilder = new ResumeTrafficService().process(input);
485 RpcResult<ResumeTrafficOutput> result =
486 RpcResultBuilder.<ResumeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
487 return Futures.immediateFuture(result);
491 public Future<RpcResult<UpgradePreCheckOutput>> upgradePreCheck(UpgradePreCheckInput input) {
492 logger.debug(String.format("LCM upgradeprecheck received input: %s", input.toString()));
493 UpgradePreCheckOutputBuilder outputBuilder = new UpgradeService("upgradePre").upgradePreCheck(input);
494 RpcResult<UpgradePreCheckOutput> result =
495 RpcResultBuilder.<UpgradePreCheckOutput>status(true).withResult(outputBuilder.build()).build();
496 return Futures.immediateFuture(result);
500 public Future<RpcResult<UpgradeSoftwareOutput>> upgradeSoftware(UpgradeSoftwareInput input) {
501 logger.debug(String.format("LCM upgradesoftware received input: %s", input.toString()));
502 UpgradeSoftwareOutputBuilder outputBuilder = new UpgradeService("upgradeSoft").upgradeSoftware(input);
503 RpcResult<UpgradeSoftwareOutput> result =
504 RpcResultBuilder.<UpgradeSoftwareOutput>status(true).withResult(outputBuilder.build()).build();
505 return Futures.immediateFuture(result);
509 public Future<RpcResult<UpgradePostCheckOutput>> upgradePostCheck(UpgradePostCheckInput input) {
510 logger.debug(String.format("LCM upgradepostcheck received input: %s", input.toString()));
511 UpgradePostCheckOutputBuilder outputBuilder = new UpgradeService("upgradePost").upgradePostCheck(input);
512 RpcResult<UpgradePostCheckOutput> result =
513 RpcResultBuilder.<UpgradePostCheckOutput>status(true).withResult(outputBuilder.build()).build();
514 return Futures.immediateFuture(result);
518 public Future<RpcResult<UpgradeBackupOutput>> upgradeBackup(UpgradeBackupInput input) {
519 logger.debug(String.format("LCM backup received input: %s", input.toString()));
520 UpgradeBackupOutputBuilder outputBuilder = new UpgradeService("upgradeBackup").upgradeBackup(input);
521 RpcResult<UpgradeBackupOutput> result =
522 RpcResultBuilder.<UpgradeBackupOutput>status(true).withResult(outputBuilder.build()).build();
523 return Futures.immediateFuture(result);
527 public Future<RpcResult<UpgradeBackoutOutput>> upgradeBackout(UpgradeBackoutInput input) {
528 logger.debug(String.format("LCM backout received input: %s", input.toString()));
529 UpgradeBackoutOutputBuilder outputBuilder = new UpgradeService("upgradeBackout").upgradeBackout(input);
530 RpcResult<UpgradeBackoutOutput> result =
531 RpcResultBuilder.<UpgradeBackoutOutput>status(true).withResult(outputBuilder.build()).build();
532 return Futures.immediateFuture(result);
536 public Future<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
537 logger.debug("Input received : " + input.toString());
538 TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
539 Action myAction = Action.Terminate;
540 String action = myAction.toString();
541 String rpcName = getRpcName(myAction);
543 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
544 if (null == status) {
546 RequestHandlerInput request = new RequestInputBuilder().requestContext()
547 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
548 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
549 status = buildStatusWithDispatcherOutput(executeRequest(request));
550 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
551 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
552 } catch (ParseException e) {
554 status = buildStatusWithParseException(e);
556 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
557 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
558 this.getClass().getName());
563 outputBuilder.setCommonHeader(input.getCommonHeader());
564 outputBuilder.setStatus(status);
565 RpcResult<TerminateOutput> result =
566 RpcResultBuilder.<TerminateOutput>status(true).withResult(outputBuilder.build()).build();
567 return Futures.immediateFuture(result);
571 public Future<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
572 logger.debug("Input received : " + input.toString());
573 ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
574 Action myAction = Action.Configure;
575 String action = myAction.toString();
576 String rpcName = getRpcName(myAction);
578 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
579 if (null == status) {
581 RequestHandlerInput request = new RequestInputBuilder().requestContext()
582 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
583 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
584 status = buildStatusWithDispatcherOutput(executeRequest(request));
585 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
586 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
587 } catch (ParseException e) {
588 status = buildStatusWithParseException(e);
590 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
591 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
592 this.getClass().getName());
596 outputBuilder.setCommonHeader(input.getCommonHeader());
597 outputBuilder.setStatus(status);
598 RpcResult<ConfigureOutput> result =
599 RpcResultBuilder.<ConfigureOutput>status(true).withResult(outputBuilder.build()).build();
600 return Futures.immediateFuture(result);
604 public Future<RpcResult<ActionStatusOutput>> actionStatus(ActionStatusInput input) {
605 logger.debug(String.format("Input received : %s", input.toString()));
606 ActionStatusOutputBuilder outputBuilder = (new ActionStatusService()).queryStatus(input);
607 RpcResult<ActionStatusOutput> result =
608 RpcResultBuilder.<ActionStatusOutput>status(true).withResult(outputBuilder.build()).build();
609 return Futures.immediateFuture(result);
613 public Future<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
614 logger.debug("Input received : " + input.toString());
615 ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
616 Action myAction = Action.ConfigModify;
617 String action = myAction.toString();
618 String rpcName = getRpcName(myAction);
620 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
621 if (null == status) {
623 RequestHandlerInput request = new RequestInputBuilder().requestContext()
624 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
625 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
626 status = buildStatusWithDispatcherOutput(executeRequest(request));
627 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
628 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
629 } catch (ParseException e) {
630 status = buildStatusWithParseException(e);
632 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
633 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
634 this.getClass().getName());
638 outputBuilder.setCommonHeader(input.getCommonHeader());
639 outputBuilder.setStatus(status);
640 RpcResult<ConfigModifyOutput> result =
641 RpcResultBuilder.<ConfigModifyOutput>status(true).withResult(outputBuilder.build()).build();
642 return Futures.immediateFuture(result);
646 public Future<RpcResult<ConfigScaleOutOutput>> configScaleOut(ConfigScaleOutInput input) {
647 logger.debug("Input received : " + input.toString());
648 ConfigScaleOutOutputBuilder outputBuilder = new ConfigScaleOutService().process(input);
649 RpcResult<ConfigScaleOutOutput> result = RpcResultBuilder.<ConfigScaleOutOutput> status(true).withResult(outputBuilder.build()).build();
650 return Futures.immediateFuture(result);
654 public Future<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
655 logger.debug("Input received : " + input.toString());
656 ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
657 Action myAction = Action.ConfigRestore;
658 String action = myAction.toString();
659 String rpcName = getRpcName(myAction);
661 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
662 if (null == status) {
664 RequestHandlerInput request = new RequestInputBuilder().requestContext()
665 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
666 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
667 status = buildStatusWithDispatcherOutput(executeRequest(request));
668 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
669 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
670 } catch (ParseException e) {
671 status = buildStatusWithParseException(e);
673 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
674 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
675 this.getClass().getName());
679 outputBuilder.setCommonHeader(input.getCommonHeader());
680 outputBuilder.setStatus(status);
681 RpcResult<ConfigRestoreOutput> result =
682 RpcResultBuilder.<ConfigRestoreOutput>status(true).withResult(outputBuilder.build()).build();
683 return Futures.immediateFuture(result);
687 public Future<RpcResult<TestOutput>> test(TestInput input) {
688 logger.debug("Input received : " + input.toString());
689 TestOutputBuilder outputBuilder = new TestOutputBuilder();
690 Action myAction = Action.Test;
691 String action = myAction.toString();
692 String rpcName = getRpcName(myAction);
694 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
695 if (null == status) {
697 RequestHandlerInput request = new RequestInputBuilder().requestContext()
698 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
699 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
700 status = buildStatusWithDispatcherOutput(executeRequest(request));
701 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
702 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
703 } catch (ParseException e) {
704 status = buildStatusWithParseException(e);
706 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
707 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
708 this.getClass().getName());
712 outputBuilder.setCommonHeader(input.getCommonHeader());
713 outputBuilder.setStatus(status);
714 RpcResult<TestOutput> result =
715 RpcResultBuilder.<TestOutput>status(true).withResult(outputBuilder.build()).build();
716 return Futures.immediateFuture(result);
721 public Future<RpcResult<StopOutput>> stop(StopInput input) {
722 logger.debug("Input received : " + input.toString());
723 StopOutputBuilder outputBuilder = new StopOutputBuilder();
724 Action myAction = Action.Stop;
725 String action = myAction.toString();
726 String rpcName = getRpcName(myAction);
728 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
729 if (null == status) {
731 RequestHandlerInput request = new RequestInputBuilder().requestContext()
732 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
733 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
734 status = buildStatusWithDispatcherOutput(executeRequest(request));
735 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
736 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
737 } catch (ParseException e) {
738 status = buildStatusWithParseException(e);
740 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
741 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
742 this.getClass().getName());
746 outputBuilder.setCommonHeader(input.getCommonHeader());
747 outputBuilder.setStatus(status);
748 RpcResult<StopOutput> result =
749 RpcResultBuilder.<StopOutput>status(true).withResult(outputBuilder.build()).build();
750 return Futures.immediateFuture(result);
754 * Starts a specific VNF
756 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#start(StartInput)
759 public Future<RpcResult<StartOutput>> start(StartInput input) {
760 logger.debug("Input received : " + input.toString());
762 StartOutputBuilder outputBuilder = new StartOutputBuilder();
763 Action myAction = Action.Start;
764 String action = myAction.toString();
765 String rpcName = getRpcName(myAction);
767 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
768 if (null == status) {
770 RequestHandlerInput request = new RequestInputBuilder().requestContext()
771 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
772 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
773 status = buildStatusWithDispatcherOutput(executeRequest(request));
774 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
775 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
776 } catch (ParseException e) {
777 status = buildStatusWithParseException(e);
779 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
780 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
781 this.getClass().getName());
785 outputBuilder.setCommonHeader(input.getCommonHeader());
786 outputBuilder.setStatus(status);
787 RpcResult<StartOutput> result =
788 RpcResultBuilder.<StartOutput>status(true).withResult(outputBuilder.build()).build();
789 return Futures.immediateFuture(result);
794 public Future<RpcResult<AuditOutput>> audit(AuditInput input) {
795 logger.debug("Input received : " + input.toString());
796 AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
797 Action myAction = Action.Audit;
798 String action = myAction.toString();
799 String rpcName = getRpcName(myAction);
801 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
802 if (null == status) {
804 RequestHandlerInput request = new RequestInputBuilder().requestContext()
805 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
806 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
807 status = buildStatusWithDispatcherOutput(executeRequest(request));
808 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
809 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
810 } catch (ParseException e) {
811 status = buildStatusWithParseException(e);
813 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
814 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
815 this.getClass().getName());
819 outputBuilder.setCommonHeader(input.getCommonHeader());
820 outputBuilder.setStatus(status);
821 RpcResult<AuditOutput> result =
822 RpcResultBuilder.<AuditOutput>status(true).withResult(outputBuilder.build()).build();
823 return Futures.immediateFuture(result);
827 public Future<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
828 logger.debug("Input received : " + input.toString());
829 SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
830 Action myAction = Action.SoftwareUpload;
831 String action = myAction.toString();
832 String rpcName = getRpcName(myAction);
834 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
835 if (null == status) {
837 RequestHandlerInput request = new RequestInputBuilder().requestContext()
838 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
839 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
840 status = buildStatusWithDispatcherOutput(executeRequest(request));
841 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
842 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
843 } catch (ParseException e) {
844 status = buildStatusWithParseException(e);
846 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
847 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
848 this.getClass().getName());
852 outputBuilder.setCommonHeader(input.getCommonHeader());
853 outputBuilder.setStatus(status);
854 RpcResult<SoftwareUploadOutput> result =
855 RpcResultBuilder.<SoftwareUploadOutput>status(true).withResult(outputBuilder.build()).build();
856 return Futures.immediateFuture(result);
860 public Future<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
861 logger.debug("Input received : " + input.toString());
862 HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
863 Action myAction = Action.HealthCheck;
864 String action = myAction.toString();
865 String rpcName = getRpcName(myAction);
867 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
868 if (null == status) {
870 RequestHandlerInput request = new RequestInputBuilder().requestContext()
871 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
872 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
873 status = buildStatusWithDispatcherOutput(executeRequest(request));
874 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
875 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
876 } catch (ParseException e) {
877 status = buildStatusWithParseException(e);
879 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
880 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
881 this.getClass().getName());
885 outputBuilder.setCommonHeader(input.getCommonHeader());
886 outputBuilder.setStatus(status);
887 RpcResult<HealthCheckOutput> result =
888 RpcResultBuilder.<HealthCheckOutput>status(true).withResult(outputBuilder.build()).build();
889 return Futures.immediateFuture(result);
893 public Future<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
894 logger.debug("Input received : " + input.toString());
895 LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
896 Action myAction = Action.LiveUpgrade;
897 String action = myAction.toString();
898 String rpcName = getRpcName(myAction);
900 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
901 if (null == status) {
903 RequestHandlerInput request = new RequestInputBuilder().requestContext()
904 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
905 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
906 status = buildStatusWithDispatcherOutput(executeRequest(request));
907 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
908 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
909 } catch (ParseException e) {
910 status = buildStatusWithParseException(e);
912 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
913 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
914 this.getClass().getName());
918 outputBuilder.setCommonHeader(input.getCommonHeader());
919 outputBuilder.setStatus(status);
920 RpcResult<LiveUpgradeOutput> result =
921 RpcResultBuilder.<LiveUpgradeOutput>status(true).withResult(outputBuilder.build()).build();
922 return Futures.immediateFuture(result);
927 public Future<RpcResult<LockOutput>> lock(LockInput input) {
928 logger.debug("Input received : " + input.toString());
929 LockOutputBuilder outputBuilder = new LockOutputBuilder();
930 Action myAction = Action.Lock;
931 String action = myAction.toString();
932 String rpcName = getRpcName(myAction);
934 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
935 if (null == status) {
937 RequestHandlerInput request = new RequestInputBuilder().requestContext()
938 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
939 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
940 status = buildStatusWithDispatcherOutput(executeRequest(request));
941 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
942 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
943 } catch (ParseException e) {
944 status = buildStatusWithParseException(e);
946 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
947 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
948 this.getClass().getName());
952 outputBuilder.setCommonHeader(input.getCommonHeader());
953 outputBuilder.setStatus(status);
954 RpcResult<LockOutput> result =
955 RpcResultBuilder.<LockOutput>status(true).withResult(outputBuilder.build()).build();
956 return Futures.immediateFuture(result);
961 public Future<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
962 logger.debug("Input received : " + input.toString());
963 UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
964 Action myAction = Action.Unlock;
965 String action = myAction.toString();
966 String rpcName = getRpcName(myAction);
968 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
969 if (null == status) {
971 RequestHandlerInput request = new RequestInputBuilder().requestContext()
972 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
973 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
974 status = buildStatusWithDispatcherOutput(executeRequest(request));
975 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
976 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
977 } catch (ParseException e) {
978 status = buildStatusWithParseException(e);
980 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
981 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
982 this.getClass().getName());
986 outputBuilder.setCommonHeader(input.getCommonHeader());
987 outputBuilder.setStatus(status);
988 RpcResult<UnlockOutput> result =
989 RpcResultBuilder.<UnlockOutput>status(true).withResult(outputBuilder.build()).build();
990 return Futures.immediateFuture(result);
994 public Future<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
995 logger.debug("Input received : " + input.toString());
996 CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
997 Action myAction = Action.CheckLock;
998 String action = myAction.toString();
999 String rpcName = getRpcName(myAction);
1000 RequestHandlerOutput requestHandlerOutput = null;
1002 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1003 if (null == status) {
1005 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1006 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1007 .action(action).rpcName(rpcName).build();
1008 requestHandlerOutput = executeRequest(request);
1010 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1011 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1012 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1013 } catch (ParseException e) {
1014 status = buildStatusWithParseException(e);
1016 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1017 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1018 this.getClass().getName());
1023 outputBuilder.setCommonHeader(input.getCommonHeader());
1024 outputBuilder.setStatus(status);
1025 if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1026 outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(
1027 requestHandlerOutput.getResponseContext().getAdditionalContext().get("locked").toUpperCase()));
1029 RpcResult<CheckLockOutput> result =
1030 RpcResultBuilder.<CheckLockOutput>status(true).withResult(outputBuilder.build()).build();
1031 return Futures.immediateFuture(result);
1035 public Future<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1036 logger.debug("Input received : " + input.toString());
1037 ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1038 Action myAction = Action.ConfigBackup;
1039 String action = myAction.toString();
1040 String rpcName = getRpcName(myAction);
1042 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1043 if (null == status) {
1045 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1046 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1047 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1048 status = buildStatusWithDispatcherOutput(executeRequest(request));
1049 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1050 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1051 } catch (ParseException e) {
1052 status = buildStatusWithParseException(e);
1054 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1055 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1056 this.getClass().getName());
1060 outputBuilder.setCommonHeader(input.getCommonHeader());
1061 outputBuilder.setStatus(status);
1062 RpcResult<ConfigBackupOutput> result =
1063 RpcResultBuilder.<ConfigBackupOutput>status(true).withResult(outputBuilder.build()).build();
1064 return Futures.immediateFuture(result);
1069 public Future<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1070 logger.debug("Input received : " + input.toString());
1071 ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1072 Action myAction = Action.ConfigBackupDelete;
1073 String action = myAction.toString();
1074 String rpcName = getRpcName(myAction);
1076 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1077 if (null == status) {
1079 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1080 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1081 .action(action).rpcName(rpcName).build();
1082 status = buildStatusWithDispatcherOutput(executeRequest(request));
1083 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1084 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1085 } catch (ParseException e) {
1086 status = buildStatusWithParseException(e);
1088 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1089 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1090 this.getClass().getName());
1094 outputBuilder.setCommonHeader(input.getCommonHeader());
1095 outputBuilder.setStatus(status);
1096 RpcResult<ConfigBackupDeleteOutput> result =
1097 RpcResultBuilder.<ConfigBackupDeleteOutput>status(true).withResult(outputBuilder.build()).build();
1098 return Futures.immediateFuture(result);
1103 public Future<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1104 logger.debug("Input received : " + input.toString());
1105 ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1106 Action myAction = Action.ConfigExport;
1107 String action = myAction.toString();
1108 String rpcName = getRpcName(myAction);
1110 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1111 if (null == status) {
1113 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1114 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1115 .action(action).rpcName(rpcName).build();
1116 status = buildStatusWithDispatcherOutput(executeRequest(request));
1117 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1118 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1119 } catch (ParseException e) {
1120 status = buildStatusWithParseException(e);
1122 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1123 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1124 this.getClass().getName());
1128 outputBuilder.setCommonHeader(input.getCommonHeader());
1129 outputBuilder.setStatus(status);
1130 RpcResult<ConfigExportOutput> result =
1131 RpcResultBuilder.<ConfigExportOutput>status(true).withResult(outputBuilder.build()).build();
1132 return Futures.immediateFuture(result);
1136 public Future<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input) {
1137 logger.debug("Input received : " + input.toString());
1138 StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1139 Action myAction = Action.StopApplication;
1140 String action = myAction.toString();
1141 String rpcName = getRpcName(myAction);
1143 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1144 if (null == status) {
1146 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1147 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1148 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1149 status = buildStatusWithDispatcherOutput(executeRequest(request));
1150 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1151 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1152 } catch (ParseException e) {
1153 status = buildStatusWithParseException(e);
1155 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1156 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1157 this.getClass().getName());
1161 outputBuilder.setCommonHeader(input.getCommonHeader());
1162 outputBuilder.setStatus(status);
1163 RpcResult<StopApplicationOutput> result =
1164 RpcResultBuilder.<StopApplicationOutput>status(true).withResult(outputBuilder.build()).build();
1165 return Futures.immediateFuture(result);
1168 RequestHandlerOutput executeRequest(RequestHandlerInput request) {
1169 return new RequestExecutor().executeRequest(request);