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-2019 Orange
10 * ================================================================================
11 * Modifications Copyright (C) 2019 Ericsson
12 * =============================================================================
13 * Licensed under the Apache License, Version 2.0 (the "License");
14 * you may not use this file except in compliance with the License.
15 * You may obtain a copy of the License at
17 * http://www.apache.org/licenses/LICENSE-2.0
19 * Unless required by applicable law or agreed to in writing, software
20 * distributed under the License is distributed on an "AS IS" BASIS,
21 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 * See the License for the specific language governing permissions and
23 * limitations under the License.
25 * ============LICENSE_END=========================================================
28 package org.onap.appc.provider;
30 import java.text.ParseException;
31 import java.util.concurrent.ExecutorService;
32 import java.util.concurrent.Executors;
33 import org.onap.appc.Constants;
34 import org.onap.appc.configuration.Configuration;
35 import org.onap.appc.configuration.ConfigurationFactory;
36 import org.onap.appc.i18n.Msg;
37 import org.onap.appc.logging.LoggingConstants;
38 import org.onap.appc.logging.LoggingUtils;
39 import org.onap.appc.provider.lcm.service.AbstractBaseUtils;
40 import org.onap.appc.provider.lcm.service.ActionStatusService;
41 import org.onap.appc.provider.lcm.service.QueryService;
42 import org.onap.appc.provider.lcm.service.QuiesceTrafficService;
43 import org.onap.appc.provider.lcm.service.RebootService;
44 import org.onap.appc.provider.lcm.service.RequestExecutor;
45 import org.onap.appc.provider.lcm.service.ResumeTrafficService;
46 import org.onap.appc.provider.lcm.service.UpgradeService;
47 import org.onap.appc.provider.lcm.service.VolumeService;
48 import org.onap.appc.provider.lcm.service.ConfigScaleOutService;
49 import org.onap.appc.provider.lcm.service.PreConfigure;
50 import org.onap.appc.provider.lcm.service.PreRebuild;
51 import org.onap.appc.provider.lcm.service.GetConfigService;
52 import org.onap.appc.provider.lcm.service.PostRebuild;
53 import org.onap.appc.provider.lcm.service.PostEvacuateService;
54 import org.onap.appc.provider.lcm.service.PreMigrateService;
55 import org.onap.appc.provider.lcm.service.PostMigrateService;
56 import org.onap.appc.provider.lcm.service.DistributeTrafficService;
57 import org.onap.appc.provider.lcm.service.DistributeTrafficCheckService;
58 import org.onap.appc.provider.lcm.service.PreEvacuate;
59 import org.onap.appc.provider.lcm.service.ProvisioningService;
60 import org.onap.appc.provider.lcm.service.LicenseManagementService;
61 import org.onap.appc.provider.lcm.service.StartTraffic;
62 import org.onap.appc.provider.lcm.service.StatusTraffic;
63 import org.onap.appc.provider.lcm.service.StopTraffic;
64 import org.onap.appc.provider.lcm.service.ConfigScaleInService;
65 import org.onap.appc.provider.lcm.service.DownloadNESw;
66 import org.onap.appc.provider.lcm.service.ActivateNESw;
67 import org.onap.appc.provider.lcm.util.RequestInputBuilder;
68 import org.onap.appc.provider.lcm.util.ValidationService;
69 import org.onap.appc.requesthandler.objects.RequestHandlerInput;
70 import org.onap.appc.requesthandler.objects.RequestHandlerOutput;
71 import org.opendaylight.mdsal.binding.api.DataBroker;
72 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
73 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
74 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
75 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.*;
76 import org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.status.Status;
77 import org.opendaylight.yangtools.yang.common.RpcResult;
78 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
79 import com.att.eelf.configuration.EELFLogger;
80 import com.att.eelf.configuration.EELFManager;
81 import com.google.common.util.concurrent.Futures;
82 import com.google.common.util.concurrent.ListenableFuture;
85 public class AppcProviderLcm extends AbstractBaseUtils implements AutoCloseable, AppcProviderLcmService {
87 private Configuration configuration = ConfigurationFactory.getConfiguration();
88 private final EELFLogger logger = EELFManager.getInstance().getLogger(AppcProviderLcm.class);
90 private final ExecutorService executor;
93 * The ODL data store broker. Provides access to a conceptual data tree store and also provides the ability to
94 * subscribe for changes to data under a given branch of the tree.
96 protected DataBroker dataBroker;
99 * ODL Notification Service that provides publish/subscribe capabilities for YANG modeled notifications.
101 protected NotificationPublishService notificationService;
104 * Provides a registry for Remote Procedure Call (RPC) service implementations. The RPCs are defined in YANG models.
106 protected RpcProviderRegistry rpcRegistry;
109 * Represents our RPC implementation registration
111 protected BindingAwareBroker.RpcRegistration<AppcProviderLcmService> rpcRegistration;
116 * @param notificationProviderService
117 * @param rpcProviderRegistry
119 @SuppressWarnings({"javadoc", "nls"})
120 public AppcProviderLcm(DataBroker dataBroker, NotificationPublishService notificationProviderService,
121 RpcProviderRegistry rpcProviderRegistry) {
123 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
124 logger.info(Msg.COMPONENT_INITIALIZING, appName, "provider-lcm");
126 executor = Executors.newFixedThreadPool(1);
127 this.dataBroker = dataBroker;
128 this.notificationService = notificationProviderService;
129 this.rpcRegistry = rpcProviderRegistry;
131 if (this.rpcRegistry != null) {
132 rpcRegistration = rpcRegistry.addRpcImplementation(AppcProviderLcmService.class, this);
134 logger.info(Msg.COMPONENT_INITIALIZED, appName, "provider");
138 * Implements the close of the service
140 * @see java.lang.AutoCloseable#close()
142 @SuppressWarnings("nls")
144 public void close() throws Exception {
145 String appName = configuration.getProperty(Constants.PROPERTY_APPLICATION_NAME);
146 logger.info(Msg.COMPONENT_TERMINATING, appName, "provider");
148 if (rpcRegistration != null) {
149 rpcRegistration.close();
151 logger.info(Msg.COMPONENT_TERMINATED, appName, "provider");
156 * Rebuilds a specific VNF
158 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#rebuild(RebuildInput)
161 public ListenableFuture<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
162 logger.debug("Input received : " + input.toString());
164 RebuildOutputBuilder outputBuilder = new RebuildOutputBuilder();
165 String action = Action.Rebuild.toString();
166 String rpcName = Action.Rebuild.name().toLowerCase();
168 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
169 if (null == status) {
171 RequestHandlerInput request = new RequestInputBuilder().requestContext()
172 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
173 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
174 status = buildStatusWithDispatcherOutput(executeRequest(request));
175 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
176 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
177 } catch (ParseException e) {
178 status = buildStatusWithParseException(e);
180 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
181 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
182 this.getClass().getName());
186 outputBuilder.setCommonHeader(input.getCommonHeader());
187 outputBuilder.setStatus(status);
188 RpcResult<RebuildOutput> result =
189 RpcResultBuilder.<RebuildOutput>status(true).withResult(outputBuilder.build()).build();
190 return Futures.immediateFuture(result);
196 * Restarts a specific VNF
198 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#restart(RestartInput)
201 public ListenableFuture<RpcResult<RestartOutput>> restart(RestartInput input) {
202 logger.debug("Input received : " + input.toString());
204 RestartOutputBuilder outputBuilder = new RestartOutputBuilder();
205 String action = Action.Restart.toString();
206 String rpcName = Action.Restart.name().toLowerCase();
208 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
209 if (null == status) {
211 RequestHandlerInput request = new RequestInputBuilder().requestContext()
212 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
213 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
215 status = buildStatusWithDispatcherOutput(executeRequest(request));
216 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
217 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
218 } catch (ParseException e) {
219 status = buildStatusWithParseException(e);
221 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
222 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
223 this.getClass().getName());
227 outputBuilder.setCommonHeader(input.getCommonHeader());
228 outputBuilder.setStatus(status);
229 RpcResult<RestartOutput> result =
230 RpcResultBuilder.<RestartOutput>status(true).withResult(outputBuilder.build()).build();
231 return Futures.immediateFuture(result);
237 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#startApplication(StartApplicationInput)
240 public ListenableFuture<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
241 logger.debug("Input received : " + input.toString());
243 StartApplicationOutputBuilder outputBuilder = new StartApplicationOutputBuilder();
244 String action = Action.StartApplication.toString();
245 String rpcName = Action.StartApplication.name().toLowerCase();
247 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
248 if (null == status) {
250 RequestHandlerInput request = new RequestInputBuilder().requestContext()
251 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
252 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
254 status = buildStatusWithDispatcherOutput(executeRequest(request));
255 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
256 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
257 } catch (ParseException e) {
258 status = buildStatusWithParseException(e);
260 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
261 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
262 this.getClass().getName());
266 outputBuilder.setCommonHeader(input.getCommonHeader());
267 outputBuilder.setStatus(status);
268 RpcResult<StartApplicationOutput> result =
269 RpcResultBuilder.<StartApplicationOutput>status(true).withResult(outputBuilder.build()).build();
270 return Futures.immediateFuture(result);
274 * Migrates a specific VNF
276 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#migrate(MigrateInput)
279 public ListenableFuture<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
280 logger.debug("Input received : " + input.toString());
282 MigrateOutputBuilder outputBuilder = new MigrateOutputBuilder();
283 String action = Action.Migrate.toString();
284 String rpcName = Action.Migrate.name().toLowerCase();
286 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
287 if (null == status) {
289 RequestHandlerInput request = new RequestInputBuilder().requestContext()
290 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
291 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
292 status = buildStatusWithDispatcherOutput(executeRequest(request));
293 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
294 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
295 } catch (ParseException e) {
296 status = buildStatusWithParseException(e);
298 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
299 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
300 this.getClass().getName());
304 outputBuilder.setCommonHeader(input.getCommonHeader());
305 outputBuilder.setStatus(status);
306 RpcResult<MigrateOutput> result =
307 RpcResultBuilder.<MigrateOutput>status(true).withResult(outputBuilder.build()).build();
308 return Futures.immediateFuture(result);
313 * Evacuates a specific VNF
315 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#evacuate(EvacuateInput)
318 public ListenableFuture<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
319 logger.debug("Input received : " + input.toString());
321 EvacuateOutputBuilder outputBuilder = new EvacuateOutputBuilder();
322 String action = Action.Evacuate.toString();
323 String rpcName = Action.Evacuate.name().toLowerCase();
325 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
326 if (null == status) {
328 RequestHandlerInput request = new RequestInputBuilder().requestContext()
329 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
330 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
331 status = buildStatusWithDispatcherOutput(executeRequest(request));
332 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
333 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
334 } catch (ParseException e) {
335 status = buildStatusWithParseException(e);
337 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
338 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
339 this.getClass().getName());
343 outputBuilder.setCommonHeader(input.getCommonHeader());
344 outputBuilder.setStatus(status);
345 RpcResult<EvacuateOutput> result =
346 RpcResultBuilder.<EvacuateOutput>status(true).withResult(outputBuilder.build()).build();
347 return Futures.immediateFuture(result);
352 * Evacuates a specific VNF
354 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#snapshot(SnapshotInput)
357 public ListenableFuture<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
358 logger.debug("Input received : " + input.toString());
360 SnapshotOutputBuilder outputBuilder = new SnapshotOutputBuilder();
361 String action = Action.Snapshot.toString();
362 String rpcName = Action.Snapshot.name().toLowerCase();
364 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
365 String identityUrl = input.getIdentityUrl();
366 if (null == status) {
368 RequestHandlerInput request =
369 new RequestInputBuilder().requestContext().commonHeader(input.getCommonHeader())
370 .actionIdentifiers(input.getActionIdentifiers()).payload(input.getPayload())
371 .action(action).rpcName(rpcName).additionalContext("identity-url", identityUrl).build();
372 status = buildStatusWithDispatcherOutput(executeRequest(request));
373 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
374 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
375 } catch (ParseException e) {
376 status = buildStatusWithParseException(e);
378 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
379 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
380 this.getClass().getName());
383 outputBuilder.setCommonHeader(input.getCommonHeader());
384 outputBuilder.setStatus(status);
385 RpcResult<SnapshotOutput> result =
386 RpcResultBuilder.<SnapshotOutput>status(true).withResult(outputBuilder.build()).build();
387 return Futures.immediateFuture(result);
391 public ListenableFuture<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
392 logger.debug("Input received : " + input.toString());
394 RollbackOutputBuilder outputBuilder = new RollbackOutputBuilder();
395 String rpcName = Action.Rollback.toString();
397 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), rpcName);
398 String identityUrl = input.getIdentityUrl();
399 String snapshotId = input.getSnapshotId();
400 if (null == status) {
402 RequestHandlerInput request = new RequestInputBuilder().requestContext()
403 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
404 .payload(input.getPayload()).additionalContext("identity-url", identityUrl)
405 .additionalContext("snapshot-id", snapshotId).action(rpcName).build();
406 status = buildStatusWithDispatcherOutput(executeRequest(request));
407 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
408 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
409 } catch (ParseException e) {
410 status = buildStatusWithParseException(e);
412 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
413 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, rpcName, e.getMessage()),
414 this.getClass().getName());
418 outputBuilder.setCommonHeader(input.getCommonHeader());
419 outputBuilder.setStatus(status);
420 RpcResult<RollbackOutput> result =
421 RpcResultBuilder.<RollbackOutput>status(true).withResult(outputBuilder.build()).build();
422 return Futures.immediateFuture(result);
426 public ListenableFuture<RpcResult<SyncOutput>> sync(SyncInput input) {
427 logger.debug("Input received : " + input.toString());
428 SyncOutputBuilder outputBuilder = new SyncOutputBuilder();
429 String action = Action.Sync.toString();
430 String rpcName = Action.Sync.name().toLowerCase();
432 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
433 if (null == status) {
435 RequestHandlerInput request = new RequestInputBuilder().requestContext()
436 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
437 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
438 status = buildStatusWithDispatcherOutput(executeRequest(request));
439 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
440 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
441 } catch (ParseException e) {
442 status = buildStatusWithParseException(e);
444 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
445 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
446 this.getClass().getName());
450 outputBuilder.setCommonHeader(input.getCommonHeader());
451 outputBuilder.setStatus(status);
452 RpcResult<SyncOutput> result =
453 RpcResultBuilder.<SyncOutput>status(true).withResult(outputBuilder.build()).build();
454 return Futures.immediateFuture(result);
458 public ListenableFuture<RpcResult<QueryOutput>> query(QueryInput input) {
459 logger.debug(String.format("LCM query received input: %s", input.toString()));
460 QueryOutputBuilder outputBuilder = new QueryService().process(input);
461 RpcResult<QueryOutput> result =
462 RpcResultBuilder.<QueryOutput>status(true).withResult(outputBuilder.build()).build();
463 return Futures.immediateFuture(result);
467 public ListenableFuture<RpcResult<RebootOutput>> reboot(RebootInput input) {
468 logger.debug(String.format("LCM reboot received input: %s", input.toString()));
469 RebootOutputBuilder outputBuilder = new RebootService().reboot(input);
470 RpcResult<RebootOutput> result =
471 RpcResultBuilder.<RebootOutput>status(true).withResult(outputBuilder.build()).build();
472 return Futures.immediateFuture(result);
476 public ListenableFuture<RpcResult<AttachVolumeOutput>> attachVolume(AttachVolumeInput input) {
477 logger.debug(String.format("LCM attachVolume received input: %s", input.toString()));
478 AttachVolumeOutputBuilder outputBuilder = new VolumeService(true).attachVolume(input);
479 RpcResult<AttachVolumeOutput> result =
480 RpcResultBuilder.<AttachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
481 return Futures.immediateFuture(result);
485 public ListenableFuture<RpcResult<DetachVolumeOutput>> detachVolume(DetachVolumeInput input) {
486 logger.debug(String.format("LCM detachVolume received input: %s", input.toString()));
487 DetachVolumeOutputBuilder outputBuilder = new VolumeService(false).detachVolume(input);
488 RpcResult<DetachVolumeOutput> result =
489 RpcResultBuilder.<DetachVolumeOutput>status(true).withResult(outputBuilder.build()).build();
490 return Futures.immediateFuture(result);
494 public ListenableFuture<RpcResult<QuiesceTrafficOutput>> quiesceTraffic(QuiesceTrafficInput input) {
495 logger.debug(String.format("LCM quiesce received input: %s", input.toString()));
496 QuiesceTrafficOutputBuilder outputBuilder = new QuiesceTrafficService().process(input);
497 RpcResult<QuiesceTrafficOutput> result =
498 RpcResultBuilder.<QuiesceTrafficOutput>status(true).withResult(outputBuilder.build()).build();
499 return Futures.immediateFuture(result);
503 public ListenableFuture<RpcResult<ResumeTrafficOutput>> resumeTraffic(ResumeTrafficInput input) {
504 logger.debug(String.format("LCM resume received input: %s", input.toString()));
505 ResumeTrafficOutputBuilder outputBuilder = new ResumeTrafficService().process(input);
506 RpcResult<ResumeTrafficOutput> result =
507 RpcResultBuilder.<ResumeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
508 return Futures.immediateFuture(result);
512 public ListenableFuture<RpcResult<DistributeTrafficOutput>> distributeTraffic(DistributeTrafficInput input) {
513 logger.debug(String.format("LCM DistributeTraffic, received input: %s", input.toString()));
514 DistributeTrafficOutputBuilder outputBuilder = new DistributeTrafficService().process(input);
515 RpcResult<DistributeTrafficOutput> result =
516 RpcResultBuilder.<DistributeTrafficOutput>status(true).withResult(outputBuilder.build()).build();
517 return Futures.immediateFuture(result);
521 public ListenableFuture<RpcResult<DistributeTrafficCheckOutput>> distributeTrafficCheck(DistributeTrafficCheckInput input) {
522 logger.debug(String.format("LCM DistributeTrafficCheck, received input: %s", input.toString()));
523 DistributeTrafficCheckOutputBuilder outputBuilder = new DistributeTrafficCheckService().process(input);
524 RpcResult<DistributeTrafficCheckOutput> result =
525 RpcResultBuilder.<DistributeTrafficCheckOutput>status(true).withResult(outputBuilder.build()).build();
526 return Futures.immediateFuture(result);
530 public ListenableFuture<RpcResult<UpgradePreCheckOutput>> upgradePreCheck(UpgradePreCheckInput input) {
531 logger.debug(String.format("LCM upgradeprecheck received input: %s", input.toString()));
532 UpgradePreCheckOutputBuilder outputBuilder = new UpgradeService("upgradePre").upgradePreCheck(input);
533 RpcResult<UpgradePreCheckOutput> result =
534 RpcResultBuilder.<UpgradePreCheckOutput>status(true).withResult(outputBuilder.build()).build();
535 return Futures.immediateFuture(result);
539 public ListenableFuture<RpcResult<UpgradeSoftwareOutput>> upgradeSoftware(UpgradeSoftwareInput input) {
540 logger.debug(String.format("LCM upgradesoftware received input: %s", input.toString()));
541 UpgradeSoftwareOutputBuilder outputBuilder = new UpgradeService("upgradeSoft").upgradeSoftware(input);
542 RpcResult<UpgradeSoftwareOutput> result =
543 RpcResultBuilder.<UpgradeSoftwareOutput>status(true).withResult(outputBuilder.build()).build();
544 return Futures.immediateFuture(result);
548 public ListenableFuture<RpcResult<UpgradePostCheckOutput>> upgradePostCheck(UpgradePostCheckInput input) {
549 logger.debug(String.format("LCM upgradepostcheck received input: %s", input.toString()));
550 UpgradePostCheckOutputBuilder outputBuilder = new UpgradeService("upgradePost").upgradePostCheck(input);
551 RpcResult<UpgradePostCheckOutput> result =
552 RpcResultBuilder.<UpgradePostCheckOutput>status(true).withResult(outputBuilder.build()).build();
553 return Futures.immediateFuture(result);
557 public ListenableFuture<RpcResult<UpgradeBackupOutput>> upgradeBackup(UpgradeBackupInput input) {
558 logger.debug(String.format("LCM backup received input: %s", input.toString()));
559 UpgradeBackupOutputBuilder outputBuilder = new UpgradeService("upgradeBackup").upgradeBackup(input);
560 RpcResult<UpgradeBackupOutput> result =
561 RpcResultBuilder.<UpgradeBackupOutput>status(true).withResult(outputBuilder.build()).build();
562 return Futures.immediateFuture(result);
566 public ListenableFuture<RpcResult<UpgradeBackoutOutput>> upgradeBackout(UpgradeBackoutInput input) {
567 logger.debug(String.format("LCM backout received input: %s", input.toString()));
568 UpgradeBackoutOutputBuilder outputBuilder = new UpgradeService("upgradeBackout").upgradeBackout(input);
569 RpcResult<UpgradeBackoutOutput> result =
570 RpcResultBuilder.<UpgradeBackoutOutput>status(true).withResult(outputBuilder.build()).build();
571 return Futures.immediateFuture(result);
575 public ListenableFuture<RpcResult<PreConfigureOutput>> preConfigure(PreConfigureInput input) {
576 logger.debug(String.format("LCM PreConfigure received input: %s", input.toString()));
577 PreConfigureOutputBuilder outputBuilder = new PreConfigure().process(input);
578 RpcResult<PreConfigureOutput> result =
579 RpcResultBuilder.<PreConfigureOutput>status(true).withResult(outputBuilder.build()).build();
580 return Futures.immediateFuture(result);
584 public ListenableFuture<RpcResult<GetConfigOutput>> getConfig(GetConfigInput input) {
585 logger.debug(String.format("LCM getConfig received input: %s", input.toString()));
586 GetConfigOutputBuilder outputBuilder = new GetConfigService().process(input);
587 RpcResult<GetConfigOutput> result =
588 RpcResultBuilder.<GetConfigOutput>status(true).withResult(outputBuilder.build()).build();
589 return Futures.immediateFuture(result);
593 public ListenableFuture<RpcResult<PreRebuildOutput>> preRebuild(PreRebuildInput input) {
594 logger.debug(String.format("LCM PreRebuild received input: %s", input.toString()));
595 PreRebuildOutputBuilder outputBuilder = new PreRebuild().process(input);
596 RpcResult<PreRebuildOutput> result =
597 RpcResultBuilder.<PreRebuildOutput>status(true).withResult(outputBuilder.build()).build();
598 return Futures.immediateFuture(result);
602 public ListenableFuture<RpcResult<PostRebuildOutput>> postRebuild(PostRebuildInput input) {
603 logger.debug(String.format("LCM PostRebuild received input: %s", input.toString()));
604 PostRebuildOutputBuilder outputBuilder = new PostRebuild().process(input);
605 RpcResult<PostRebuildOutput> result =
606 RpcResultBuilder.<PostRebuildOutput>status(true).withResult(outputBuilder.build()).build();
607 return Futures.immediateFuture(result);
611 public ListenableFuture<RpcResult<PreEvacuateOutput>> preEvacuate(PreEvacuateInput input) {
612 logger.debug(String.format("LCM PreEvacuate received input: %s", input.toString()));
613 PreEvacuateOutputBuilder outputBuilder = new PreEvacuate().process(input);
614 RpcResult<PreEvacuateOutput> result =
615 RpcResultBuilder.<PreEvacuateOutput>status(true).withResult(outputBuilder.build()).build();
616 return Futures.immediateFuture(result);
620 public ListenableFuture<RpcResult<ProvisioningOutput>> provisioning(ProvisioningInput input) {
621 logger.debug(String.format("LCM ProvisioningService received input: %s", input.toString()));
622 ProvisioningOutputBuilder outputBuilder = new ProvisioningService().process(input);
623 RpcResult<ProvisioningOutput> result =
624 RpcResultBuilder.<ProvisioningOutput>status(true).withResult(outputBuilder.build()).build();
625 return Futures.immediateFuture(result);
629 public ListenableFuture<RpcResult<LicenseManagementOutput>> licenseManagement(LicenseManagementInput input) {
630 logger.debug(String.format("LCM licensemangementService received input: %s", input.toString()));
631 LicenseManagementOutputBuilder outputBuilder = new LicenseManagementService().process(input);
632 RpcResult<LicenseManagementOutput> result =
633 RpcResultBuilder.<LicenseManagementOutput>status(true).withResult(outputBuilder.build()).build();
634 return Futures.immediateFuture(result);
638 public ListenableFuture<RpcResult<StartTrafficOutput>> startTraffic(StartTrafficInput input) {
639 logger.debug(String.format("LCM StartTraffic received input: %s", input.toString()));
640 StartTrafficOutputBuilder outputBuilder = new StartTraffic().process(input);
641 RpcResult<StartTrafficOutput> result =
642 RpcResultBuilder.<StartTrafficOutput>status(true).withResult(outputBuilder.build()).build();
643 return Futures.immediateFuture(result);
647 public ListenableFuture<RpcResult<StatusTrafficOutput>> statusTraffic(StatusTrafficInput input) {
648 logger.debug(String.format("LCM StatusTraffic received input: %s", input.toString()));
649 StatusTrafficOutputBuilder outputBuilder = new StatusTraffic().process(input);
650 RpcResult<StatusTrafficOutput> result =
651 RpcResultBuilder.<StatusTrafficOutput>status(true).withResult(outputBuilder.build()).build();
652 return Futures.immediateFuture(result);
656 public ListenableFuture<RpcResult<StopTrafficOutput>> stopTraffic(StopTrafficInput input) {
657 logger.debug(String.format("LCM StopTraffic received input: %s", input.toString()));
658 StopTrafficOutputBuilder outputBuilder = new StopTraffic().process(input);
659 RpcResult<StopTrafficOutput> result =
660 RpcResultBuilder.<StopTrafficOutput>status(true).withResult(outputBuilder.build()).build();
661 return Futures.immediateFuture(result);
665 public ListenableFuture<RpcResult<DownloadNESwOutput>> downloadNESw(DownloadNESwInput input) {
666 logger.debug(String.format("LCM DownloadNESw received input: %s", input.toString()));
667 DownloadNESwOutputBuilder outputBuilder = new DownloadNESw().process(input);
668 RpcResult<DownloadNESwOutput> result =
669 RpcResultBuilder.<DownloadNESwOutput>status(true).withResult(outputBuilder.build()).build();
670 return Futures.immediateFuture(result);
674 public ListenableFuture<RpcResult<ActivateNESwOutput>> activateNESw(ActivateNESwInput input) {
675 logger.debug(String.format("LCM ActivateNESw received input: %s", input.toString()));
676 ActivateNESwOutputBuilder outputBuilder = new ActivateNESw().process(input);
677 RpcResult<ActivateNESwOutput> result =
678 RpcResultBuilder.<ActivateNESwOutput>status(true).withResult(outputBuilder.build()).build();
679 return Futures.immediateFuture(result);
683 public ListenableFuture<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
684 logger.debug("Input received : " + input.toString());
685 TerminateOutputBuilder outputBuilder = new TerminateOutputBuilder();
686 Action myAction = Action.Terminate;
687 String action = myAction.toString();
688 String rpcName = getRpcName(myAction);
690 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
691 if (null == status) {
693 RequestHandlerInput request = new RequestInputBuilder().requestContext()
694 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
695 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
696 status = buildStatusWithDispatcherOutput(executeRequest(request));
697 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
698 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
699 } catch (ParseException e) {
701 status = buildStatusWithParseException(e);
703 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
704 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
705 this.getClass().getName());
710 outputBuilder.setCommonHeader(input.getCommonHeader());
711 outputBuilder.setStatus(status);
712 RpcResult<TerminateOutput> result =
713 RpcResultBuilder.<TerminateOutput>status(true).withResult(outputBuilder.build()).build();
714 return Futures.immediateFuture(result);
718 public ListenableFuture<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
719 logger.debug("Input received : " + input.toString());
720 ConfigureOutputBuilder outputBuilder = new ConfigureOutputBuilder();
721 Action myAction = Action.Configure;
722 String action = myAction.toString();
723 String rpcName = getRpcName(myAction);
725 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
726 if (null == status) {
728 RequestHandlerInput request = new RequestInputBuilder().requestContext()
729 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
730 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
731 status = buildStatusWithDispatcherOutput(executeRequest(request));
732 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
733 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
734 } catch (ParseException e) {
735 status = buildStatusWithParseException(e);
737 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
738 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
739 this.getClass().getName());
743 outputBuilder.setCommonHeader(input.getCommonHeader());
744 outputBuilder.setStatus(status);
745 RpcResult<ConfigureOutput> result =
746 RpcResultBuilder.<ConfigureOutput>status(true).withResult(outputBuilder.build()).build();
747 return Futures.immediateFuture(result);
751 public ListenableFuture<RpcResult<ActionStatusOutput>> actionStatus(ActionStatusInput input) {
752 logger.debug(String.format("Input received : %s", input.toString()));
753 ActionStatusOutputBuilder outputBuilder = (new ActionStatusService()).queryStatus(input);
754 RpcResult<ActionStatusOutput> result =
755 RpcResultBuilder.<ActionStatusOutput>status(true).withResult(outputBuilder.build()).build();
756 return Futures.immediateFuture(result);
760 public ListenableFuture<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
761 logger.debug("Input received : " + input.toString());
762 ConfigModifyOutputBuilder outputBuilder = new ConfigModifyOutputBuilder();
763 Action myAction = Action.ConfigModify;
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<ConfigModifyOutput> result =
788 RpcResultBuilder.<ConfigModifyOutput>status(true).withResult(outputBuilder.build()).build();
789 return Futures.immediateFuture(result);
793 public ListenableFuture<RpcResult<ConfigScaleOutOutput>> configScaleOut(ConfigScaleOutInput input) {
794 logger.debug("Input received : " + input.toString());
795 ConfigScaleOutOutputBuilder outputBuilder = new ConfigScaleOutService().process(input);
796 RpcResult<ConfigScaleOutOutput> result = RpcResultBuilder.<ConfigScaleOutOutput> status(true).withResult(outputBuilder.build()).build();
797 return Futures.immediateFuture(result);
801 public ListenableFuture<RpcResult<ConfigScaleInOutput>> configScaleIn(ConfigScaleInInput input) {
802 logger.debug("Input received : " + input.toString());
803 ConfigScaleInOutputBuilder outputBuilder = new ConfigScaleInService().process(input);
804 RpcResult<ConfigScaleInOutput> result = RpcResultBuilder.<ConfigScaleInOutput> status(true).withResult(outputBuilder.build()).build();
805 return Futures.immediateFuture(result);
809 public ListenableFuture<RpcResult<PostEvacuateOutput>> postEvacuate(PostEvacuateInput input) {
810 logger.debug("Input received : " + input.toString());
811 PostEvacuateOutputBuilder outputBuilder = new PostEvacuateService().process(input);
812 RpcResult<PostEvacuateOutput> result = RpcResultBuilder.<PostEvacuateOutput> status(true).withResult(outputBuilder.build()).build();
813 return Futures.immediateFuture(result);
817 public ListenableFuture<RpcResult<PreMigrateOutput>> preMigrate(PreMigrateInput input) {
818 logger.debug("Input received : " + input.toString());
819 PreMigrateOutputBuilder outputBuilder = new PreMigrateService().process(input);
820 RpcResult<PreMigrateOutput> result = RpcResultBuilder.<PreMigrateOutput> status(true).withResult(outputBuilder.build()).build();
821 return Futures.immediateFuture(result);
825 public ListenableFuture<RpcResult<PostMigrateOutput>> postMigrate(PostMigrateInput input) {
826 logger.debug("Input received : " + input.toString());
827 PostMigrateOutputBuilder outputBuilder = new PostMigrateService().process(input);
828 RpcResult<PostMigrateOutput> result = RpcResultBuilder.<PostMigrateOutput> status(true).withResult(outputBuilder.build()).build();
829 return Futures.immediateFuture(result);
833 public ListenableFuture<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
834 logger.debug("Input received : " + input.toString());
835 ConfigRestoreOutputBuilder outputBuilder = new ConfigRestoreOutputBuilder();
836 Action myAction = Action.ConfigRestore;
837 String action = myAction.toString();
838 String rpcName = getRpcName(myAction);
840 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
841 if (null == status) {
843 RequestHandlerInput request = new RequestInputBuilder().requestContext()
844 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
845 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
846 status = buildStatusWithDispatcherOutput(executeRequest(request));
847 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
848 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
849 } catch (ParseException e) {
850 status = buildStatusWithParseException(e);
852 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
853 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
854 this.getClass().getName());
858 outputBuilder.setCommonHeader(input.getCommonHeader());
859 outputBuilder.setStatus(status);
860 RpcResult<ConfigRestoreOutput> result =
861 RpcResultBuilder.<ConfigRestoreOutput>status(true).withResult(outputBuilder.build()).build();
862 return Futures.immediateFuture(result);
866 public ListenableFuture<RpcResult<TestOutput>> test(TestInput input) {
867 logger.debug("Input received : " + input.toString());
868 TestOutputBuilder outputBuilder = new TestOutputBuilder();
869 Action myAction = Action.Test;
870 String action = myAction.toString();
871 String rpcName = getRpcName(myAction);
873 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
874 if (null == status) {
876 RequestHandlerInput request = new RequestInputBuilder().requestContext()
877 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
878 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
879 status = buildStatusWithDispatcherOutput(executeRequest(request));
880 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
881 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
882 } catch (ParseException e) {
883 status = buildStatusWithParseException(e);
885 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
886 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
887 this.getClass().getName());
891 outputBuilder.setCommonHeader(input.getCommonHeader());
892 outputBuilder.setStatus(status);
893 RpcResult<TestOutput> result =
894 RpcResultBuilder.<TestOutput>status(true).withResult(outputBuilder.build()).build();
895 return Futures.immediateFuture(result);
900 public ListenableFuture<RpcResult<StopOutput>> stop(StopInput input) {
901 logger.debug("Input received : " + input.toString());
902 StopOutputBuilder outputBuilder = new StopOutputBuilder();
903 Action myAction = Action.Stop;
904 String action = myAction.toString();
905 String rpcName = getRpcName(myAction);
907 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
908 if (null == status) {
910 RequestHandlerInput request = new RequestInputBuilder().requestContext()
911 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
912 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
913 status = buildStatusWithDispatcherOutput(executeRequest(request));
914 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
915 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
916 } catch (ParseException e) {
917 status = buildStatusWithParseException(e);
919 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
920 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
921 this.getClass().getName());
925 outputBuilder.setCommonHeader(input.getCommonHeader());
926 outputBuilder.setStatus(status);
927 RpcResult<StopOutput> result =
928 RpcResultBuilder.<StopOutput>status(true).withResult(outputBuilder.build()).build();
929 return Futures.immediateFuture(result);
933 * Starts a specific VNF
935 * @see org.opendaylight.yang.gen.v1.org.onap.appc.lcm.rev160108.AppcProviderLcmService#start(StartInput)
938 public ListenableFuture<RpcResult<StartOutput>> start(StartInput input) {
939 logger.debug("Input received : " + input.toString());
941 StartOutputBuilder outputBuilder = new StartOutputBuilder();
942 Action myAction = Action.Start;
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<StartOutput> result =
967 RpcResultBuilder.<StartOutput>status(true).withResult(outputBuilder.build()).build();
968 return Futures.immediateFuture(result);
973 public ListenableFuture<RpcResult<AuditOutput>> audit(AuditInput input) {
974 logger.debug("Input received : " + input.toString());
975 AuditOutputBuilder outputBuilder = new AuditOutputBuilder();
976 Action myAction = Action.Audit;
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<AuditOutput> result =
1001 RpcResultBuilder.<AuditOutput>status(true).withResult(outputBuilder.build()).build();
1002 return Futures.immediateFuture(result);
1006 public ListenableFuture<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
1007 logger.debug("Input received : " + input.toString());
1008 SoftwareUploadOutputBuilder outputBuilder = new SoftwareUploadOutputBuilder();
1009 Action myAction = Action.SoftwareUpload;
1010 String action = myAction.toString();
1011 String rpcName = getRpcName(myAction);
1013 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1014 if (null == status) {
1016 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1017 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1018 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1019 status = buildStatusWithDispatcherOutput(executeRequest(request));
1020 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1021 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1022 } catch (ParseException e) {
1023 status = buildStatusWithParseException(e);
1025 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1026 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1027 this.getClass().getName());
1031 outputBuilder.setCommonHeader(input.getCommonHeader());
1032 outputBuilder.setStatus(status);
1033 RpcResult<SoftwareUploadOutput> result =
1034 RpcResultBuilder.<SoftwareUploadOutput>status(true).withResult(outputBuilder.build()).build();
1035 return Futures.immediateFuture(result);
1039 public ListenableFuture<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
1040 logger.debug("Input received : " + input.toString());
1041 HealthCheckOutputBuilder outputBuilder = new HealthCheckOutputBuilder();
1042 Action myAction = Action.HealthCheck;
1043 String action = myAction.toString();
1044 String rpcName = getRpcName(myAction);
1046 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1047 if (null == status) {
1049 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1050 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1051 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1052 status = buildStatusWithDispatcherOutput(executeRequest(request));
1053 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1054 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1055 } catch (ParseException e) {
1056 status = buildStatusWithParseException(e);
1058 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1059 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1060 this.getClass().getName());
1064 outputBuilder.setCommonHeader(input.getCommonHeader());
1065 outputBuilder.setStatus(status);
1066 RpcResult<HealthCheckOutput> result =
1067 RpcResultBuilder.<HealthCheckOutput>status(true).withResult(outputBuilder.build()).build();
1068 return Futures.immediateFuture(result);
1072 public ListenableFuture<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
1073 logger.debug("Input received : " + input.toString());
1074 LiveUpgradeOutputBuilder outputBuilder = new LiveUpgradeOutputBuilder();
1075 Action myAction = Action.LiveUpgrade;
1076 String action = myAction.toString();
1077 String rpcName = getRpcName(myAction);
1079 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1080 if (null == status) {
1082 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1083 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1084 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1085 status = buildStatusWithDispatcherOutput(executeRequest(request));
1086 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1087 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1088 } catch (ParseException e) {
1089 status = buildStatusWithParseException(e);
1091 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1092 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1093 this.getClass().getName());
1097 outputBuilder.setCommonHeader(input.getCommonHeader());
1098 outputBuilder.setStatus(status);
1099 RpcResult<LiveUpgradeOutput> result =
1100 RpcResultBuilder.<LiveUpgradeOutput>status(true).withResult(outputBuilder.build()).build();
1101 return Futures.immediateFuture(result);
1106 public ListenableFuture<RpcResult<LockOutput>> lock(LockInput input) {
1107 logger.debug("Input received : " + input.toString());
1108 LockOutputBuilder outputBuilder = new LockOutputBuilder();
1109 Action myAction = Action.Lock;
1110 String action = myAction.toString();
1111 String rpcName = getRpcName(myAction);
1113 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1114 if (null == status) {
1116 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1117 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1118 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1119 status = buildStatusWithDispatcherOutput(executeRequest(request));
1120 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1121 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1122 } catch (ParseException e) {
1123 status = buildStatusWithParseException(e);
1125 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1126 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1127 this.getClass().getName());
1131 outputBuilder.setCommonHeader(input.getCommonHeader());
1132 outputBuilder.setStatus(status);
1133 RpcResult<LockOutput> result =
1134 RpcResultBuilder.<LockOutput>status(true).withResult(outputBuilder.build()).build();
1135 return Futures.immediateFuture(result);
1140 public ListenableFuture<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
1141 logger.debug("Input received : " + input.toString());
1142 UnlockOutputBuilder outputBuilder = new UnlockOutputBuilder();
1143 Action myAction = Action.Unlock;
1144 String action = myAction.toString();
1145 String rpcName = getRpcName(myAction);
1147 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1148 if (null == status) {
1150 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1151 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1152 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1153 status = buildStatusWithDispatcherOutput(executeRequest(request));
1154 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1155 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1156 } catch (ParseException e) {
1157 status = buildStatusWithParseException(e);
1159 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1160 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1161 this.getClass().getName());
1165 outputBuilder.setCommonHeader(input.getCommonHeader());
1166 outputBuilder.setStatus(status);
1167 RpcResult<UnlockOutput> result =
1168 RpcResultBuilder.<UnlockOutput>status(true).withResult(outputBuilder.build()).build();
1169 return Futures.immediateFuture(result);
1173 public ListenableFuture<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
1174 logger.debug("Input received : " + input.toString());
1175 CheckLockOutputBuilder outputBuilder = new CheckLockOutputBuilder();
1176 Action myAction = Action.CheckLock;
1177 String action = myAction.toString();
1178 String rpcName = getRpcName(myAction);
1179 RequestHandlerOutput requestHandlerOutput = null;
1181 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1182 if (null == status) {
1184 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1185 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1186 .action(action).rpcName(rpcName).build();
1187 requestHandlerOutput = executeRequest(request);
1189 status = buildStatusWithDispatcherOutput(requestHandlerOutput);
1190 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1191 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1192 } catch (ParseException e) {
1193 status = buildStatusWithParseException(e);
1195 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1196 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1197 this.getClass().getName());
1202 outputBuilder.setCommonHeader(input.getCommonHeader());
1203 outputBuilder.setStatus(status);
1204 if (requestHandlerOutput != null && requestHandlerOutput.getResponseContext().getStatus().getCode() == 400) {
1205 outputBuilder.setLocked(CheckLockOutput.Locked.valueOf(
1206 requestHandlerOutput.getResponseContext().getAdditionalContext().get("locked").toUpperCase()));
1208 RpcResult<CheckLockOutput> result =
1209 RpcResultBuilder.<CheckLockOutput>status(true).withResult(outputBuilder.build()).build();
1210 return Futures.immediateFuture(result);
1214 public ListenableFuture<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
1215 logger.debug("Input received : " + input.toString());
1216 ConfigBackupOutputBuilder outputBuilder = new ConfigBackupOutputBuilder();
1217 Action myAction = Action.ConfigBackup;
1218 String action = myAction.toString();
1219 String rpcName = getRpcName(myAction);
1221 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1222 if (null == status) {
1224 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1225 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1226 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1227 status = buildStatusWithDispatcherOutput(executeRequest(request));
1228 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1229 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1230 } catch (ParseException e) {
1231 status = buildStatusWithParseException(e);
1233 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1234 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1235 this.getClass().getName());
1239 outputBuilder.setCommonHeader(input.getCommonHeader());
1240 outputBuilder.setStatus(status);
1241 RpcResult<ConfigBackupOutput> result =
1242 RpcResultBuilder.<ConfigBackupOutput>status(true).withResult(outputBuilder.build()).build();
1243 return Futures.immediateFuture(result);
1248 public ListenableFuture<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
1249 logger.debug("Input received : " + input.toString());
1250 ConfigBackupDeleteOutputBuilder outputBuilder = new ConfigBackupDeleteOutputBuilder();
1251 Action myAction = Action.ConfigBackupDelete;
1252 String action = myAction.toString();
1253 String rpcName = getRpcName(myAction);
1255 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1256 if (null == status) {
1258 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1259 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1260 .action(action).rpcName(rpcName).build();
1261 status = buildStatusWithDispatcherOutput(executeRequest(request));
1262 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1263 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1264 } catch (ParseException e) {
1265 status = buildStatusWithParseException(e);
1267 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1268 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1269 this.getClass().getName());
1273 outputBuilder.setCommonHeader(input.getCommonHeader());
1274 outputBuilder.setStatus(status);
1275 RpcResult<ConfigBackupDeleteOutput> result =
1276 RpcResultBuilder.<ConfigBackupDeleteOutput>status(true).withResult(outputBuilder.build()).build();
1277 return Futures.immediateFuture(result);
1282 public ListenableFuture<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
1283 logger.debug("Input received : " + input.toString());
1284 ConfigExportOutputBuilder outputBuilder = new ConfigExportOutputBuilder();
1285 Action myAction = Action.ConfigExport;
1286 String action = myAction.toString();
1287 String rpcName = getRpcName(myAction);
1289 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1290 if (null == status) {
1292 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1293 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1294 .action(action).rpcName(rpcName).build();
1295 status = buildStatusWithDispatcherOutput(executeRequest(request));
1296 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1297 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1298 } catch (ParseException e) {
1299 status = buildStatusWithParseException(e);
1301 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1302 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1303 this.getClass().getName());
1307 outputBuilder.setCommonHeader(input.getCommonHeader());
1308 outputBuilder.setStatus(status);
1309 RpcResult<ConfigExportOutput> result =
1310 RpcResultBuilder.<ConfigExportOutput>status(true).withResult(outputBuilder.build()).build();
1311 return Futures.immediateFuture(result);
1315 public ListenableFuture<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input) {
1316 logger.debug("Input received : " + input.toString());
1317 StopApplicationOutputBuilder outputBuilder = new StopApplicationOutputBuilder();
1318 Action myAction = Action.StopApplication;
1319 String action = myAction.toString();
1320 String rpcName = getRpcName(myAction);
1322 ValidationService.getInstance().validateInput(input.getCommonHeader(), input.getAction(), action);
1323 if (null == status) {
1325 RequestHandlerInput request = new RequestInputBuilder().requestContext()
1326 .commonHeader(input.getCommonHeader()).actionIdentifiers(input.getActionIdentifiers())
1327 .payload(input.getPayload()).action(action).rpcName(rpcName).build();
1328 status = buildStatusWithDispatcherOutput(executeRequest(request));
1329 logger.info(String.format("Execute of '%s' finished with status %s. Reason: %s",
1330 input.getActionIdentifiers(), status.getCode(), status.getMessage()));
1331 } catch (ParseException e) {
1332 status = buildStatusWithParseException(e);
1334 LoggingUtils.logErrorMessage(LoggingConstants.TargetNames.APPC_PROVIDER,
1335 String.format(COMMON_ERROR_MESSAGE_TEMPLATE, action, e.getMessage()),
1336 this.getClass().getName());
1340 outputBuilder.setCommonHeader(input.getCommonHeader());
1341 outputBuilder.setStatus(status);
1342 RpcResult<StopApplicationOutput> result =
1343 RpcResultBuilder.<StopApplicationOutput>status(true).withResult(outputBuilder.build()).build();
1344 return Futures.immediateFuture(result);
1347 RequestHandlerOutput executeRequest(RequestHandlerInput request) {
1348 return new RequestExecutor().executeRequest(request);