ONAP-REST/src/main/java/org/onap/policy/rest/util/PolicyValidationRequestWrapper.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 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  */package org.onap.policy.rest.util;
  20
  21 import java.io.IOException;
  22 import java.io.StringReader;
  23 import java.text.SimpleDateFormat;
  24 import java.util.ArrayList;
  25 import java.util.Date;
  26 import java.util.LinkedHashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29
  30 import javax.json.Json;
  31 import javax.json.JsonException;
  32 import javax.json.JsonObject;
  33 import javax.json.JsonReader;
  34 import javax.servlet.http.HttpServletRequest;
  35
  36 import org.onap.policy.api.AttributeType;
  37 import org.onap.policy.api.PolicyParameters;
  38 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  39 import org.onap.policy.common.logging.flexlogger.Logger;
  40 import org.onap.policy.rest.adapter.ClosedLoopFaultTrapDatas;
  41 import org.onap.policy.rest.adapter.PolicyRestAdapter;
  42 import org.onap.policy.rest.adapter.RainyDayParams;
  43 import org.onap.policy.rest.adapter.YAMLParams;
  44 import org.onap.policy.xacml.api.XACMLErrorConstants;
  45
  46 import com.fasterxml.jackson.databind.DeserializationFeature;
  47 import com.fasterxml.jackson.databind.JsonNode;
  48 import com.fasterxml.jackson.databind.ObjectMapper;
  49 import com.google.common.base.Strings;
  50
  51 public class PolicyValidationRequestWrapper {
  52
  53     private static final Logger LOGGER  = FlexLogger.getLogger(PolicyValidationRequestWrapper.class);
  54     public static final String CONFIG_NAME="configName";
  55     public static final String INVALIDJSON = " improper JSON format: ";
  56     public static final String ONAPNAME = "onapname";
  57     public static final String CONTENT = "content";
  58     public static final String GUARD = "guard";
  59     public static final String LOCATION = "location";
  60     public static final String POLICYSCOPE = "policyScope";
  61     public static final String PRIORITY = "priority";
  62     public static final String RISKLEVEL = "riskLevel";
  63     public static final String RISKTYPE = "riskType";
  64     public static final String SERVICE = "service";
  65     public static final String VERSION = "version";
  66
  67     public static final String SERVICETYPE_POLICY_NAME = "serviceTypePolicyName";
  68
  69     public PolicyRestAdapter populateRequestParameters(HttpServletRequest request) {
  70
  71         PolicyRestAdapter policyData = null;
  72         ClosedLoopFaultTrapDatas trapDatas = null;
  73         ClosedLoopFaultTrapDatas faultDatas = null;
  74         try {
  75             ObjectMapper mapper = new ObjectMapper();
  76             mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  77             JsonNode root = mapper.readTree(request.getReader());
  78             policyData = mapper.readValue(root.get("policyData").toString(), PolicyRestAdapter.class);
  79             if(root.get("trapData") != null){
  80                 trapDatas = mapper.readValue(root.get("trapData").toString(), ClosedLoopFaultTrapDatas.class);
  81                 policyData.setTrapDatas(trapDatas);
  82             }
  83             if(root.get("faultData") != null){
  84                 faultDatas = mapper.readValue(root.get("faultData").toString(), ClosedLoopFaultTrapDatas.class);
  85                 policyData.setFaultDatas(faultDatas);
  86             }
  87
  88             JsonObject json;
  89             json = stringToJsonObject(root.toString());
  90
  91             if(json != null){
  92                 if(json.containsKey("policyJSON")){
  93                     policyData.setPolicyJSON(root.get("policyJSON"));
  94                 }else{
  95                     String jsonBodyData = json.getJsonObject("policyData").get("jsonBodyData").toString();
  96                     policyData.setJsonBody(jsonBodyData);
  97                 }
  98             }
  99
 100         } catch (Exception e) {
 101             LOGGER.error("Exception Occured while populating request parameters: " +e);
 102         }
 103
 104         return policyData;
 105     }
 106
 107     public PolicyRestAdapter populateRequestParameters(PolicyParameters parameters) {
 108
 109         PolicyRestAdapter policyData = new PolicyRestAdapter();
 110
 111         /*
 112          * set policy adapter values for Building JSON object containing policy data
 113          */
 114         //Common Policy Fields
 115         policyData.setPolicyName(parameters.getPolicyName());
 116         policyData.setOnapName(parameters.getOnapName());
 117         policyData.setPriority(parameters.getPriority()); //Micro Service
 118         policyData.setConfigName(parameters.getConfigName());  //Base and Firewall
 119         policyData.setRiskType(parameters.getRiskType()); //Safe parameters Attributes
 120         policyData.setRiskLevel(parameters.getRiskLevel());//Safe parameters Attributes
 121         policyData.setGuard(String.valueOf(parameters.getGuard()));//Safe parameters Attributes
 122         policyData.setTtlDate(convertDate(parameters.getTtlDate()));//Safe parameters Attributes
 123         policyData.setApiflag("API");
 124
 125         //Some policies require jsonObject conversion from String for configBody (i.e. MicroService and Firewall)
 126         JsonObject json = null;
 127         try{
 128             if(parameters.getConfigBody()!= null){
 129                 json = stringToJsonObject(parameters.getConfigBody());
 130             }
 131         } catch(JsonException| IllegalStateException e){
 132             String message = XACMLErrorConstants.ERROR_DATA_ISSUE+ INVALIDJSON + parameters.getConfigBody();
 133             LOGGER.error(message, e);
 134             return null;
 135         }
 136
 137         if(parameters.getPolicyClass()!=null && !"Config".equals(parameters.getPolicyClass().toString())){
 138
 139             policyData.setPolicyType(parameters.getPolicyClass().toString());
 140
 141             //Get Matching attribute values
 142             Map<AttributeType, Map<String, String>> attributes = parameters.getAttributes();
 143             Map<String, String> matching = null;
 144             if(attributes != null){
 145                 matching = attributes.get(AttributeType.MATCHING);
 146             }
 147
 148             if("Decision".equals(parameters.getPolicyClass().toString())){
 149
 150                 String ruleProvider = parameters.getRuleProvider().toString();
 151                 policyData.setRuleProvider(ruleProvider);
 152
 153                 if("Rainy_Day".equals(ruleProvider)){
 154
 155                     // Set Matching attributes in RainyDayParams in adapter
 156                     RainyDayParams rainyday = new RainyDayParams();
 157
 158                     if(matching != null) {
 159                         rainyday.setServiceType(matching.get("ServiceType"));
 160                         rainyday.setVnfType(matching.get("VNFType"));
 161                         rainyday.setBbid(matching.get("BB_ID"));
 162                         rainyday.setWorkstep(matching.get("WorkStep"));
 163                     }
 164
 165                     Map<String, String> treatments = parameters.getTreatments();
 166                     ArrayList<Object> treatmentsTableChoices = new ArrayList<>();
 167
 168                     for (String keyField : treatments.keySet()) {
 169                         LinkedHashMap<String, String> treatmentMap = new LinkedHashMap<>();
 170                         String errorcode = keyField;
 171                         String treatment = treatments.get(errorcode);
 172                         treatmentMap.put("errorcode", errorcode);
 173                         treatmentMap.put("treatment", treatment);
 174                         treatmentsTableChoices.add(treatmentMap);
 175                     }
 176                     rainyday.setTreatmentTableChoices(treatmentsTableChoices);
 177                     policyData.setRainyday(rainyday);
 178
 179                 }else if("GUARD_YAML".equals(ruleProvider) || "GUARD_BL_YAML".equals(ruleProvider)) {
 180
 181                     // Set Matching attributes in YAMLParams in adapter
 182                     YAMLParams yamlparams = new YAMLParams();
 183
 184                     if (matching != null) {
 185                         yamlparams.setActor(matching.get("actor"));
 186                         yamlparams.setRecipe(matching.get("recipe"));
 187                         yamlparams.setGuardActiveStart(matching.get("guardActiveStart"));
 188                         yamlparams.setGuardActiveEnd(matching.get("guardActiveEnd"));
 189
 190                         if("GUARD_YAML".equals(ruleProvider)){
 191                             yamlparams.setLimit(matching.get("limit"));
 192                             yamlparams.setTimeWindow(matching.get("timeWindow"));
 193                             yamlparams.setTimeUnits(matching.get("timeUnits"));
 194                         }else{
 195
 196                             List<String> blackList = new ArrayList<>();
 197
 198                             if(!Strings.isNullOrEmpty(matching.get("blackList"))){
 199                                 String[] blackListArray = matching.get("blackList").split(",");
 200                                 for(String element : blackListArray){
 201                                     blackList.add(element);
 202                                 }
 203                             }
 204
 205                             yamlparams.setBlackList(blackList);
 206
 207                         }
 208                     }
 209                     policyData.setYamlparams(yamlparams);
 210                 }
 211
 212             } else if("Action".equals(parameters.getPolicyClass().toString())){
 213
 214                 ArrayList<Object> ruleAlgorithmChoices = new ArrayList<>();
 215
 216                 List<String> dynamicLabelRuleAlgorithms = parameters.getDynamicRuleAlgorithmLabels();
 217                 List<String> dynamicFieldFunctionRuleAlgorithms = parameters.getDynamicRuleAlgorithmFunctions();
 218                 List<String> dynamicFieldOneRuleAlgorithms = parameters.getDynamicRuleAlgorithmField1();
 219                 List<String> dyrnamicFieldTwoRuleAlgorithms = parameters.getDynamicRuleAlgorithmField2();
 220
 221                 if (dynamicLabelRuleAlgorithms != null && !dynamicLabelRuleAlgorithms.isEmpty()) {
 222                     int i = dynamicLabelRuleAlgorithms.size() - 1;
 223
 224                     for (String labelAttr : dynamicLabelRuleAlgorithms) {
 225                         LinkedHashMap<String, String> ruleAlgorithm = new LinkedHashMap<>();
 226
 227                         String id = dynamicLabelRuleAlgorithms.get(i);
 228                         String dynamicRuleAlgorithmField1 = dynamicFieldOneRuleAlgorithms.get(i);
 229                         String dynamicRuleAlgorithmCombo = dynamicFieldFunctionRuleAlgorithms.get(i);
 230                         String dynamicRuleAlgorithmField2 = dyrnamicFieldTwoRuleAlgorithms.get(i);
 231
 232                         ruleAlgorithm.put("id", id);
 233                         ruleAlgorithm.put("dynamicRuleAlgorithmField1", dynamicRuleAlgorithmField1);
 234                         ruleAlgorithm.put("dynamicRuleAlgorithmCombo", dynamicRuleAlgorithmCombo);
 235                         ruleAlgorithm.put("dynamicRuleAlgorithmField2", dynamicRuleAlgorithmField2);
 236
 237                         ruleAlgorithmChoices.add(ruleAlgorithm);
 238
 239                         i--;
 240
 241                     }
 242                 }
 243
 244                 policyData.setRuleAlgorithmschoices(ruleAlgorithmChoices);
 245
 246                 ArrayList<Object> attributeList = new ArrayList<>();
 247                 if (matching != null) {
 248                     for (Map.Entry<String, String> entry : matching.entrySet()) {
 249                         LinkedHashMap<String, String> attributeMap = new LinkedHashMap<>();
 250                         String key = entry.getKey();
 251                         String value = entry.getValue();
 252                         attributeMap.put("key", key);
 253                         attributeMap.put("value", value);
 254                         attributeList.add(attributeMap);
 255                     }
 256                 }
 257
 258                 policyData.setAttributes(attributeList);
 259                 policyData.setActionAttributeValue(parameters.getActionAttribute());
 260                 policyData.setActionPerformer(parameters.getActionPerformer());
 261
 262             }
 263         }else {
 264
 265             policyData.setPolicyType("Config");
 266             policyData.setConfigPolicyType(parameters.getPolicyConfigType().toString());
 267
 268             //Config Specific
 269             policyData.setConfigBodyData(parameters.getConfigBody()); //Base
 270             policyData.setConfigType((parameters.getConfigBodyType()!=null) ? parameters.getConfigBodyType().toString().toUpperCase(): null);  //Base
 271
 272             if("FW".equalsIgnoreCase(parameters.getPolicyConfigType().toString())){
 273
 274                 policyData.setConfigPolicyType("Firewall Config");
 275
 276                 // get values and attributes from the JsonObject
 277                 if(json != null){
 278                     if (json.get("securityZoneId")!=null){
 279                         String securityZone = json.get("securityZoneId").toString().replace("\"", "");
 280                         policyData.setSecurityZone(securityZone);
 281                     }
 282                     if (json.get(CONFIG_NAME)!=null){
 283                         String configName = json.get(CONFIG_NAME).toString().replace("\"", "");
 284                         policyData.setConfigName(configName);
 285                     }
 286                 }
 287
 288             }else if("MS".equals(parameters.getPolicyConfigType().toString())){
 289
 290                 policyData.setConfigPolicyType("Micro Service");
 291
 292                 // get values and attributes from the JsonObject
 293                 if(json != null){
 294                     if (json.containsKey(CONTENT)){
 295                         String content = json.get(CONTENT).toString();
 296                         ObjectMapper mapper = new ObjectMapper();
 297                         JsonNode policyJSON = null;
 298                         try {
 299                             policyJSON = mapper.readTree(content);
 300                         } catch (IOException e) {
 301                             String message = XACMLErrorConstants.ERROR_DATA_ISSUE+ INVALIDJSON + parameters.getConfigBody();
 302                             LOGGER.error(message, e);
 303                             return null;
 304                         }
 305                         policyData.setPolicyJSON(policyJSON);
 306                     }
 307                     if (json.containsKey(SERVICE)){
 308                         String serviceType = json.get(SERVICE).toString().replace("\"", "");
 309                         policyData.setServiceType(serviceType);
 310                     }
 311                     if (json.containsKey("uuid")){
 312                         String uuid = json.get("uuid").toString().replace("\"", "");
 313                         policyData.setUuid(uuid);
 314                     }
 315                     if (json.containsKey(LOCATION)){
 316                         String msLocation = json.get(LOCATION).toString().replace("\"", "");
 317                         policyData.setLocation(msLocation);
 318                     }
 319                     if (json.containsKey(CONFIG_NAME)){
 320                         String configName = json.get(CONFIG_NAME).toString().replace("\"", "");
 321                         policyData.setConfigName(configName);
 322                     }
 323                     if(json.containsKey(PRIORITY)){
 324                         String priority = json.get(PRIORITY).toString().replace("\"", "");
 325                         policyData.setPriority(priority);
 326                     }
 327                     if(json.containsKey(VERSION)){
 328                         String version = json.get(VERSION).toString().replace("\"", "");
 329                         policyData.setVersion(version);
 330                     }
 331                     if(json.containsKey(POLICYSCOPE)){
 332                         String policyScope = json.get(POLICYSCOPE).toString().replace("\"", "");
 333                         policyData.setPolicyScope(policyScope);
 334                     }
 335                     if(json.containsKey(RISKTYPE)){
 336                         String riskType = json.get(RISKTYPE).toString().replace("\"", "");
 337                         policyData.setRiskType(riskType);
 338                     }
 339                     if(json.containsKey(RISKLEVEL)){
 340                         String riskLevel = json.get(RISKLEVEL).toString().replace("\"", "");
 341                         policyData.setRiskLevel(riskLevel);
 342                     }
 343                     if(json.containsKey(GUARD)){
 344                         String guard = json.get(GUARD).toString().replace("\"", "");
 345                         policyData.setGuard(guard);
 346                     }
 347                 } else {
 348                     String message = XACMLErrorConstants.ERROR_DATA_ISSUE+ INVALIDJSON + parameters.getConfigBody();
 349                     LOGGER.error(message);
 350                     return null;
 351                 }
 352
 353             }else if("Optimization".equals(parameters.getPolicyConfigType().toString())){
 354
 355                 policyData.setConfigPolicyType("Optimization");
 356
 357                 // get values and attributes from the JsonObject
 358                 if(json != null){
 359                     if (json.containsKey(CONTENT)){
 360                         String content = json.get(CONTENT).toString();
 361                         ObjectMapper mapper = new ObjectMapper();
 362                         JsonNode policyJSON = null;
 363                         try {
 364                             policyJSON = mapper.readTree(content);
 365                         } catch (IOException e) {
 366                             String message = XACMLErrorConstants.ERROR_DATA_ISSUE+ INVALIDJSON + parameters.getConfigBody();
 367                             LOGGER.error(message, e);
 368                             return null;
 369                         }
 370                         policyData.setPolicyJSON(policyJSON);
 371                     }
 372                     if (json.containsKey(SERVICE)){
 373                         String serviceType = json.get(SERVICE).toString().replace("\"", "");
 374                         policyData.setServiceType(serviceType);
 375                     }
 376                     if (json.containsKey("uuid")){
 377                         String uuid = json.get("uuid").toString().replace("\"", "");
 378                         policyData.setUuid(uuid);
 379                     }
 380                     if (json.containsKey(LOCATION)){
 381                         String msLocation = json.get(LOCATION).toString().replace("\"", "");
 382                         policyData.setLocation(msLocation);
 383                     }
 384                     if (json.containsKey(CONFIG_NAME)){
 385                         String configName = json.get(CONFIG_NAME).toString().replace("\"", "");
 386                         policyData.setConfigName(configName);
 387                     }
 388                     if(json.containsKey(PRIORITY)){
 389                         String priority = json.get(PRIORITY).toString().replace("\"", "");
 390                         policyData.setPriority(priority);
 391                     }
 392                     if(json.containsKey(VERSION)){
 393                         String version = json.get(VERSION).toString().replace("\"", "");
 394                         policyData.setVersion(version);
 395                     }
 396                     if(json.containsKey(POLICYSCOPE)){
 397                         String policyScope = json.get(POLICYSCOPE).toString().replace("\"", "");
 398                         policyData.setPolicyScope(policyScope);
 399                     }
 400                     if(json.containsKey(RISKTYPE)){
 401                         String riskType = json.get(RISKTYPE).toString().replace("\"", "");
 402                         policyData.setRiskType(riskType);
 403                     }
 404                     if(json.containsKey(RISKLEVEL)){
 405                         String riskLevel = json.get(RISKLEVEL).toString().replace("\"", "");
 406                         policyData.setRiskLevel(riskLevel);
 407                     }
 408                     if(json.containsKey(GUARD)){
 409                         String guard = json.get(GUARD).toString().replace("\"", "");
 410                         policyData.setGuard(guard);
 411                     }
 412                 }
 413
 414             } else if("Fault".equals(parameters.getPolicyConfigType().toString())){
 415
 416                 policyData.setConfigPolicyType("ClosedLoop_Fault");
 417
 418                 if(json != null){
 419                     policyData.setJsonBody(json.toString());
 420                     if (json.get(ONAPNAME)!=null){
 421                         String onapName = json.get(ONAPNAME).toString().replace("\"", "");
 422                         policyData.setOnapName(onapName);
 423                     }
 424                 }
 425
 426             } else if("PM".equals(parameters.getPolicyConfigType().toString())){
 427
 428                 policyData.setConfigPolicyType("ClosedLoop_PM");
 429
 430                 if(json != null){
 431                     policyData.setJsonBody(json.toString());
 432                     if (json.get(ONAPNAME)!=null){
 433                         String onapName = json.get(ONAPNAME).toString().replace("\"", "");
 434                         policyData.setOnapName(onapName);
 435                     }
 436                     if (json.get(SERVICETYPE_POLICY_NAME)!=null){
 437                         String serviceType = json.get(SERVICETYPE_POLICY_NAME).toString().replace("\"", "");
 438                         LinkedHashMap<String, String> serviceTypePolicyName = new LinkedHashMap<>();
 439                         serviceTypePolicyName.put(SERVICETYPE_POLICY_NAME, serviceType);
 440                         policyData.setServiceTypePolicyName(serviceTypePolicyName);
 441                     }
 442                 }
 443             } else if("BRMS_Param".equals(parameters.getPolicyConfigType().toString())){
 444                 Map<AttributeType, Map<String, String>> drlRuleAndUIParams = parameters.getAttributes();
 445                 Map<String, String> rule = drlRuleAndUIParams.get(AttributeType.RULE);
 446                 policyData.setRuleName(rule.get("templateName"));
 447
 448             }
 449         }
 450
 451         return policyData;
 452
 453     }
 454
 455     private JsonObject stringToJsonObject(String value) {
 456         try(JsonReader jsonReader = Json.createReader(new StringReader(value))){
 457             return jsonReader.readObject();
 458         } catch(JsonException| IllegalStateException e){
 459             LOGGER.info(XACMLErrorConstants.ERROR_DATA_ISSUE+ "Improper JSON format... may or may not cause issues in validating the policy: " + value, e);
 460             return null;
 461         }
 462     }
 463
 464     private String convertDate(Date date) {
 465         String strDate = null;
 466         if (date!=null) {
 467             SimpleDateFormat dateformatJava = new SimpleDateFormat("dd-MM-yyyy");
 468             strDate = dateformatJava.format(date);
 469         }
 470         return (strDate==null) ? "NA": strDate;
 471     }
 472
 473 }