appc-client/client-kit/src/main/java/org/onap/appc/client/lcm/api/LifeCycleManagerStateful.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * =============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 /*
  26  * NOTE: This file is auto-generated and should not be changed manually.
  27  */
  28 package org.onap.appc.client.lcm.api;
  29
  30 import org.onap.appc.client.lcm.model.AuditOutput;
  31 import org.onap.appc.client.lcm.model.AuditInput;
  32 import org.onap.appc.client.lcm.model.CheckLockOutput;
  33 import org.onap.appc.client.lcm.model.CheckLockInput;
  34 import org.onap.appc.client.lcm.model.ConfigBackupOutput;
  35 import org.onap.appc.client.lcm.model.ConfigBackupInput;
  36 import org.onap.appc.client.lcm.model.ConfigBackupDeleteOutput;
  37 import org.onap.appc.client.lcm.model.ConfigBackupDeleteInput;
  38 import org.onap.appc.client.lcm.model.ConfigExportOutput;
  39 import org.onap.appc.client.lcm.model.ConfigExportInput;
  40 import org.onap.appc.client.lcm.model.ConfigModifyOutput;
  41 import org.onap.appc.client.lcm.model.ConfigModifyInput;
  42 import org.onap.appc.client.lcm.model.ConfigRestoreOutput;
  43 import org.onap.appc.client.lcm.model.ConfigRestoreInput;
  44 import org.onap.appc.client.lcm.model.ConfigScaleoutOutput;
  45 import org.onap.appc.client.lcm.model.ConfigScaleoutInput;
  46 import org.onap.appc.client.lcm.model.ConfigureOutput;
  47 import org.onap.appc.client.lcm.model.ConfigureInput;
  48 import org.onap.appc.client.lcm.model.EvacuateOutput;
  49 import org.onap.appc.client.lcm.model.EvacuateInput;
  50 import org.onap.appc.client.lcm.model.HealthCheckOutput;
  51 import org.onap.appc.client.lcm.model.HealthCheckInput;
  52 import org.onap.appc.client.lcm.model.LiveUpgradeOutput;
  53 import org.onap.appc.client.lcm.model.LiveUpgradeInput;
  54 import org.onap.appc.client.lcm.model.LockOutput;
  55 import org.onap.appc.client.lcm.model.LockInput;
  56 import org.onap.appc.client.lcm.model.MigrateOutput;
  57 import org.onap.appc.client.lcm.model.MigrateInput;
  58 import org.onap.appc.client.lcm.model.RebuildOutput;
  59 import org.onap.appc.client.lcm.model.RebuildInput;
  60 import org.onap.appc.client.lcm.model.RestartOutput;
  61 import org.onap.appc.client.lcm.model.RestartInput;
  62 import org.onap.appc.client.lcm.model.RollbackOutput;
  63 import org.onap.appc.client.lcm.model.RollbackInput;
  64 import org.onap.appc.client.lcm.model.SnapshotOutput;
  65 import org.onap.appc.client.lcm.model.SnapshotInput;
  66 import org.onap.appc.client.lcm.model.SoftwareUploadOutput;
  67 import org.onap.appc.client.lcm.model.SoftwareUploadInput;
  68 import org.onap.appc.client.lcm.model.StartOutput;
  69 import org.onap.appc.client.lcm.model.StartInput;
  70 import org.onap.appc.client.lcm.model.StopOutput;
  71 import org.onap.appc.client.lcm.model.StopInput;
  72 import org.onap.appc.client.lcm.model.SyncOutput;
  73 import org.onap.appc.client.lcm.model.SyncInput;
  74 import org.onap.appc.client.lcm.model.TerminateOutput;
  75 import org.onap.appc.client.lcm.model.TerminateInput;
  76 import org.onap.appc.client.lcm.model.TestOutput;
  77 import org.onap.appc.client.lcm.model.TestInput;
  78 import org.onap.appc.client.lcm.model.UnlockOutput;
  79 import org.onap.appc.client.lcm.model.UnlockInput;
  80 import org.onap.appc.RPC;
  81 import org.onap.appc.client.lcm.exceptions.AppcClientException;
  82
  83 /**
  84  * Defines the services and request/response requirements for the ECOMP APP-C
  85  * component.
  86  */
  87 @javax.annotation.Generated(value = {
  88         "templates/client-kit/open-api-to-java.ftl" }, date = "2017-05-04T20:09:01.723+05:30", comments = "Auto-generated from Open API specification")
  89 public interface LifeCycleManagerStateful {
  90
  91     /**
  92      * The Audit command compares the configuration of the VNF associated with the
  93      * current request against the configuration that is stored in APPC's
  94      * configuration store. A successful Audit means that the current VNF
  95      * configuration matches the APPC stored configuration. A failed Audit indicates
  96      * that the request configuration is different from the stored configuration.
  97      * This command can be applied to any VNF type. The only restriction is that a
  98      * particular VNF should be able to support the interface for Reading
  99      * Configuration using existing adapters and use the following protocols: CLI,
 100      * RestConf and XML. The Audit action does not require any payload parameters
 101      *
 102      * @param auditInput
 103      *            - RPC input object
 104      * @throws AppcClientException
 105      *             - throw AppcClientException
 106      */
 107     @RPC(name = "audit", outputType = AuditOutput.class)
 108     AuditOutput audit(AuditInput auditInput) throws AppcClientException;
 109
 110     /**
 111      * The Audit command compares the configuration of the VNF associated with the
 112      * current request against the configuration that is stored in APPC's
 113      * configuration store. A successful Audit means that the current VNF
 114      * configuration matches the APPC stored configuration. A failed Audit indicates
 115      * that the request configuration is different from the stored configuration.
 116      * This command can be applied to any VNF type. The only restriction is that a
 117      * particular VNF should be able to support the interface for Reading
 118      * Configuration using existing adapters and use the following protocols: CLI,
 119      * RestConf and XML. The Audit action does not require any payload parameters
 120      *
 121      * @param auditInput
 122      *            - RPC input object
 123      * @param listener
 124      *            - callback implementation
 125      * @throws AppcClientException
 126      *             - throw AppcClientException
 127      */
 128     @RPC(name = "audit", outputType = AuditOutput.class)
 129     void audit(AuditInput auditInput, ResponseHandler<AuditOutput> listener) throws AppcClientException;
 130
 131     /**
 132      * The CheckLock command returns true if the specified VNF is locked, false if
 133      * not. A CheckLock command is deemed successful if the processing completes
 134      * without error, whether the VNF is locked or not. The command returns only a
 135      * single response with a final status. The APPC also locks the target VNF
 136      * during any command processing, so a VNF can have a locked status even if no
 137      * Lock command has been explicitly called. The CheckLock command returns a
 138      * specific response structure that extends the default LCM response. The
 139      * CheckLock action does not require any payload parameters
 140      *
 141      * @param checkLockInput
 142      *            - RPC input object
 143      * @throws AppcClientException
 144      *             - throw AppcClientException
 145      */
 146     @RPC(name = "check-lock", outputType = CheckLockOutput.class)
 147     CheckLockOutput checkLock(CheckLockInput checkLockInput) throws AppcClientException;
 148
 149     /**
 150      * The CheckLock command returns true if the specified VNF is locked, false if
 151      * not. A CheckLock command is deemed successful if the processing completes
 152      * without error, whether the VNF is locked or not. The command returns only a
 153      * single response with a final status. The APPC also locks the target VNF
 154      * during any command processing, so a VNF can have a locked status even if no
 155      * Lock command has been explicitly called. The CheckLock command returns a
 156      * specific response structure that extends the default LCM response. The
 157      * CheckLock action does not require any payload parameters
 158      *
 159      * @param checkLockInput
 160      *            - RPC input object
 161      * @param listener
 162      *            - callback implementation
 163      * @throws AppcClientException
 164      *             - throw AppcClientException
 165      */
 166     @RPC(name = "check-lock", outputType = CheckLockOutput.class)
 167     void checkLock(CheckLockInput checkLockInput, ResponseHandler<CheckLockOutput> listener) throws AppcClientException;
 168
 169     /**
 170      * An operation to Backup configurations of a virtual network function (or VM)
 171      *
 172      * @param configBackupInput
 173      *            - RPC input object
 174      * @throws AppcClientException
 175      *             - throw AppcClientException
 176      */
 177     @RPC(name = "config-backup", outputType = ConfigBackupOutput.class)
 178     ConfigBackupOutput configBackup(ConfigBackupInput configBackupInput) throws AppcClientException;
 179
 180     /**
 181      * An operation to Backup configurations of a virtual network function (or VM)
 182      *
 183      * @param configBackupInput
 184      *            - RPC input object
 185      * @param listener
 186      *            - callback implementation
 187      * @throws AppcClientException
 188      *             - throw AppcClientException
 189      */
 190     @RPC(name = "config-backup", outputType = ConfigBackupOutput.class)
 191     void configBackup(ConfigBackupInput configBackupInput, ResponseHandler<ConfigBackupOutput> listener)
 192             throws AppcClientException;
 193
 194     /**
 195      * An operation to Delete backup configurations of a virtual network function
 196      * (or VM)
 197      *
 198      * @param configBackupDeleteInput
 199      *            - RPC input object
 200      * @throws AppcClientException
 201      *             - throw AppcClientException
 202      */
 203     @RPC(name = "config-backup-delete", outputType = ConfigBackupDeleteOutput.class)
 204     ConfigBackupDeleteOutput configBackupDelete(ConfigBackupDeleteInput configBackupDeleteInput)
 205             throws AppcClientException;
 206
 207     /**
 208      * An operation to Delete backup configurations of a virtual network function
 209      * (or VM)
 210      *
 211      * @param configBackupDeleteInput
 212      *            - RPC input object
 213      * @param listener
 214      *            - callback implementation
 215      * @throws AppcClientException
 216      *             - throw AppcClientException
 217      */
 218     @RPC(name = "config-backup-delete", outputType = ConfigBackupDeleteOutput.class)
 219     void configBackupDelete(ConfigBackupDeleteInput configBackupDeleteInput,
 220             ResponseHandler<ConfigBackupDeleteOutput> listener) throws AppcClientException;
 221
 222     /**
 223      * An operation to Export configurations of a virtual network function (or VM)
 224      *
 225      * @param configExportInput
 226      *            - RPC input object
 227      * @throws AppcClientException
 228      *             - throw AppcClientException
 229      */
 230     @RPC(name = "config-export", outputType = ConfigExportOutput.class)
 231     ConfigExportOutput configExport(ConfigExportInput configExportInput) throws AppcClientException;
 232
 233     /**
 234      * An operation to Export configurations of a virtual network function (or VM)
 235      *
 236      * @param configExportInput
 237      *            - RPC input object
 238      * @param listener
 239      *            - callback implementation
 240      * @throws AppcClientException
 241      *             - throw AppcClientException
 242      */
 243     @RPC(name = "config-export", outputType = ConfigExportOutput.class)
 244     void configExport(ConfigExportInput configExportInput, ResponseHandler<ConfigExportOutput> listener)
 245             throws AppcClientException;
 246
 247     /**
 248      * Use the ModifyConfig command when a full configuration cycle is either not
 249      * required or is considered too costly. The ModifyConfig LCM action affects
 250      * only a subset of the total configuration data of a VNF. The set of
 251      * configuration parameters to be affected is a subset of the total
 252      * configuration data of the target VNF type. The payload block must contain the
 253      * configuration parameters to be modified and their values. A successful modify
 254      * returns a success response. A failed modify returns a failure response and
 255      * the specific failure messages in the response payload block
 256      *
 257      * @param configModifyInput
 258      *            - RPC input object
 259      * @throws AppcClientException
 260      *             - throw AppcClientException
 261      */
 262     @RPC(name = "config-modify", outputType = ConfigModifyOutput.class)
 263     ConfigModifyOutput configModify(ConfigModifyInput configModifyInput) throws AppcClientException;
 264
 265     /**
 266      * Use the ModifyConfig command when a full configuration cycle is either not
 267      * required or is considered too costly. The ModifyConfig LCM action affects
 268      * only a subset of the total configuration data of a VNF. The set of
 269      * configuration parameters to be affected is a subset of the total
 270      * configuration data of the target VNF type. The payload block must contain the
 271      * configuration parameters to be modified and their values. A successful modify
 272      * returns a success response. A failed modify returns a failure response and
 273      * the specific failure messages in the response payload block
 274      *
 275      * @param configModifyInput
 276      *            - RPC input object
 277      * @param listener
 278      *            - callback implementation
 279      * @throws AppcClientException
 280      *             - throw AppcClientException
 281      */
 282     @RPC(name = "config-modify", outputType = ConfigModifyOutput.class)
 283     void configModify(ConfigModifyInput configModifyInput, ResponseHandler<ConfigModifyOutput> listener)
 284             throws AppcClientException;
 285
 286     /**
 287      * An operation to restore the configurations of a virtual network function (or
 288      * VM)
 289      *
 290      * @param configRestoreInput
 291      *            - RPC input object
 292      * @throws AppcClientException
 293      *             - throw AppcClientException
 294      */
 295     @RPC(name = "config-restore", outputType = ConfigRestoreOutput.class)
 296     ConfigRestoreOutput configRestore(ConfigRestoreInput configRestoreInput) throws AppcClientException;
 297
 298     /**
 299      * An operation to restore the configurations of a virtual network function (or
 300      * VM)
 301      *
 302      * @param configRestoreInput
 303      *            - RPC input object
 304      * @param listener
 305      *            - callback implementation
 306      * @throws AppcClientException
 307      *             - throw AppcClientException
 308      */
 309     @RPC(name = "config-restore", outputType = ConfigRestoreOutput.class)
 310     void configRestore(ConfigRestoreInput configRestoreInput, ResponseHandler<ConfigRestoreOutput> listener)
 311             throws AppcClientException;
 312
 313     /**
 314      * An operation to scaleout the configurations of a virtual network function (or
 315      * VM)
 316      *
 317      * @param configScaleoutInput
 318      *            - RPC input object
 319      * @throws AppcClientException
 320      *             - throw AppcClientException
 321      */
 322     @RPC(name = "config-scaleout", outputType = ConfigScaleoutOutput.class)
 323     ConfigScaleoutOutput configScaleout(ConfigScaleoutInput configScaleoutInput) throws AppcClientException;
 324
 325     /**
 326      * An operation to scaleout the configurations of a virtual network function (or
 327      * VM)
 328      *
 329      * @param configScaleoutInput
 330      *            - RPC input object
 331      * @param listener
 332      *            - callback implementation
 333      * @throws AppcClientException
 334      *             - throw AppcClientException
 335      */
 336     @RPC(name = "config-scaleout", outputType = ConfigScaleoutOutput.class)
 337     void configScaleout(ConfigScaleoutInput configScaleoutInput, ResponseHandler<ConfigScaleoutOutput> listener)
 338             throws AppcClientException;
 339
 340     /**
 341      * An operation to configure the configurations of a virtual network function
 342      * (or VM)
 343      *
 344      * @param configureInput
 345      *            - RPC input object
 346      * @throws AppcClientException
 347      *             - throw AppcClientException
 348      */
 349     @RPC(name = "configure", outputType = ConfigureOutput.class)
 350     ConfigureOutput configure(ConfigureInput configureInput) throws AppcClientException;
 351
 352     /**
 353      * An operation to configure the configurations of a virtual network function
 354      * (or VM)
 355      *
 356      * @param configureInput
 357      *            - RPC input object
 358      * @param listener
 359      *            - callback implementation
 360      * @throws AppcClientException
 361      *             - throw AppcClientException
 362      */
 363     @RPC(name = "configure", outputType = ConfigureOutput.class)
 364     void configure(ConfigureInput configureInput, ResponseHandler<ConfigureOutput> listener) throws AppcClientException;
 365
 366     /**
 367      * An operation to evacuate a virtual network function (or VM)
 368      *
 369      * @param evacuateInput
 370      *            - RPC input object
 371      * @throws AppcClientException
 372      *             - throw AppcClientException
 373      */
 374     @RPC(name = "evacuate", outputType = EvacuateOutput.class)
 375     EvacuateOutput evacuate(EvacuateInput evacuateInput) throws AppcClientException;
 376
 377     /**
 378      * An operation to evacuate a virtual network function (or VM)
 379      *
 380      * @param evacuateInput
 381      *            - RPC input object
 382      * @param listener
 383      *            - callback implementation
 384      * @throws AppcClientException
 385      *             - throw AppcClientException
 386      */
 387     @RPC(name = "evacuate", outputType = EvacuateOutput.class)
 388     void evacuate(EvacuateInput evacuateInput, ResponseHandler<EvacuateOutput> listener) throws AppcClientException;
 389
 390     /**
 391      * This command runs a VNF health check and returns the result. A health check
 392      * is VNF-specific. For a complex VNF, APPC initiates further subordinate health
 393      * checks
 394      *
 395      * @param healthCheckInput
 396      *            - RPC input object
 397      * @throws AppcClientException
 398      *             - throw AppcClientException
 399      */
 400     @RPC(name = "health-check", outputType = HealthCheckOutput.class)
 401     HealthCheckOutput healthCheck(HealthCheckInput healthCheckInput) throws AppcClientException;
 402
 403     /**
 404      * This command runs a VNF health check and returns the result. A health check
 405      * is VNF-specific. For a complex VNF, APPC initiates further subordinate health
 406      * checks
 407      *
 408      * @param healthCheckInput
 409      *            - RPC input object
 410      * @param listener
 411      *            - callback implementation
 412      * @throws AppcClientException
 413      *             - throw AppcClientException
 414      */
 415     @RPC(name = "health-check", outputType = HealthCheckOutput.class)
 416     void healthCheck(HealthCheckInput healthCheckInput, ResponseHandler<HealthCheckOutput> listener)
 417             throws AppcClientException;
 418
 419     /**
 420      * The LiveUpgrade LCM action upgrades the target VNF to a new version without
 421      * interrupting VNF operation. A successful upgrade returns a success status. A
 422      * failed upgrade returns a failure code and the failure messages in the
 423      * response payload block. The payload includes the IP of the location that
 424      * hosts the new software version installer file and the new software version.
 425      * Connections or operations that are active at the time of the LiveUpgrade
 426      * action request will not be interrupted by the action and, therefore, the
 427      * action may take a significant amount of time to run. A LiveUpgrade is defined
 428      * as non-disruptive; it is the responsibility of the VNF to handle disruptions
 429      * if they occur
 430      *
 431      * @param liveUpgradeInput
 432      *            - RPC input object
 433      * @throws AppcClientException
 434      *             - throw AppcClientException
 435      */
 436     @RPC(name = "live-upgrade", outputType = LiveUpgradeOutput.class)
 437     LiveUpgradeOutput liveUpgrade(LiveUpgradeInput liveUpgradeInput) throws AppcClientException;
 438
 439     /**
 440      * The LiveUpgrade LCM action upgrades the target VNF to a new version without
 441      * interrupting VNF operation. A successful upgrade returns a success status. A
 442      * failed upgrade returns a failure code and the failure messages in the
 443      * response payload block. The payload includes the IP of the location that
 444      * hosts the new software version installer file and the new software version.
 445      * Connections or operations that are active at the time of the LiveUpgrade
 446      * action request will not be interrupted by the action and, therefore, the
 447      * action may take a significant amount of time to run. A LiveUpgrade is defined
 448      * as non-disruptive; it is the responsibility of the VNF to handle disruptions
 449      * if they occur
 450      *
 451      * @param liveUpgradeInput
 452      *            - RPC input object
 453      * @param listener
 454      *            - callback implementation
 455      * @throws AppcClientException
 456      *             - throw AppcClientException
 457      */
 458     @RPC(name = "live-upgrade", outputType = LiveUpgradeOutput.class)
 459     void liveUpgrade(LiveUpgradeInput liveUpgradeInput, ResponseHandler<LiveUpgradeOutput> listener)
 460             throws AppcClientException;
 461
 462     /**
 463      * Use the Lock command to ensure exclusive access during a series of critical
 464      * LCM commands. The Lock action will return a successful result if the VNF is
 465      * not already locked or if it was locked with the same request-id, otherwise
 466      * the action returns a response with a reject status code. When a VNF is
 467      * locked, any subsequent sequential commands with same request-id will be
 468      * accepted. Commands associated with other request-ids will be rejected. The
 469      * Lock command returns only one final response with the status of the request
 470      * processing. The APPC also locks the target VNF during any command processing.
 471      * If a lock action is then requested on that VNF, it will be rejected because
 472      * the VNF was already locked, even though no actual lock command was explicitly
 473      * invoked
 474      *
 475      * @param lockInput
 476      *            - RPC input object
 477      * @throws AppcClientException
 478      *             - throw AppcClientException
 479      */
 480     @RPC(name = "lock", outputType = LockOutput.class)
 481     LockOutput lock(LockInput lockInput) throws AppcClientException;
 482
 483     /**
 484      * Use the Lock command to ensure exclusive access during a series of critical
 485      * LCM commands. The Lock action will return a successful result if the VNF is
 486      * not already locked or if it was locked with the same request-id, otherwise
 487      * the action returns a response with a reject status code. When a VNF is
 488      * locked, any subsequent sequential commands with same request-id will be
 489      * accepted. Commands associated with other request-ids will be rejected. The
 490      * Lock command returns only one final response with the status of the request
 491      * processing. The APPC also locks the target VNF during any command processing.
 492      * If a lock action is then requested on that VNF, it will be rejected because
 493      * the VNF was already locked, even though no actual lock command was explicitly
 494      * invoked
 495      *
 496      * @param lockInput
 497      *            - RPC input object
 498      * @param listener
 499      *            - callback implementation
 500      * @throws AppcClientException
 501      *             - throw AppcClientException
 502      */
 503     @RPC(name = "lock", outputType = LockOutput.class)
 504     void lock(LockInput lockInput, ResponseHandler<LockOutput> listener) throws AppcClientException;
 505
 506     /**
 507      * Migrates a running target VFC from its current AIC host to another. A
 508      * destination AIC node will be selected by relying on AIC internal rules to
 509      * migrate. A successful Migrate action returns a success response and the new
 510      * AIC node identity in the response payload block. A failed Migrate action
 511      * returns a failure and the failure messages in the response payload block
 512      *
 513      * @param migrateInput
 514      *            - RPC input object
 515      * @throws AppcClientException
 516      *             - throw AppcClientException
 517      */
 518     @RPC(name = "migrate", outputType = MigrateOutput.class)
 519     MigrateOutput migrate(MigrateInput migrateInput) throws AppcClientException;
 520
 521     /**
 522      * Migrates a running target VFC from its current AIC host to another. A
 523      * destination AIC node will be selected by relying on AIC internal rules to
 524      * migrate. A successful Migrate action returns a success response and the new
 525      * AIC node identity in the response payload block. A failed Migrate action
 526      * returns a failure and the failure messages in the response payload block
 527      *
 528      * @param migrateInput
 529      *            - RPC input object
 530      * @param listener
 531      *            - callback implementation
 532      * @throws AppcClientException
 533      *             - throw AppcClientException
 534      */
 535     @RPC(name = "migrate", outputType = MigrateOutput.class)
 536     void migrate(MigrateInput migrateInput, ResponseHandler<MigrateOutput> listener) throws AppcClientException;
 537
 538     /**
 539      * Recreates a target VFC instance to a known, stable state. A successful
 540      * rebuild returns a success response and the rebuild details in the response
 541      * payload block. A failed rebuild returns a failure and the failure messages in
 542      * the response payload block
 543      *
 544      * @param rebuildInput
 545      *            - RPC input object
 546      * @throws AppcClientException
 547      *             - throw AppcClientException
 548      */
 549     @RPC(name = "rebuild", outputType = RebuildOutput.class)
 550     RebuildOutput rebuild(RebuildInput rebuildInput) throws AppcClientException;
 551
 552     /**
 553      * Recreates a target VFC instance to a known, stable state. A successful
 554      * rebuild returns a success response and the rebuild details in the response
 555      * payload block. A failed rebuild returns a failure and the failure messages in
 556      * the response payload block
 557      *
 558      * @param rebuildInput
 559      *            - RPC input object
 560      * @param listener
 561      *            - callback implementation
 562      * @throws AppcClientException
 563      *             - throw AppcClientException
 564      */
 565     @RPC(name = "rebuild", outputType = RebuildOutput.class)
 566     void rebuild(RebuildInput rebuildInput, ResponseHandler<RebuildOutput> listener) throws AppcClientException;
 567
 568     /**
 569      * An operation to restart a virtual network function (or VM)
 570      *
 571      * @param restartInput
 572      *            - RPC input object
 573      * @throws AppcClientException
 574      *             - throw AppcClientException
 575      */
 576     @RPC(name = "restart", outputType = RestartOutput.class)
 577     RestartOutput restart(RestartInput restartInput) throws AppcClientException;
 578
 579     /**
 580      * An operation to restart a virtual network function (or VM)
 581      *
 582      * @param restartInput
 583      *            - RPC input object
 584      * @param listener
 585      *            - callback implementation
 586      * @throws AppcClientException
 587      *             - throw AppcClientException
 588      */
 589     @RPC(name = "restart", outputType = RestartOutput.class)
 590     void restart(RestartInput restartInput, ResponseHandler<RestartOutput> listener) throws AppcClientException;
 591
 592     /**
 593      * Sets a VNF to the previous version of the configuration without explicitly
 594      * invoking the configuration set name. This command is used when the
 595      * configuration was successful, but the health-check was not. A successful
 596      * rollback returns a success status when the restart process has completed. A
 597      * failed or a partially failed (for a complex VNF) rollback returns a failure
 598      * and the failure messages in the response payload block. This command can be
 599      * applied to any VNF type. The only restriction is that the particular VNF
 600      * should be built based on the generic heap stack
 601      *
 602      * @param rollbackInput
 603      *            - RPC input object
 604      * @throws AppcClientException
 605      *             - throw AppcClientException
 606      */
 607     @RPC(name = "rollback", outputType = RollbackOutput.class)
 608     RollbackOutput rollback(RollbackInput rollbackInput) throws AppcClientException;
 609
 610     /**
 611      * Sets a VNF to the previous version of the configuration without explicitly
 612      * invoking the configuration set name. This command is used when the
 613      * configuration was successful, but the health-check was not. A successful
 614      * rollback returns a success status when the restart process has completed. A
 615      * failed or a partially failed (for a complex VNF) rollback returns a failure
 616      * and the failure messages in the response payload block. This command can be
 617      * applied to any VNF type. The only restriction is that the particular VNF
 618      * should be built based on the generic heap stack
 619      *
 620      * @param rollbackInput
 621      *            - RPC input object
 622      * @param listener
 623      *            - callback implementation
 624      * @throws AppcClientException
 625      *             - throw AppcClientException
 626      */
 627     @RPC(name = "rollback", outputType = RollbackOutput.class)
 628     void rollback(RollbackInput rollbackInput, ResponseHandler<RollbackOutput> listener) throws AppcClientException;
 629
 630     /**
 631      * Creates a snapshot of a VNF, or VM. The Snapshot command returns a customized
 632      * response containing a reference to the newly created snapshot instance if the
 633      * action is successful. This command can be applied to any VNF type. The only
 634      * restriction is that the particular VNF should be built based on the generic
 635      * heap stack
 636      *
 637      * @param snapshotInput
 638      *            - RPC input object
 639      * @throws AppcClientException
 640      *             - throw AppcClientException
 641      */
 642     @RPC(name = "snapshot", outputType = SnapshotOutput.class)
 643     SnapshotOutput snapshot(SnapshotInput snapshotInput) throws AppcClientException;
 644
 645     /**
 646      * Creates a snapshot of a VNF, or VM. The Snapshot command returns a customized
 647      * response containing a reference to the newly created snapshot instance if the
 648      * action is successful. This command can be applied to any VNF type. The only
 649      * restriction is that the particular VNF should be built based on the generic
 650      * heap stack
 651      *
 652      * @param snapshotInput
 653      *            - RPC input object
 654      * @param listener
 655      *            - callback implementation
 656      * @throws AppcClientException
 657      *             - throw AppcClientException
 658      */
 659     @RPC(name = "snapshot", outputType = SnapshotOutput.class)
 660     void snapshot(SnapshotInput snapshotInput, ResponseHandler<SnapshotOutput> listener) throws AppcClientException;
 661
 662     /**
 663      * This LCM command uploads the file that contains a new software version to the
 664      * target VNF
 665      *
 666      * @param softwareUploadInput
 667      *            - RPC input object
 668      * @throws AppcClientException
 669      *             - throw AppcClientException
 670      */
 671     @RPC(name = "software-upload", outputType = SoftwareUploadOutput.class)
 672     SoftwareUploadOutput softwareUpload(SoftwareUploadInput softwareUploadInput) throws AppcClientException;
 673
 674     /**
 675      * This LCM command uploads the file that contains a new software version to the
 676      * target VNF
 677      *
 678      * @param softwareUploadInput
 679      *            - RPC input object
 680      * @param listener
 681      *            - callback implementation
 682      * @throws AppcClientException
 683      *             - throw AppcClientException
 684      */
 685     @RPC(name = "software-upload", outputType = SoftwareUploadOutput.class)
 686     void softwareUpload(SoftwareUploadInput softwareUploadInput, ResponseHandler<SoftwareUploadOutput> listener)
 687             throws AppcClientException;
 688
 689     /**
 690      * An operation to start a virtual network function (or VM)
 691      *
 692      * @param startInput
 693      *            - RPC input object
 694      * @throws AppcClientException
 695      *             - throw AppcClientException
 696      */
 697     @RPC(name = "start", outputType = StartOutput.class)
 698     StartOutput start(StartInput startInput) throws AppcClientException;
 699
 700     /**
 701      * An operation to start a virtual network function (or VM)
 702      *
 703      * @param startInput
 704      *            - RPC input object
 705      * @param listener
 706      *            - callback implementation
 707      * @throws AppcClientException
 708      *             - throw AppcClientException
 709      */
 710     @RPC(name = "start", outputType = StartOutput.class)
 711     void start(StartInput startInput, ResponseHandler<StartOutput> listener) throws AppcClientException;
 712
 713     /**
 714      * Stop a target VNF or VNFC. A successful stop returns a success response. For
 715      * a multi-component stop to be considered successful, all component stop
 716      * actions must succeed. A failed stop returns a failure and the failure
 717      * messages in the response payload block
 718      *
 719      * @param stopInput
 720      *            - RPC input object
 721      * @throws AppcClientException
 722      *             - throw AppcClientException
 723      */
 724     @RPC(name = "stop", outputType = StopOutput.class)
 725     StopOutput stop(StopInput stopInput) throws AppcClientException;
 726
 727     /**
 728      * Stop a target VNF or VNFC. A successful stop returns a success response. For
 729      * a multi-component stop to be considered successful, all component stop
 730      * actions must succeed. A failed stop returns a failure and the failure
 731      * messages in the response payload block
 732      *
 733      * @param stopInput
 734      *            - RPC input object
 735      * @param listener
 736      *            - callback implementation
 737      * @throws AppcClientException
 738      *             - throw AppcClientException
 739      */
 740     @RPC(name = "stop", outputType = StopOutput.class)
 741     void stop(StopInput stopInput, ResponseHandler<StopOutput> listener) throws AppcClientException;
 742
 743     /**
 744      * The Sync action updates the current configuration in the APPC store with the
 745      * running configuration from the device. A successful Sync returns a success
 746      * status. A failed Sync returns a failure response status and failure messages
 747      * in the response payload block. This command can be applied to any VNF type.
 748      * The only restriction is that a particular VNF should be able to support the
 749      * interface for Reading Configuration using existing adapters and use the
 750      * following protocols: CLI, RestConf and XML
 751      *
 752      * @param syncInput
 753      *            - RPC input object
 754      * @throws AppcClientException
 755      *             - throw AppcClientException
 756      */
 757     @RPC(name = "sync", outputType = SyncOutput.class)
 758     SyncOutput sync(SyncInput syncInput) throws AppcClientException;
 759
 760     /**
 761      * The Sync action updates the current configuration in the APPC store with the
 762      * running configuration from the device. A successful Sync returns a success
 763      * status. A failed Sync returns a failure response status and failure messages
 764      * in the response payload block. This command can be applied to any VNF type.
 765      * The only restriction is that a particular VNF should be able to support the
 766      * interface for Reading Configuration using existing adapters and use the
 767      * following protocols: CLI, RestConf and XML
 768      *
 769      * @param syncInput
 770      *            - RPC input object
 771      * @param listener
 772      *            - callback implementation
 773      * @throws AppcClientException
 774      *             - throw AppcClientException
 775      */
 776     @RPC(name = "sync", outputType = SyncOutput.class)
 777     void sync(SyncInput syncInput, ResponseHandler<SyncOutput> listener) throws AppcClientException;
 778
 779     /**
 780      * Terminate a target VNF and release its resources (possibly gracefully).
 781      * Specific scripts can be run before termination by placing them under the
 782      * Terminate life cycle event. All configuration files related to the target VNF
 783      * are deleted. The resources of a terminated VNF that are not managed by APPC,
 784      * such as those handled by SDNC or other components, are not handled and remain
 785      * the responsibility of their respective managing functions. A successful
 786      * Terminate action returns a success response. For a multi-component terminate
 787      * to be considered successful, all component Terminate actions must also
 788      * succeed. A failed Terminate returns a failure status and the failure messages
 789      * in the response payload block
 790      *
 791      * @param terminateInput
 792      *            - RPC input object
 793      * @throws AppcClientException
 794      *             - throw AppcClientException
 795      */
 796     @RPC(name = "terminate", outputType = TerminateOutput.class)
 797     TerminateOutput terminate(TerminateInput terminateInput) throws AppcClientException;
 798
 799     /**
 800      * Terminate a target VNF and release its resources (possibly gracefully).
 801      * Specific scripts can be run before termination by placing them under the
 802      * Terminate life cycle event. All configuration files related to the target VNF
 803      * are deleted. The resources of a terminated VNF that are not managed by APPC,
 804      * such as those handled by SDNC or other components, are not handled and remain
 805      * the responsibility of their respective managing functions. A successful
 806      * Terminate action returns a success response. For a multi-component terminate
 807      * to be considered successful, all component Terminate actions must also
 808      * succeed. A failed Terminate returns a failure status and the failure messages
 809      * in the response payload block
 810      *
 811      * @param terminateInput
 812      *            - RPC input object
 813      * @param listener
 814      *            - callback implementation
 815      * @throws AppcClientException
 816      *             - throw AppcClientException
 817      */
 818     @RPC(name = "terminate", outputType = TerminateOutput.class)
 819     void terminate(TerminateInput terminateInput, ResponseHandler<TerminateOutput> listener) throws AppcClientException;
 820
 821     /**
 822      * The Test LCM action checks a target VNF or VNFC for correct operation. The
 823      * functionality of the Test LCM action involves should involve more than a
 824      * HealthCheck , it should provide a means for launching a test transaction and
 825      * determining if the transaction completed successfully or not. A transaction
 826      * launcher microservice will have to be supplied by the VNF and called by APPC.
 827      * A successful test returns a success and the results of the test in the
 828      * payload block. A failed test returns a failure and specific failure messages
 829      * in the payload block
 830      *
 831      * @param testInput
 832      *            - RPC input object
 833      * @throws AppcClientException
 834      *             - throw AppcClientException
 835      */
 836     @RPC(name = "test", outputType = TestOutput.class)
 837     TestOutput test(TestInput testInput) throws AppcClientException;
 838
 839     /**
 840      * The Test LCM action checks a target VNF or VNFC for correct operation. The
 841      * functionality of the Test LCM action involves should involve more than a
 842      * HealthCheck , it should provide a means for launching a test transaction and
 843      * determining if the transaction completed successfully or not. A transaction
 844      * launcher microservice will have to be supplied by the VNF and called by APPC.
 845      * A successful test returns a success and the results of the test in the
 846      * payload block. A failed test returns a failure and specific failure messages
 847      * in the payload block
 848      *
 849      * @param testInput
 850      *            - RPC input object
 851      * @param listener
 852      *            - callback implementation
 853      * @throws AppcClientException
 854      *             - throw AppcClientException
 855      */
 856     @RPC(name = "test", outputType = TestOutput.class)
 857     void test(TestInput testInput, ResponseHandler<TestOutput> listener) throws AppcClientException;
 858
 859     /**
 860      * Run the Unlock command to release the lock on a VNF and allow other clients
 861      * to perform LCM commands on that VNF. The Unlock command will result in
 862      * success if the VNF successfully unlocked or if it was already unlocked,
 863      * otherwise commands will be rejected. The Unlock command will only return
 864      * success if the VNF was locked with same request-id (on page 6). The Unlock
 865      * command returns only one final response with the status of the request
 866      * processing. The APPC also locks the target VNF during any command processing.
 867      * If an Unlock action is then requested on that VNF with a different
 868      * request-id, it will be rejected because the VNF is already locked for another
 869      * process, even though no actual lock command was explicitly invoked
 870      *
 871      * @param unlockInput
 872      *            - RPC input object
 873      * @throws AppcClientException
 874      *             - throw AppcClientException
 875      */
 876     @RPC(name = "unlock", outputType = UnlockOutput.class)
 877     UnlockOutput unlock(UnlockInput unlockInput) throws AppcClientException;
 878
 879     /**
 880      * Run the Unlock command to release the lock on a VNF and allow other clients
 881      * to perform LCM commands on that VNF. The Unlock command will result in
 882      * success if the VNF successfully unlocked or if it was already unlocked,
 883      * otherwise commands will be rejected. The Unlock command will only return
 884      * success if the VNF was locked with same request-id (on page 6). The Unlock
 885      * command returns only one final response with the status of the request
 886      * processing. The APPC also locks the target VNF during any command processing.
 887      * If an Unlock action is then requested on that VNF with a different
 888      * request-id, it will be rejected because the VNF is already locked for another
 889      * process, even though no actual lock command was explicitly invoked
 890      *
 891      * @param unlockInput
 892      *            - RPC input object
 893      * @param listener
 894      *            - callback implementation
 895      * @throws AppcClientException
 896      *             - throw AppcClientException
 897      */
 898     @RPC(name = "unlock", outputType = UnlockOutput.class)
 899     void unlock(UnlockInput unlockInput, ResponseHandler<UnlockOutput> listener) throws AppcClientException;
 900
 901 }