gerrit.onap Code Review - ccsdk/features.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                      reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.ccsdk.features.sdnr.northbound.a1Adapter;
  23
  24 import java.util.Properties;
  25 import java.util.concurrent.ExecutorService;
  26 import java.util.concurrent.Executors;
  27
  28 import org.onap.ccsdk.sli.core.sli.provider.MdsalHelper;
  29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  30 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  31 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  32 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  33 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  34 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration;
  35 import org.opendaylight.yang.gen.v1.org.onap.ccsdk.rev191212.*;
  36
  37 import com.google.common.base.Preconditions;
  38 import org.opendaylight.yangtools.yang.common.RpcResult;
  39 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 import com.google.common.base.Preconditions;
  44 import com.google.common.util.concurrent.Futures;
  45 import com.google.common.util.concurrent.ListenableFuture;
  46
  47 /**
  48  * Defines a base implementation for your provider. This class extends from a helper class
  49  * which provides storage for the most commonly used components of the MD-SAL. Additionally the
  50  * base class provides some basic logging and initialization / clean up methods.
  51  *
  52  */
  53 public class A1AdapterProvider implements AutoCloseable, A1ADAPTERAPIService {
  54
  55     private static final Logger LOG = LoggerFactory.getLogger(A1AdapterProvider.class);
  56
  57     private static final String APPLICATION_NAME = "a1Adapter-api";
  58
  59     private final ExecutorService executor;
  60
  61     protected DataBroker dataBroker;
  62     protected NotificationPublishService notificationService;
  63     protected RpcProviderRegistry rpcRegistry;
  64     protected BindingAwareBroker.RpcRegistration<A1ADAPTERAPIService> rpcRegistration;
  65     private final A1AdapterClient A1AdapterClient;
  66
  67
  68     public A1AdapterProvider(final DataBroker dataBroker,
  69                                                           final NotificationPublishService notificationPublishService,
  70                                                           final RpcProviderRegistry rpcProviderRegistry,
  71                                                           final A1AdapterClient A1AdapterClient) {
  72
  73         this.LOG.info( "Creating provider for {}", APPLICATION_NAME);
  74         executor = Executors.newFixedThreadPool(1);
  75                 this.dataBroker = dataBroker;
  76                 this.notificationService = notificationPublishService;
  77                 this.rpcRegistry = rpcProviderRegistry;
  78                 this.A1AdapterClient = A1AdapterClient;
  79                 initialize();
  80     }
  81
  82     public void initialize(){
  83         LOG.info( "Initializing provider for {}", APPLICATION_NAME);
  84         rpcRegistration = rpcRegistry.addRpcImplementation(A1ADAPTERAPIService.class, this);
  85         LOG.info( "Initialization complete for {}", APPLICATION_NAME);
  86     }
  87
  88     protected void initializeChild() {
  89         //Override if you have custom initialization intelligence
  90     }
  91
  92     @Override
  93     public void close() throws Exception {
  94         LOG.info( "Closing provider for {}", APPLICATION_NAME);
  95             executor.shutdown();
  96             rpcRegistration.close();
  97         LOG.info( "Successfully closed provider for {}", APPLICATION_NAME);
  98     }
  99
 100 // RPC getNearRT-RICs
 101
 102 @Override
 103 public ListenableFuture<RpcResult<GetNearRTRICsOutput>> getNearRTRICs(
 104     GetNearRTRICsInput input) {
 105   final String svcOperation = "getNearRT-RICs";
 106
 107   Properties parms = new Properties();
 108   GetNearRTRICsOutputBuilder serviceDataBuilder = new GetNearRTRICsOutputBuilder();
 109
 110   LOG.info( "Reached RPC getNearRT-RICs");
 111
 112   LOG.info( svcOperation +" called." );
 113
 114   if(input == null ) {
 115     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 116     serviceDataBuilder.setResponseCode("Input is null");
 117     RpcResult<GetNearRTRICsOutput> rpcResult =
 118       RpcResultBuilder.<GetNearRTRICsOutput> status(true).withResult(serviceDataBuilder.build()).build();
 119     return Futures.immediateFuture(rpcResult);
 120   }
 121
 122   // add input to parms
 123   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 124   GetNearRTRICsInputBuilder inputBuilder = new GetNearRTRICsInputBuilder(input);
 125   MdsalHelper.toProperties(parms, inputBuilder.build());
 126
 127   // Call SLI sync method
 128   try
 129   {
 130     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 131     {
 132       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 133       try
 134       {
 135         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 136       }
 137       catch (Exception e)
 138       {
 139         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 140         serviceDataBuilder.setResponseCode("500");
 141       }
 142     } else {
 143       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 144       serviceDataBuilder.setResponseCode("503");
 145     }
 146   }
 147   catch (Exception e)
 148   {
 149     LOG.error("Caught exception looking for service logic", e);
 150     serviceDataBuilder.setResponseCode("500");
 151   }
 152
 153   String errorCode = serviceDataBuilder.getResponseCode();
 154
 155   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 156     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 157   } else {
 158     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 159     serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetNearRTRICs " );
 160   }
 161
 162   RpcResult<GetNearRTRICsOutput> rpcResult =
 163       RpcResultBuilder.<GetNearRTRICsOutput> status(true).withResult(serviceDataBuilder.build()).build();
 164
 165   LOG.info("Successful exit from getNearRT-RICs ");
 166
 167   return Futures.immediateFuture(rpcResult);
 168 }
 169
 170 // RPC getHealthCheck
 171
 172         @Override
 173         public ListenableFuture<RpcResult<GetHealthCheckOutput>> getHealthCheck(
 174                         GetHealthCheckInput input) {
 175                 final String svcOperation = "getHealthCheck";
 176
 177                 Properties parms = new Properties();
 178                 GetHealthCheckOutputBuilder serviceDataBuilder = new GetHealthCheckOutputBuilder();
 179
 180     LOG.info( "Reached RPC getHealthCheck");
 181
 182                 LOG.info( svcOperation +" called." );
 183
 184                 if(input == null ) {
 185                         LOG.debug("exiting " +svcOperation+ " because of invalid input");
 186                         serviceDataBuilder.setResponseCode("Input is null");
 187                         RpcResult<GetHealthCheckOutput> rpcResult =
 188                                 RpcResultBuilder.<GetHealthCheckOutput> status(true).withResult(serviceDataBuilder.build()).build();
 189                         return Futures.immediateFuture(rpcResult);
 190                 }
 191
 192                 // add input to parms
 193                 LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 194                 GetHealthCheckInputBuilder inputBuilder = new GetHealthCheckInputBuilder(input);
 195                 MdsalHelper.toProperties(parms, inputBuilder.build());
 196
 197                 // Call SLI sync method
 198                 try
 199                 {
 200                         if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 201                         {
 202         LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 203                                 try
 204                                 {
 205           A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 206                                 }
 207                                 catch (Exception e)
 208                                 {
 209                                         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 210                                         serviceDataBuilder.setResponseCode("500");
 211                                 }
 212                         } else {
 213                                 LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 214                                 serviceDataBuilder.setResponseCode("503");
 215                         }
 216                 }
 217                 catch (Exception e)
 218                 {
 219                         LOG.error("Caught exception looking for service logic", e);
 220                         serviceDataBuilder.setResponseCode("500");
 221                 }
 222
 223                 String errorCode = serviceDataBuilder.getResponseCode();
 224
 225                 if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 226                         LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 227                 } else {
 228                         LOG.info("Returned SUCCESS for "+svcOperation+" ");
 229       serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetHealthCheck. " );
 230                 }
 231
 232                 RpcResult<GetHealthCheckOutput> rpcResult =
 233                                 RpcResultBuilder.<GetHealthCheckOutput> status(true).withResult(serviceDataBuilder.build()).build();
 234
 235     LOG.info("Successful exit from getHealthCheck ");
 236
 237                 return Futures.immediateFuture(rpcResult);
 238         }
 239
 240 // RPC getPolicyTypes
 241
 242 @Override
 243 public ListenableFuture<RpcResult<GetPolicyTypesOutput>> getPolicyTypes(
 244     GetPolicyTypesInput input) {
 245   final String svcOperation = "getPolicyTypes";
 246
 247   Properties parms = new Properties();
 248   GetPolicyTypesOutputBuilder serviceDataBuilder = new GetPolicyTypesOutputBuilder();
 249
 250   LOG.info( "Reached RPC getPolicyTypes");
 251
 252   LOG.info( svcOperation +" called." );
 253
 254   if(input == null ) {
 255     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 256     serviceDataBuilder.setResponseCode("Input is null");
 257     RpcResult<GetPolicyTypesOutput> rpcResult =
 258       RpcResultBuilder.<GetPolicyTypesOutput> status(true).withResult(serviceDataBuilder.build()).build();
 259     return Futures.immediateFuture(rpcResult);
 260   }
 261
 262   // add input to parms
 263   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 264   GetPolicyTypesInputBuilder inputBuilder = new GetPolicyTypesInputBuilder(input);
 265   MdsalHelper.toProperties(parms, inputBuilder.build());
 266
 267   // Call SLI sync method
 268   try
 269   {
 270     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 271     {
 272       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 273       try
 274       {
 275         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 276       }
 277       catch (Exception e)
 278       {
 279         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 280         serviceDataBuilder.setResponseCode("500");
 281       }
 282     } else {
 283       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 284       serviceDataBuilder.setResponseCode("503");
 285     }
 286   }
 287   catch (Exception e)
 288   {
 289     LOG.error("Caught exception looking for service logic", e);
 290     serviceDataBuilder.setResponseCode("500");
 291   }
 292
 293   String errorCode = serviceDataBuilder.getResponseCode();
 294
 295   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 296     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 297   } else {
 298     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 299     serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetPolicyTypes ");
 300   }
 301
 302   RpcResult<GetPolicyTypesOutput> rpcResult =
 303       RpcResultBuilder.<GetPolicyTypesOutput> status(true).withResult(serviceDataBuilder.build()).build();
 304
 305   LOG.info("Successful exit from getPolicyTypes ");
 306
 307   return Futures.immediateFuture(rpcResult);
 308 }
 309
 310 // RPC createPolicyType
 311
 312 @Override
 313 public ListenableFuture<RpcResult<CreatePolicyTypeOutput>> createPolicyType(
 314     CreatePolicyTypeInput input) {
 315   final String svcOperation = "createPolicyType";
 316
 317   Properties parms = new Properties();
 318   CreatePolicyTypeOutputBuilder serviceDataBuilder = new CreatePolicyTypeOutputBuilder();
 319
 320   LOG.info( "Reached RPC createPolicyType");
 321
 322   LOG.info( svcOperation +" called." );
 323
 324   if(input == null ) {
 325     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 326     serviceDataBuilder.setResponseCode("Input is null");
 327     RpcResult<CreatePolicyTypeOutput> rpcResult =
 328       RpcResultBuilder.<CreatePolicyTypeOutput> status(true).withResult(serviceDataBuilder.build()).build();
 329     return Futures.immediateFuture(rpcResult);
 330   }
 331
 332   // add input to parms
 333   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 334   CreatePolicyTypeInputBuilder inputBuilder = new CreatePolicyTypeInputBuilder(input);
 335   MdsalHelper.toProperties(parms, inputBuilder.build());
 336
 337   // Call SLI sync method
 338   try
 339   {
 340     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 341     {
 342       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 343       try
 344       {
 345         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 346       }
 347       catch (Exception e)
 348       {
 349         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 350         serviceDataBuilder.setResponseCode("500");
 351       }
 352     } else {
 353       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 354       serviceDataBuilder.setResponseCode("503");
 355     }
 356   }
 357   catch (Exception e)
 358   {
 359     LOG.error("Caught exception looking for service logic", e);
 360     serviceDataBuilder.setResponseCode("500");
 361   }
 362
 363   String errorCode = serviceDataBuilder.getResponseCode();
 364
 365   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 366     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 367   } else {
 368     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 369     serviceDataBuilder.setResponseCode("A1 Adapter Executed for CreatePolicyType" );
 370   }
 371
 372   RpcResult<CreatePolicyTypeOutput> rpcResult =
 373       RpcResultBuilder.<CreatePolicyTypeOutput> status(true).withResult(serviceDataBuilder.build()).build();
 374
 375   LOG.info("Successful exit from createPolicyType ");
 376
 377   return Futures.immediateFuture(rpcResult);
 378 }
 379
 380 // RPC getPolicyType
 381
 382 @Override
 383 public ListenableFuture<RpcResult<GetPolicyTypeOutput>> getPolicyType(
 384     GetPolicyTypeInput input) {
 385   final String svcOperation = "getPolicyType";
 386
 387   Properties parms = new Properties();
 388   GetPolicyTypeOutputBuilder serviceDataBuilder = new GetPolicyTypeOutputBuilder();
 389
 390   LOG.info( "Reached RPC getPolicyType");
 391
 392   LOG.info( svcOperation +" called." );
 393
 394   if(input == null ) {
 395     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 396     serviceDataBuilder.setResponseCode("Input is null");
 397     RpcResult<GetPolicyTypeOutput> rpcResult =
 398       RpcResultBuilder.<GetPolicyTypeOutput> status(true).withResult(serviceDataBuilder.build()).build();
 399     return Futures.immediateFuture(rpcResult);
 400   }
 401
 402   // add input to parms
 403   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 404   GetPolicyTypeInputBuilder inputBuilder = new GetPolicyTypeInputBuilder(input);
 405   MdsalHelper.toProperties(parms, inputBuilder.build());
 406
 407   // Call SLI sync method
 408   try
 409   {
 410     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 411     {
 412       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 413       try
 414       {
 415         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 416       }
 417       catch (Exception e)
 418       {
 419         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 420         serviceDataBuilder.setResponseCode("500");
 421       }
 422     } else {
 423       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 424       serviceDataBuilder.setResponseCode("503");
 425     }
 426   }
 427   catch (Exception e)
 428   {
 429     LOG.error("Caught exception looking for service logic", e);
 430     serviceDataBuilder.setResponseCode("500");
 431   }
 432
 433   String errorCode = serviceDataBuilder.getResponseCode();
 434
 435   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 436     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 437   } else {
 438     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 439     serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetPolicyType. " );
 440   }
 441
 442   RpcResult<GetPolicyTypeOutput> rpcResult =
 443       RpcResultBuilder.<GetPolicyTypeOutput> status(true).withResult(serviceDataBuilder.build()).build();
 444
 445   LOG.info("Successful exit from getPolicyType ");
 446
 447   return Futures.immediateFuture(rpcResult);
 448 }
 449
 450 // RPC deletePolicyType
 451
 452 @Override
 453 public ListenableFuture<RpcResult<DeletePolicyTypeOutput>> deletePolicyType(
 454     DeletePolicyTypeInput input) {
 455   final String svcOperation = "deletePolicyType";
 456
 457   Properties parms = new Properties();
 458   DeletePolicyTypeOutputBuilder serviceDataBuilder = new DeletePolicyTypeOutputBuilder();
 459
 460   LOG.info( "Reached RPC deletePolicyType");
 461
 462   LOG.info( svcOperation +" called." );
 463
 464   if(input == null ) {
 465     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 466     serviceDataBuilder.setResponseCode("Input is null");
 467     RpcResult<DeletePolicyTypeOutput> rpcResult =
 468       RpcResultBuilder.<DeletePolicyTypeOutput> status(true).withResult(serviceDataBuilder.build()).build();
 469     return Futures.immediateFuture(rpcResult);
 470   }
 471
 472   // add input to parms
 473   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 474   DeletePolicyTypeInputBuilder inputBuilder = new DeletePolicyTypeInputBuilder(input);
 475   MdsalHelper.toProperties(parms, inputBuilder.build());
 476
 477   // Call SLI sync method
 478   try
 479   {
 480     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 481     {
 482       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 483       try
 484       {
 485         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 486       }
 487       catch (Exception e)
 488       {
 489         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 490         serviceDataBuilder.setResponseCode("500");
 491       }
 492     } else {
 493       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 494       serviceDataBuilder.setResponseCode("503");
 495     }
 496   }
 497   catch (Exception e)
 498   {
 499     LOG.error("Caught exception looking for service logic", e);
 500     serviceDataBuilder.setResponseCode("500");
 501   }
 502
 503   String errorCode = serviceDataBuilder.getResponseCode();
 504
 505   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 506     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 507   } else {
 508     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 509     serviceDataBuilder.setResponseCode("A1 Adapter Executed for DeletePolicyType ");
 510   }
 511
 512   RpcResult<DeletePolicyTypeOutput> rpcResult =
 513       RpcResultBuilder.<DeletePolicyTypeOutput> status(true).withResult(serviceDataBuilder.build()).build();
 514
 515   LOG.info("Successful exit from deletePolicyType ");
 516
 517   return Futures.immediateFuture(rpcResult);
 518 }
 519
 520 // RPC getPolicyInstances
 521
 522 @Override
 523 public ListenableFuture<RpcResult<GetPolicyInstancesOutput>> getPolicyInstances(
 524     GetPolicyInstancesInput input) {
 525   final String svcOperation = "getPolicyInstances";
 526
 527   Properties parms = new Properties();
 528   GetPolicyInstancesOutputBuilder serviceDataBuilder = new GetPolicyInstancesOutputBuilder();
 529
 530   LOG.info( "Reached RPC getPolicyInstances");
 531
 532   LOG.info( svcOperation +" called." );
 533
 534   if(input == null ) {
 535     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 536     serviceDataBuilder.setResponseCode("Input is null");
 537     RpcResult<GetPolicyInstancesOutput> rpcResult =
 538       RpcResultBuilder.<GetPolicyInstancesOutput> status(true).withResult(serviceDataBuilder.build()).build();
 539     return Futures.immediateFuture(rpcResult);
 540   }
 541
 542   // add input to parms
 543   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 544   GetPolicyInstancesInputBuilder inputBuilder = new GetPolicyInstancesInputBuilder(input);
 545   MdsalHelper.toProperties(parms, inputBuilder.build());
 546
 547   // Call SLI sync method
 548   try
 549   {
 550     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 551     {
 552       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 553       try
 554       {
 555         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 556       }
 557       catch (Exception e)
 558       {
 559         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 560         serviceDataBuilder.setResponseCode("500");
 561       }
 562     } else {
 563       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 564       serviceDataBuilder.setResponseCode("503");
 565     }
 566   }
 567   catch (Exception e)
 568   {
 569     LOG.error("Caught exception looking for service logic", e);
 570     serviceDataBuilder.setResponseCode("500");
 571   }
 572
 573   String errorCode = serviceDataBuilder.getResponseCode();
 574
 575   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 576     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 577   } else {
 578     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 579     serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetPolicyInstances " );
 580   }
 581
 582   RpcResult<GetPolicyInstancesOutput> rpcResult =
 583       RpcResultBuilder.<GetPolicyInstancesOutput> status(true).withResult(serviceDataBuilder.build()).build();
 584
 585   LOG.info("Successful exit from getPolicyInstances ");
 586
 587   return Futures.immediateFuture(rpcResult);
 588 }
 589
 590
 591 // RPC createPolicyInstance
 592
 593 @Override
 594 public ListenableFuture<RpcResult<CreatePolicyInstanceOutput>> createPolicyInstance(
 595     CreatePolicyInstanceInput input) {
 596   final String svcOperation = "createPolicyInstance";
 597
 598   Properties parms = new Properties();
 599   CreatePolicyInstanceOutputBuilder serviceDataBuilder = new CreatePolicyInstanceOutputBuilder();
 600
 601   LOG.info( "Reached RPC createPolicyInstance");
 602
 603   LOG.info( svcOperation +" called." );
 604
 605   if(input == null ) {
 606     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 607     serviceDataBuilder.setResponseCode("Input is null");
 608     RpcResult<CreatePolicyInstanceOutput> rpcResult =
 609       RpcResultBuilder.<CreatePolicyInstanceOutput> status(true).withResult(serviceDataBuilder.build()).build();
 610     return Futures.immediateFuture(rpcResult);
 611   }
 612
 613   // add input to parms
 614   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 615   CreatePolicyInstanceInputBuilder inputBuilder = new CreatePolicyInstanceInputBuilder(input);
 616   MdsalHelper.toProperties(parms, inputBuilder.build());
 617
 618   // Call SLI sync method
 619   try
 620   {
 621     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 622     {
 623       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 624       try
 625       {
 626         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 627       }
 628       catch (Exception e)
 629       {
 630         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 631         serviceDataBuilder.setResponseCode("500");
 632       }
 633     } else {
 634       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 635       serviceDataBuilder.setResponseCode("503");
 636     }
 637   }
 638   catch (Exception e)
 639   {
 640     LOG.error("Caught exception looking for service logic", e);
 641     serviceDataBuilder.setResponseCode("500");
 642   }
 643
 644   String errorCode = serviceDataBuilder.getResponseCode();
 645
 646   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 647     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 648   } else {
 649     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 650     serviceDataBuilder.setResponseCode("A1 Adapter Executed for CreatePolicyInstance. " );
 651   }
 652
 653   RpcResult<CreatePolicyInstanceOutput> rpcResult =
 654       RpcResultBuilder.<CreatePolicyInstanceOutput> status(true).withResult(serviceDataBuilder.build()).build();
 655
 656   LOG.info("Successful exit from createPolicyInstance ");
 657
 658   return Futures.immediateFuture(rpcResult);
 659 }
 660
 661
 662
 663 // RPC getPolicyInstance
 664
 665 @Override
 666 public ListenableFuture<RpcResult<GetPolicyInstanceOutput>> getPolicyInstance(
 667     GetPolicyInstanceInput input) {
 668   final String svcOperation = "getPolicyInstance";
 669
 670   Properties parms = new Properties();
 671   GetPolicyInstanceOutputBuilder serviceDataBuilder = new GetPolicyInstanceOutputBuilder();
 672
 673   LOG.info( "Reached RPC getPolicyInstance");
 674
 675   LOG.info( svcOperation +" called." );
 676
 677   if(input == null ) {
 678     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 679     serviceDataBuilder.setResponseCode("Input is null");
 680     RpcResult<GetPolicyInstanceOutput> rpcResult =
 681       RpcResultBuilder.<GetPolicyInstanceOutput> status(true).withResult(serviceDataBuilder.build()).build();
 682     return Futures.immediateFuture(rpcResult);
 683   }
 684
 685   // add input to parms
 686   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 687   GetPolicyInstanceInputBuilder inputBuilder = new GetPolicyInstanceInputBuilder(input);
 688   MdsalHelper.toProperties(parms, inputBuilder.build());
 689
 690   // Call SLI sync method
 691   try
 692   {
 693     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 694     {
 695       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 696       try
 697       {
 698         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 699       }
 700       catch (Exception e)
 701       {
 702         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 703         serviceDataBuilder.setResponseCode("500");
 704       }
 705     } else {
 706       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 707       serviceDataBuilder.setResponseCode("503");
 708     }
 709   }
 710   catch (Exception e)
 711   {
 712     LOG.error("Caught exception looking for service logic", e);
 713     serviceDataBuilder.setResponseCode("500");
 714   }
 715
 716   String errorCode = serviceDataBuilder.getResponseCode();
 717
 718   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 719     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 720   } else {
 721     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 722     serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetPolicyInstance. " );
 723   }
 724
 725   RpcResult<GetPolicyInstanceOutput> rpcResult =
 726       RpcResultBuilder.<GetPolicyInstanceOutput> status(true).withResult(serviceDataBuilder.build()).build();
 727
 728   LOG.info("Successful exit from getPolicyInstance ");
 729
 730   return Futures.immediateFuture(rpcResult);
 731 }
 732
 733
 734
 735 // RPC deletePolicyInstance
 736
 737 @Override
 738 public ListenableFuture<RpcResult<DeletePolicyInstanceOutput>> deletePolicyInstance(
 739     DeletePolicyInstanceInput input) {
 740   final String svcOperation = "deletePolicyInstance";
 741
 742   Properties parms = new Properties();
 743   DeletePolicyInstanceOutputBuilder serviceDataBuilder = new DeletePolicyInstanceOutputBuilder();
 744
 745   LOG.info( "Reached RPC deletePolicyInstance");
 746
 747   LOG.info( svcOperation +" called." );
 748
 749   if(input == null ) {
 750     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 751     serviceDataBuilder.setResponseCode("Input is null");
 752     RpcResult<DeletePolicyInstanceOutput> rpcResult =
 753       RpcResultBuilder.<DeletePolicyInstanceOutput> status(true).withResult(serviceDataBuilder.build()).build();
 754     return Futures.immediateFuture(rpcResult);
 755   }
 756
 757   // add input to parms
 758   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 759   DeletePolicyInstanceInputBuilder inputBuilder = new DeletePolicyInstanceInputBuilder(input);
 760   MdsalHelper.toProperties(parms, inputBuilder.build());
 761
 762   // Call SLI sync method
 763   try
 764   {
 765     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 766     {
 767       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 768       try
 769       {
 770         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 771       }
 772       catch (Exception e)
 773       {
 774         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 775         serviceDataBuilder.setResponseCode("500");
 776       }
 777     } else {
 778       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 779       serviceDataBuilder.setResponseCode("503");
 780     }
 781   }
 782   catch (Exception e)
 783   {
 784     LOG.error("Caught exception looking for service logic", e);
 785     serviceDataBuilder.setResponseCode("500");
 786   }
 787
 788   String errorCode = serviceDataBuilder.getResponseCode();
 789
 790   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 791     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 792   } else {
 793     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 794     serviceDataBuilder.setResponseCode("A1 Adapter Executed for DeletePolicyInstance. ");
 795   }
 796
 797   RpcResult<DeletePolicyInstanceOutput> rpcResult =
 798       RpcResultBuilder.<DeletePolicyInstanceOutput> status(true).withResult(serviceDataBuilder.build()).build();
 799
 800   LOG.info("Successful exit from deletePolicyInstance ");
 801
 802   return Futures.immediateFuture(rpcResult);
 803 }
 804
 805
 806
 807 // RPC getStatus
 808
 809 @Override
 810 public ListenableFuture<RpcResult<GetStatusOutput>> getStatus(
 811     GetStatusInput input) {
 812   final String svcOperation = "getStatus";
 813
 814   Properties parms = new Properties();
 815   GetStatusOutputBuilder serviceDataBuilder = new GetStatusOutputBuilder();
 816
 817   LOG.info( "Reached RPC getStatus");
 818
 819   LOG.info( svcOperation +" called." );
 820
 821   if(input == null ) {
 822     LOG.debug("exiting " +svcOperation+ " because of invalid input");
 823     serviceDataBuilder.setResponseCode("Input is null");
 824     RpcResult<GetStatusOutput> rpcResult =
 825       RpcResultBuilder.<GetStatusOutput> status(true).withResult(serviceDataBuilder.build()).build();
 826     return Futures.immediateFuture(rpcResult);
 827   }
 828
 829   // add input to parms
 830   LOG.info("Adding INPUT data for "+svcOperation+" input: " + input);
 831   GetStatusInputBuilder inputBuilder = new GetStatusInputBuilder(input);
 832   MdsalHelper.toProperties(parms, inputBuilder.build());
 833
 834   // Call SLI sync method
 835   try
 836   {
 837     if (A1AdapterClient.hasGraph("A1-ADAPTER-API", svcOperation , null, "sync"))
 838     {
 839       LOG.info( "A1AdapterClient has a Directed Graph for '" + svcOperation + "'");
 840       try
 841       {
 842         A1AdapterClient.execute("A1-ADAPTER-API", svcOperation, null, "sync", serviceDataBuilder, parms);
 843       }
 844       catch (Exception e)
 845       {
 846         LOG.error("Caught exception executing service logic for "+ svcOperation, e);
 847         serviceDataBuilder.setResponseCode("500");
 848       }
 849     } else {
 850       LOG.error("No service logic active for A1Adapter: '" + svcOperation + "'");
 851       serviceDataBuilder.setResponseCode("503");
 852     }
 853   }
 854   catch (Exception e)
 855   {
 856     LOG.error("Caught exception looking for service logic", e);
 857     serviceDataBuilder.setResponseCode("500");
 858   }
 859
 860   String errorCode = serviceDataBuilder.getResponseCode();
 861
 862   if (!("0".equals(errorCode) || "200".equals(errorCode))) {
 863     LOG.error("Returned FAILED for "+svcOperation+" error code: '" + errorCode + "'");
 864   } else {
 865     LOG.info("Returned SUCCESS for "+svcOperation+" ");
 866     serviceDataBuilder.setResponseCode("A1 Adapter Executed for GetStatus. " );
 867   }
 868
 869   RpcResult<GetStatusOutput> rpcResult =
 870       RpcResultBuilder.<GetStatusOutput> status(true).withResult(serviceDataBuilder.build()).build();
 871
 872   LOG.info("Successful exit from getStatus ");
 873
 874   return Futures.immediateFuture(rpcResult);
 875 }
 876
 877
 878
 879
 880 }