PyPDPServer/src/main/java/org/openecomp/policy/pypdp/controller/PolicyEngineServices.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP Policy Engine
   4  * ================================================================================
   5  * Copyright (C) 2017 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.openecomp.policy.pypdp.controller;
  22
  23 import io.swagger.annotations.Api;
  24 import io.swagger.annotations.ApiImplicitParam;
  25 import io.swagger.annotations.ApiImplicitParams;
  26 import io.swagger.annotations.ApiOperation;
  27
  28 import java.util.Base64;
  29 import java.util.Collection;
  30 import java.util.List;
  31 import java.util.StringTokenizer;
  32 import java.util.concurrent.atomic.AtomicLong;
  33
  34 import org.openecomp.policy.api.ConfigRequestParameters;
  35 import org.openecomp.policy.api.DeletePolicyParameters;
  36 import org.openecomp.policy.api.EventRequestParameters;
  37 import org.openecomp.policy.api.NotificationScheme;
  38 import org.openecomp.policy.api.PolicyParameters;
  39 import org.openecomp.policy.api.PolicyResponse;
  40 import org.openecomp.policy.pypdp.ConfigFirewallPolicyRequest;
  41 import org.openecomp.policy.pypdp.ConfigRequest;
  42 import org.openecomp.policy.pypdp.DeletePolicyRequest;
  43 import org.openecomp.policy.pypdp.EventRequest;
  44 import org.openecomp.policy.pypdp.ListConfigRequest;
  45 import org.openecomp.policy.pypdp.PolicyCreateUpdateRequest;
  46 import org.openecomp.policy.pypdp.PushPolicyRequest;
  47 import org.openecomp.policy.pypdp.authorization.AuthenticationService;
  48 import org.openecomp.policy.pypdp.authorization.Config;
  49 import org.openecomp.policy.pypdp.jmx.PyPdpMonitor;
  50 import org.openecomp.policy.pypdp.model_pojo.PepConfigFirewallPolicyRequest;
  51 import org.openecomp.policy.pypdp.model_pojo.PepConfigPolicyNameRequest;
  52 import org.openecomp.policy.pypdp.model_pojo.PepConfigPolicyRequest;
  53 import org.openecomp.policy.pypdp.model_pojo.PepPushPolicyRequest;
  54 import org.openecomp.policy.pypdp.model_pojo.PyPolicyConfig;
  55 import org.openecomp.policy.pypdp.notifications.NotificationController;
  56 import org.openecomp.policy.std.StdPolicyEngine;
  57 import org.openecomp.policy.utils.PolicyUtils;
  58 import org.springframework.http.HttpStatus;
  59 import org.springframework.http.ResponseEntity;
  60 import org.springframework.web.bind.annotation.RequestBody;
  61 import org.springframework.web.bind.annotation.RequestHeader;
  62 import org.springframework.web.bind.annotation.RequestMapping;
  63 import org.springframework.web.bind.annotation.RequestMethod;
  64 import org.springframework.web.bind.annotation.ResponseBody;
  65 import org.springframework.web.bind.annotation.RestController;
  66
  67 import springfox.documentation.annotations.ApiIgnore;
  68
  69 import org.openecomp.policy.common.logging.eelf.PolicyLogger;
  70 import org.openecomp.policy.common.im.AdministrativeStateException;
  71 import org.openecomp.policy.common.im.StandbyStatusException;
  72
  73 @RestController
  74 @Api(value="Policy Engine Services")
  75 public class PolicyEngineServices {
  76         private final NotificationScheme scheme = NotificationScheme.AUTO_ALL_NOTIFICATIONS;
  77         private final NotificationController handler = new NotificationController();
  78         private final AtomicLong configCounter = PyPdpMonitor.singleton.getAtomicConfigCounter();
  79         private final AtomicLong eventCounter =  PyPdpMonitor.singleton.getAtomicEventCounter();
  80         private final AtomicLong configPolicyNameCounter = PyPdpMonitor.singleton.getAtomicConfigPolicyNameCounter();
  81         private final StdPolicyEngine policyEngine = new StdPolicyEngine(Config.getPDPs(), Config.getPAPs(), Config.getEncodingPAP(), Config.getEncoding(), scheme, handler, Config.getEnvironment(), Config.getClientFile(), Config.isTest());
  82
  83         @ApiImplicitParams({
  84                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
  85                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
  86         })
  87         @ApiOperation(value= "Gets the configuration from the PolicyDecisionPoint(PDP)")
  88         @RequestMapping(value = "/getConfig", method = RequestMethod.POST)
  89         public @ResponseBody ResponseEntity<Collection<PyPolicyConfig>> createConfigRequest(@RequestBody ConfigRequestParameters pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding, @RequestHeader(value="X-ECOMP-RequestID", required=false)String requestID) {
  90                 Collection<PyPolicyConfig> policyConfig = null;
  91                 String[] userNamePass =  null;
  92                 try {
  93                         userNamePass = decodeEncoding(clientEncoding, "CONFIG");
  94                 } catch (Exception e1) {
  95                         return new ResponseEntity<Collection<PyPolicyConfig>>(policyConfig, HttpStatus.UNAUTHORIZED);
  96                 }
  97                 ConfigRequest configRequest = new ConfigRequest(policyEngine);
  98                 try{
  99                         Config.getIntegrityMonitor().startTransaction();
 100                 } catch (AdministrativeStateException e) {
 101                         PolicyLogger.error("Error while starting Transaction " + e);
 102                 } catch (Exception e) {
 103                         PolicyLogger.error("Error while starting Transaction " + e);
 104                 }
 105                 policyConfig = configRequest.run(pep, requestID, userNamePass[0], userNamePass[1]);
 106                 configCounter.incrementAndGet();
 107                 Config.getIntegrityMonitor().endTransaction();
 108                 for(PyPolicyConfig pythonConfig: policyConfig){
 109                         if(pythonConfig.getPolicyConfigMessage()!=null && pythonConfig.getPolicyConfigMessage().contains("PE300")){
 110                                 return new ResponseEntity<Collection<PyPolicyConfig>>(policyConfig, HttpStatus.BAD_REQUEST);
 111                         }
 112                 }
 113                 return new ResponseEntity<Collection<PyPolicyConfig>>(policyConfig, HttpStatus.OK);
 114         }
 115
 116         @ApiImplicitParams({
 117                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 118                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 119         })
 120         @ApiOperation(value= "Gets the configuration from the PDP")
 121         @RequestMapping(value = "/listConfig", method = RequestMethod.POST)
 122         public @ResponseBody ResponseEntity<Collection<String>> createListConfigRequest(@RequestBody ConfigRequestParameters pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding, @RequestHeader(value="X-ECOMP-RequestID", required=false)String requestID) {
 123                 Collection<String> policyList = null;
 124                 String[] userNamePass =  null;
 125                 try {
 126                         userNamePass = decodeEncoding(clientEncoding, "CONFIG");
 127                 } catch (Exception e1) {
 128                         return new ResponseEntity<Collection<String>>(policyList, HttpStatus.UNAUTHORIZED);
 129                 }
 130                 ListConfigRequest listConfigRequest = new ListConfigRequest(policyEngine);
 131                 try{
 132                         Config.getIntegrityMonitor().startTransaction();
 133                 } catch (AdministrativeStateException e) {
 134                         PolicyLogger.error("Error while starting Transaction " + e);
 135                 } catch (StandbyStatusException e) {
 136                         PolicyLogger.error("Error while starting Transaction " + e);
 137                 }
 138                 policyList = listConfigRequest.run(pep, requestID, userNamePass[0], userNamePass[1]);
 139
 140                 configCounter.incrementAndGet();
 141                 Config.getIntegrityMonitor().endTransaction();
 142
 143                 for(String response : policyList){
 144                         if(response!=null && response.contains("PE300")){
 145                                 return new ResponseEntity<Collection<String>>(policyList, HttpStatus.BAD_REQUEST);
 146                         }
 147                 }
 148                 return new ResponseEntity<Collection<String>>(policyList, HttpStatus.OK);
 149         }
 150
 151         @ApiImplicitParams({
 152                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 153                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 154         })
 155         @ApiOperation(value= "Sends the Events specified to the Policy Engine")
 156         @RequestMapping(value = "/sendEvent", method = RequestMethod.POST)
 157         public @ResponseBody ResponseEntity<Collection<PolicyResponse>> createEventParameterRequest(@RequestBody EventRequestParameters pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding, @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 158                 Collection<PolicyResponse> policyResponse = null;
 159                 String[] userNamePass =  null;
 160                 try {
 161                         userNamePass = decodeEncoding(clientEncoding, "ACTION");
 162                 } catch (Exception e1) {
 163                         return new ResponseEntity<Collection<PolicyResponse>>(policyResponse, HttpStatus.UNAUTHORIZED);
 164                 }
 165                 EventRequest eventRequest = new EventRequest(policyEngine);
 166                 try{
 167                         Config.getIntegrityMonitor().startTransaction();
 168                 } catch (AdministrativeStateException e) {
 169                         PolicyLogger.error("Error while starting Transaction " + e);
 170                 } catch (Exception e) {
 171                         PolicyLogger.error("Error while starting Transaction " + e);
 172                 }
 173                 policyResponse = eventRequest.run(pep, requestID, userNamePass[0], userNamePass[1]);
 174                 eventCounter.incrementAndGet();
 175                 Config.getIntegrityMonitor().endTransaction();
 176                 for(PolicyResponse response: policyResponse ){
 177                         if(response.getPolicyResponseMessage()!=null && response.getPolicyResponseMessage().contains("PE300")){
 178                                 return new ResponseEntity<Collection<PolicyResponse>>(policyResponse,HttpStatus.BAD_REQUEST);
 179                         }
 180                 }
 181                 return new ResponseEntity<Collection<PolicyResponse>>(policyResponse,HttpStatus.OK);
 182         }
 183
 184         @ApiImplicitParams({
 185                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 186                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 187         })
 188         @ApiOperation(value= "Gets the configuration from the PolicyDecisionPoint(PDP)")
 189         @RequestMapping(value = "/getConfigByPolicyName", method = RequestMethod.POST)
 190         @Deprecated
 191         public @ResponseBody ResponseEntity<Collection<PyPolicyConfig>> createConfigRequest(@RequestBody PepConfigPolicyNameRequest pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding, @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 192                 Collection<PyPolicyConfig> policyConfig = null;
 193                 String[] userNamePass =  null;
 194                 try {
 195                         userNamePass = decodeEncoding(clientEncoding, "CONFIG");
 196                 } catch (Exception e1) {
 197                         return new ResponseEntity<Collection<PyPolicyConfig>>(policyConfig, HttpStatus.UNAUTHORIZED);
 198                 }
 199                 ConfigRequest configRequest = new ConfigRequest(policyEngine);
 200                 try{
 201                         Config.getIntegrityMonitor().startTransaction();
 202                 } catch (AdministrativeStateException e) {
 203                         PolicyLogger.error("Error while starting Transaction " + e);
 204                 } catch (Exception e) {
 205                         PolicyLogger.error("Error while starting Transaction " + e);
 206                 }
 207                 policyConfig = configRequest.run(pep, requestID, userNamePass[0], userNamePass[1]);
 208                 configPolicyNameCounter.incrementAndGet();
 209                 Config.getIntegrityMonitor().endTransaction();
 210                 return new ResponseEntity<Collection<PyPolicyConfig>>(policyConfig, HttpStatus.OK);
 211         }
 212
 213         @ApiImplicitParams({
 214                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 215                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 216         })
 217         @ApiOperation(value="Pushes the specified policy to the PDP Group.")
 218         @RequestMapping(value = "/pushPolicy", method = RequestMethod.PUT)
 219         public @ResponseBody ResponseEntity<String> pushPolicyRequest(@RequestBody PepPushPolicyRequest pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 220                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 221                 String response = null;
 222                 String[] userNamePass =  null;
 223                 try {
 224                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 225                 } catch (Exception e1) {
 226                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 227                 }
 228                 PushPolicyRequest pushPolicy = new PushPolicyRequest(policyEngine);
 229                 try{
 230                         Config.getIntegrityMonitor().startTransaction();
 231                 } catch (AdministrativeStateException e) {
 232                         PolicyLogger.error("Error while starting Transaction " + e);
 233                 } catch (Exception e) {
 234                         PolicyLogger.error("Error while starting Transaction " + e);
 235                 }
 236                 response = pushPolicy.run(pep, requestID, userNamePass[0], userNamePass[1]);
 237
 238                 Config.getIntegrityMonitor().endTransaction();
 239                 if (response.contains("BAD REQUEST")||response.contains("PE300")) {
 240                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 241                 } else {
 242                         return new ResponseEntity<String>(response, HttpStatus.OK);
 243                 }
 244         }
 245
 246         @ApiImplicitParams({
 247                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 248                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 249         })
 250         @ApiOperation(value="Deletes the specified policy from the PDP Group or PAP.")
 251         @RequestMapping(value = "/deletePolicy", method = RequestMethod.DELETE)
 252         public @ResponseBody ResponseEntity<String> deletePolicyRequest(@RequestBody DeletePolicyParameters pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 253                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 254                 String response = null;
 255                 String[] userNamePass =  null;
 256                 try {
 257                         userNamePass = decodeEncoding(clientEncoding, "DELETEPOLICY");
 258                 } catch (Exception e1) {
 259                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 260                 }
 261                 DeletePolicyRequest deletePolicy = new DeletePolicyRequest(policyEngine);
 262                 try{
 263                         Config.getIntegrityMonitor().startTransaction();
 264                 } catch (AdministrativeStateException e) {
 265                         PolicyLogger.error("Error while starting Transaction " + e);
 266                 } catch (Exception e) {
 267                         PolicyLogger.error("Error while starting Transaction " + e);
 268                 }
 269                 response = deletePolicy.run(pep, requestID, userNamePass[0], userNamePass[1]);
 270
 271                 Config.getIntegrityMonitor().endTransaction();
 272                 if (response.contains("BAD REQUEST")||response.contains("PE300")||response.contains("not exist")||response.contains("Invalid policyName")) {
 273                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 274                 } else if (response.contains("locked down")){
 275                         return new ResponseEntity<String>(response, HttpStatus.ACCEPTED);
 276                 } else if (response.contains("not Authorized")) {
 277                         return new ResponseEntity<String>(response, HttpStatus.FORBIDDEN);
 278                 } else if (response.contains("groupId")) {
 279                         return new ResponseEntity<String>(response, HttpStatus.NOT_FOUND);
 280                 } else if (response.contains("JPAUtils")||response.contains("database")||response.contains("policy file")||
 281                                 response.contains("unknown")||response.contains("configuration")) {
 282                         return new ResponseEntity<String>(response, HttpStatus.INTERNAL_SERVER_ERROR);
 283                 } else {
 284                         return new ResponseEntity<String>(response, HttpStatus.OK);
 285                 }
 286         }
 287
 288         @ApiImplicitParams({
 289                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 290                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 291         })
 292         @ApiOperation(value= "Creates a Policy based on given Policy Parameters.")
 293         @RequestMapping(value = "/createPolicy", method = RequestMethod.PUT)
 294         public @ResponseBody ResponseEntity<String> createRequest(@RequestBody PolicyParameters pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 295                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false)String requestID) {
 296                 String response = null;
 297                 String[] userNamePass =  null;
 298                 try {
 299                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 300                 } catch (Exception e1) {
 301                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 302                 }
 303                 PolicyCreateUpdateRequest policyCreateUpdateRequest = new PolicyCreateUpdateRequest(policyEngine);
 304                 try{
 305                         Config.getIntegrityMonitor().startTransaction();
 306                 } catch (AdministrativeStateException e) {
 307                         PolicyLogger.error("Error while starting Transaction " + e);
 308                 } catch (Exception e) {
 309                         PolicyLogger.error("Error while starting Transaction " + e);
 310                 }
 311                 response = policyCreateUpdateRequest.run(pep, requestID, "create", userNamePass[0], userNamePass[1]);
 312
 313                 Config.getIntegrityMonitor().endTransaction();
 314                 if(response== null || response.contains("BAD REQUEST")||response.contains("PE300")){
 315                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 316                 }
 317                 else if (response.contains("Policy Exist Error")) {
 318                         return new ResponseEntity<String>(response, HttpStatus.CONFLICT);
 319                 } else if (response.contains("PE200")){
 320                         return new ResponseEntity<String>(response, HttpStatus.INTERNAL_SERVER_ERROR);
 321                 } else {
 322                         return new ResponseEntity<String>(response, HttpStatus.OK);
 323                 }
 324
 325         }
 326
 327         @ApiImplicitParams({
 328                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 329                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 330         })
 331         @ApiOperation(value= "Updates a Policy based on given Policy Parameters.")
 332         @RequestMapping(value = "/updatePolicy", method = RequestMethod.PUT)
 333         public @ResponseBody ResponseEntity<String> updateRequest(@RequestBody PolicyParameters pep,@RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 334                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 335                 String response = null;
 336                 String[] userNamePass =  null;
 337                 try {
 338                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 339                 } catch (Exception e1) {
 340                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 341                 }
 342                 PolicyCreateUpdateRequest policyCreateUpdateRequest = new PolicyCreateUpdateRequest(policyEngine);
 343                 try{
 344                         Config.getIntegrityMonitor().startTransaction();
 345                 } catch (AdministrativeStateException e) {
 346                         PolicyLogger.error("Error while starting Transaction " + e);
 347                 } catch (Exception e) {
 348                         PolicyLogger.error("Error while starting Transaction " + e);
 349                 }
 350                 response = policyCreateUpdateRequest.run(pep, requestID, "update", userNamePass[0], userNamePass[1]);
 351
 352                 Config.getIntegrityMonitor().endTransaction();
 353                 if (response==null|| response.contains("BAD REQUEST")||response.contains("PE300")){
 354                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 355                 } else if (response.contains("PE200")){
 356                         return new ResponseEntity<String>(response, HttpStatus.INTERNAL_SERVER_ERROR);
 357                 } else {
 358                         return new ResponseEntity<String>(response, HttpStatus.OK);
 359                 }
 360
 361         }
 362
 363         @ApiImplicitParams({
 364                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 365                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 366         })
 367         @ApiOperation(value= "Creates a Config Policy based on given Policy Parameters.")
 368         @RequestMapping(value = "/createConfig", method = RequestMethod.PUT)
 369         @Deprecated
 370         public @ResponseBody ResponseEntity<String> createConfigRequest(@RequestBody PepConfigPolicyRequest pep, @RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 371                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 372                 String response = null;
 373                 String[] userNamePass =  null;
 374                 try {
 375                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 376                 } catch (Exception e1) {
 377                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 378                 }
 379                 PolicyCreateUpdateRequest policyCreateUpdateRequest = new PolicyCreateUpdateRequest(policyEngine);
 380                 try{
 381                         Config.getIntegrityMonitor().startTransaction();
 382                 } catch (AdministrativeStateException e) {
 383                         PolicyLogger.error("Error while starting Transaction " + e);
 384                 } catch (Exception e) {
 385                         PolicyLogger.error("Error while starting Transaction " + e);
 386                 }
 387                 response = policyCreateUpdateRequest.run(pep, requestID, "create", userNamePass[0], userNamePass[1]);
 388
 389                 Config.getIntegrityMonitor().endTransaction();
 390                 if (response!=null && !response.contains("BAD REQUEST")) {
 391                         return new ResponseEntity<String>(response, HttpStatus.OK);
 392                 } else {
 393                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 394                 }
 395
 396         }
 397
 398         @ApiImplicitParams({
 399                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 400                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 401         })
 402         @ApiOperation(value= "Updates a Config Policy based on given Policy Parameters.")
 403         @RequestMapping(value = "/updateConfig", method = RequestMethod.PUT)
 404         @Deprecated
 405         public @ResponseBody ResponseEntity<String> updateConfigRequest(@RequestBody PepConfigPolicyRequest pep, @RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 406                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 407                 String response = null;
 408                 String[] userNamePass =  null;
 409                 try {
 410                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 411                 } catch (Exception e1) {
 412                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 413                 }
 414                 PolicyCreateUpdateRequest policyCreateUpdateRequest = new PolicyCreateUpdateRequest(policyEngine);
 415                 try{
 416                         Config.getIntegrityMonitor().startTransaction();
 417                 } catch (AdministrativeStateException e) {
 418                         PolicyLogger.error("Error while starting Transaction " + e);
 419                 } catch (Exception e) {
 420                         PolicyLogger.error("Error while starting Transaction " + e);
 421                 }
 422                 response = policyCreateUpdateRequest.run(pep, requestID, "update", userNamePass[0], userNamePass[1]);
 423
 424                 Config.getIntegrityMonitor().endTransaction();
 425                 if (response!=null && !response.contains("BAD REQUEST")) {
 426                         return new ResponseEntity<String>(response, HttpStatus.OK);
 427                 } else {
 428                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 429                 }
 430
 431         }
 432
 433         @ApiImplicitParams({
 434                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 435                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 436         })
 437         @ApiOperation(value = "Creates a Config Firewall Policy")
 438         @RequestMapping(value = "/createFirewallConfig", method = RequestMethod.PUT)
 439         @Deprecated
 440         public @ResponseBody ResponseEntity<String> createFirewallConfigRequest(@RequestBody PepConfigFirewallPolicyRequest pep, @RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 441                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 442                 String response = null;
 443                 String[] userNamePass =  null;
 444                 try {
 445                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 446                 } catch (Exception e1) {
 447                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 448                 }
 449                 ConfigFirewallPolicyRequest firewallPolicyRequest = new ConfigFirewallPolicyRequest(policyEngine);
 450                 try{
 451                         Config.getIntegrityMonitor().startTransaction();
 452                 } catch (AdministrativeStateException e) {
 453                         PolicyLogger.error("Error while starting Transaction " + e);
 454                 } catch (Exception e) {
 455                         PolicyLogger.error("Error while starting Transaction " + e);
 456                 }
 457                 response = firewallPolicyRequest.run(pep, requestID, "create", userNamePass[0], userNamePass[1]);
 458
 459                 Config.getIntegrityMonitor().endTransaction();
 460                 if (response!=null && !response.contains("BAD REQUEST")) {
 461                         return new ResponseEntity<String>(response, HttpStatus.OK);
 462                 } else {
 463                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 464                 }
 465
 466         }
 467
 468         @ApiImplicitParams({
 469                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
 470                 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
 471         })
 472         @ApiOperation(value = "Updates a Config Firewall Policy")
 473         @RequestMapping(value = "/updateFirewallConfig", method = RequestMethod.PUT)
 474         @Deprecated
 475         public @ResponseBody ResponseEntity<String> updateFirewallConfigRequest(@RequestBody PepConfigFirewallPolicyRequest pep, @RequestHeader(value="ClientAuth", required=true)String clientEncoding,
 476                                                                                                                         @RequestHeader(value="X-ECOMP-RequestID", required=false) String requestID) {
 477                 String response = null;
 478                 String[] userNamePass =  null;
 479                 try {
 480                         userNamePass = decodeEncoding(clientEncoding, "CREATEPOLICY");
 481                 } catch (Exception e1) {
 482                         return new ResponseEntity<String>(response, HttpStatus.UNAUTHORIZED);
 483                 }
 484                 ConfigFirewallPolicyRequest firewallPolicyRequest = new ConfigFirewallPolicyRequest(policyEngine);
 485                 try{
 486                         Config.getIntegrityMonitor().startTransaction();
 487                 } catch (AdministrativeStateException e) {
 488                         PolicyLogger.error("Error while starting Transaction " + e);
 489                 } catch (Exception e) {
 490                         PolicyLogger.error("Error while starting Transaction " + e);
 491                 }
 492                 response = firewallPolicyRequest.run(pep, requestID, "update", userNamePass[0], userNamePass[1]);
 493
 494                 Config.getIntegrityMonitor().endTransaction();
 495                 if (response!=null && !response.contains("BAD REQUEST")) {
 496                         return new ResponseEntity<String>(response, HttpStatus.OK);
 497                 } else {
 498                         return new ResponseEntity<String>(response, HttpStatus.BAD_REQUEST);
 499                 }
 500
 501         }
 502
 503         @ApiImplicitParams({
 504                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header")
 505         })
 506         @ApiOperation(value= "Gets the API Services usage Information")
 507         @ApiIgnore
 508         @RequestMapping(value = "/count", method = RequestMethod.GET)
 509         public String getCount() {
 510                 return "Total Config Calls : " + configCounter + "\n"
 511                                 +"Total Config calls made using Policy File Name: " + configPolicyNameCounter + "\n"
 512                                 + "Total Event Calls : " + eventCounter;
 513         }
 514
 515         @ApiImplicitParams({
 516                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header")
 517         })
 518         @ApiOperation(value = "Gets the PDPs that are listed to provide service.")
 519         @RequestMapping(value = "/pdps", method = RequestMethod.GET)
 520         public List<String> listPDPs() {
 521                 return Config.getPDPs();
 522         }
 523
 524         @ApiImplicitParams({
 525                 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header")
 526         })
 527         @ApiOperation(value = "Gets the PAPs that are listed to provide service.")
 528         @RequestMapping(value = "/paps", method = RequestMethod.GET)
 529         public List<String> listPAPs() {
 530                 return Config.getPAPs();
 531         }
 532
 533         /*
 534          * Internal Decoding System. to support old and new Calls.
 535          */
 536         private String[] decodeEncoding(String clientEncoding, String scope) throws Exception{
 537                 String[] userNamePass = PolicyUtils.decodeBasicEncoding(clientEncoding);
 538                 if(userNamePass==null){
 539                         if(AuthenticationService.clientAuth(clientEncoding)){
 540                                 if(AuthenticationService.checkClientScope(clientEncoding, scope)){
 541                                         String usernameAndPassword = null;
 542                                         byte[] decodedBytes = Base64.getDecoder().decode(clientEncoding);
 543                                         usernameAndPassword = new String(decodedBytes, "UTF-8");
 544                                         StringTokenizer tokenizer = new StringTokenizer(usernameAndPassword, ":");
 545                                         String username = tokenizer.nextToken();
 546                                         String password = tokenizer.nextToken();
 547                                         userNamePass=  new String[]{username, password};
 548                                 }
 549                         }
 550                 }
 551                 if(userNamePass==null){
 552                         throw new Exception("Client is Not authrorized to make this call. Please contact PyPDP Admin.");
 553                 }
 554                 return userNamePass;
 555         }
 556 }