lcm/provider/src/main/java/org/onap/ccsdk/sli/northbound/LcmProvider.java

   1 package org.onap.ccsdk.sli.northbound;
   2 /*-
   3  * ============LICENSE_START=======================================================
   4  * openECOMP : SDN-C
   5  * ================================================================================
   6  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   7  *                      reserved.
   8  *      Modifications Copyright © 2018 IBM.
   9  * ================================================================================
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 import java.text.SimpleDateFormat;
  25 import java.util.Date;
  26 import java.util.Properties;
  27 import java.util.concurrent.ExecutorService;
  28 import java.util.concurrent.Executors;
  29 import java.util.concurrent.Future;
  30 import org.onap.ccsdk.sli.core.sli.provider.MdsalHelper;
  31 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  32 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  33 import org.opendaylight.controller.md.sal.binding.impl.AbstractForwardedDataBroker;
  34 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  35 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  36 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  37 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.sli.northbound.lcm.rev180329.*;
  38 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.sli.northbound.lcm.rev180329.common.header.CommonHeaderBuilder;
  39 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.sli.northbound.lcm.rev180329.status.StatusBuilder;
  40 import org.opendaylight.yangtools.yang.common.RpcResult;
  41 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  42 import org.slf4j.Logger;
  43 import org.slf4j.LoggerFactory;
  44
  45 import com.google.common.util.concurrent.Futures;
  46 import com.google.common.util.concurrent.ListenableFuture;
  47
  48 import org.onap.ccsdk.sli.northbound.LcmResponseCode.*;
  49
  50 /**
  51  * Defines a base implementation for your provider. This class extends from a
  52  * helper class which provides storage for the most commonly used components of
  53  * the MD-SAL. Additionally the base class provides some basic logging and
  54  * initialization / clean up methods.
  55  *
  56  */
  57 public class LcmProvider implements AutoCloseable, LCMService {
  58
  59         private class CommonLcmFields {
  60                 private StatusBuilder statusBuilder;
  61                 private CommonHeaderBuilder commonHeaderBuilder;
  62                 private Payload payload;
  63
  64                 public CommonLcmFields(StatusBuilder statusBuilder, CommonHeaderBuilder commonHeaderBuilder) {
  65                         this.statusBuilder = statusBuilder;
  66                         this.commonHeaderBuilder = commonHeaderBuilder;
  67                         this.payload = null;
  68                 }
  69
  70                 public CommonLcmFields(StatusBuilder statusBuilder, CommonHeaderBuilder commonHeaderBuilder, Payload payload) {
  71                         this.statusBuilder = statusBuilder;
  72                         this.commonHeaderBuilder = commonHeaderBuilder;
  73                         this.payload = payload;
  74                 }
  75
  76                 public StatusBuilder getStatusBuilder() {
  77                         return statusBuilder;
  78                 }
  79
  80                 public CommonHeaderBuilder getCommonHeaderBuilder() {
  81                         return commonHeaderBuilder;
  82                 }
  83
  84                 public Payload getPayload() {
  85                         return payload;
  86                 }
  87         }
  88
  89         private static final Logger LOG = LoggerFactory.getLogger(LcmProvider.class);
  90
  91         private static final String exceptionMessage = "Caught exception";
  92
  93         private static final String APPLICATION_NAME = "LCM";
  94
  95         private final ExecutorService executor;
  96         protected DataBroker dataBroker;
  97         protected DOMDataBroker domDataBroker;
  98         protected NotificationPublishService notificationService;
  99         protected RpcProviderRegistry rpcRegistry;
 100         private final LcmSliClient lcmSliClient;
 101
 102         protected BindingAwareBroker.RpcRegistration<LCMService> rpcRegistration;
 103
 104         public LcmProvider(final DataBroker dataBroker, final NotificationPublishService notificationPublishService,
 105                         final RpcProviderRegistry rpcProviderRegistry, final LcmSliClient lcmSliClient) {
 106
 107                 LOG.info("Creating provider for {}", APPLICATION_NAME);
 108                 executor = Executors.newFixedThreadPool(1);
 109                 this.dataBroker = dataBroker;
 110                 if (dataBroker instanceof AbstractForwardedDataBroker) {
 111                         domDataBroker = ((AbstractForwardedDataBroker) dataBroker).getDelegate();
 112                 }
 113                 notificationService = notificationPublishService;
 114                 rpcRegistry = rpcProviderRegistry;
 115                 this.lcmSliClient = lcmSliClient;
 116                 initialize();
 117         }
 118
 119         public void initialize() {
 120                 LOG.info("Initializing {} for {}", this.getClass().getName(), APPLICATION_NAME);
 121
 122                 if (rpcRegistration == null) {
 123                         if (rpcRegistry != null) {
 124                                 rpcRegistration = rpcRegistry.addRpcImplementation(LCMService.class, this);
 125                                 LOG.info("Initialization complete for {}", APPLICATION_NAME);
 126                         } else {
 127                                 LOG.warn("Error initializing {} : rpcRegistry unset", APPLICATION_NAME);
 128                         }
 129                 }
 130         }
 131
 132         protected void initializeChild() {
 133                 // Override if you have custom initialization intelligence
 134         }
 135
 136         @Override
 137         public void close() throws Exception {
 138                 LOG.info("Closing provider for " + APPLICATION_NAME);
 139                 executor.shutdown();
 140                 rpcRegistration.close();
 141                 LOG.info("Successfully closed provider for " + APPLICATION_NAME);
 142         }
 143
 144
 145
 146         @Override
 147         public ListenableFuture<RpcResult<CheckLockOutput>> checkLock(CheckLockInput input) {
 148                 CheckLockInputBuilder iBuilder = new CheckLockInputBuilder(input);
 149                 CheckLockOutputBuilder oBuilder = new CheckLockOutputBuilder();
 150
 151                 try {
 152                         CommonLcmFields retval = callDG("check-lock", iBuilder.build());
 153                         oBuilder.setStatus(retval.getStatusBuilder().build());
 154                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 155                 } catch (LcmRpcInvocationException e) {
 156                         LOG.debug(exceptionMessage, e);
 157                         oBuilder.setCommonHeader(e.getCommonHeader());
 158                         oBuilder.setStatus(e.getStatus());
 159                 }
 160
 161                 RpcResult<CheckLockOutput> rpcResult =
 162                                 RpcResultBuilder.<CheckLockOutput> status(true).withResult(oBuilder.build()).build();
 163                 // return error
 164                 return Futures.immediateFuture(rpcResult);
 165
 166         }
 167
 168         @Override
 169         public ListenableFuture<RpcResult<RebootOutput>> reboot(RebootInput input) {
 170                 RebootInputBuilder iBuilder = new RebootInputBuilder(input);
 171                 RebootOutputBuilder oBuilder = new RebootOutputBuilder();
 172
 173                 try {
 174                         CommonLcmFields retval = callDG("reboot", iBuilder.build());
 175                         oBuilder.setStatus(retval.getStatusBuilder().build());
 176                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 177                 } catch (LcmRpcInvocationException e) {
 178                         LOG.debug(exceptionMessage, e);
 179                         oBuilder.setCommonHeader(e.getCommonHeader());
 180                         oBuilder.setStatus(e.getStatus());
 181                 }
 182
 183                 RpcResult<RebootOutput> rpcResult =
 184                                 RpcResultBuilder.<RebootOutput> status(true).withResult(oBuilder.build()).build();
 185                 // return error
 186                 return Futures.immediateFuture(rpcResult);
 187         }
 188
 189         @Override
 190         public ListenableFuture<RpcResult<UpgradeBackupOutput>> upgradeBackup(UpgradeBackupInput input) {
 191                 UpgradeBackupInputBuilder iBuilder = new UpgradeBackupInputBuilder(input);
 192                 UpgradeBackupOutputBuilder oBuilder = new UpgradeBackupOutputBuilder();
 193
 194                 try {
 195                         CommonLcmFields retval = callDG("upgrade-backup", iBuilder.build());
 196                         oBuilder.setStatus(retval.getStatusBuilder().build());
 197                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 198
 199                 } catch (LcmRpcInvocationException e) {
 200                         LOG.debug(exceptionMessage, e);
 201                         oBuilder.setCommonHeader(e.getCommonHeader());
 202                         oBuilder.setStatus(e.getStatus());
 203                 }
 204
 205                 RpcResult<UpgradeBackupOutput> rpcResult =
 206                                 RpcResultBuilder.<UpgradeBackupOutput> status(true).withResult(oBuilder.build()).build();
 207                 // return error
 208                 return Futures.immediateFuture(rpcResult);
 209         }
 210
 211         @Override
 212         public ListenableFuture<RpcResult<RollbackOutput>> rollback(RollbackInput input) {
 213                 RollbackInputBuilder iBuilder = new RollbackInputBuilder(input);
 214                 RollbackOutputBuilder oBuilder = new RollbackOutputBuilder();
 215
 216                 try {
 217                         CommonLcmFields retval = callDG("rollback", iBuilder.build());
 218                         oBuilder.setStatus(retval.getStatusBuilder().build());
 219                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 220                         if (retval.getPayload() != null) {
 221                                 oBuilder.setPayload(retval.getPayload());
 222                         }
 223                 } catch (LcmRpcInvocationException e) {
 224                         LOG.debug(exceptionMessage, e);
 225                         oBuilder.setCommonHeader(e.getCommonHeader());
 226                         oBuilder.setStatus(e.getStatus());
 227                 }
 228
 229                 RpcResult<RollbackOutput> rpcResult =
 230                                 RpcResultBuilder.<RollbackOutput> status(true).withResult(oBuilder.build()).build();
 231                 // return error
 232                 return Futures.immediateFuture(rpcResult);
 233         }
 234
 235         @Override
 236         public ListenableFuture<RpcResult<SyncOutput>> sync(SyncInput input) {
 237                 SyncInputBuilder iBuilder = new SyncInputBuilder(input);
 238                 SyncOutputBuilder oBuilder = new SyncOutputBuilder();
 239
 240                 try {
 241                         CommonLcmFields retval = callDG("sync", iBuilder.build());
 242                         oBuilder.setStatus(retval.getStatusBuilder().build());
 243                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 244                 } catch (LcmRpcInvocationException e) {
 245                         LOG.debug(exceptionMessage, e);
 246                         oBuilder.setCommonHeader(e.getCommonHeader());
 247                         oBuilder.setStatus(e.getStatus());
 248                 }
 249
 250                 RpcResult<SyncOutput> rpcResult =
 251                                 RpcResultBuilder.<SyncOutput> status(true).withResult(oBuilder.build()).build();
 252                 // return error
 253                 return Futures.immediateFuture(rpcResult);
 254         }
 255
 256         @Override
 257         public ListenableFuture<RpcResult<QueryOutput>> query(QueryInput input) {
 258                 QueryInputBuilder iBuilder = new QueryInputBuilder(input);
 259                 QueryOutputBuilder oBuilder = new QueryOutputBuilder();
 260
 261                 try {
 262                         CommonLcmFields retval = callDG("query", iBuilder.build());
 263                         oBuilder.setStatus(retval.getStatusBuilder().build());
 264                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 265                 } catch (LcmRpcInvocationException e) {
 266                         LOG.debug(exceptionMessage, e);
 267                         oBuilder.setCommonHeader(e.getCommonHeader());
 268                         oBuilder.setStatus(e.getStatus());
 269                 }
 270
 271                 RpcResult<QueryOutput> rpcResult =
 272                                 RpcResultBuilder.<QueryOutput> status(true).withResult(oBuilder.build()).build();
 273                 // return error
 274                 return Futures.immediateFuture(rpcResult);
 275         }
 276
 277         @Override
 278         public ListenableFuture<RpcResult<ConfigExportOutput>> configExport(ConfigExportInput input) {
 279                 ConfigExportInputBuilder iBuilder = new ConfigExportInputBuilder(input);
 280                 ConfigExportOutputBuilder oBuilder = new ConfigExportOutputBuilder();
 281
 282                 try {
 283                         CommonLcmFields retval = callDG("config-export", iBuilder.build());
 284                         oBuilder.setStatus(retval.getStatusBuilder().build());
 285                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 286                 } catch (LcmRpcInvocationException e) {
 287                         LOG.debug(exceptionMessage, e);
 288                         oBuilder.setCommonHeader(e.getCommonHeader());
 289                         oBuilder.setStatus(e.getStatus());
 290                 }
 291
 292                 RpcResult<ConfigExportOutput> rpcResult =
 293                                 RpcResultBuilder.<ConfigExportOutput> status(true).withResult(oBuilder.build()).build();
 294                 // return error
 295                 return Futures.immediateFuture(rpcResult);
 296         }
 297
 298         @Override
 299         public ListenableFuture<RpcResult<StopApplicationOutput>> stopApplication(StopApplicationInput input) {
 300                 StopApplicationInputBuilder iBuilder = new StopApplicationInputBuilder(input);
 301                 StopApplicationOutputBuilder oBuilder = new StopApplicationOutputBuilder();
 302
 303                 try {
 304                         CommonLcmFields retval = callDG("stop-application", iBuilder.build());
 305                         oBuilder.setStatus(retval.getStatusBuilder().build());
 306                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 307                 } catch (LcmRpcInvocationException e) {
 308                         LOG.debug(exceptionMessage, e);
 309                         oBuilder.setCommonHeader(e.getCommonHeader());
 310                         oBuilder.setStatus(e.getStatus());
 311                 }
 312
 313                 RpcResult<StopApplicationOutput> rpcResult =
 314                                 RpcResultBuilder.<StopApplicationOutput> status(true).withResult(oBuilder.build()).build();
 315                 // return error
 316                 return Futures.immediateFuture(rpcResult);
 317         }
 318
 319         @Override
 320         public ListenableFuture<RpcResult<SoftwareUploadOutput>> softwareUpload(SoftwareUploadInput input) {
 321                 SoftwareUploadInputBuilder iBuilder = new SoftwareUploadInputBuilder(input);
 322                 SoftwareUploadOutputBuilder oBuilder = new SoftwareUploadOutputBuilder();
 323
 324                 try {
 325                         CommonLcmFields retval = callDG("software-upload", iBuilder.build());
 326                         oBuilder.setStatus(retval.getStatusBuilder().build());
 327                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 328                 } catch (LcmRpcInvocationException e) {
 329                         LOG.debug(exceptionMessage, e);
 330                         oBuilder.setCommonHeader(e.getCommonHeader());
 331                         oBuilder.setStatus(e.getStatus());
 332                 }
 333
 334                 RpcResult<SoftwareUploadOutput> rpcResult =
 335                                 RpcResultBuilder.<SoftwareUploadOutput> status(true).withResult(oBuilder.build()).build();
 336                 // return error
 337                 return Futures.immediateFuture(rpcResult);
 338         }
 339
 340         @Override
 341         public ListenableFuture<RpcResult<ResumeTrafficOutput>> resumeTraffic(ResumeTrafficInput input) {
 342                 ResumeTrafficInputBuilder iBuilder = new ResumeTrafficInputBuilder(input);
 343                 ResumeTrafficOutputBuilder oBuilder = new ResumeTrafficOutputBuilder();
 344
 345                 try {
 346                         CommonLcmFields retval = callDG("resume-traffic", iBuilder.build());
 347                         oBuilder.setStatus(retval.getStatusBuilder().build());
 348                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 349                 } catch (LcmRpcInvocationException e) {
 350                         LOG.debug(exceptionMessage, e);
 351                         oBuilder.setCommonHeader(e.getCommonHeader());
 352                         oBuilder.setStatus(e.getStatus());
 353                 }
 354
 355                 RpcResult<ResumeTrafficOutput> rpcResult =
 356                                 RpcResultBuilder.<ResumeTrafficOutput> status(true).withResult(oBuilder.build()).build();
 357                 // return error
 358                 return Futures.immediateFuture(rpcResult);
 359         }
 360
 361         @Override
 362         public ListenableFuture<RpcResult<DistributeTrafficOutput>> distributeTraffic(DistributeTrafficInput input) {
 363                 DistributeTrafficInputBuilder iBuilder = new DistributeTrafficInputBuilder(input);
 364                 DistributeTrafficOutputBuilder oBuilder = new DistributeTrafficOutputBuilder();
 365
 366                 try {
 367                         CommonLcmFields retval = callDG("distribute-traffic", iBuilder.build());
 368                         oBuilder.setStatus(retval.getStatusBuilder().build());
 369                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 370                 } catch (LcmRpcInvocationException e) {
 371                         LOG.debug(exceptionMessage, e);
 372                         oBuilder.setCommonHeader(e.getCommonHeader());
 373                         oBuilder.setStatus(e.getStatus());
 374                 }
 375
 376                 RpcResult<DistributeTrafficOutput> rpcResult =
 377                                 RpcResultBuilder.<DistributeTrafficOutput> status(true).withResult(oBuilder.build()).build();
 378                 // return error
 379                 return Futures.immediateFuture(rpcResult);
 380         }
 381
 382         @Override
 383         public ListenableFuture<RpcResult<ConfigureOutput>> configure(ConfigureInput input) {
 384                 ConfigureInputBuilder iBuilder = new ConfigureInputBuilder(input);
 385                 ConfigureOutputBuilder oBuilder = new ConfigureOutputBuilder();
 386
 387                 try {
 388                         CommonLcmFields retval = callDG("configure", iBuilder.build());
 389                         oBuilder.setStatus(retval.getStatusBuilder().build());
 390                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 391                 } catch (LcmRpcInvocationException e) {
 392                         LOG.debug(exceptionMessage, e);
 393                         oBuilder.setCommonHeader(e.getCommonHeader());
 394                         oBuilder.setStatus(e.getStatus());
 395                 }
 396
 397                 RpcResult<ConfigureOutput> rpcResult =
 398                                 RpcResultBuilder.<ConfigureOutput> status(true).withResult(oBuilder.build()).build();
 399                 // return error
 400                 return Futures.immediateFuture(rpcResult);
 401         }
 402
 403         @Override
 404         public ListenableFuture<RpcResult<ActionStatusOutput>> actionStatus(ActionStatusInput input) {
 405                 ActionStatusInputBuilder iBuilder = new ActionStatusInputBuilder(input);
 406                 ActionStatusOutputBuilder oBuilder = new ActionStatusOutputBuilder();
 407
 408                 try {
 409                         CommonLcmFields retval = callDG("action-status", iBuilder.build());
 410                         oBuilder.setStatus(retval.getStatusBuilder().build());
 411                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 412                 } catch (LcmRpcInvocationException e) {
 413                         LOG.debug(exceptionMessage, e);
 414                         oBuilder.setCommonHeader(e.getCommonHeader());
 415                         oBuilder.setStatus(e.getStatus());
 416                 }
 417
 418                 RpcResult<ActionStatusOutput> rpcResult =
 419                                 RpcResultBuilder.<ActionStatusOutput> status(true).withResult(oBuilder.build()).build();
 420                 // return error
 421                 return Futures.immediateFuture(rpcResult);
 422         }
 423
 424         @Override
 425         public ListenableFuture<RpcResult<UpgradePreCheckOutput>> upgradePreCheck(UpgradePreCheckInput input) {
 426                 UpgradePreCheckInputBuilder iBuilder = new UpgradePreCheckInputBuilder(input);
 427                 UpgradePreCheckOutputBuilder oBuilder = new UpgradePreCheckOutputBuilder();
 428
 429                 try {
 430                         CommonLcmFields retval = callDG("upgrade-pre-check", iBuilder.build());
 431                         oBuilder.setStatus(retval.getStatusBuilder().build());
 432                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 433                         if (retval.getPayload() != null) {
 434                                 oBuilder.setPayload(retval.getPayload());
 435                         }
 436                 } catch (LcmRpcInvocationException e) {
 437                         LOG.debug(exceptionMessage, e);
 438                         oBuilder.setCommonHeader(e.getCommonHeader());
 439                         oBuilder.setStatus(e.getStatus());
 440                 }
 441
 442                 RpcResult<UpgradePreCheckOutput> rpcResult =
 443                                 RpcResultBuilder.<UpgradePreCheckOutput> status(true).withResult(oBuilder.build()).build();
 444                 // return error
 445                 return Futures.immediateFuture(rpcResult);
 446         }
 447
 448         @Override
 449         public ListenableFuture<RpcResult<LiveUpgradeOutput>> liveUpgrade(LiveUpgradeInput input) {
 450                 LiveUpgradeInputBuilder iBuilder = new LiveUpgradeInputBuilder(input);
 451                 LiveUpgradeOutputBuilder oBuilder = new LiveUpgradeOutputBuilder();
 452
 453                 try {
 454                         CommonLcmFields retval = callDG("live-upgrade", iBuilder.build());
 455                         oBuilder.setStatus(retval.getStatusBuilder().build());
 456                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 457                 } catch (LcmRpcInvocationException e) {
 458                         LOG.debug(exceptionMessage, e);
 459                         oBuilder.setCommonHeader(e.getCommonHeader());
 460                         oBuilder.setStatus(e.getStatus());
 461                 }
 462
 463                 RpcResult<LiveUpgradeOutput> rpcResult =
 464                                 RpcResultBuilder.<LiveUpgradeOutput> status(true).withResult(oBuilder.build()).build();
 465                 // return error
 466                 return Futures.immediateFuture(rpcResult);
 467         }
 468
 469         @Override
 470         public ListenableFuture<RpcResult<ConfigModifyOutput>> configModify(ConfigModifyInput input) {
 471                 ConfigModifyInputBuilder iBuilder = new ConfigModifyInputBuilder(input);
 472                 ConfigModifyOutputBuilder oBuilder = new ConfigModifyOutputBuilder();
 473
 474                 try {
 475                         CommonLcmFields retval = callDG("config-modify", iBuilder.build());
 476                         oBuilder.setStatus(retval.getStatusBuilder().build());
 477                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 478                 } catch (LcmRpcInvocationException e) {
 479                         LOG.debug(exceptionMessage, e);
 480                         oBuilder.setCommonHeader(e.getCommonHeader());
 481                         oBuilder.setStatus(e.getStatus());
 482                 }
 483
 484                 RpcResult<ConfigModifyOutput> rpcResult =
 485                                 RpcResultBuilder.<ConfigModifyOutput> status(true).withResult(oBuilder.build()).build();
 486                 // return error
 487                 return Futures.immediateFuture(rpcResult);
 488         }
 489
 490         @Override
 491         public ListenableFuture<RpcResult<RestartOutput>> restart(RestartInput input) {
 492                 RestartInputBuilder iBuilder = new RestartInputBuilder(input);
 493                 RestartOutputBuilder oBuilder = new RestartOutputBuilder();
 494
 495                 try {
 496                         CommonLcmFields retval = callDG("restart", iBuilder.build());
 497                         oBuilder.setStatus(retval.getStatusBuilder().build());
 498                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 499                 } catch (LcmRpcInvocationException e) {
 500                         LOG.debug(exceptionMessage, e);
 501                         oBuilder.setCommonHeader(e.getCommonHeader());
 502                         oBuilder.setStatus(e.getStatus());
 503                 }
 504
 505                 RpcResult<RestartOutput> rpcResult =
 506                                 RpcResultBuilder.<RestartOutput> status(true).withResult(oBuilder.build()).build();
 507                 // return error
 508                 return Futures.immediateFuture(rpcResult);
 509         }
 510
 511         @Override
 512         public ListenableFuture<RpcResult<HealthCheckOutput>> healthCheck(HealthCheckInput input) {
 513                 HealthCheckInputBuilder iBuilder = new HealthCheckInputBuilder(input);
 514                 HealthCheckOutputBuilder oBuilder = new HealthCheckOutputBuilder();
 515
 516                 try {
 517                         CommonLcmFields retval = callDG("health-check", iBuilder.build());
 518                         oBuilder.setStatus(retval.getStatusBuilder().build());
 519                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 520                 } catch (LcmRpcInvocationException e) {
 521                         LOG.debug(exceptionMessage, e);
 522                         oBuilder.setCommonHeader(e.getCommonHeader());
 523                         oBuilder.setStatus(e.getStatus());
 524                 }
 525
 526                 RpcResult<HealthCheckOutput> rpcResult =
 527                                 RpcResultBuilder.<HealthCheckOutput> status(true).withResult(oBuilder.build()).build();
 528                 // return error
 529                 return Futures.immediateFuture(rpcResult);
 530         }
 531
 532         @Override
 533         public ListenableFuture<RpcResult<LockOutput>> lock(LockInput input) {
 534                 LockInputBuilder iBuilder = new LockInputBuilder(input);
 535                 LockOutputBuilder oBuilder = new LockOutputBuilder();
 536
 537                 try {
 538                         CommonLcmFields retval = callDG("lock", iBuilder.build());
 539                         oBuilder.setStatus(retval.getStatusBuilder().build());
 540                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 541                 } catch (LcmRpcInvocationException e) {
 542                         LOG.debug(exceptionMessage, e);
 543                         oBuilder.setCommonHeader(e.getCommonHeader());
 544                         oBuilder.setStatus(e.getStatus());
 545                 }
 546
 547                 RpcResult<LockOutput> rpcResult =
 548                                 RpcResultBuilder.<LockOutput> status(true).withResult(oBuilder.build()).build();
 549                 // return error
 550                 return Futures.immediateFuture(rpcResult);
 551         }
 552
 553         @Override
 554         public ListenableFuture<RpcResult<TerminateOutput>> terminate(TerminateInput input) {
 555                 TerminateInputBuilder iBuilder = new TerminateInputBuilder(input);
 556                 TerminateOutputBuilder oBuilder = new TerminateOutputBuilder();
 557
 558                 try {
 559                         CommonLcmFields retval = callDG("terminate", iBuilder.build());
 560                         oBuilder.setStatus(retval.getStatusBuilder().build());
 561                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 562                 } catch (LcmRpcInvocationException e) {
 563                         LOG.debug(exceptionMessage, e);
 564                         oBuilder.setCommonHeader(e.getCommonHeader());
 565                         oBuilder.setStatus(e.getStatus());
 566                 }
 567
 568                 RpcResult<TerminateOutput> rpcResult =
 569                                 RpcResultBuilder.<TerminateOutput> status(true).withResult(oBuilder.build()).build();
 570                 // return error
 571                 return Futures.immediateFuture(rpcResult);
 572         }
 573
 574         @Override
 575         public ListenableFuture<RpcResult<AttachVolumeOutput>> attachVolume(AttachVolumeInput input) {
 576                 AttachVolumeInputBuilder iBuilder = new AttachVolumeInputBuilder(input);
 577                 AttachVolumeOutputBuilder oBuilder = new AttachVolumeOutputBuilder();
 578
 579                 try {
 580                         CommonLcmFields retval = callDG("attach-volume", iBuilder.build());
 581                         oBuilder.setStatus(retval.getStatusBuilder().build());
 582                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 583                 } catch (LcmRpcInvocationException e) {
 584                         LOG.debug(exceptionMessage, e);
 585                         oBuilder.setCommonHeader(e.getCommonHeader());
 586                         oBuilder.setStatus(e.getStatus());
 587                 }
 588
 589                 RpcResult<AttachVolumeOutput> rpcResult =
 590                                 RpcResultBuilder.<AttachVolumeOutput> status(true).withResult(oBuilder.build()).build();
 591                 // return error
 592                 return Futures.immediateFuture(rpcResult);
 593         }
 594
 595         @Override
 596         public ListenableFuture<RpcResult<MigrateOutput>> migrate(MigrateInput input) {
 597                 MigrateInputBuilder iBuilder = new MigrateInputBuilder(input);
 598                 MigrateOutputBuilder oBuilder = new MigrateOutputBuilder();
 599
 600                 try {
 601                         CommonLcmFields retval = callDG("migrate", iBuilder.build());
 602                         oBuilder.setStatus(retval.getStatusBuilder().build());
 603                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 604                 } catch (LcmRpcInvocationException e) {
 605                         LOG.debug(exceptionMessage, e);
 606                         oBuilder.setCommonHeader(e.getCommonHeader());
 607                         oBuilder.setStatus(e.getStatus());
 608                 }
 609
 610                 RpcResult<MigrateOutput> rpcResult =
 611                                 RpcResultBuilder.<MigrateOutput> status(true).withResult(oBuilder.build()).build();
 612                 // return error
 613                 return Futures.immediateFuture(rpcResult);
 614         }
 615
 616         @Override
 617         public ListenableFuture<RpcResult<QuiesceTrafficOutput>> quiesceTraffic(QuiesceTrafficInput input) {
 618                 QuiesceTrafficInputBuilder iBuilder = new QuiesceTrafficInputBuilder(input);
 619                 QuiesceTrafficOutputBuilder oBuilder = new QuiesceTrafficOutputBuilder();
 620
 621                 try {
 622                         CommonLcmFields retval = callDG("quiesce-traffic", iBuilder.build());
 623                         oBuilder.setStatus(retval.getStatusBuilder().build());
 624                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 625                 } catch (LcmRpcInvocationException e) {
 626                         LOG.debug(exceptionMessage, e);
 627                         oBuilder.setCommonHeader(e.getCommonHeader());
 628                         oBuilder.setStatus(e.getStatus());
 629                 }
 630
 631                 RpcResult<QuiesceTrafficOutput> rpcResult =
 632                                 RpcResultBuilder.<QuiesceTrafficOutput> status(true).withResult(oBuilder.build()).build();
 633                 // return error
 634                 return Futures.immediateFuture(rpcResult);
 635         }
 636
 637         @Override
 638         public ListenableFuture<RpcResult<ConfigRestoreOutput>> configRestore(ConfigRestoreInput input) {
 639                 ConfigRestoreInputBuilder iBuilder = new ConfigRestoreInputBuilder(input);
 640                 ConfigRestoreOutputBuilder oBuilder = new ConfigRestoreOutputBuilder();
 641
 642                 try {
 643                         CommonLcmFields retval = callDG("config-restore", iBuilder.build());
 644                         oBuilder.setStatus(retval.getStatusBuilder().build());
 645                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 646                 } catch (LcmRpcInvocationException e) {
 647                         LOG.debug(exceptionMessage, e);
 648                         oBuilder.setCommonHeader(e.getCommonHeader());
 649                         oBuilder.setStatus(e.getStatus());
 650                 }
 651
 652                 RpcResult<ConfigRestoreOutput> rpcResult =
 653                                 RpcResultBuilder.<ConfigRestoreOutput> status(true).withResult(oBuilder.build()).build();
 654                 // return error
 655                 return Futures.immediateFuture(rpcResult);
 656         }
 657
 658         @Override
 659         public ListenableFuture<RpcResult<UpgradeBackoutOutput>> upgradeBackout(UpgradeBackoutInput input) {
 660                 UpgradeBackoutInputBuilder iBuilder = new UpgradeBackoutInputBuilder(input);
 661                 UpgradeBackoutOutputBuilder oBuilder = new UpgradeBackoutOutputBuilder();
 662
 663                 try {
 664                         CommonLcmFields retval = callDG("upgrade-backout", iBuilder.build());
 665                         oBuilder.setStatus(retval.getStatusBuilder().build());
 666                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 667                 } catch (LcmRpcInvocationException e) {
 668                         LOG.debug(exceptionMessage, e);
 669                         oBuilder.setCommonHeader(e.getCommonHeader());
 670                         oBuilder.setStatus(e.getStatus());
 671                 }
 672
 673                 RpcResult<UpgradeBackoutOutput> rpcResult =
 674                                 RpcResultBuilder.<UpgradeBackoutOutput> status(true).withResult(oBuilder.build()).build();
 675                 // return error
 676                 return Futures.immediateFuture(rpcResult);
 677         }
 678
 679         @Override
 680         public ListenableFuture<RpcResult<EvacuateOutput>> evacuate(EvacuateInput input) {
 681                 EvacuateInputBuilder iBuilder = new EvacuateInputBuilder(input);
 682                 EvacuateOutputBuilder oBuilder = new EvacuateOutputBuilder();
 683
 684                 try {
 685                         CommonLcmFields retval = callDG("evacuate", iBuilder.build());
 686                         oBuilder.setStatus(retval.getStatusBuilder().build());
 687                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 688                 } catch (LcmRpcInvocationException e) {
 689                         LOG.debug(exceptionMessage, e);
 690                         oBuilder.setCommonHeader(e.getCommonHeader());
 691                         oBuilder.setStatus(e.getStatus());
 692                 }
 693
 694                 RpcResult<EvacuateOutput> rpcResult =
 695                                 RpcResultBuilder.<EvacuateOutput> status(true).withResult(oBuilder.build()).build();
 696                 // return error
 697                 return Futures.immediateFuture(rpcResult);
 698         }
 699
 700         @Override
 701         public ListenableFuture<RpcResult<UnlockOutput>> unlock(UnlockInput input) {
 702                 UnlockInputBuilder iBuilder = new UnlockInputBuilder(input);
 703                 UnlockOutputBuilder oBuilder = new UnlockOutputBuilder();
 704
 705                 try {
 706                         CommonLcmFields retval = callDG("unlock", iBuilder.build());
 707                         oBuilder.setStatus(retval.getStatusBuilder().build());
 708                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 709                 } catch (LcmRpcInvocationException e) {
 710                         LOG.debug(exceptionMessage, e);
 711                         oBuilder.setCommonHeader(e.getCommonHeader());
 712                         oBuilder.setStatus(e.getStatus());
 713                 }
 714
 715                 RpcResult<UnlockOutput> rpcResult =
 716                                 RpcResultBuilder.<UnlockOutput> status(true).withResult(oBuilder.build()).build();
 717                 // return error
 718                 return Futures.immediateFuture(rpcResult);
 719         }
 720
 721         @Override
 722         public ListenableFuture<RpcResult<ConfigBackupDeleteOutput>> configBackupDelete(ConfigBackupDeleteInput input) {
 723                 ConfigBackupDeleteInputBuilder iBuilder = new ConfigBackupDeleteInputBuilder(input);
 724                 ConfigBackupDeleteOutputBuilder oBuilder = new ConfigBackupDeleteOutputBuilder();
 725
 726                 try {
 727                         CommonLcmFields retval = callDG("config-backup-delete", iBuilder.build());
 728                         oBuilder.setStatus(retval.getStatusBuilder().build());
 729                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 730                 } catch (LcmRpcInvocationException e) {
 731                         LOG.debug(exceptionMessage, e);
 732                         oBuilder.setCommonHeader(e.getCommonHeader());
 733                         oBuilder.setStatus(e.getStatus());
 734                 }
 735
 736                 RpcResult<ConfigBackupDeleteOutput> rpcResult =
 737                                 RpcResultBuilder.<ConfigBackupDeleteOutput> status(true).withResult(oBuilder.build()).build();
 738                 // return error
 739                 return Futures.immediateFuture(rpcResult);
 740         }
 741
 742         @Override
 743         public ListenableFuture<RpcResult<UpgradeSoftwareOutput>> upgradeSoftware(UpgradeSoftwareInput input) {
 744                 UpgradeSoftwareInputBuilder iBuilder = new UpgradeSoftwareInputBuilder(input);
 745                 UpgradeSoftwareOutputBuilder oBuilder = new UpgradeSoftwareOutputBuilder();
 746
 747                 try {
 748                         CommonLcmFields retval = callDG("upgrade-software", iBuilder.build());
 749                         oBuilder.setStatus(retval.getStatusBuilder().build());
 750                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 751                 } catch (LcmRpcInvocationException e) {
 752                         LOG.debug(exceptionMessage, e);
 753                         oBuilder.setCommonHeader(e.getCommonHeader());
 754                         oBuilder.setStatus(e.getStatus());
 755                 }
 756
 757                 RpcResult<UpgradeSoftwareOutput> rpcResult =
 758                                 RpcResultBuilder.<UpgradeSoftwareOutput> status(true).withResult(oBuilder.build()).build();
 759                 // return error
 760                 return Futures.immediateFuture(rpcResult);
 761         }
 762
 763         @Override
 764         public ListenableFuture<RpcResult<DownloadNeSwOutput>> downloadNeSw(DownloadNeSwInput input) {
 765                 DownloadNeSwInputBuilder iBuilder = new DownloadNeSwInputBuilder(input);
 766                 DownloadNeSwOutputBuilder oBuilder = new DownloadNeSwOutputBuilder();
 767
 768                 try {
 769                         CommonLcmFields retval = callDG("download-ne-sw", iBuilder.build());
 770                         oBuilder.setStatus(retval.getStatusBuilder().build());
 771                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 772                         if (retval.getPayload() != null) {
 773                                 oBuilder.setPayload(retval.getPayload());
 774                         }
 775                 } catch (LcmRpcInvocationException e) {
 776                         LOG.debug(exceptionMessage, e);
 777                         oBuilder.setCommonHeader(e.getCommonHeader());
 778                         oBuilder.setStatus(e.getStatus());
 779                 }
 780
 781                 RpcResult<DownloadNeSwOutput> rpcResult =
 782                                 RpcResultBuilder.<DownloadNeSwOutput> status(true).withResult(oBuilder.build()).build();
 783                 // return error
 784                 return Futures.immediateFuture(rpcResult);
 785         }
 786
 787         @Override
 788         public ListenableFuture<RpcResult<ActivateNeSwOutput>> activateNeSw(ActivateNeSwInput input) {
 789                 ActivateNeSwInputBuilder iBuilder = new ActivateNeSwInputBuilder(input);
 790                 ActivateNeSwOutputBuilder oBuilder = new ActivateNeSwOutputBuilder();
 791
 792                 try {
 793                         CommonLcmFields retval = callDG("activate-ne-sw", iBuilder.build());
 794                         oBuilder.setStatus(retval.getStatusBuilder().build());
 795                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 796                         if (retval.getPayload() != null) {
 797                                 oBuilder.setPayload(retval.getPayload());
 798                         }
 799                 } catch (LcmRpcInvocationException e) {
 800                         LOG.debug(exceptionMessage, e);
 801                         oBuilder.setCommonHeader(e.getCommonHeader());
 802                         oBuilder.setStatus(e.getStatus());
 803                 }
 804
 805                 RpcResult<ActivateNeSwOutput> rpcResult =
 806                                 RpcResultBuilder.<ActivateNeSwOutput> status(true).withResult(oBuilder.build()).build();
 807                 // return error
 808                 return Futures.immediateFuture(rpcResult);
 809         }
 810
 811         @Override
 812         public ListenableFuture<RpcResult<StopOutput>> stop(StopInput input) {
 813                 StopInputBuilder iBuilder = new StopInputBuilder(input);
 814                 StopOutputBuilder oBuilder = new StopOutputBuilder();
 815
 816                 try {
 817                         CommonLcmFields retval = callDG("stop", iBuilder.build());
 818                         oBuilder.setStatus(retval.getStatusBuilder().build());
 819                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 820                 } catch (LcmRpcInvocationException e) {
 821                         LOG.debug(exceptionMessage, e);
 822                         oBuilder.setCommonHeader(e.getCommonHeader());
 823                         oBuilder.setStatus(e.getStatus());
 824                 }
 825
 826                 RpcResult<StopOutput> rpcResult =
 827                                 RpcResultBuilder.<StopOutput> status(true).withResult(oBuilder.build()).build();
 828                 // return error
 829                 return Futures.immediateFuture(rpcResult);
 830         }
 831
 832         @Override
 833         public ListenableFuture<RpcResult<DetachVolumeOutput>> detachVolume(DetachVolumeInput input) {
 834                 DetachVolumeInputBuilder iBuilder = new DetachVolumeInputBuilder(input);
 835                 DetachVolumeOutputBuilder oBuilder = new DetachVolumeOutputBuilder();
 836
 837                 try {
 838                         CommonLcmFields retval = callDG("detach-volume", iBuilder.build());
 839                         oBuilder.setStatus(retval.getStatusBuilder().build());
 840                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 841                 } catch (LcmRpcInvocationException e) {
 842                         LOG.debug(exceptionMessage, e);
 843                         oBuilder.setCommonHeader(e.getCommonHeader());
 844                         oBuilder.setStatus(e.getStatus());
 845                 }
 846
 847                 RpcResult<DetachVolumeOutput> rpcResult =
 848                                 RpcResultBuilder.<DetachVolumeOutput> status(true).withResult(oBuilder.build()).build();
 849                 // return error
 850                 return Futures.immediateFuture(rpcResult);
 851         }
 852
 853         @Override
 854         public ListenableFuture<RpcResult<ConfigScaleOutOutput>> configScaleOut(ConfigScaleOutInput input) {
 855                 ConfigScaleOutInputBuilder iBuilder = new ConfigScaleOutInputBuilder(input);
 856                 ConfigScaleOutOutputBuilder oBuilder = new ConfigScaleOutOutputBuilder();
 857
 858                 try {
 859                         CommonLcmFields retval = callDG("config-scale-out", iBuilder.build());
 860                         oBuilder.setStatus(retval.getStatusBuilder().build());
 861                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 862                 } catch (LcmRpcInvocationException e) {
 863                         LOG.debug(exceptionMessage, e);
 864                         oBuilder.setCommonHeader(e.getCommonHeader());
 865                         oBuilder.setStatus(e.getStatus());
 866                 }
 867
 868                 RpcResult<ConfigScaleOutOutput> rpcResult =
 869                                 RpcResultBuilder.<ConfigScaleOutOutput> status(true).withResult(oBuilder.build()).build();
 870                 // return error
 871                 return Futures.immediateFuture(rpcResult);
 872         }
 873
 874         @Override
 875         public ListenableFuture<RpcResult<UpgradePostCheckOutput>> upgradePostCheck(UpgradePostCheckInput input) {
 876                 UpgradePostCheckInputBuilder iBuilder = new UpgradePostCheckInputBuilder(input);
 877                 UpgradePostCheckOutputBuilder oBuilder = new UpgradePostCheckOutputBuilder();
 878
 879                 try {
 880                         CommonLcmFields retval = callDG("upgrade-post-check", iBuilder.build());
 881                         oBuilder.setStatus(retval.getStatusBuilder().build());
 882                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 883                         if (retval.getPayload() != null) {
 884                                 oBuilder.setPayload(retval.getPayload());
 885                         }
 886                 } catch (LcmRpcInvocationException e) {
 887                         LOG.debug(exceptionMessage, e);
 888                         oBuilder.setCommonHeader(e.getCommonHeader());
 889                         oBuilder.setStatus(e.getStatus());
 890                 }
 891
 892                 RpcResult<UpgradePostCheckOutput> rpcResult =
 893                                 RpcResultBuilder.<UpgradePostCheckOutput> status(true).withResult(oBuilder.build()).build();
 894                 // return error
 895                 return Futures.immediateFuture(rpcResult);
 896         }
 897
 898         @Override
 899         public ListenableFuture<RpcResult<TestOutput>> test(TestInput input) {
 900                 TestInputBuilder iBuilder = new TestInputBuilder(input);
 901                 TestOutputBuilder oBuilder = new TestOutputBuilder();
 902
 903                 try {
 904                         CommonLcmFields retval = callDG("test", iBuilder.build());
 905                         oBuilder.setStatus(retval.getStatusBuilder().build());
 906                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 907                 } catch (LcmRpcInvocationException e) {
 908                         LOG.debug(exceptionMessage, e);
 909                         oBuilder.setCommonHeader(e.getCommonHeader());
 910                         oBuilder.setStatus(e.getStatus());
 911                 }
 912
 913                 RpcResult<TestOutput> rpcResult =
 914                                 RpcResultBuilder.<TestOutput> status(true).withResult(oBuilder.build()).build();
 915                 // return error
 916                 return Futures.immediateFuture(rpcResult);
 917         }
 918
 919         @Override
 920         public ListenableFuture<RpcResult<StartApplicationOutput>> startApplication(StartApplicationInput input) {
 921                 StartApplicationInputBuilder iBuilder = new StartApplicationInputBuilder(input);
 922                 StartApplicationOutputBuilder oBuilder = new StartApplicationOutputBuilder();
 923
 924                 try {
 925                         CommonLcmFields retval = callDG("start-application", iBuilder.build());
 926                         oBuilder.setStatus(retval.getStatusBuilder().build());
 927                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 928                 } catch (LcmRpcInvocationException e) {
 929                         LOG.debug(exceptionMessage, e);
 930                         oBuilder.setCommonHeader(e.getCommonHeader());
 931                         oBuilder.setStatus(e.getStatus());
 932                 }
 933
 934                 RpcResult<StartApplicationOutput> rpcResult =
 935                                 RpcResultBuilder.<StartApplicationOutput> status(true).withResult(oBuilder.build()).build();
 936                 // return error
 937                 return Futures.immediateFuture(rpcResult);
 938         }
 939
 940         @Override
 941         public ListenableFuture<RpcResult<ConfigBackupOutput>> configBackup(ConfigBackupInput input) {
 942                 ConfigBackupInputBuilder iBuilder = new ConfigBackupInputBuilder(input);
 943                 ConfigBackupOutputBuilder oBuilder = new ConfigBackupOutputBuilder();
 944
 945                 try {
 946                         CommonLcmFields retval = callDG("config-backup", iBuilder.build());
 947                         oBuilder.setStatus(retval.getStatusBuilder().build());
 948                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 949                 } catch (LcmRpcInvocationException e) {
 950                         LOG.debug(exceptionMessage, e);
 951                         oBuilder.setCommonHeader(e.getCommonHeader());
 952                         oBuilder.setStatus(e.getStatus());
 953                 }
 954
 955                 RpcResult<ConfigBackupOutput> rpcResult =
 956                                 RpcResultBuilder.<ConfigBackupOutput> status(true).withResult(oBuilder.build()).build();
 957                 // return error
 958                 return Futures.immediateFuture(rpcResult);
 959         }
 960
 961         @Override
 962         public ListenableFuture<RpcResult<RebuildOutput>> rebuild(RebuildInput input) {
 963                 RebuildInputBuilder iBuilder = new RebuildInputBuilder(input);
 964                 RebuildOutputBuilder oBuilder = new RebuildOutputBuilder();
 965
 966                 try {
 967                         CommonLcmFields retval = callDG("rebuild", iBuilder.build());
 968                         oBuilder.setStatus(retval.getStatusBuilder().build());
 969                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 970                 } catch (LcmRpcInvocationException e) {
 971                         LOG.debug(exceptionMessage, e);
 972                         oBuilder.setCommonHeader(e.getCommonHeader());
 973                         oBuilder.setStatus(e.getStatus());
 974                 }
 975
 976                 RpcResult<RebuildOutput> rpcResult =
 977                                 RpcResultBuilder.<RebuildOutput> status(true).withResult(oBuilder.build()).build();
 978                 // return error
 979                 return Futures.immediateFuture(rpcResult);
 980         }
 981
 982         @Override
 983         public ListenableFuture<RpcResult<AuditOutput>> audit(AuditInput input) {
 984                 AuditInputBuilder iBuilder = new AuditInputBuilder(input);
 985                 AuditOutputBuilder oBuilder = new AuditOutputBuilder();
 986
 987                 try {
 988                         CommonLcmFields retval = callDG("audit", iBuilder.build());
 989                         oBuilder.setStatus(retval.getStatusBuilder().build());
 990                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
 991                 } catch (LcmRpcInvocationException e) {
 992                         LOG.debug(exceptionMessage, e);
 993                         oBuilder.setCommonHeader(e.getCommonHeader());
 994                         oBuilder.setStatus(e.getStatus());
 995                 }
 996
 997                 RpcResult<AuditOutput> rpcResult =
 998                                 RpcResultBuilder.<AuditOutput> status(true).withResult(oBuilder.build()).build();
 999                 // return error
1000                 return Futures.immediateFuture(rpcResult);
1001         }
1002
1003         @Override
1004         public ListenableFuture<RpcResult<StartOutput>> start(StartInput input) {
1005                 StartInputBuilder iBuilder = new StartInputBuilder(input);
1006                 StartOutputBuilder oBuilder = new StartOutputBuilder();
1007
1008                 try {
1009                         CommonLcmFields retval = callDG("start", iBuilder.build());
1010                         oBuilder.setStatus(retval.getStatusBuilder().build());
1011                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
1012                 } catch (LcmRpcInvocationException e) {
1013                         LOG.debug(exceptionMessage, e);
1014                         oBuilder.setCommonHeader(e.getCommonHeader());
1015                         oBuilder.setStatus(e.getStatus());
1016                 }
1017
1018                 RpcResult<StartOutput> rpcResult =
1019                                 RpcResultBuilder.<StartOutput> status(true).withResult(oBuilder.build()).build();
1020                 // return error
1021                 return Futures.immediateFuture(rpcResult);
1022         }
1023
1024         @Override
1025         public ListenableFuture<RpcResult<SnapshotOutput>> snapshot(SnapshotInput input) {
1026                 SnapshotInputBuilder iBuilder = new SnapshotInputBuilder(input);
1027                 SnapshotOutputBuilder oBuilder = new SnapshotOutputBuilder();
1028
1029                 try {
1030                         CommonLcmFields retval = callDG("snapshot", iBuilder.build());
1031                         oBuilder.setStatus(retval.getStatusBuilder().build());
1032                         oBuilder.setCommonHeader(retval.getCommonHeaderBuilder().build());
1033                 } catch (LcmRpcInvocationException e) {
1034                         LOG.debug(exceptionMessage, e);
1035                         oBuilder.setCommonHeader(e.getCommonHeader());
1036                         oBuilder.setStatus(e.getStatus());
1037                 }
1038
1039                 RpcResult<SnapshotOutput> rpcResult =
1040                                 RpcResultBuilder.<SnapshotOutput> status(true).withResult(oBuilder.build()).build();
1041                 // return error
1042                 return Futures.immediateFuture(rpcResult);
1043         }
1044
1045         private CommonLcmFields callDG(String rpcName, Object input) throws LcmRpcInvocationException {
1046
1047                 StatusBuilder statusBuilder = new StatusBuilder();
1048
1049                 if (input == null) {
1050                         LOG.debug("Rejecting " +rpcName+ " because of invalid input");
1051                         statusBuilder.setCode(LcmResponseCode.REJECT_INVALID_INPUT.getValue());
1052                         statusBuilder.setMessage("REJECT - INVALID INPUT.  Missing input");
1053                         CommonHeaderBuilder hBuilder = new CommonHeaderBuilder();
1054                         hBuilder.setApiVer("1");
1055                         hBuilder.setOriginatorId("unknown");
1056                         hBuilder.setRequestId("unset");
1057                         hBuilder.setTimestamp(new ZULU(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").format(new Date())));
1058                         throw new LcmRpcInvocationException(statusBuilder.build(), hBuilder.build());
1059                 }
1060
1061                 CommonHeaderBuilder hBuilder = new CommonHeaderBuilder(((CommonHeader)input).getCommonHeader());
1062
1063                 // add input to parms
1064                 LOG.info("Adding INPUT data for "+ rpcName +" input: " + input.toString());
1065                 Properties inputProps = new Properties();
1066                 MdsalHelper.toProperties(inputProps, input);
1067
1068                 Properties respProps = new Properties();
1069
1070                 // Call SLI sync method
1071                 try
1072                 {
1073                         if (lcmSliClient.hasGraph("LCM", rpcName , null, "sync"))
1074                         {
1075                                 try
1076                                 {
1077                                         respProps = lcmSliClient.execute("LCM", rpcName, null, "sync", inputProps, domDataBroker);
1078                                 }
1079                                 catch (Exception e)
1080                                 {
1081                                         LOG.error("Caught exception executing service logic for "+ rpcName, e);
1082                                         statusBuilder.setCode(LcmResponseCode.FAILURE_DG_FAILURE.getValue());
1083                                         statusBuilder.setMessage("FAILURE - DG FAILURE ("+e.getMessage()+")");
1084                                         throw new LcmRpcInvocationException(statusBuilder.build(), hBuilder.build());
1085                                 }
1086                         } else {
1087                                 LOG.error("No service logic active for LCM: '" + rpcName + "'");
1088
1089                                 statusBuilder.setCode(LcmResponseCode.REJECT_DG_NOT_FOUND.getValue());
1090                                 statusBuilder.setMessage("FAILURE - DG not found for action "+rpcName);
1091                                 throw new LcmRpcInvocationException(statusBuilder.build(), hBuilder.build());
1092                         }
1093                 }
1094                 catch (Exception e)
1095                 {
1096                         LOG.error("Caught exception looking for service logic", e);
1097
1098                         statusBuilder.setCode(LcmResponseCode.FAILURE_DG_FAILURE.getValue());
1099                         statusBuilder.setMessage("FAILURE - Unexpected error looking for DG ("+e.getMessage()+")");
1100                         throw new LcmRpcInvocationException(statusBuilder.build(), hBuilder.build());
1101                 }
1102
1103
1104                 StatusBuilder sBuilder = new StatusBuilder();
1105                 MdsalHelper.toBuilder(respProps, sBuilder);
1106                 MdsalHelper.toBuilder(respProps, hBuilder);
1107
1108                 Payload payload = null;
1109                 String payloadValue = respProps.getProperty("payload");
1110                 if (payloadValue != null) {
1111                         payload = new Payload(payloadValue);
1112                 }
1113
1114                 String statusCode = sBuilder.getCode().toString();
1115
1116                 if (!"400".equals(statusCode)) {
1117                         LOG.error("Returned FAILED for "+rpcName+" error code: '" + statusCode + "'");
1118                 } else {
1119                         LOG.info("Returned SUCCESS for "+rpcName+" ");
1120                 }
1121
1122                 return new CommonLcmFields(sBuilder, hBuilder, payload);
1123
1124         }
1125
1126 }