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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020 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.ccsdk.features.a1.adapter;
  22
  23 import static org.apache.http.HttpStatus.SC_INTERNAL_SERVER_ERROR;
  24 import static org.apache.http.HttpStatus.SC_SERVICE_UNAVAILABLE;
  25
  26 import com.google.common.util.concurrent.Futures;
  27 import com.google.common.util.concurrent.ListenableFuture;
  28 import java.lang.reflect.Method;
  29 import java.util.Properties;
  30 import java.util.concurrent.ExecutorService;
  31 import java.util.concurrent.Executors;
  32 import org.onap.ccsdk.sli.core.sli.provider.MdsalHelper;
  33 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  34 import org.opendaylight.mdsal.binding.api.RpcProviderService;
  35 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.A1ADAPTERAPIService;
  36 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.DeleteA1PolicyInput;
  37 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.DeleteA1PolicyInputBuilder;
  38 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.DeleteA1PolicyOutput;
  39 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.DeleteA1PolicyOutputBuilder;
  40 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyInput;
  41 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyInputBuilder;
  42 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyOutput;
  43 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyOutputBuilder;
  44 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyStatusInput;
  45 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyStatusInputBuilder;
  46 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyStatusOutput;
  47 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyStatusOutputBuilder;
  48 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyTypeInput;
  49 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyTypeInputBuilder;
  50 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyTypeOutput;
  51 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.GetA1PolicyTypeOutputBuilder;
  52 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.PutA1PolicyInput;
  53 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.PutA1PolicyInputBuilder;
  54 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.PutA1PolicyOutput;
  55 import org.opendaylight.yang.gen.v1.org.onap.a1.adapter.rev200122.PutA1PolicyOutputBuilder;
  56 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  57 import org.opendaylight.yangtools.yang.common.RpcResult;
  58 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  59 import org.slf4j.Logger;
  60 import org.slf4j.LoggerFactory;
  61
  62 /**
  63  * This class implements the generated interface from the YANG model and implements the request model for the A1
  64  * interface. This class identifies the Near-RT RIC throughout the IP passed over the payload and calls the
  65  * corresponding Near-RT RIC over Rest API.
  66  */
  67 @SuppressWarnings("squid:S1874") // "@Deprecated" code should not be used
  68 public class A1AdapterProvider implements AutoCloseable, A1ADAPTERAPIService {
  69
  70     private static final String START_OPERATION_MESSAGE = "Start of {}";
  71     private static final String END_OPERATION_MESSAGE = "End of {}";
  72
  73     private static final String A1_ADAPTER_API = "A1-ADAPTER-API";
  74     private static final String RESPONSE_BODY = "responseBody";
  75     private static final String RESPONSE_CODE = "response-code";
  76     private static final String SYNC = "sync";
  77
  78     private static final Logger log = LoggerFactory.getLogger(A1AdapterProvider.class);
  79
  80     private static final String APPLICATION_NAME = "a1Adapter-api";
  81
  82     private final ExecutorService executor;
  83     protected NotificationPublishService notificationService;
  84     protected RpcProviderService rpcService;
  85     private final A1AdapterClient a1AdapterClient;
  86     private ObjectRegistration<A1ADAPTERAPIService> rpcRegistration;
  87
  88     public A1AdapterProvider(final NotificationPublishService notificationPublishService,
  89         final RpcProviderService rpcProviderService, final A1AdapterClient a1AdapterClient) {
  90
  91         log.info("Creating provider for {}", APPLICATION_NAME);
  92         executor = Executors.newFixedThreadPool(1);
  93         this.notificationService = notificationPublishService;
  94         this.rpcService = rpcProviderService;
  95         this.a1AdapterClient = a1AdapterClient;
  96         initialize();
  97     }
  98
  99     public void initialize() {
 100         log.info("Initializing provider for {}", APPLICATION_NAME);
 101         rpcRegistration = rpcService.registerRpcImplementation(A1ADAPTERAPIService.class, this);
 102         log.info("Initialization complete for {}", APPLICATION_NAME);
 103     }
 104
 105     @Override
 106     public void close() throws Exception {
 107         log.info("Closing provider for {}", APPLICATION_NAME);
 108         executor.shutdown();
 109         rpcRegistration.close();
 110         log.info("Successfully closed provider for {}", APPLICATION_NAME);
 111     }
 112
 113     @Override
 114     public ListenableFuture<RpcResult<DeleteA1PolicyOutput>> deleteA1Policy(DeleteA1PolicyInput deletePolicyInput) {
 115         final String svcOperation = "deleteA1Policy";
 116         log.info(START_OPERATION_MESSAGE, svcOperation);
 117         DeleteA1PolicyOutputBuilder deletePolicyResponse = new DeleteA1PolicyOutputBuilder();
 118         setUpAndExecuteOperation(svcOperation, new DeleteA1PolicyInputBuilder(deletePolicyInput), deletePolicyResponse);
 119
 120         RpcResult<DeleteA1PolicyOutput> deletePolicyResult =
 121             RpcResultBuilder.<DeleteA1PolicyOutput>status(true).withResult(deletePolicyResponse.build()).build();
 122         log.info(END_OPERATION_MESSAGE, svcOperation);
 123         return Futures.immediateFuture(deletePolicyResult);
 124     }
 125
 126     @Override
 127     public ListenableFuture<RpcResult<GetA1PolicyOutput>> getA1Policy(GetA1PolicyInput getPolicyInput) {
 128         final String svcOperation = "getA1Policy";
 129         log.info(START_OPERATION_MESSAGE, svcOperation);
 130         GetA1PolicyOutputBuilder getPolicyResponse = new GetA1PolicyOutputBuilder();
 131         setUpAndExecuteOperation(svcOperation, new GetA1PolicyInputBuilder(getPolicyInput), getPolicyResponse);
 132
 133         RpcResult<GetA1PolicyOutput> getPolicyResult =
 134             RpcResultBuilder.<GetA1PolicyOutput>status(true).withResult(getPolicyResponse.build()).build();
 135         log.info(END_OPERATION_MESSAGE, svcOperation);
 136         return Futures.immediateFuture(getPolicyResult);
 137     }
 138
 139     @Override
 140     public ListenableFuture<RpcResult<GetA1PolicyStatusOutput>> getA1PolicyStatus(
 141         GetA1PolicyStatusInput getPolicyStatusInput) {
 142         final String svcOperation = "getA1PolicyStatus";
 143         log.info(START_OPERATION_MESSAGE, svcOperation);
 144         GetA1PolicyStatusOutputBuilder getPolicyStatusResponse = new GetA1PolicyStatusOutputBuilder();
 145         setUpAndExecuteOperation(svcOperation, new GetA1PolicyStatusInputBuilder(getPolicyStatusInput),
 146             getPolicyStatusResponse);
 147
 148         RpcResult<GetA1PolicyStatusOutput> getPolicyStatusResult =
 149             RpcResultBuilder.<GetA1PolicyStatusOutput>status(true).withResult(getPolicyStatusResponse.build()).build();
 150         log.info(END_OPERATION_MESSAGE, svcOperation);
 151         return Futures.immediateFuture(getPolicyStatusResult);
 152     }
 153
 154     @Override
 155     public ListenableFuture<RpcResult<GetA1PolicyTypeOutput>> getA1PolicyType(GetA1PolicyTypeInput getPolicyTypeInput) {
 156         final String svcOperation = "getA1PolicyType";
 157         log.info(START_OPERATION_MESSAGE, svcOperation);
 158         GetA1PolicyTypeOutputBuilder getPolicyTypeResponse = new GetA1PolicyTypeOutputBuilder();
 159         setUpAndExecuteOperation(svcOperation, new GetA1PolicyTypeInputBuilder(getPolicyTypeInput),
 160             getPolicyTypeResponse);
 161
 162         RpcResult<GetA1PolicyTypeOutput> getPolicyTypeResult =
 163             RpcResultBuilder.<GetA1PolicyTypeOutput>status(true).withResult(getPolicyTypeResponse.build()).build();
 164         log.info(END_OPERATION_MESSAGE, svcOperation);
 165         return Futures.immediateFuture(getPolicyTypeResult);
 166     }
 167
 168     @Override
 169     public ListenableFuture<RpcResult<PutA1PolicyOutput>> putA1Policy(PutA1PolicyInput putPolicyInput) {
 170         final String svcOperation = "putA1Policy";
 171         log.info(START_OPERATION_MESSAGE, svcOperation);
 172         PutA1PolicyOutputBuilder putPolicyResponse = new PutA1PolicyOutputBuilder();
 173         setUpAndExecuteOperation(svcOperation, new PutA1PolicyInputBuilder(putPolicyInput), putPolicyResponse);
 174
 175         RpcResult<PutA1PolicyOutput> putPolicyResult =
 176             RpcResultBuilder.<PutA1PolicyOutput>status(true).withResult(putPolicyResponse.build()).build();
 177         log.info(END_OPERATION_MESSAGE, svcOperation);
 178         return Futures.immediateFuture(putPolicyResult);
 179     }
 180
 181     private boolean hasGraph(final String svcOperation, DeleteA1PolicyOutputBuilder response) {
 182         try {
 183             return a1AdapterClient.hasGraph(A1_ADAPTER_API, svcOperation, null, SYNC);
 184         } catch (Exception e) {
 185             log.error("Caught exception looking for service logic, {}", e.getMessage());
 186             setHttpResponse(response, SC_INTERNAL_SERVER_ERROR);
 187         }
 188         return false;
 189     }
 190
 191     private boolean hasGraph(final String svcOperation, GetA1PolicyOutputBuilder response) {
 192         try {
 193             return a1AdapterClient.hasGraph(A1_ADAPTER_API, svcOperation, null, SYNC);
 194         } catch (Exception e) {
 195             log.error("Caught exception looking for service logic, {}", e.getMessage());
 196             setHttpResponse(response, SC_INTERNAL_SERVER_ERROR);
 197         }
 198         return false;
 199     }
 200
 201     private boolean hasGraph(final String svcOperation, GetA1PolicyStatusOutputBuilder response) {
 202         try {
 203             return a1AdapterClient.hasGraph(A1_ADAPTER_API, svcOperation, null, SYNC);
 204         } catch (Exception e) {
 205             log.error("Caught exception looking for service logic, {}", e.getMessage());
 206             setHttpResponse(response, SC_INTERNAL_SERVER_ERROR);
 207         }
 208         return false;
 209     }
 210
 211     private boolean hasGraph(final String svcOperation, GetA1PolicyTypeOutputBuilder response) {
 212         try {
 213             return a1AdapterClient.hasGraph(A1_ADAPTER_API, svcOperation, null, SYNC);
 214         } catch (Exception e) {
 215             log.error("Caught exception looking for service logic, {}", e.getMessage());
 216             setHttpResponse(response, SC_INTERNAL_SERVER_ERROR);
 217         }
 218         return false;
 219     }
 220
 221     private boolean hasGraph(final String svcOperation, PutA1PolicyOutputBuilder response) {
 222         try {
 223             return a1AdapterClient.hasGraph(A1_ADAPTER_API, svcOperation, null, SYNC);
 224         } catch (Exception e) {
 225             log.error("Caught exception looking for service logic, {}", e.getMessage());
 226             setHttpResponse(response, SC_INTERNAL_SERVER_ERROR);
 227         }
 228         return false;
 229     }
 230
 231     private void setUpAndExecuteOperation(final String svcOperation, DeleteA1PolicyInputBuilder inputBuilder,
 232         DeleteA1PolicyOutputBuilder responseBuilder) {
 233         log.info("Adding INPUT data for {} input: {}", svcOperation, inputBuilder);
 234         // add input to parms
 235         Properties parms = new Properties();
 236         MdsalHelper.toProperties(parms, inputBuilder.build());
 237         logSliParameters(parms);
 238         // Call SLI sync method
 239         if (hasGraph(svcOperation, responseBuilder)) {
 240             log.info("A1AdapterClient has a Directed Graph for '{}'", svcOperation);
 241             executeOperation(svcOperation, parms, responseBuilder);
 242         } else {
 243             log.error("No service logic active for A1Adapter: '{}'", svcOperation);
 244             setHttpResponse(responseBuilder, Integer.valueOf(SC_SERVICE_UNAVAILABLE));
 245         }
 246     }
 247
 248     private void setUpAndExecuteOperation(final String svcOperation, GetA1PolicyInputBuilder inputBuilder,
 249                                                  GetA1PolicyOutputBuilder responseBuilder) {
 250         log.info("Adding INPUT data for {} input: {}", svcOperation, inputBuilder);
 251         // add input to parms
 252         Properties parms = new Properties();
 253         MdsalHelper.toProperties(parms, inputBuilder.build());
 254         logSliParameters(parms);
 255         // Call SLI sync method
 256         if (hasGraph(svcOperation, responseBuilder)) {
 257             log.info("A1AdapterClient has a Directed Graph for '{}'", svcOperation);
 258             executeOperation(svcOperation, parms, responseBuilder);
 259         } else {
 260             log.error("No service logic active for A1Adapter: '{}'", svcOperation);
 261             setHttpResponse(responseBuilder, Integer.valueOf(SC_SERVICE_UNAVAILABLE));
 262         }
 263     }
 264
 265     private void setUpAndExecuteOperation(final String svcOperation, GetA1PolicyStatusInputBuilder inputBuilder,
 266                                           GetA1PolicyStatusOutputBuilder responseBuilder) {
 267         log.info("Adding INPUT data for {} input: {}", svcOperation, inputBuilder);
 268         // add input to parms
 269         Properties parms = new Properties();
 270         MdsalHelper.toProperties(parms, inputBuilder.build());
 271         logSliParameters(parms);
 272         // Call SLI sync method
 273         if (hasGraph(svcOperation, responseBuilder)) {
 274             log.info("A1AdapterClient has a Directed Graph for '{}'", svcOperation);
 275             executeOperation(svcOperation, parms, responseBuilder);
 276         } else {
 277             log.error("No service logic active for A1Adapter: '{}'", svcOperation);
 278             setHttpResponse(responseBuilder, Integer.valueOf(SC_SERVICE_UNAVAILABLE));
 279         }
 280     }
 281
 282     private void setUpAndExecuteOperation(final String svcOperation, GetA1PolicyTypeInputBuilder inputBuilder,
 283                                           GetA1PolicyTypeOutputBuilder responseBuilder) {
 284         log.info("Adding INPUT data for {} input: {}", svcOperation, inputBuilder);
 285         // add input to parms
 286         Properties parms = new Properties();
 287         MdsalHelper.toProperties(parms, inputBuilder.build());
 288         logSliParameters(parms);
 289         // Call SLI sync method
 290         if (hasGraph(svcOperation, responseBuilder)) {
 291             log.info("A1AdapterClient has a Directed Graph for '{}'", svcOperation);
 292             executeOperation(svcOperation, parms, responseBuilder);
 293         } else {
 294             log.error("No service logic active for A1Adapter: '{}'", svcOperation);
 295             setHttpResponse(responseBuilder, Integer.valueOf(SC_SERVICE_UNAVAILABLE));
 296         }
 297     }
 298
 299     private void setUpAndExecuteOperation(final String svcOperation, PutA1PolicyInputBuilder inputBuilder,
 300                                                  PutA1PolicyOutputBuilder responseBuilder) {
 301         log.info("Adding INPUT data for {} input: {}", svcOperation, inputBuilder);
 302         // add input to parms
 303         Properties parms = new Properties();
 304         MdsalHelper.toProperties(parms, inputBuilder.build());
 305         logSliParameters(parms);
 306         // Call SLI sync method
 307         if (hasGraph(svcOperation, responseBuilder)) {
 308             log.info("A1AdapterClient has a Directed Graph for '{}'", svcOperation);
 309             executeOperation(svcOperation, parms, responseBuilder);
 310         } else {
 311             log.error("No service logic active for A1Adapter: '{}'", svcOperation);
 312             setHttpResponse(responseBuilder, Integer.valueOf(SC_SERVICE_UNAVAILABLE));
 313         }
 314     }
 315
 316     private  void executeOperation(final String svcOperation, Properties parms, DeleteA1PolicyOutputBuilder response) {
 317         try {
 318             Properties responseParms =
 319                 a1AdapterClient.execute(A1_ADAPTER_API, svcOperation, null, SYNC, response, parms);
 320             logResponse(responseParms);
 321             setBody(response, responseParms.getProperty(RESPONSE_BODY));
 322             setHttpResponse(response, Integer.valueOf(responseParms.getProperty(RESPONSE_CODE)));
 323         } catch (Exception e) {
 324             log.error("Caught exception executing service logic for {}, {}", svcOperation, e.getMessage());
 325             setHttpResponse(response, Integer.valueOf(SC_INTERNAL_SERVER_ERROR));
 326         }
 327     }
 328
 329     private  void executeOperation(final String svcOperation, Properties parms, GetA1PolicyOutputBuilder response) {
 330         try {
 331             Properties responseParms =
 332                     a1AdapterClient.execute(A1_ADAPTER_API, svcOperation, null, SYNC, response, parms);
 333             logResponse(responseParms);
 334             setBody(response, responseParms.getProperty(RESPONSE_BODY));
 335             setHttpResponse(response, Integer.valueOf(responseParms.getProperty(RESPONSE_CODE)));
 336         } catch (Exception e) {
 337             log.error("Caught exception executing service logic for {}, {}", svcOperation, e.getMessage());
 338             setHttpResponse(response, Integer.valueOf(SC_INTERNAL_SERVER_ERROR));
 339         }
 340     }
 341
 342     private  void executeOperation(final String svcOperation, Properties parms, GetA1PolicyStatusOutputBuilder response) {
 343         try {
 344             Properties responseParms =
 345                     a1AdapterClient.execute(A1_ADAPTER_API, svcOperation, null, SYNC, response, parms);
 346             logResponse(responseParms);
 347             setBody(response, responseParms.getProperty(RESPONSE_BODY));
 348             setHttpResponse(response, Integer.valueOf(responseParms.getProperty(RESPONSE_CODE)));
 349         } catch (Exception e) {
 350             log.error("Caught exception executing service logic for {}, {}", svcOperation, e.getMessage());
 351             setHttpResponse(response, Integer.valueOf(SC_INTERNAL_SERVER_ERROR));
 352         }
 353     }
 354
 355     private  void executeOperation(final String svcOperation, Properties parms, GetA1PolicyTypeOutputBuilder response) {
 356         try {
 357             Properties responseParms =
 358                     a1AdapterClient.execute(A1_ADAPTER_API, svcOperation, null, SYNC, response, parms);
 359             logResponse(responseParms);
 360             setBody(response, responseParms.getProperty(RESPONSE_BODY));
 361             setHttpResponse(response, Integer.valueOf(responseParms.getProperty(RESPONSE_CODE)));
 362         } catch (Exception e) {
 363             log.error("Caught exception executing service logic for {}, {}", svcOperation, e.getMessage());
 364             setHttpResponse(response, Integer.valueOf(SC_INTERNAL_SERVER_ERROR));
 365         }
 366     }
 367
 368     private  void executeOperation(final String svcOperation, Properties parms, PutA1PolicyOutputBuilder response) {
 369         try {
 370             Properties responseParms =
 371                     a1AdapterClient.execute(A1_ADAPTER_API, svcOperation, null, SYNC, response, parms);
 372             logResponse(responseParms);
 373             setBody(response, responseParms.getProperty(RESPONSE_BODY));
 374             setHttpResponse(response, Integer.valueOf(responseParms.getProperty(RESPONSE_CODE)));
 375         } catch (Exception e) {
 376             log.error("Caught exception executing service logic for {}, {}", svcOperation, e.getMessage());
 377             setHttpResponse(response, Integer.valueOf(SC_INTERNAL_SERVER_ERROR));
 378         }
 379     }
 380
 381     private void setBody(DeleteA1PolicyOutputBuilder responseBuilder, String body) {
 382         try {
 383             Method method = responseBuilder.getClass().getMethod("setBody", String.class);
 384             method.invoke(responseBuilder, body);
 385         } catch (Exception reflectionException) {
 386             throw new MissingResponseMethodRuntimeException(reflectionException);
 387         }
 388     }
 389
 390     private void setBody(GetA1PolicyOutputBuilder responseBuilder, String body) {
 391         try {
 392             Method method = responseBuilder.getClass().getMethod("setBody", String.class);
 393             method.invoke(responseBuilder, body);
 394         } catch (Exception reflectionException) {
 395             throw new MissingResponseMethodRuntimeException(reflectionException);
 396         }
 397     }
 398
 399     private void setBody(GetA1PolicyStatusOutputBuilder responseBuilder, String body) {
 400         try {
 401             Method method = responseBuilder.getClass().getMethod("setBody", String.class);
 402             method.invoke(responseBuilder, body);
 403         } catch (Exception reflectionException) {
 404             throw new MissingResponseMethodRuntimeException(reflectionException);
 405         }
 406     }
 407
 408     private void setBody(GetA1PolicyTypeOutputBuilder responseBuilder, String body) {
 409         try {
 410             Method method = responseBuilder.getClass().getMethod("setBody", String.class);
 411             method.invoke(responseBuilder, body);
 412         } catch (Exception reflectionException) {
 413             throw new MissingResponseMethodRuntimeException(reflectionException);
 414         }
 415     }
 416
 417     private void setBody(PutA1PolicyOutputBuilder responseBuilder, String body) {
 418         try {
 419             Method method = responseBuilder.getClass().getMethod("setBody", String.class);
 420             method.invoke(responseBuilder, body);
 421         } catch (Exception reflectionException) {
 422             throw new MissingResponseMethodRuntimeException(reflectionException);
 423         }
 424     }
 425
 426     private void setHttpResponse(DeleteA1PolicyOutputBuilder responseBuilder, Integer response) {
 427         try {
 428             Method method = responseBuilder.getClass().getMethod("setHttpStatus", Integer.class);
 429             method.invoke(responseBuilder, response);
 430         } catch (Exception reflectionException) {
 431             throw new MissingResponseMethodRuntimeException(reflectionException);
 432         }
 433     }
 434
 435     private void setHttpResponse(GetA1PolicyOutputBuilder responseBuilder, Integer response) {
 436         try {
 437             Method method = responseBuilder.getClass().getMethod("setHttpStatus", Integer.class);
 438             method.invoke(responseBuilder, response);
 439         } catch (Exception reflectionException) {
 440             throw new MissingResponseMethodRuntimeException(reflectionException);
 441         }
 442     }
 443
 444     private void setHttpResponse(GetA1PolicyStatusOutputBuilder responseBuilder, Integer response) {
 445         try {
 446             Method method = responseBuilder.getClass().getMethod("setHttpStatus", Integer.class);
 447             method.invoke(responseBuilder, response);
 448         } catch (Exception reflectionException) {
 449             throw new MissingResponseMethodRuntimeException(reflectionException);
 450         }
 451     }
 452
 453     private void setHttpResponse(GetA1PolicyTypeOutputBuilder responseBuilder, Integer response) {
 454         try {
 455             Method method = responseBuilder.getClass().getMethod("setHttpStatus", Integer.class);
 456             method.invoke(responseBuilder, response);
 457         } catch (Exception reflectionException) {
 458             throw new MissingResponseMethodRuntimeException(reflectionException);
 459         }
 460     }
 461
 462     private void setHttpResponse(PutA1PolicyOutputBuilder responseBuilder, Integer response) {
 463         try {
 464             Method method = responseBuilder.getClass().getMethod("setHttpStatus", Integer.class);
 465             method.invoke(responseBuilder, response);
 466         } catch (Exception reflectionException) {
 467             throw new MissingResponseMethodRuntimeException(reflectionException);
 468         }
 469     }
 470
 471     private void logSliParameters(Properties parms) {
 472         log.info("Printing SLI parameters to be passed");
 473         // iterate properties file to get key-value pairs
 474         for (String key : parms.stringPropertyNames()) {
 475             String value = parms.getProperty(key);
 476             log.info("The SLI parameter in {} is: {}", key, value);
 477         }
 478     }
 479
 480     private void logResponse(Properties responseParms) {
 481         log.info("responseBody::{}", responseParms.getProperty(RESPONSE_BODY));
 482         log.info("responseCode::{}", responseParms.getProperty(RESPONSE_CODE));
 483         log.info("responseMessage::{}", responseParms.getProperty("response-message"));
 484     }
 485
 486     public class MissingResponseMethodRuntimeException extends RuntimeException {
 487         private static final long serialVersionUID = -6803869291161765099L;
 488
 489         MissingResponseMethodRuntimeException(Exception e) {
 490             super(e);
 491         }
 492     }
 493 }