2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Copyright (C) 2017 Amdocs
8 * ================================================================================
9 * Modifications Copyright (C) 2018 Orange
10 * =============================================================================
11 * Licensed under the Apache License, Version 2.0 (the "License");
12 * you may not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
15 * http://www.apache.org/licenses/LICENSE-2.0
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
23 * ============LICENSE_END=========================================================
26 package org.onap.appc.provider;
28 import java.text.ParseException;
29 import java.util.concurrent.ExecutorService;
30 import java.util.concurrent.Executors;
31 import org.onap.appc.Constants;
32 import org.onap.appc.configuration.Configuration;
33 import org.onap.appc.configuration.ConfigurationFactory;
34 import org.onap.appc.i18n.Msg;
35 import org.onap.appc.logging.LoggingConstants;
36 import org.onap.appc.logging.LoggingUtils;
37 import org.onap.appc.provider.lcm.service.AbstractBaseUtils;
38 import org.onap.appc.provider.lcm.service.ActionStatusService;
39 import org.onap.appc.provider.lcm.service.QueryService;
40 import org.onap.appc.provider.lcm.service.QuiesceTrafficService;
41 import org.onap.appc.provider.lcm.service.RebootService;
42 import org.onap.appc.provider.lcm.service.RequestExecutor;
43 import org.onap.appc.provider.lcm.service.ResumeTrafficService;
44 import org.onap.appc.provider.lcm.service.UpgradeService;
45 import org.onap.appc.provider.lcm.service.VolumeService;
46 import org.onap.appc.provider.lcm.service.ConfigScaleOutService;
47 import org.onap.appc.provider.lcm.service.DistributeTrafficService;
48 import org.onap.appc.provider.lcm.util.RequestInputBuilder;
49 import org.onap.appc.provider.lcm.util.ValidationService;
50 import org.onap.appc.requesthandler.objects.RequestHandlerInput;
51 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
52 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
53 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
54 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
55 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
56 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
57 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
58 import org.opendaylight.yangtools.yang.common.RpcResult;
59 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
60 import com.att.eelf.configuration.EELFLogger;
61 import com.att.eelf.configuration.EELFManager;
62 import com.google.common.util.concurrent.Futures;
63 import com.google.common.util.concurrent.ListenableFuture;
66 public class AppcProviderLcm extends AbstractBaseUtils implements AutoCloseable, AppcProviderLcmService {
68 private Configuration configuration = ConfigurationFactory.getConfiguration();
69 private final EELFLogger logger = EELFManager.getInstance().getLogger(AppcProviderLcm.class);
71 private final ExecutorService executor;
74 * The ODL data store broker. Provides access to a conceptual data tree store and also provides the ability to
75 * subscribe for changes to data under a given branch of the tree.
77 protected DataBroker dataBroker;
80 * ODL Notification Service that provides publish/subscribe capabilities for YANG modeled notifications.
82 protected NotificationPublishService notificationService;
85 * Provides a registry for Remote Procedure Call (RPC) service implementations. The RPCs are defined in YANG models.
87 protected RpcProviderRegistry rpcRegistry;
90 * Represents our RPC implementation registration
92 protected BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
97 * @param notificationProviderService
98 * @param rpcProviderRegistry
100 @SuppressWarnings({"javadoc", "nls"})
101 public AppcProviderLcm(DataBroker dataBroker, NotificationPublishService notificationProviderService,
102 RpcProviderRegistry rpcProviderRegistry) {
104 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
105 logger.info(Msg.COMPONENT_INITIALIZING, appName, "provider-lcm");
107 executor = Executors.newFixedThreadPool(1);
108 this.dataBroker = dataBroker;
109 this.notificationService = notificationProviderService;
110 this.rpcRegistry = rpcProviderRegistry;
112 if (this.rpcRegistry != null) {
113 rpcRegistration = rpcRegistry.addRpcImplementation(AppcProviderLcmService.class, this);
116 logger.info(Msg.COMPONENT_INITIALIZED, appName, "provider");
120 * Implements the close of the service
122 * @see java.lang.AutoCloseable#close()
124 @SuppressWarnings("nls")
126 public void close() throws Exception {
127 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
128 logger.info(Msg.COMPONENT_TERMINATING, appName, "provider");
130 if (rpcRegistration != null) {
131 rpcRegistration.close();
133 logger.info(Msg.COMPONENT_TERMINATED, appName, "provider");
138 * Rebuilds a specific VNF
140 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#rebuild(RebuildInput)
143 public ListenableFuture<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
144 logger.debug("Input received : " + input.toString());
146 RebuildOutputBuilder outputBuilder = new RebuildOutputBuilder();
147 String action = Action.Rebuild.toString();
148 String rpcName = Action.Rebuild.name().toLowerCase();
150 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
151 if (null == status) {
153 RequestHandlerInput request = new RequestInputBuilder().requestContext()
154 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
155 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
156 status = buildStatusWithDispatcherOutput(executeRequest(request));
157 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
158 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
159 } catch (ParseException e) {
160 status = buildStatusWithParseException(e);
162 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
163 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
164 this.getClass().getName());
168 outputBuilder.setCommonHeader(input.getCommonHeader());
169 outputBuilder.setStatus(status);
170 RpcResult<RebuildOutput> result =
171 RpcResultBuilder.<RebuildOutput>status(true).withResult(outputBuilder.build()).build();
172 return Futures.immediateFuture(result);
178 * Restarts a specific VNF
180 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#restart(RestartInput)
183 public ListenableFuture<RpcResult<RestartOutput>> restart(RestartInput input) {
184 logger.debug("Input received : " + input.toString());
186 RestartOutputBuilder outputBuilder = new RestartOutputBuilder();
187 String action = Action.Restart.toString();
188 String rpcName = Action.Restart.name().toLowerCase();
190 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
191 if (null == status) {
193 RequestHandlerInput request = new RequestInputBuilder().requestContext()
194 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
195 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
197 status = buildStatusWithDispatcherOutput(executeRequest(request));
198 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
199 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
200 } catch (ParseException e) {
201 status = buildStatusWithParseException(e);
203 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
204 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
205 this.getClass().getName());
209 outputBuilder.setCommonHeader(input.getCommonHeader());
210 outputBuilder.setStatus(status);
211 RpcResult<RestartOutput> result =
212 RpcResultBuilder.<RestartOutput>status(true).withResult(outputBuilder.build()).build();
213 return Futures.immediateFuture(result);
219 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#startApplication(StartApplicationInput)
222 public ListenableFuture<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
223 logger.debug("Input received : " + input.toString());
225 StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
226 String action = Action.StartApplication.toString();
227 String rpcName = Action.StartApplication.name().toLowerCase();
229 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
230 if (null == status) {
232 RequestHandlerInput request = new RequestInputBuilder().requestContext()
233 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
234 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
236 status = buildStatusWithDispatcherOutput(executeRequest(request));
237 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
238 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
239 } catch (ParseException e) {
240 status = buildStatusWithParseException(e);
242 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
243 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
244 this.getClass().getName());
248 outputBuilder.setCommonHeader(input.getCommonHeader());
249 outputBuilder.setStatus(status);
250 RpcResult<StartApplicationOutput> result =
251 RpcResultBuilder.<StartApplicationOutput>status(true).withResult(outputBuilder.build()).build();
252 return Futures.immediateFuture(result);
256 * Migrates a specific VNF
258 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#migrate(MigrateInput)
261 public ListenableFuture<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
262 logger.debug("Input received : " + input.toString());
264 MigrateOutputBuilder outputBuilder = new MigrateOutputBuilder();
265 String action = Action.Migrate.toString();
266 String rpcName = Action.Migrate.name().toLowerCase();
268 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
269 if (null == status) {
271 RequestHandlerInput request = new RequestInputBuilder().requestContext()
272 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
273 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
274 status = buildStatusWithDispatcherOutput(executeRequest(request));
275 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
276 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
277 } catch (ParseException e) {
278 status = buildStatusWithParseException(e);
280 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
281 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
282 this.getClass().getName());
286 outputBuilder.setCommonHeader(input.getCommonHeader());
287 outputBuilder.setStatus(status);
288 RpcResult<MigrateOutput> result =
289 RpcResultBuilder.<MigrateOutput>status(true).withResult(outputBuilder.build()).build();
290 return Futures.immediateFuture(result);
295 * Evacuates a specific VNF
297 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#evacuate(EvacuateInput)
300 public ListenableFuture<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
301 logger.debug("Input received : " + input.toString());
303 EvacuateOutputBuilder outputBuilder = new EvacuateOutputBuilder();
304 String action = Action.Evacuate.toString();
305 String rpcName = Action.Evacuate.name().toLowerCase();
307 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
308 if (null == status) {
310 RequestHandlerInput request = new RequestInputBuilder().requestContext()
311 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
312 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
313 status = buildStatusWithDispatcherOutput(executeRequest(request));
314 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
315 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
316 } catch (ParseException e) {
317 status = buildStatusWithParseException(e);
319 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
320 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
321 this.getClass().getName());
325 outputBuilder.setCommonHeader(input.getCommonHeader());
326 outputBuilder.setStatus(status);
327 RpcResult<EvacuateOutput> result =
328 RpcResultBuilder.<EvacuateOutput>status(true).withResult(outputBuilder.build()).build();
329 return Futures.immediateFuture(result);
334 * Evacuates a specific VNF
336 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#snapshot(SnapshotInput)
339 public ListenableFuture<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
340 logger.debug("Input received : " + input.toString());
342 SnapshotOutputBuilder outputBuilder = new SnapshotOutputBuilder();
343 String action = Action.Snapshot.toString();
344 String rpcName = Action.Snapshot.name().toLowerCase();
346 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
347 String identityUrl = input.getIdentityUrl();
348 if (null == status) {
350 RequestHandlerInput request =
351 new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader())
352 .actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload())
353 .action(action).rpcName(rpcName).additionalContext("identity-url", identityUrl).build();
354 status = buildStatusWithDispatcherOutput(executeRequest(request));
355 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
356 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
357 } catch (ParseException e) {
358 status = buildStatusWithParseException(e);
360 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
361 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
362 this.getClass().getName());
365 outputBuilder.setCommonHeader(input.getCommonHeader());
366 outputBuilder.setStatus(status);
367 RpcResult<SnapshotOutput> result =
368 RpcResultBuilder.<SnapshotOutput>status(true).withResult(outputBuilder.build()).build();
369 return Futures.immediateFuture(result);
373 public ListenableFuture<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
374 logger.debug("Input received : " + input.toString());
376 RollbackOutputBuilder outputBuilder = new RollbackOutputBuilder();
377 String rpcName = Action.Rollback.toString();
379 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), rpcName);
380 String identityUrl = input.getIdentityUrl();
381 String snapshotId = input.getSnapshotId();
382 if (null == status) {
384 RequestHandlerInput request = new RequestInputBuilder().requestContext()
385 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
386 .payload(input.getPayload()).additionalContext("identity-url", identityUrl)
387 .additionalContext("snapshot-id", snapshotId).action(rpcName).build();
388 status = buildStatusWithDispatcherOutput(executeRequest(request));
389 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
390 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
391 } catch (ParseException e) {
392 status = buildStatusWithParseException(e);
394 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
395 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, rpcName, e.getMessage()),
396 this.getClass().getName());
400 outputBuilder.setCommonHeader(input.getCommonHeader());
401 outputBuilder.setStatus(status);
402 RpcResult<RollbackOutput> result =
403 RpcResultBuilder.<RollbackOutput>status(true).withResult(outputBuilder.build()).build();
404 return Futures.immediateFuture(result);
408 public ListenableFuture<RpcResult<SyncOutput>> sync(SyncInput input) {
409 logger.debug("Input received : " + input.toString());
410 SyncOutputBuilder outputBuilder = new SyncOutputBuilder();
411 String action = Action.Sync.toString();
412 String rpcName = Action.Sync.name().toLowerCase();
414 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
415 if (null == status) {
417 RequestHandlerInput request = new RequestInputBuilder().requestContext()
418 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
419 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
420 status = buildStatusWithDispatcherOutput(executeRequest(request));
421 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
422 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
423 } catch (ParseException e) {
424 status = buildStatusWithParseException(e);
426 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
427 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
428 this.getClass().getName());
432 outputBuilder.setCommonHeader(input.getCommonHeader());
433 outputBuilder.setStatus(status);
434 RpcResult<SyncOutput> result =
435 RpcResultBuilder.<SyncOutput>status(true).withResult(outputBuilder.build()).build();
436 return Futures.immediateFuture(result);
440 public ListenableFuture<RpcResult<QueryOutput>> query(QueryInput input) {
441 logger.debug(String.format("LCM query received input: %s", input.toString()));
442 QueryOutputBuilder outputBuilder = new QueryService().process(input);
443 RpcResult<QueryOutput> result =
444 RpcResultBuilder.<QueryOutput>status(true).withResult(outputBuilder.build()).build();
445 return Futures.immediateFuture(result);
449 public ListenableFuture<RpcResult<RebootOutput>> reboot(RebootInput input) {
450 logger.debug(String.format("LCM reboot received input: %s", input.toString()));
451 RebootOutputBuilder outputBuilder = new RebootService().reboot(input);
452 RpcResult<RebootOutput> result =
453 RpcResultBuilder.<RebootOutput>status(true).withResult(outputBuilder.build()).build();
454 return Futures.immediateFuture(result);
458 public ListenableFuture<RpcResult<AttachVolumeOutput>> attachVolume(AttachVolumeInput input) {
459 logger.debug(String.format("LCM attachVolume received input: %s", input.toString()));
460 AttachVolumeOutputBuilder outputBuilder = new VolumeService(true).attachVolume(input);
461 RpcResult<AttachVolumeOutput> result =
462 RpcResultBuilder.<AttachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
463 return Futures.immediateFuture(result);
467 public ListenableFuture<RpcResult<DetachVolumeOutput>> detachVolume(DetachVolumeInput input) {
468 logger.debug(String.format("LCM detachVolume received input: %s", input.toString()));
469 DetachVolumeOutputBuilder outputBuilder = new VolumeService(false).detachVolume(input);
470 RpcResult<DetachVolumeOutput> result =
471 RpcResultBuilder.<DetachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
472 return Futures.immediateFuture(result);
476 public ListenableFuture<RpcResult<QuiesceTrafficOutput>> quiesceTraffic(QuiesceTrafficInput input) {
477 logger.debug(String.format("LCM quiesce received input: %s", input.toString()));
478 QuiesceTrafficOutputBuilder outputBuilder = new QuiesceTrafficService().process(input);
479 RpcResult<QuiesceTrafficOutput> result =
480 RpcResultBuilder.<QuiesceTrafficOutput>status(true).withResult(outputBuilder.build()).build();
481 return Futures.immediateFuture(result);
485 public ListenableFuture<RpcResult<ResumeTrafficOutput>> resumeTraffic(ResumeTrafficInput input) {
486 logger.debug(String.format("LCM resume received input: %s", input.toString()));
487 ResumeTrafficOutputBuilder outputBuilder = new ResumeTrafficService().process(input);
488 RpcResult<ResumeTrafficOutput> result =
489 RpcResultBuilder.<ResumeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
490 return Futures.immediateFuture(result);
494 public ListenableFuture<RpcResult<DistributeTrafficOutput>> distributeTraffic(DistributeTrafficInput input) {
495 logger.debug(String.format("LCM DistributeTraffic, received input: %s", input.toString()));
496 DistributeTrafficOutputBuilder outputBuilder = new DistributeTrafficService().process(input);
497 RpcResult<DistributeTrafficOutput> result =
498 RpcResultBuilder.<DistributeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
499 return Futures.immediateFuture(result);
503 public ListenableFuture<RpcResult<UpgradePreCheckOutput>> upgradePreCheck(UpgradePreCheckInput input) {
504 logger.debug(String.format("LCM upgradeprecheck received input: %s", input.toString()));
505 UpgradePreCheckOutputBuilder outputBuilder = new UpgradeService("upgradePre").upgradePreCheck(input);
506 RpcResult<UpgradePreCheckOutput> result =
507 RpcResultBuilder.<UpgradePreCheckOutput>status(true).withResult(outputBuilder.build()).build();
508 return Futures.immediateFuture(result);
512 public ListenableFuture<RpcResult<UpgradeSoftwareOutput>> upgradeSoftware(UpgradeSoftwareInput input) {
513 logger.debug(String.format("LCM upgradesoftware received input: %s", input.toString()));
514 UpgradeSoftwareOutputBuilder outputBuilder = new UpgradeService("upgradeSoft").upgradeSoftware(input);
515 RpcResult<UpgradeSoftwareOutput> result =
516 RpcResultBuilder.<UpgradeSoftwareOutput>status(true).withResult(outputBuilder.build()).build();
517 return Futures.immediateFuture(result);
521 public ListenableFuture<RpcResult<UpgradePostCheckOutput>> upgradePostCheck(UpgradePostCheckInput input) {
522 logger.debug(String.format("LCM upgradepostcheck received input: %s", input.toString()));
523 UpgradePostCheckOutputBuilder outputBuilder = new UpgradeService("upgradePost").upgradePostCheck(input);
524 RpcResult<UpgradePostCheckOutput> result =
525 RpcResultBuilder.<UpgradePostCheckOutput>status(true).withResult(outputBuilder.build()).build();
526 return Futures.immediateFuture(result);
530 public ListenableFuture<RpcResult<UpgradeBackupOutput>> upgradeBackup(UpgradeBackupInput input) {
531 logger.debug(String.format("LCM backup received input: %s", input.toString()));
532 UpgradeBackupOutputBuilder outputBuilder = new UpgradeService("upgradeBackup").upgradeBackup(input);
533 RpcResult<UpgradeBackupOutput> result =
534 RpcResultBuilder.<UpgradeBackupOutput>status(true).withResult(outputBuilder.build()).build();
535 return Futures.immediateFuture(result);
539 public ListenableFuture<RpcResult<UpgradeBackoutOutput>> upgradeBackout(UpgradeBackoutInput input) {
540 logger.debug(String.format("LCM backout received input: %s", input.toString()));
541 UpgradeBackoutOutputBuilder outputBuilder = new UpgradeService("upgradeBackout").upgradeBackout(input);
542 RpcResult<UpgradeBackoutOutput> result =
543 RpcResultBuilder.<UpgradeBackoutOutput>status(true).withResult(outputBuilder.build()).build();
544 return Futures.immediateFuture(result);
548 public ListenableFuture<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
549 logger.debug("Input received : " + input.toString());
550 TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
551 Action myAction = Action.Terminate;
552 String action = myAction.toString();
553 String rpcName = getRpcName(myAction);
555 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
556 if (null == status) {
558 RequestHandlerInput request = new RequestInputBuilder().requestContext()
559 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
560 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
561 status = buildStatusWithDispatcherOutput(executeRequest(request));
562 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
563 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
564 } catch (ParseException e) {
566 status = buildStatusWithParseException(e);
568 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
569 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
570 this.getClass().getName());
575 outputBuilder.setCommonHeader(input.getCommonHeader());
576 outputBuilder.setStatus(status);
577 RpcResult<TerminateOutput> result =
578 RpcResultBuilder.<TerminateOutput>status(true).withResult(outputBuilder.build()).build();
579 return Futures.immediateFuture(result);
583 public ListenableFuture<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
584 logger.debug("Input received : " + input.toString());
585 ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
586 Action myAction = Action.Configure;
587 String action = myAction.toString();
588 String rpcName = getRpcName(myAction);
590 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
591 if (null == status) {
593 RequestHandlerInput request = new RequestInputBuilder().requestContext()
594 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
595 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
596 status = buildStatusWithDispatcherOutput(executeRequest(request));
597 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
598 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
599 } catch (ParseException e) {
600 status = buildStatusWithParseException(e);
602 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
603 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
604 this.getClass().getName());
608 outputBuilder.setCommonHeader(input.getCommonHeader());
609 outputBuilder.setStatus(status);
610 RpcResult<ConfigureOutput> result =
611 RpcResultBuilder.<ConfigureOutput>status(true).withResult(outputBuilder.build()).build();
612 return Futures.immediateFuture(result);
616 public ListenableFuture<RpcResult<ActionStatusOutput>> actionStatus(ActionStatusInput input) {
617 logger.debug(String.format("Input received : %s", input.toString()));
618 ActionStatusOutputBuilder outputBuilder = (new ActionStatusService()).queryStatus(input);
619 RpcResult<ActionStatusOutput> result =
620 RpcResultBuilder.<ActionStatusOutput>status(true).withResult(outputBuilder.build()).build();
621 return Futures.immediateFuture(result);
625 public ListenableFuture<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
626 logger.debug("Input received : " + input.toString());
627 ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
628 Action myAction = Action.ConfigModify;
629 String action = myAction.toString();
630 String rpcName = getRpcName(myAction);
632 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
633 if (null == status) {
635 RequestHandlerInput request = new RequestInputBuilder().requestContext()
636 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
637 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
638 status = buildStatusWithDispatcherOutput(executeRequest(request));
639 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
640 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
641 } catch (ParseException e) {
642 status = buildStatusWithParseException(e);
644 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
645 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
646 this.getClass().getName());
650 outputBuilder.setCommonHeader(input.getCommonHeader());
651 outputBuilder.setStatus(status);
652 RpcResult<ConfigModifyOutput> result =
653 RpcResultBuilder.<ConfigModifyOutput>status(true).withResult(outputBuilder.build()).build();
654 return Futures.immediateFuture(result);
658 public ListenableFuture<RpcResult<ConfigScaleOutOutput>> configScaleOut(ConfigScaleOutInput input) {
659 logger.debug("Input received : " + input.toString());
660 ConfigScaleOutOutputBuilder outputBuilder = new ConfigScaleOutService().process(input);
661 RpcResult<ConfigScaleOutOutput> result = RpcResultBuilder.<ConfigScaleOutOutput> status(true).withResult(outputBuilder.build()).build();
662 return Futures.immediateFuture(result);
666 public ListenableFuture<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
667 logger.debug("Input received : " + input.toString());
668 ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
669 Action myAction = Action.ConfigRestore;
670 String action = myAction.toString();
671 String rpcName = getRpcName(myAction);
673 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
674 if (null == status) {
676 RequestHandlerInput request = new RequestInputBuilder().requestContext()
677 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
678 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
679 status = buildStatusWithDispatcherOutput(executeRequest(request));
680 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
681 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
682 } catch (ParseException e) {
683 status = buildStatusWithParseException(e);
685 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
686 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
687 this.getClass().getName());
691 outputBuilder.setCommonHeader(input.getCommonHeader());
692 outputBuilder.setStatus(status);
693 RpcResult<ConfigRestoreOutput> result =
694 RpcResultBuilder.<ConfigRestoreOutput>status(true).withResult(outputBuilder.build()).build();
695 return Futures.immediateFuture(result);
699 public ListenableFuture<RpcResult<TestOutput>> test(TestInput input) {
700 logger.debug("Input received : " + input.toString());
701 TestOutputBuilder outputBuilder = new TestOutputBuilder();
702 Action myAction = Action.Test;
703 String action = myAction.toString();
704 String rpcName = getRpcName(myAction);
706 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
707 if (null == status) {
709 RequestHandlerInput request = new RequestInputBuilder().requestContext()
710 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
711 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
712 status = buildStatusWithDispatcherOutput(executeRequest(request));
713 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
714 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
715 } catch (ParseException e) {
716 status = buildStatusWithParseException(e);
718 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
719 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
720 this.getClass().getName());
724 outputBuilder.setCommonHeader(input.getCommonHeader());
725 outputBuilder.setStatus(status);
726 RpcResult<TestOutput> result =
727 RpcResultBuilder.<TestOutput>status(true).withResult(outputBuilder.build()).build();
728 return Futures.immediateFuture(result);
733 public ListenableFuture<RpcResult<StopOutput>> stop(StopInput input) {
734 logger.debug("Input received : " + input.toString());
735 StopOutputBuilder outputBuilder = new StopOutputBuilder();
736 Action myAction = Action.Stop;
737 String action = myAction.toString();
738 String rpcName = getRpcName(myAction);
740 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
741 if (null == status) {
743 RequestHandlerInput request = new RequestInputBuilder().requestContext()
744 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
745 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
746 status = buildStatusWithDispatcherOutput(executeRequest(request));
747 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
748 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
749 } catch (ParseException e) {
750 status = buildStatusWithParseException(e);
752 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
753 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
754 this.getClass().getName());
758 outputBuilder.setCommonHeader(input.getCommonHeader());
759 outputBuilder.setStatus(status);
760 RpcResult<StopOutput> result =
761 RpcResultBuilder.<StopOutput>status(true).withResult(outputBuilder.build()).build();
762 return Futures.immediateFuture(result);
766 * Starts a specific VNF
768 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#start(StartInput)
771 public ListenableFuture<RpcResult<StartOutput>> start(StartInput input) {
772 logger.debug("Input received : " + input.toString());
774 StartOutputBuilder outputBuilder = new StartOutputBuilder();
775 Action myAction = Action.Start;
776 String action = myAction.toString();
777 String rpcName = getRpcName(myAction);
779 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
780 if (null == status) {
782 RequestHandlerInput request = new RequestInputBuilder().requestContext()
783 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
784 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
785 status = buildStatusWithDispatcherOutput(executeRequest(request));
786 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
787 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
788 } catch (ParseException e) {
789 status = buildStatusWithParseException(e);
791 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
792 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
793 this.getClass().getName());
797 outputBuilder.setCommonHeader(input.getCommonHeader());
798 outputBuilder.setStatus(status);
799 RpcResult<StartOutput> result =
800 RpcResultBuilder.<StartOutput>status(true).withResult(outputBuilder.build()).build();
801 return Futures.immediateFuture(result);
806 public ListenableFuture<RpcResult<AuditOutput>> audit(AuditInput input) {
807 logger.debug("Input received : " + input.toString());
808 AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
809 Action myAction = Action.Audit;
810 String action = myAction.toString();
811 String rpcName = getRpcName(myAction);
813 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
814 if (null == status) {
816 RequestHandlerInput request = new RequestInputBuilder().requestContext()
817 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
818 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
819 status = buildStatusWithDispatcherOutput(executeRequest(request));
820 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
821 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
822 } catch (ParseException e) {
823 status = buildStatusWithParseException(e);
825 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
826 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
827 this.getClass().getName());
831 outputBuilder.setCommonHeader(input.getCommonHeader());
832 outputBuilder.setStatus(status);
833 RpcResult<AuditOutput> result =
834 RpcResultBuilder.<AuditOutput>status(true).withResult(outputBuilder.build()).build();
835 return Futures.immediateFuture(result);
839 public ListenableFuture<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
840 logger.debug("Input received : " + input.toString());
841 SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
842 Action myAction = Action.SoftwareUpload;
843 String action = myAction.toString();
844 String rpcName = getRpcName(myAction);
846 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
847 if (null == status) {
849 RequestHandlerInput request = new RequestInputBuilder().requestContext()
850 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
851 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
852 status = buildStatusWithDispatcherOutput(executeRequest(request));
853 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
854 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
855 } catch (ParseException e) {
856 status = buildStatusWithParseException(e);
858 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
859 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
860 this.getClass().getName());
864 outputBuilder.setCommonHeader(input.getCommonHeader());
865 outputBuilder.setStatus(status);
866 RpcResult<SoftwareUploadOutput> result =
867 RpcResultBuilder.<SoftwareUploadOutput>status(true).withResult(outputBuilder.build()).build();
868 return Futures.immediateFuture(result);
872 public ListenableFuture<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
873 logger.debug("Input received : " + input.toString());
874 HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
875 Action myAction = Action.HealthCheck;
876 String action = myAction.toString();
877 String rpcName = getRpcName(myAction);
879 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
880 if (null == status) {
882 RequestHandlerInput request = new RequestInputBuilder().requestContext()
883 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
884 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
885 status = buildStatusWithDispatcherOutput(executeRequest(request));
886 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
887 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
888 } catch (ParseException e) {
889 status = buildStatusWithParseException(e);
891 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
892 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
893 this.getClass().getName());
897 outputBuilder.setCommonHeader(input.getCommonHeader());
898 outputBuilder.setStatus(status);
899 RpcResult<HealthCheckOutput> result =
900 RpcResultBuilder.<HealthCheckOutput>status(true).withResult(outputBuilder.build()).build();
901 return Futures.immediateFuture(result);
905 public ListenableFuture<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
906 logger.debug("Input received : " + input.toString());
907 LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
908 Action myAction = Action.LiveUpgrade;
909 String action = myAction.toString();
910 String rpcName = getRpcName(myAction);
912 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
913 if (null == status) {
915 RequestHandlerInput request = new RequestInputBuilder().requestContext()
916 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
917 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
918 status = buildStatusWithDispatcherOutput(executeRequest(request));
919 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
920 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
921 } catch (ParseException e) {
922 status = buildStatusWithParseException(e);
924 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
925 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
926 this.getClass().getName());
930 outputBuilder.setCommonHeader(input.getCommonHeader());
931 outputBuilder.setStatus(status);
932 RpcResult<LiveUpgradeOutput> result =
933 RpcResultBuilder.<LiveUpgradeOutput>status(true).withResult(outputBuilder.build()).build();
934 return Futures.immediateFuture(result);
939 public ListenableFuture<RpcResult<LockOutput>> lock(LockInput input) {
940 logger.debug("Input received : " + input.toString());
941 LockOutputBuilder outputBuilder = new LockOutputBuilder();
942 Action myAction = Action.Lock;
943 String action = myAction.toString();
944 String rpcName = getRpcName(myAction);
946 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
947 if (null == status) {
949 RequestHandlerInput request = new RequestInputBuilder().requestContext()
950 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
951 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
952 status = buildStatusWithDispatcherOutput(executeRequest(request));
953 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
954 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
955 } catch (ParseException e) {
956 status = buildStatusWithParseException(e);
958 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
959 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
960 this.getClass().getName());
964 outputBuilder.setCommonHeader(input.getCommonHeader());
965 outputBuilder.setStatus(status);
966 RpcResult<LockOutput> result =
967 RpcResultBuilder.<LockOutput>status(true).withResult(outputBuilder.build()).build();
968 return Futures.immediateFuture(result);
973 public ListenableFuture<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
974 logger.debug("Input received : " + input.toString());
975 UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
976 Action myAction = Action.Unlock;
977 String action = myAction.toString();
978 String rpcName = getRpcName(myAction);
980 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
981 if (null == status) {
983 RequestHandlerInput request = new RequestInputBuilder().requestContext()
984 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
985 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
986 status = buildStatusWithDispatcherOutput(executeRequest(request));
987 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
988 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
989 } catch (ParseException e) {
990 status = buildStatusWithParseException(e);
992 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
993 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
994 this.getClass().getName());
998 outputBuilder.setCommonHeader(input.getCommonHeader());
999 outputBuilder.setStatus(status);
1000 RpcResult<UnlockOutput> result =
1001 RpcResultBuilder.<UnlockOutput>status(true).withResult(outputBuilder.build()).build();
1002 return Futures.immediateFuture(result);
1006 public ListenableFuture<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
1007 logger.debug("Input received : " + input.toString());
1008 CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
1009 Action myAction = Action.CheckLock;
1010 String action = myAction.toString();
1011 String rpcName = getRpcName(myAction);
1012 RequestHandlerOutput requestHandlerOutput = null;
1014 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1015 if (null == status) {
1017 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1018 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1019 .action(action).rpcName(rpcName).build();
1020 requestHandlerOutput = executeRequest(request);
1022 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1023 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1024 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1025 } catch (ParseException e) {
1026 status = buildStatusWithParseException(e);
1028 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1029 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1030 this.getClass().getName());
1035 outputBuilder.setCommonHeader(input.getCommonHeader());
1036 outputBuilder.setStatus(status);
1037 if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1038 outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(
1039 requestHandlerOutput.getResponseContext().getAdditionalContext().get("locked").toUpperCase()));
1041 RpcResult<CheckLockOutput> result =
1042 RpcResultBuilder.<CheckLockOutput>status(true).withResult(outputBuilder.build()).build();
1043 return Futures.immediateFuture(result);
1047 public ListenableFuture<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1048 logger.debug("Input received : " + input.toString());
1049 ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1050 Action myAction = Action.ConfigBackup;
1051 String action = myAction.toString();
1052 String rpcName = getRpcName(myAction);
1054 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1055 if (null == status) {
1057 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1058 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1059 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1060 status = buildStatusWithDispatcherOutput(executeRequest(request));
1061 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1062 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1063 } catch (ParseException e) {
1064 status = buildStatusWithParseException(e);
1066 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1067 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1068 this.getClass().getName());
1072 outputBuilder.setCommonHeader(input.getCommonHeader());
1073 outputBuilder.setStatus(status);
1074 RpcResult<ConfigBackupOutput> result =
1075 RpcResultBuilder.<ConfigBackupOutput>status(true).withResult(outputBuilder.build()).build();
1076 return Futures.immediateFuture(result);
1081 public ListenableFuture<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1082 logger.debug("Input received : " + input.toString());
1083 ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1084 Action myAction = Action.ConfigBackupDelete;
1085 String action = myAction.toString();
1086 String rpcName = getRpcName(myAction);
1088 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1089 if (null == status) {
1091 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1092 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1093 .action(action).rpcName(rpcName).build();
1094 status = buildStatusWithDispatcherOutput(executeRequest(request));
1095 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1096 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1097 } catch (ParseException e) {
1098 status = buildStatusWithParseException(e);
1100 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1101 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1102 this.getClass().getName());
1106 outputBuilder.setCommonHeader(input.getCommonHeader());
1107 outputBuilder.setStatus(status);
1108 RpcResult<ConfigBackupDeleteOutput> result =
1109 RpcResultBuilder.<ConfigBackupDeleteOutput>status(true).withResult(outputBuilder.build()).build();
1110 return Futures.immediateFuture(result);
1115 public ListenableFuture<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1116 logger.debug("Input received : " + input.toString());
1117 ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1118 Action myAction = Action.ConfigExport;
1119 String action = myAction.toString();
1120 String rpcName = getRpcName(myAction);
1122 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1123 if (null == status) {
1125 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1126 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1127 .action(action).rpcName(rpcName).build();
1128 status = buildStatusWithDispatcherOutput(executeRequest(request));
1129 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1130 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1131 } catch (ParseException e) {
1132 status = buildStatusWithParseException(e);
1134 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1135 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1136 this.getClass().getName());
1140 outputBuilder.setCommonHeader(input.getCommonHeader());
1141 outputBuilder.setStatus(status);
1142 RpcResult<ConfigExportOutput> result =
1143 RpcResultBuilder.<ConfigExportOutput>status(true).withResult(outputBuilder.build()).build();
1144 return Futures.immediateFuture(result);
1148 public ListenableFuture<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input) {
1149 logger.debug("Input received : " + input.toString());
1150 StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1151 Action myAction = Action.StopApplication;
1152 String action = myAction.toString();
1153 String rpcName = getRpcName(myAction);
1155 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1156 if (null == status) {
1158 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1159 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1160 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1161 status = buildStatusWithDispatcherOutput(executeRequest(request));
1162 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1163 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1164 } catch (ParseException e) {
1165 status = buildStatusWithParseException(e);
1167 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1168 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1169 this.getClass().getName());
1173 outputBuilder.setCommonHeader(input.getCommonHeader());
1174 outputBuilder.setStatus(status);
1175 RpcResult<StopApplicationOutput> result =
1176 RpcResultBuilder.<StopApplicationOutput>status(true).withResult(outputBuilder.build()).build();
1177 return Futures.immediateFuture(result);
1180 RequestHandlerOutput executeRequest(RequestHandlerInput request) {
1181 return new RequestExecutor().executeRequest(request);