ONAP-PDP-REST/src/main/java/org/onap/policy/pdp/rest/api/controller/PolicyEngineServices.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PDP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pdp.rest.api.controller;
  22
  23 import java.lang.reflect.InvocationTargetException;
  24 import java.util.Collection;
  25 import java.util.concurrent.atomic.AtomicLong;
  26 import javax.servlet.http.HttpServletRequest;
  27 import org.onap.policy.api.ConfigNameRequest;
  28 import org.onap.policy.api.ConfigRequestParameters;
  29 import org.onap.policy.api.DecisionRequestParameters;
  30 import org.onap.policy.api.DecisionResponse;
  31 import org.onap.policy.api.DeletePolicyParameters;
  32 import org.onap.policy.api.DictionaryParameters;
  33 import org.onap.policy.api.DictionaryResponse;
  34 import org.onap.policy.api.EventRequestParameters;
  35 import org.onap.policy.api.MetricsResponse;
  36 import org.onap.policy.api.PolicyParameters;
  37 import org.onap.policy.api.PolicyResponse;
  38 import org.onap.policy.api.PushPolicyParameters;
  39 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  40 import org.onap.policy.common.logging.flexlogger.Logger;
  41 import org.onap.policy.pdp.rest.XACMLPdpServlet;
  42 import org.onap.policy.pdp.rest.api.models.ConfigFirewallPolicyAPIRequest;
  43 import org.onap.policy.pdp.rest.api.models.ConfigPolicyAPIRequest;
  44 import org.onap.policy.pdp.rest.api.models.PolicyConfig;
  45 import org.onap.policy.pdp.rest.api.services.CreateUpdateConfigPolicyService;
  46 import org.onap.policy.pdp.rest.api.services.CreateUpdateDictionaryService;
  47 import org.onap.policy.pdp.rest.api.services.CreateUpdateFirewallPolicyService;
  48 import org.onap.policy.pdp.rest.api.services.CreateUpdatePolicyService;
  49 import org.onap.policy.pdp.rest.api.services.DeletePolicyService;
  50 import org.onap.policy.pdp.rest.api.services.GetConfigService;
  51 import org.onap.policy.pdp.rest.api.services.GetDecisionService;
  52 import org.onap.policy.pdp.rest.api.services.GetDictionaryService;
  53 import org.onap.policy.pdp.rest.api.services.GetMetricsService;
  54 import org.onap.policy.pdp.rest.api.services.ListConfigService;
  55 import org.onap.policy.pdp.rest.api.services.ListPolicyService;
  56 import org.onap.policy.pdp.rest.api.services.NotificationService;
  57 import org.onap.policy.pdp.rest.api.services.NotificationService.NotificationServiceType;
  58 import org.onap.policy.pdp.rest.api.services.PolicyEngineImportService;
  59 import org.onap.policy.pdp.rest.api.services.PushPolicyService;
  60 import org.onap.policy.pdp.rest.api.services.SendEventService;
  61 import org.onap.policy.pdp.rest.config.PDPApiAuth;
  62 import org.springframework.http.HttpStatus;
  63 import org.springframework.http.ResponseEntity;
  64 import org.springframework.http.converter.HttpMessageNotReadableException;
  65 import org.springframework.web.bind.annotation.ExceptionHandler;
  66 import org.springframework.web.bind.annotation.PostMapping;
  67 import org.springframework.web.bind.annotation.RequestBody;
  68 import org.springframework.web.bind.annotation.RequestHeader;
  69 import org.springframework.web.bind.annotation.RequestMapping;
  70 import org.springframework.web.bind.annotation.RequestMethod;
  71 import org.springframework.web.bind.annotation.RequestParam;
  72 import org.springframework.web.bind.annotation.ResponseBody;
  73 import org.springframework.web.bind.annotation.RestController;
  74 import org.springframework.web.multipart.MultipartFile;
  75 import io.swagger.annotations.Api;
  76 import io.swagger.annotations.ApiImplicitParam;
  77 import io.swagger.annotations.ApiImplicitParams;
  78 import io.swagger.annotations.ApiOperation;
  79 import springfox.documentation.annotations.ApiIgnore;
  80
  81 @RestController
  82 @Api(value = "Policy Engine Services")
  83 @RequestMapping("/")
  84 public class PolicyEngineServices {
  85     private static Logger logger = FlexLogger.getLogger(PolicyEngineServices.class.getName());
  86     private static final String NOTIFICATIONPERM = "notification";
  87
  88     private final AtomicLong configCounter = new AtomicLong();
  89     private final AtomicLong configNameCounter = new AtomicLong();
  90     private final AtomicLong eventCounter = new AtomicLong();
  91     private final AtomicLong decisionCounter = new AtomicLong();
  92     private final AtomicLong pushCounter = new AtomicLong();
  93     private final AtomicLong deleteCounter = new AtomicLong();
  94     private final AtomicLong createPolicyCounter = new AtomicLong();
  95     private final AtomicLong updatePolicyCounter = new AtomicLong();
  96     private final AtomicLong createDictionaryCounter = new AtomicLong();
  97     private final AtomicLong updateDictionaryCounter = new AtomicLong();
  98     private final AtomicLong getDictionaryCounter = new AtomicLong();
  99     private final AtomicLong policyEngineImportCounter = new AtomicLong();
 100     private final AtomicLong deprecatedCounter = new AtomicLong();
 101     private final AtomicLong metricCounter = new AtomicLong();
 102     private final AtomicLong notificationCounter = new AtomicLong();
 103
 104     /**
 105      * Gets the config.
 106      *
 107      * @param configRequestParameters the config request parameters
 108      * @param clientEncoding the client encoding
 109      * @param requestId the request ID
 110      * @return the config
 111      */
 112     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 113             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 114     @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP)")
 115     @RequestMapping(value = "/getConfig", method = RequestMethod.POST)
 116     @ResponseBody
 117     public ResponseEntity<Collection<PolicyConfig>> getConfig(
 118             @RequestBody ConfigRequestParameters configRequestParameters,
 119             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 120             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 121         Collection<PolicyConfig> policyConfig = null;
 122         HttpStatus status = HttpStatus.UNAUTHORIZED;
 123         // Check Permissions.
 124         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getConfig")) {
 125             GetConfigService getConfigService = new GetConfigService(configRequestParameters, requestID);
 126             policyConfig = getConfigService.getResult();
 127             status = getConfigService.getResponseCode();
 128         }
 129         configCounter.incrementAndGet();
 130         return new ResponseEntity<>(policyConfig, status);
 131     }
 132
 133     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 134             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 135     @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP) using PolicyName")
 136     @RequestMapping(value = "/getConfigByPolicyName", method = RequestMethod.POST)
 137     @ResponseBody
 138     @Deprecated
 139     public ResponseEntity<Collection<PolicyConfig>> getConfigByPolicyName(
 140             @RequestBody ConfigNameRequest configNameRequest,
 141             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 142             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 143         Collection<PolicyConfig> policyConfig = null;
 144         HttpStatus status = HttpStatus.UNAUTHORIZED;
 145         // Check Permissions.
 146         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getConfigByPolicyName")) {
 147             ConfigRequestParameters configRequestParameters = new ConfigRequestParameters();
 148             configRequestParameters.setPolicyName(configNameRequest.getPolicyName());
 149             GetConfigService getConfigService = new GetConfigService(configRequestParameters, requestID);
 150             policyConfig = getConfigService.getResult();
 151             status = getConfigService.getResponseCode();
 152         }
 153         configNameCounter.incrementAndGet();
 154         return new ResponseEntity<>(policyConfig, status);
 155     }
 156
 157     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 158             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 159     @ApiOperation(value = "Gets the list of configuration policies from the PDP")
 160     @RequestMapping(value = "/listConfig", method = RequestMethod.POST)
 161     @ResponseBody
 162     public ResponseEntity<Collection<String>> listConfig(@RequestBody ConfigRequestParameters configRequestParameters,
 163             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 164             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 165         Collection<String> results = null;
 166         HttpStatus status = HttpStatus.UNAUTHORIZED;
 167         // Check Permissions.
 168         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "listConfig")) {
 169             ListConfigService listConfigService = new ListConfigService(configRequestParameters, requestID);
 170             results = listConfigService.getResult();
 171             status = listConfigService.getResponseCode();
 172         }
 173         configCounter.incrementAndGet();
 174         return new ResponseEntity<>(results, status);
 175     }
 176
 177     /**
 178      * List Policy.
 179      *
 180      * @param ConfigNameRequest the config request parameters
 181      * @param clientEncoding the client encoding
 182      * @param requestId the request ID
 183      * @return the response entity
 184      */
 185     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 186             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 187     @ApiOperation(value = "Gets the list of policies from the PDP")
 188     @PostMapping(value = "/listPolicy")
 189     @ResponseBody
 190     public ResponseEntity<Collection<String>> listPolicy(@RequestBody ConfigNameRequest configNameRequest,
 191             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 192             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestId) {
 193         Collection<String> results = null;
 194         HttpStatus status = HttpStatus.UNAUTHORIZED;
 195         logger.info("Operation: listPolicy - " + configNameRequest);
 196         // Check Permissions.
 197         if (PDPApiAuth.checkPermissions(clientEncoding, requestId, "listPolicy")) {
 198             ListPolicyService listPolicyService = new ListPolicyService(configNameRequest);
 199             results = listPolicyService.getResult();
 200             status = listPolicyService.getResponseCode();
 201         }
 202         configCounter.incrementAndGet();
 203         return new ResponseEntity<>(results, status);
 204     }
 205
 206     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 207             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 208     @ApiOperation(value = "Gets the policy metrics from the PolicyAccessPoint(PAP)")
 209     @RequestMapping(value = "/getMetrics", method = RequestMethod.GET)
 210     @ResponseBody
 211     public ResponseEntity<MetricsResponse> getMetrics(
 212             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 213             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 214         MetricsResponse response = null;
 215         HttpStatus status = HttpStatus.UNAUTHORIZED;
 216         // Check Permissions.
 217         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getMetrics")) {
 218             GetMetricsService getMetricsService = new GetMetricsService(requestID);
 219             response = getMetricsService.getResult();
 220             status = getMetricsService.getResponseCode();
 221         }
 222         metricCounter.incrementAndGet();
 223         return new ResponseEntity<>(response, status);
 224     }
 225
 226     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 227             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 228     @ApiOperation(value = "Registers DMaaP Topic to recieve notification from Policy Engine")
 229     @RequestMapping(value = "/getNotification", method = RequestMethod.POST)
 230     @ResponseBody
 231     public ResponseEntity<String> getNotification(@RequestBody String notificationTopic,
 232             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 233             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 234         String policyResponse = "Error Unauthorized to use Notification Service.";
 235         HttpStatus status = HttpStatus.UNAUTHORIZED;
 236         // Check Permissions.
 237         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
 238             NotificationService notificationService =
 239                     new NotificationService(notificationTopic, requestID, NotificationServiceType.ADD);
 240             policyResponse = notificationService.getResult();
 241             status = notificationService.getResponseCode();
 242         }
 243         notificationCounter.incrementAndGet();
 244         return new ResponseEntity<>(policyResponse, status);
 245     }
 246
 247     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 248             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 249     @ApiOperation(value = "De-Registers DMaaP Topic to stop recieving notifications from Policy Engine")
 250     @RequestMapping(value = "/stopNotification", method = RequestMethod.POST)
 251     @ResponseBody
 252     public ResponseEntity<String> stopNotification(@RequestBody String notificationTopic,
 253             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 254             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 255         String policyResponse = "Error Unauthorized to use Notification Service.";
 256         HttpStatus status = HttpStatus.UNAUTHORIZED;
 257         // Check Permissions.
 258         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
 259             NotificationService notificationService =
 260                     new NotificationService(notificationTopic, requestID, NotificationServiceType.REMOVE);
 261             policyResponse = notificationService.getResult();
 262             status = notificationService.getResponseCode();
 263         }
 264         notificationCounter.incrementAndGet();
 265         return new ResponseEntity<>(policyResponse, status);
 266     }
 267
 268     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 269             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 270     @ApiOperation(
 271             value = "Sends Heartbeat to DMaaP Topic Registry to continue recieving notifications from Policy Engine")
 272     @RequestMapping(value = "/sendHeartbeat", method = RequestMethod.POST)
 273     @ResponseBody
 274     public ResponseEntity<String> sendHeartbeat(@RequestBody String notificationTopic,
 275             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 276             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 277         String policyResponse = "Error Unauthorized to use Heartbeat Service.";
 278         HttpStatus status = HttpStatus.UNAUTHORIZED;
 279         // Check Permissions.
 280         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
 281             NotificationService notificationService =
 282                     new NotificationService(notificationTopic, requestID, NotificationServiceType.HB);
 283             policyResponse = notificationService.getResult();
 284             status = notificationService.getResponseCode();
 285         }
 286         return new ResponseEntity<>(policyResponse, status);
 287     }
 288
 289     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 290             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 291     @ApiOperation(value = "Sends the Events specified to the Policy Engine")
 292     @RequestMapping(value = "/sendEvent", method = RequestMethod.POST)
 293     @ResponseBody
 294     public ResponseEntity<Collection<PolicyResponse>> sendEvent(
 295             @RequestBody EventRequestParameters eventRequestParameters,
 296             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 297             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 298         Collection<PolicyResponse> policyResponse = null;
 299         HttpStatus status = HttpStatus.UNAUTHORIZED;
 300         // Check Permissions.
 301         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "sendEvent")) {
 302             SendEventService sendEventService = new SendEventService(eventRequestParameters, requestID);
 303             policyResponse = sendEventService.getResult();
 304             status = sendEventService.getResponseCode();
 305         }
 306         eventCounter.incrementAndGet();
 307         return new ResponseEntity<>(policyResponse, status);
 308     }
 309
 310     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 311             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 312     @ApiOperation(value = "Gets the Decision using specified decision parameters")
 313     @RequestMapping(value = "/getDecision", method = RequestMethod.POST)
 314     @ResponseBody
 315     public ResponseEntity<DecisionResponse> getDecision(
 316             @RequestBody DecisionRequestParameters decisionRequestParameters,
 317             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 318             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 319         DecisionResponse decisionResponse = null;
 320         HttpStatus status = HttpStatus.UNAUTHORIZED;
 321         // Check Permissions.
 322         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getDecision")) {
 323             GetDecisionService getDecisionService = new GetDecisionService(decisionRequestParameters, requestID);
 324             decisionResponse = getDecisionService.getResult();
 325             status = getDecisionService.getResponseCode();
 326         }
 327         decisionCounter.incrementAndGet();
 328         return new ResponseEntity<>(decisionResponse, status);
 329     }
 330
 331     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 332             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 333     @ApiOperation(value = "Pushes the specified policy to the PDP Group.")
 334     @RequestMapping(value = "/pushPolicy", method = RequestMethod.PUT)
 335     @ResponseBody
 336     public ResponseEntity<String> pushPolicy(@RequestBody PushPolicyParameters pushPolicyParameters,
 337             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 338             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 339         String response = null;
 340         HttpStatus status = HttpStatus.UNAUTHORIZED;
 341         // Check Permissions.
 342         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "pushPolicy")) {
 343             PushPolicyService pushPolicyService = new PushPolicyService(pushPolicyParameters, requestID);
 344             response = pushPolicyService.getResult();
 345             status = pushPolicyService.getResponseCode();
 346         }
 347         pushCounter.incrementAndGet();
 348         return new ResponseEntity<>(response, status);
 349     }
 350
 351     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 352             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 353     @ApiOperation(value = "Deletes the specified policy from the PDP Group or PAP.")
 354     @RequestMapping(value = "/deletePolicy", method = RequestMethod.DELETE)
 355     @ResponseBody
 356     public ResponseEntity<String> deletePolicy(@RequestBody DeletePolicyParameters deletePolicyParameters,
 357             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 358             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 359         String response = null;
 360         HttpStatus status = HttpStatus.UNAUTHORIZED;
 361         // Check Permissions.
 362         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "deletePolicy")) {
 363             DeletePolicyService deletePolicyService = new DeletePolicyService(deletePolicyParameters, requestID);
 364             response = deletePolicyService.getResult();
 365             status = deletePolicyService.getResponseCode();
 366         }
 367         deleteCounter.incrementAndGet();
 368         return new ResponseEntity<>(response, status);
 369     }
 370
 371     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 372             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 373     @ApiOperation(value = "Creates a Policy based on given Policy Parameters.")
 374     @RequestMapping(value = "/createPolicy", method = RequestMethod.PUT)
 375     @ResponseBody
 376     public ResponseEntity<String> createPolicy(@RequestBody PolicyParameters policyParameters,
 377             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 378             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 379         String response = null;
 380         HttpStatus status = HttpStatus.UNAUTHORIZED;
 381         // Check Permissions.
 382         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "createPolicy")) {
 383             CreateUpdatePolicyService createPolicyService;
 384             try {
 385                 createPolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor()
 386                         .newInstance(policyParameters, requestID, false);
 387                 response = createPolicyService.getResult();
 388                 status = createPolicyService.getResponseCode();
 389             } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
 390                     | InvocationTargetException e) {
 391                 logger.error(e.getMessage(), e);
 392                 response = "Problem with CreateUpdate Policy Service. ";
 393                 status = HttpStatus.INTERNAL_SERVER_ERROR;
 394             }
 395         }
 396         createPolicyCounter.incrementAndGet();
 397         return new ResponseEntity<>(response, status);
 398     }
 399
 400     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 401             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 402     @ApiOperation(value = "Updates a Policy based on given Policy Parameters.")
 403     @RequestMapping(value = "/updatePolicy", method = RequestMethod.PUT)
 404     @ResponseBody
 405     public ResponseEntity<String> updatePolicy(@RequestBody PolicyParameters policyParameters,
 406             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 407             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 408         String response = null;
 409         HttpStatus status = HttpStatus.UNAUTHORIZED;
 410         // Check Permissions.
 411         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "updatePolicy")) {
 412             CreateUpdatePolicyService updatePolicyService;
 413             try {
 414                 updatePolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor()
 415                         .newInstance(policyParameters, requestID, true);
 416                 response = updatePolicyService.getResult();
 417                 status = updatePolicyService.getResponseCode();
 418             } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
 419                     | InvocationTargetException e) {
 420                 logger.error(e.getMessage(), e);
 421                 response = "Problem with CreateUpdate Policy Service. ";
 422                 status = HttpStatus.INTERNAL_SERVER_ERROR;
 423             }
 424         }
 425         updatePolicyCounter.incrementAndGet();
 426         return new ResponseEntity<>(response, status);
 427     }
 428
 429     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 430             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 431     @ApiOperation(value = "Creates a Dictionary Item for a specific dictionary based on given Parameters.")
 432     @RequestMapping(value = "/createDictionaryItem", method = RequestMethod.PUT)
 433     @ResponseBody
 434     public ResponseEntity<String> createDictionaryItem(@RequestBody DictionaryParameters dictionaryParameters,
 435             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 436             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 437         String response = null;
 438         HttpStatus status = HttpStatus.UNAUTHORIZED;
 439         // Check Permissions.
 440         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "createDictionary")) {
 441             CreateUpdateDictionaryService createDictionaryService =
 442                     new CreateUpdateDictionaryService(dictionaryParameters, requestID, false);
 443             response = createDictionaryService.getResult();
 444             status = createDictionaryService.getResponseCode();
 445         }
 446         createDictionaryCounter.incrementAndGet();
 447         return new ResponseEntity<>(response, status);
 448     }
 449
 450     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 451             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 452     @ApiOperation(value = "Updates a Dictionary Item for a specific dictionary based on given Parameters.")
 453     @RequestMapping(value = "/updateDictionaryItem", method = RequestMethod.PUT)
 454     @ResponseBody
 455     public ResponseEntity<String> updateDictionaryItem(@RequestBody DictionaryParameters dictionaryParameters,
 456             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 457             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 458         String response = null;
 459         HttpStatus status = HttpStatus.UNAUTHORIZED;
 460         // Check Permissions.
 461         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "updateDictionary")) {
 462             CreateUpdateDictionaryService updateDictionaryService =
 463                     new CreateUpdateDictionaryService(dictionaryParameters, requestID, true);
 464             response = updateDictionaryService.getResult();
 465             status = updateDictionaryService.getResponseCode();
 466         }
 467         updateDictionaryCounter.incrementAndGet();
 468         return new ResponseEntity<>(response, status);
 469     }
 470
 471     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 472             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 473     @ApiOperation(value = "Gets the dictionary items from the PAP")
 474     @RequestMapping(value = "/getDictionaryItems", method = RequestMethod.POST)
 475     @ResponseBody
 476     public ResponseEntity<DictionaryResponse> getDictionaryItems(@RequestBody DictionaryParameters dictionaryParameters,
 477             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 478             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 479         DictionaryResponse dictionaryResponse = null;
 480         HttpStatus status = HttpStatus.UNAUTHORIZED;
 481         // Check Permissions.
 482         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getDictionary")) {
 483             GetDictionaryService getDictionaryService = new GetDictionaryService(dictionaryParameters, requestID);
 484             dictionaryResponse = getDictionaryService.getResult();
 485             status = getDictionaryService.getResponseCode();
 486         }
 487         getDictionaryCounter.incrementAndGet();
 488         return new ResponseEntity<>(dictionaryResponse, status);
 489     }
 490
 491     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 492             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 493     @ApiOperation(
 494             value = "Imports Policy based on the parameters which represent the service used to create a policy Service.")
 495     @RequestMapping(value = "/policyEngineImport", method = RequestMethod.POST)
 496     @ResponseBody
 497     public ResponseEntity<String> policyEngineImport(@RequestParam("importParametersJson") String importParametersJson,
 498             @RequestParam("file") MultipartFile file,
 499             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 500             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 501         String response = null;
 502         HttpStatus status = HttpStatus.UNAUTHORIZED;
 503         // Check Permissions.
 504         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "policyEngineImport")) {
 505             PolicyEngineImportService policyEngineImportService =
 506                     new PolicyEngineImportService(importParametersJson, file, requestID);
 507             response = policyEngineImportService.getResult();
 508             status = policyEngineImportService.getResponseCode();
 509         }
 510         policyEngineImportCounter.incrementAndGet();
 511         return new ResponseEntity<>(response, status);
 512     }
 513
 514     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 515             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 516     @ApiOperation(value = "Creates a Config Policy based on given Policy Parameters.")
 517     @RequestMapping(value = "/createConfig", method = RequestMethod.PUT)
 518     @ResponseBody
 519     @Deprecated
 520     public ResponseEntity<String> createConfig(@RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
 521             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 522             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 523         String response = null;
 524         HttpStatus status = HttpStatus.UNAUTHORIZED;
 525         // Check Permissions.
 526         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "createPolicy")) {
 527             CreateUpdateConfigPolicyService createPolicyService =
 528                     new CreateUpdateConfigPolicyService(configPolicyAPIRequest, requestID, false);
 529             response = createPolicyService.getResult();
 530             status = createPolicyService.getResponseCode();
 531         }
 532         deprecatedCounter.incrementAndGet();
 533         return new ResponseEntity<>(response, status);
 534     }
 535
 536     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 537             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 538     @ApiOperation(value = "Updates a Config Policy based on given Policy Parameters.")
 539     @RequestMapping(value = "/updateConfig", method = RequestMethod.PUT)
 540     @ResponseBody
 541     @Deprecated
 542     public ResponseEntity<String> updateConfig(@RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
 543             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 544             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 545         String response = null;
 546         HttpStatus status = HttpStatus.UNAUTHORIZED;
 547         // Check Permissions.
 548         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "updatePolicy")) {
 549             CreateUpdateConfigPolicyService updatePolicyService =
 550                     new CreateUpdateConfigPolicyService(configPolicyAPIRequest, requestID, true);
 551             response = updatePolicyService.getResult();
 552             status = updatePolicyService.getResponseCode();
 553         }
 554         deprecatedCounter.incrementAndGet();
 555         return new ResponseEntity<>(response, status);
 556     }
 557
 558     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 559             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 560     @ApiOperation(value = "Creates a Config Firewall Policy")
 561     @RequestMapping(value = "/createFirewallConfig", method = RequestMethod.PUT)
 562     @ResponseBody
 563     @Deprecated
 564     public ResponseEntity<String> createFirewallConfig(
 565             @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
 566             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 567             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 568         String response = null;
 569         HttpStatus status = HttpStatus.UNAUTHORIZED;
 570         // Check Permissions.
 571         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "createPolicy")) {
 572             CreateUpdateFirewallPolicyService createFirewallPolicyService =
 573                     new CreateUpdateFirewallPolicyService(configFirewallPolicyAPIRequest, requestID, false);
 574             response = createFirewallPolicyService.getResult();
 575             status = createFirewallPolicyService.getResponseCode();
 576         }
 577         deprecatedCounter.incrementAndGet();
 578         return new ResponseEntity<>(response, status);
 579     }
 580
 581     @ApiImplicitParams({@ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
 582             @ApiImplicitParam(name = "Environment", required = true, paramType = "Header")})
 583     @ApiOperation(value = "Updates a Config Firewall Policy")
 584     @RequestMapping(value = "/updateFirewallConfig", method = RequestMethod.PUT)
 585     @ResponseBody
 586     @Deprecated
 587     public ResponseEntity<String> updateFirewallConfig(
 588             @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
 589             @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
 590             @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
 591         String response = null;
 592         HttpStatus status = HttpStatus.UNAUTHORIZED;
 593         // Check Permissions.
 594         if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "updatePolicy")) {
 595             CreateUpdateFirewallPolicyService updateFirewallPolicyService =
 596                     new CreateUpdateFirewallPolicyService(configFirewallPolicyAPIRequest, requestID, true);
 597             response = updateFirewallPolicyService.getResult();
 598             status = updateFirewallPolicyService.getResponseCode();
 599         }
 600         deprecatedCounter.incrementAndGet();
 601         return new ResponseEntity<>(response, status);
 602     }
 603
 604     @ApiOperation(value = "Gets the API Services usage Information")
 605     @ApiIgnore
 606     @RequestMapping(value = "/count", method = RequestMethod.GET)
 607     public String getCount() {
 608         return "Total Config Calls : " + configCounter + "\n" + "Total Config calls made using Policy File Name: "
 609                 + configNameCounter + "\n" + "Total Event Calls : " + eventCounter + "\nTotal Decision Calls: "
 610                 + decisionCounter + "\nTotal Push policy Calls: " + pushCounter + "\nTotal Delete Policy Calls: "
 611                 + deleteCounter + "\nTotal Create Policy Calls: " + createPolicyCounter
 612                 + "\nTotal Update Policy Calls: " + updatePolicyCounter + "\nTotal Create Dictionary Calls: "
 613                 + createDictionaryCounter + "\nTotal Update Dictionary Calls: " + updateDictionaryCounter
 614                 + "\nTotal Get Dictionary Calls: " + getDictionaryCounter + "\nTotal PolicyEngine Import Calls: "
 615                 + policyEngineImportCounter + "\nTotal Deprecated Policy Calls: " + deprecatedCounter
 616                 + "\nTotal Metrics Calls:" + metricCounter + "\nTotal Notification Calls:" + notificationCounter;
 617     }
 618
 619     @ExceptionHandler({HttpMessageNotReadableException.class})
 620     public ResponseEntity<String> messageNotReadableExceptionHandler(HttpServletRequest req,
 621             HttpMessageNotReadableException exception) {
 622         logger.error("Request not readable: {}", exception);
 623         StringBuilder message = new StringBuilder();
 624         message.append(exception.getMessage());
 625         if (exception.getCause() != null) {
 626             message.append(" Reason Caused: " + exception.getCause().getMessage());
 627         }
 628         return new ResponseEntity<>(message.toString(), HttpStatus.BAD_REQUEST);
 629     }
 630 }