sdnc-a1-controller/northbound/nonrt-ric-api/provider/src/main/java/org/onap/sdnc/northbound/provider/NonrtRicApiProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.sdnc.northbound.provider;
  22
  23 import com.google.common.util.concurrent.CheckedFuture;
  24 import com.google.common.util.concurrent.Futures;
  25 import com.google.common.util.concurrent.ListenableFuture;
  26 import com.google.gson.Gson;
  27 import java.text.DateFormat;
  28 import java.text.SimpleDateFormat;
  29 import java.util.ArrayList;
  30 import java.util.Date;
  31 import java.util.List;
  32 import java.util.TimeZone;
  33 import java.util.concurrent.ExecutionException;
  34 import java.util.concurrent.ExecutorService;
  35 import java.util.concurrent.Executors;
  36 import org.json.JSONObject;
  37 import org.onap.sdnc.northbound.exceptions.NearRtRicNotFoundException;
  38 import org.onap.sdnc.northbound.restadpter.NearRicUrlProvider;
  39 import org.onap.sdnc.northbound.restadpter.RestAdapter;
  40 import org.onap.sdnc.northbound.restadpter.RestAdapterImpl;
  41 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  42 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  43 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  44 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  45 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  46 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.A1ADAPTERAPIService;
  48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceInput;
  49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceOutput;
  50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyInstanceOutputBuilder;
  51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeInput;
  52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeOutput;
  53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.CreatePolicyTypeOutputBuilder;
  54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceInput;
  55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceOutput;
  56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyInstanceOutputBuilder;
  57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeInput;
  58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeOutput;
  59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.DeletePolicyTypeOutputBuilder;
  60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckInput;
  61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckOutput;
  62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetHealthCheckOutputBuilder;
  63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsInput;
  64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsOutput;
  65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetNearRTRICsOutputBuilder;
  66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceInput;
  67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceOutput;
  68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstanceOutputBuilder;
  69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesInput;
  70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesOutput;
  71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyInstancesOutputBuilder;
  72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeInput;
  73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeOutput;
  74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypeOutputBuilder;
  75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesInput;
  76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesOutput;
  77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetPolicyTypesOutputBuilder;
  78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusInput;
  79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusOutput;
  80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.a1.adapter.rev191002.GetStatusOutputBuilder;
  81 import org.opendaylight.yangtools.yang.common.RpcResult;
  82 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  83 import org.slf4j.Logger;
  84 import org.slf4j.LoggerFactory;
  85 import org.springframework.http.HttpStatus;
  86 import org.springframework.http.ResponseEntity;
  87 import org.springframework.web.client.RestClientResponseException;
  88
  89 /**
  90  * Defines a base implementation for your provider. This class overrides the generated interface
  91  * from the YANG model and implements the request model for the A1 interface. This class identifies
  92  * the Near-RIC throught the IP passed over the payload and calls the corresponding Near-RIC over
  93  * Rest API
  94  *
  95  * <pre>
  96  *
  97  * @author lathishbabu.ganesan@est.tech
  98  *
  99  */
 100
 101 public class NonrtRicApiProvider implements AutoCloseable, A1ADAPTERAPIService {
 102
 103   protected static final String APP_NAME = "nonrt-ric-api";
 104   protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
 105   private static final String NON_NULL_PARAM = "non-null";
 106   private static final String NULL_PARAM = "null";
 107
 108   private final Logger log = LoggerFactory.getLogger(NonrtRicApiProvider.class);
 109   private final ExecutorService executor;
 110
 111   protected DataBroker dataBroker;
 112   protected NotificationPublishService notificationService;
 113   protected RpcProviderRegistry rpcRegistry;
 114   protected BindingAwareBroker.RpcRegistration<?> rpcRegistration;
 115   private RestAdapter restAdapter;
 116   private NearRicUrlProvider nearRicUrlProvider;
 117
 118   public NonrtRicApiProvider(DataBroker dataBroker,
 119       NotificationPublishService notificationPublishService,
 120       RpcProviderRegistry rpcProviderRegistry) {
 121     log.info("Creating provider for {}", APP_NAME);
 122     executor = Executors.newFixedThreadPool(1);
 123     setDataBroker(dataBroker);
 124     setNotificationService(notificationPublishService);
 125     setRpcRegistry(rpcProviderRegistry);
 126     initialize();
 127
 128   }
 129
 130   public void initialize() {
 131     log.info("Initializing provider for {}", APP_NAME);
 132     createContainers();
 133     restAdapter = new RestAdapterImpl();
 134     nearRicUrlProvider = new NearRicUrlProvider();
 135     log.info("Initialization complete for {}", APP_NAME);
 136   }
 137
 138   protected void initializeChild() {
 139     // Override if you have custom initialization intelligence
 140   }
 141
 142   @Override
 143   public void close() throws Exception {
 144     log.info("Closing provider for {}", APP_NAME);
 145     executor.shutdown();
 146     rpcRegistration.close();
 147     log.info("Successfully closed provider for {}", APP_NAME);
 148   }
 149
 150   private static class Iso8601Util {
 151
 152     private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
 153     private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
 154
 155     private Iso8601Util() {}
 156
 157     static {
 158       dateFormat.setTimeZone(timeZone);
 159     }
 160
 161     private static String now() {
 162       return dateFormat.format(new Date());
 163     }
 164   }
 165
 166   public void setDataBroker(DataBroker dataBroker) {
 167     this.dataBroker = dataBroker;
 168     if (log.isDebugEnabled()) {
 169       log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
 170     }
 171   }
 172
 173   public void setNotificationService(NotificationPublishService notificationService) {
 174     this.notificationService = notificationService;
 175     if (log.isDebugEnabled()) {
 176       log.debug("Notification Service set to {}",
 177           notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
 178     }
 179   }
 180
 181   public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
 182     this.rpcRegistry = rpcRegistry;
 183     if (log.isDebugEnabled()) {
 184       log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
 185     }
 186   }
 187
 188   private void createContainers() {
 189
 190     final WriteTransaction t = dataBroker.newReadWriteTransaction();
 191
 192     try {
 193       CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
 194       checkedFuture.get();
 195       log.info("Create containers succeeded!");
 196
 197     } catch (InterruptedException | ExecutionException e) {
 198       log.error("Create containers failed: ", e);
 199     }
 200   }
 201
 202   @Override
 203   public ListenableFuture<RpcResult<CreatePolicyInstanceOutput>> createPolicyInstance(
 204       CreatePolicyInstanceInput input) {
 205     log.info("Start of createPolicyInstance");
 206     CreatePolicyInstanceOutputBuilder responseBuilder = new CreatePolicyInstanceOutputBuilder();
 207     try {
 208         String uri = nearRicUrlProvider.getPolicyInstanceId(String.valueOf(input.getNearRtRicId()),
 209                 String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
 210         log.info("PUT Request input.getPolicyInstance() : {} ", input.getPolicyInstance());
 211         ResponseEntity<Void> response = restAdapter.put(uri, input.getPolicyInstance());
 212         responseBuilder.setCode(response.getStatusCode().toString());
 213     } catch (NearRtRicNotFoundException ex) {
 214         log.error("Caught exception: {}", ex);
 215         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 216     } catch (RestClientResponseException ex) {
 217         log.error("Caught exception: {}", ex);
 218         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 219     }
 220     log.info("End of createPolicyInstance");
 221     RpcResult<CreatePolicyInstanceOutput> rpcResult = RpcResultBuilder
 222         .<CreatePolicyInstanceOutput>status(true).withResult(responseBuilder.build()).build();
 223     return Futures.immediateFuture(rpcResult);
 224   }
 225
 226   @Override
 227   public ListenableFuture<RpcResult<CreatePolicyTypeOutput>> createPolicyType(
 228       CreatePolicyTypeInput input) {
 229     log.info("Start of createPolicyType");
 230     CreatePolicyTypeOutputBuilder responseBuilder = new CreatePolicyTypeOutputBuilder();
 231     try {
 232         String uri = nearRicUrlProvider.getPolicyTypeId(String.valueOf(input.getNearRtRicId()),
 233                 String.valueOf(input.getPolicyTypeId()));
 234         log.info("PUT Request input.getPolicyType() : {} ", input.getPolicyType());
 235         ResponseEntity<Void> response = restAdapter.put(uri, input.getPolicyType());
 236         responseBuilder.setCode(response.getStatusCode().toString());
 237     } catch (NearRtRicNotFoundException ex) {
 238         log.error("Caught exception: {}", ex);
 239         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 240     } catch (RestClientResponseException ex) {
 241         log.error("Caught exception: {}", ex);
 242         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 243     }
 244     log.info("End of createPolicyType");
 245     RpcResult<CreatePolicyTypeOutput> rpcResult = RpcResultBuilder
 246         .<CreatePolicyTypeOutput>status(true).withResult(responseBuilder.build()).build();
 247     return Futures.immediateFuture(rpcResult);
 248   }
 249
 250   @Override
 251   public ListenableFuture<RpcResult<DeletePolicyInstanceOutput>> deletePolicyInstance(
 252       DeletePolicyInstanceInput input) {
 253     log.info("Start of deletePolicyInstance");
 254     DeletePolicyInstanceOutputBuilder responseBuilder = new DeletePolicyInstanceOutputBuilder();
 255     try {
 256         String uri = nearRicUrlProvider.getPolicyInstanceId(String.valueOf(input.getNearRtRicId()),
 257                 String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
 258         ResponseEntity<Void> response = restAdapter.delete(uri);
 259         responseBuilder.setCode(response.getStatusCode().toString());
 260     } catch (NearRtRicNotFoundException ex) {
 261         log.error("Caught exception: {}", ex);
 262         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 263     } catch (RestClientResponseException ex) {
 264         log.error("Caught exception: {}", ex);
 265         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 266     }
 267     log.info("End of deletePolicyInstance");
 268     RpcResult<DeletePolicyInstanceOutput> rpcResult = RpcResultBuilder
 269         .<DeletePolicyInstanceOutput>status(true).withResult(responseBuilder.build()).build();
 270     return Futures.immediateFuture(rpcResult);
 271   }
 272
 273   @Override
 274   public ListenableFuture<RpcResult<DeletePolicyTypeOutput>> deletePolicyType(
 275       DeletePolicyTypeInput input) {
 276     log.info("Start of deletePolicyType");
 277     DeletePolicyTypeOutputBuilder responseBuilder = new DeletePolicyTypeOutputBuilder();
 278     try {
 279         String uri = nearRicUrlProvider.getPolicyTypeId(String.valueOf(input.getNearRtRicId()),
 280                 String.valueOf(input.getPolicyTypeId()));
 281         ResponseEntity<Void> response = restAdapter.delete(uri);
 282         responseBuilder.setCode(response.getStatusCode().toString());
 283     } catch (NearRtRicNotFoundException ex) {
 284         log.error("Caught exception: {}", ex);
 285         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 286     } catch (RestClientResponseException ex) {
 287         log.error("Caught exception: {}", ex);
 288         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 289     }
 290     log.info("End of deletePolicyType");
 291     RpcResult<DeletePolicyTypeOutput> rpcResult = RpcResultBuilder
 292         .<DeletePolicyTypeOutput>status(true).withResult(responseBuilder.build()).build();
 293     return Futures.immediateFuture(rpcResult);
 294   }
 295
 296   @Override
 297   public ListenableFuture<RpcResult<GetHealthCheckOutput>> getHealthCheck(
 298       GetHealthCheckInput input) {
 299     log.info("Start of getHealthCheck");
 300     GetHealthCheckOutputBuilder responseBuilder = new GetHealthCheckOutputBuilder();
 301     try {
 302         String uri = nearRicUrlProvider.getHealthCheck(String.valueOf(input.getNearRtRicId()));
 303         ResponseEntity<Object> response = restAdapter.get(uri, Object.class);
 304         responseBuilder.setHealthStatus(false);
 305         if (response.getStatusCode().equals(HttpStatus.OK)) {
 306             responseBuilder.setHealthStatus(true);
 307         }
 308         responseBuilder.setCode(response.getStatusCode().toString());
 309     } catch (NearRtRicNotFoundException ex) {
 310         log.error("Caught exception: {}", ex);
 311         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 312     } catch (RestClientResponseException ex) {
 313         log.error("Caught exception: {}", ex);
 314         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 315     }
 316     log.info("End of getHealthCheck");
 317     RpcResult<GetHealthCheckOutput> rpcResult = RpcResultBuilder.<GetHealthCheckOutput>status(true)
 318         .withResult(responseBuilder.build()).build();
 319     return Futures.immediateFuture(rpcResult);
 320   }
 321
 322   @Override
 323   public ListenableFuture<RpcResult<GetNearRTRICsOutput>> getNearRTRICs(GetNearRTRICsInput input) {
 324       log.info("Start of getNearRTRICs");
 325       GetNearRTRICsOutputBuilder responseBuilder = new GetNearRTRICsOutputBuilder();
 326       responseBuilder.setNearRtRicIdList(nearRicUrlProvider.getNearRTRicIdsList());
 327       responseBuilder.setCode(HttpStatus.OK.toString());
 328       log.info("End of getNearRTRICs");
 329       RpcResult<GetNearRTRICsOutput> rpcResult = RpcResultBuilder.<GetNearRTRICsOutput>status(true)
 330           .withResult(responseBuilder.build()).build();
 331       return Futures.immediateFuture(rpcResult);
 332   }
 333
 334   @Override
 335   public ListenableFuture<RpcResult<GetPolicyInstanceOutput>> getPolicyInstance(
 336       GetPolicyInstanceInput input) {
 337     log.info("Start of getPolicyInstance");
 338     log.info("Policy Type Id : {},  Policy Instance Id : {}", input.getPolicyTypeId(), input.getPolicyInstanceId());
 339     GetPolicyInstanceOutputBuilder responseBuilder = new GetPolicyInstanceOutputBuilder();
 340     try {
 341         String uri = nearRicUrlProvider.getPolicyInstanceId(String.valueOf(input.getNearRtRicId()),
 342                 String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
 343         ResponseEntity<String> response = restAdapter.get(uri, String.class);
 344         if (response.hasBody()) {
 345             log.info("Response getPolicyInstance : {} ", response.getBody());
 346             responseBuilder.setPolicyInstance(response.getBody());
 347         }
 348         responseBuilder.setCode(response.getStatusCode().toString());
 349     } catch (NearRtRicNotFoundException ex) {
 350         log.error("Caught exception: {}", ex);
 351         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 352     } catch (RestClientResponseException ex) {
 353         log.error("Caught exception: {}", ex);
 354         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 355     }
 356     log.info("End of getPolicyInstance");
 357     RpcResult<GetPolicyInstanceOutput> rpcResult = RpcResultBuilder
 358         .<GetPolicyInstanceOutput>status(true).withResult(responseBuilder.build()).build();
 359     return Futures.immediateFuture(rpcResult);
 360   }
 361
 362   @Override
 363   public ListenableFuture<RpcResult<GetPolicyInstancesOutput>> getPolicyInstances(
 364       GetPolicyInstancesInput input) {
 365     log.info("Start of getPolicyInstances");
 366     GetPolicyInstancesOutputBuilder responseBuilder = new GetPolicyInstancesOutputBuilder();
 367     try {
 368         String uri = nearRicUrlProvider.getPolicyInstances(String.valueOf(input.getNearRtRicId()),
 369                 String.valueOf(input.getPolicyTypeId()));
 370         ResponseEntity<List<String>> response = restAdapter.get(uri, List.class);
 371         if (response.hasBody()) {
 372           log.info("Response getPolicyInstances : {} ", response.getBody());
 373           responseBuilder.setPolicyInstanceIdList(response.getBody());
 374         }
 375         responseBuilder.setCode(response.getStatusCode().toString());
 376     } catch (NearRtRicNotFoundException ex) {
 377         log.error("Caught exception: {}", ex);
 378         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 379     } catch (RestClientResponseException ex) {
 380         log.error("Caught exception: {}", ex);
 381         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 382     }
 383     log.info("End of getPolicyInstances");
 384     RpcResult<GetPolicyInstancesOutput> rpcResult = RpcResultBuilder
 385         .<GetPolicyInstancesOutput>status(true).withResult(responseBuilder.build()).build();
 386     return Futures.immediateFuture(rpcResult);
 387   }
 388
 389   @Override
 390   public ListenableFuture<RpcResult<GetPolicyTypeOutput>> getPolicyType(GetPolicyTypeInput input) {
 391     log.info("Start of getPolicyType");
 392     log.info("Policy Type Id : {} ", input.getPolicyTypeId());
 393     GetPolicyTypeOutputBuilder responseBuilder = new GetPolicyTypeOutputBuilder();
 394     try {
 395         String uri = nearRicUrlProvider.getPolicyTypeId(String.valueOf(input.getNearRtRicId()),
 396                 String.valueOf(input.getPolicyTypeId()));
 397         ResponseEntity<String> response = restAdapter.get(uri, String.class);
 398         if (response.hasBody()) {
 399             log.info("Response getPolicyType : {} ", response.getBody());
 400             JSONObject policyTypeObj = new JSONObject(response.getBody());
 401             responseBuilder.setDescription(policyTypeObj.getString("description"));
 402             responseBuilder.setName(policyTypeObj.getString("name"));
 403             responseBuilder.setPolicyType(policyTypeObj.getJSONObject("create_schema").toString());
 404         }
 405         responseBuilder.setCode(response.getStatusCode().toString());
 406     } catch (NearRtRicNotFoundException ex) {
 407         log.error("Caught exception: {}", ex);
 408         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 409     } catch (RestClientResponseException ex) {
 410         log.error("Caught exception: {}", ex);
 411         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 412     }
 413     log.info("End of getPolicyType");
 414     RpcResult<GetPolicyTypeOutput> rpcResult = RpcResultBuilder.<GetPolicyTypeOutput>status(true)
 415         .withResult(responseBuilder.build()).build();
 416     return Futures.immediateFuture(rpcResult);
 417   }
 418
 419   @Override
 420   public ListenableFuture<RpcResult<GetPolicyTypesOutput>> getPolicyTypes(
 421       GetPolicyTypesInput input) {
 422     log.info("Start of getPolicyTypes");
 423     GetPolicyTypesOutputBuilder responseBuilder = new GetPolicyTypesOutputBuilder();
 424     try {
 425         String uri = nearRicUrlProvider.getPolicyTypes(String.valueOf(input.getNearRtRicId()));
 426         ResponseEntity<List<Integer>> response = restAdapter.get(uri, List.class);
 427         if (response.hasBody()) {
 428             log.info("Response getPolicyTypes : {} ", response.getBody());
 429             List<Integer> policyTypesListInteger = response.getBody();
 430             List<Long> policyTypesListLong = new ArrayList<>();
 431             for(Integer i : policyTypesListInteger){
 432                 policyTypesListLong.add(i.longValue());
 433             }
 434             responseBuilder.setPolicyTypeIdList(policyTypesListLong);
 435         }
 436         responseBuilder.setCode(response.getStatusCode().toString());
 437     } catch (NearRtRicNotFoundException ex) {
 438         log.error("Caught exception: {}", ex);
 439         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 440     } catch (RestClientResponseException ex) {
 441         log.error("Caught exception: {}", ex);
 442         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 443     }
 444     log.info("End of getPolicyTypes");
 445     RpcResult<GetPolicyTypesOutput> rpcResult = RpcResultBuilder.<GetPolicyTypesOutput>status(true)
 446         .withResult(responseBuilder.build()).build();
 447     return Futures.immediateFuture(rpcResult);
 448   }
 449
 450   @Override
 451   public ListenableFuture<RpcResult<GetStatusOutput>> getStatus(GetStatusInput input) {
 452     log.info("Start of getStatus");
 453     GetStatusOutputBuilder responseBuilder = new GetStatusOutputBuilder();
 454     try {
 455         String uri = nearRicUrlProvider.getPolicyInstanceIdStatus(String.valueOf(input.getNearRtRicId()),
 456                 String.valueOf(input.getPolicyTypeId()), String.valueOf(input.getPolicyInstanceId()));
 457         ResponseEntity<List<Object>> response = restAdapter.get(uri, List.class);
 458         if (response.hasBody()) {
 459             log.info("Response getStatus : {} ", response.getBody());
 460             // only return the status of first handler for compliance with current yang model, ignore handler_id
 461             JSONObject statusObj = new JSONObject(new Gson().toJson(response.getBody().get(0)));
 462             responseBuilder.setStatus(statusObj.getString("status"));
 463         }
 464         responseBuilder.setCode(response.getStatusCode().toString());
 465     } catch (NearRtRicNotFoundException ex) {
 466         log.error("Caught exception: {}", ex);
 467         responseBuilder.setCode(HttpStatus.INTERNAL_SERVER_ERROR.toString());
 468     } catch (RestClientResponseException ex) {
 469         log.error("Caught exception: {}", ex);
 470         responseBuilder.setCode(String.valueOf(ex.getRawStatusCode()));
 471     }
 472     log.info("End of getStatus");
 473     RpcResult<GetStatusOutput> rpcResult =
 474         RpcResultBuilder.<GetStatusOutput>status(true).withResult(responseBuilder.build()).build();
 475     return Futures.immediateFuture(rpcResult);
 476   }
 477 }