private static final String policyDBDaoVar = "PolicyDBDao";
private static final String duplicatePolicyId = "Somehow, more than one policy with the id ";
private static final String foundInDB = " were found in the database";
+ private static final String TIMESTAMP = "\n TimeStamp = ";
+ private static final String CAUGHTEXCEPTIONONNOTIFY = "Caught Exception on notifyOthers(";
private static boolean isJunit = false;
}
}
boolean needToUpdate = false;
- if (updateGroupPoliciesInFileSystem(localGroupClone, localGroup, groupRecord, transaction)) {
+ if (updateGroupPoliciesInFileSystem(localGroupClone, localGroup, groupRecord)) {
needToUpdate = true;
}
if (!stringEquals(localGroupClone.getId(), groupRecord.getGroupId())
// this will also handle removes, since incoming pdpGroup has no policies internally, we are just going to add
// them all in from the db
private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup, OnapPDPGroup oldPdpGroup,
- GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException, PolicyDBException {
+ GroupEntity groupRecord) throws PAPException, PolicyDBException {
if (!(pdpGroup instanceof StdPDPGroup)) {
throw new PAPException("group is not a StdPDPGroup");
}
if (logger.isDebugEnabled()) {
Date date = new java.util.Date();
logger.debug("\n\nTransactionTimer.run() - SLEEPING: " + "\n sleepTime (ms) = " + sleepTime
- + "\n TimeStamp = " + date.getTime() + "\n\n");
+ + TIMESTAMP + date.getTime() + "\n\n");
}
try {
Thread.sleep(sleepTime);
// probably, the transaction was completed, the last thing we want to do is roll back
if (logger.isDebugEnabled()) {
Date date = new java.util.Date();
- logger.debug("\n\nTransactionTimer.run() - WAKE Interrupt: " + "\n TimeStamp = "
+ logger.debug("\n\nTransactionTimer.run() - WAKE Interrupt: " + TIMESTAMP
+ date.getTime() + "\n\n");
}
Thread.currentThread().interrupt();
}
if (logger.isDebugEnabled()) {
Date date = new java.util.Date();
- logger.debug("\n\nTransactionTimer.run() - WAKE Timeout: " + "\n TimeStamp = "
+ logger.debug("\n\nTransactionTimer.run() - WAKE Timeout: " + TIMESTAMP
+ date.getTime() + "\n\n");
}
rollbackTransaction();
notifyOthers(policyId, POLICY_NOTIFICATION, newGroupId);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on notifyOthers(" + policyId + "," + POLICY_NOTIFICATION + ","
+ CAUGHTEXCEPTIONONNOTIFY + policyId + "," + POLICY_NOTIFICATION + ","
+ newGroupId + ")");
}
} else {
notifyOthers(policyId, POLICY_NOTIFICATION);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on notifyOthers(" + policyId + "," + POLICY_NOTIFICATION + ")");
+ CAUGHTEXCEPTIONONNOTIFY + policyId + "," + POLICY_NOTIFICATION + ")");
}
}
}
notifyOthers(groupId, GROUP_NOTIFICATION, newGroupId);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on notifyOthers(" + groupId + "," + GROUP_NOTIFICATION + ","
+ CAUGHTEXCEPTIONONNOTIFY + groupId + "," + GROUP_NOTIFICATION + ","
+ newGroupId + ")");
}
} else {
notifyOthers(groupId, GROUP_NOTIFICATION);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on notifyOthers(" + groupId + "," + GROUP_NOTIFICATION + ")");
+ CAUGHTEXCEPTIONONNOTIFY + groupId + "," + GROUP_NOTIFICATION + ")");
}
}
}
notifyOthers(pdpId, PDP_NOTIFICATION);
} catch (Exception e) {
PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, policyDBDaoVar,
- "Caught Exception on notifyOthers(" + pdpId + "," + PDP_NOTIFICATION + ")");
+ CAUGHTEXCEPTIONONNOTIFY + pdpId + "," + PDP_NOTIFICATION + ")");
}
}
}
newConfigurationDataEntity.setModifiedBy(username);
}
if (newConfigurationDataEntity.getDescription() == null
- || !newConfigurationDataEntity.getDescription().equals("")) {
+ || !"".equals(newConfigurationDataEntity.getDescription())) {
newConfigurationDataEntity.setDescription("");
}
if (newConfigurationDataEntity.getConfigBody() == null
}
protected void doPutConfig(String config, HttpServletRequest request, HttpServletResponse response,
- ONAPLoggingContext loggingContext) throws ServletException, IOException {
+ ONAPLoggingContext loggingContext) throws IOException {
try {
// prevent multiple configuration changes from stacking up
logger.info("XACMLPdpServlet: checking remainingCapacity of Queue.");
XACMLRest.dumpRequest(request);
String pathInfo = request.getRequestURI();
- if (pathInfo != null) {
+ if (pathInfo != null && "/pdp/test".equals(pathInfo)) {
// health check from Global Site Selector (iDNS).
// DO NOT do a im.startTransaction for the test request
- if (pathInfo.equals("/pdp/test")) {
- loggingContext.setServiceName("iDNS:PDP.test");
+ loggingContext.setServiceName("iDNS:PDP.test");
+ try {
+ im.evaluateSanity();
+ // If we make it this far, all is well
+ String message = "GET:/pdp/test called and PDP " + pdpResourceName + " is OK";
+ PolicyLogger.debug(message);
+ PolicyLogger.audit("Success");
+ response.setStatus(HttpServletResponse.SC_OK);
+ return;
+ } catch (ForwardProgressException | AdministrativeStateException | StandbyStatusException fpe) {
+ // No forward progress is being made
+ String message = "GET:/pdp/test called and PDP " + pdpResourceName + " is not making forward progress."
+ + " Exception Message: " + fpe.getMessage();
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, message + fpe);
+ PolicyLogger.audit("Transaction Failed - See Error.log");
try {
- im.evaluateSanity();
- // If we make it this far, all is well
- String message = "GET:/pdp/test called and PDP " + pdpResourceName + " is OK";
- PolicyLogger.debug(message);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Success");
- response.setStatus(HttpServletResponse.SC_OK);
- return;
- } catch (ForwardProgressException fpe) {
- // No forward progress is being made
- String message = "GET:/pdp/test called and PDP " + pdpResourceName
- + " is not making forward progress." + " Exception Message: " + fpe.getMessage();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, message + fpe);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- try {
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- } catch (Exception e1) {
- logger.error("Exception occured while sending error in response" + e1);
- }
- return;
- } catch (AdministrativeStateException ase) {
- // Administrative State is locked
- String message = "GET:/pdp/test called and PDP " + pdpResourceName
- + " Administrative State is LOCKED " + " Exception Message: " + ase.getMessage();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, message + ase);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- try {
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- } catch (Exception e1) {
- logger.error("Exception occured while sending error in response" + e1);
- }
- return;
- } catch (StandbyStatusException sse) {
- // Administrative State is locked
- String message = "GET:/pdp/test called and PDP " + pdpResourceName
- + " Standby Status is NOT PROVIDING SERVICE " + " Exception Message: " + sse.getMessage();
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, message + sse);
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log");
- try {
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- } catch (Exception e1) {
- logger.error("Exception occured while sending error in response" + e1);
- }
- return;
- } catch (Exception e) {
- // A subsystem is not making progress or is not responding
- String eMsg = e.getMessage();
- if (eMsg == null) {
- eMsg = "No Exception Message";
- }
- String message = "GET:/pdp/test called and PDP " + pdpResourceName + " has had a subsystem failure."
- + " Exception Message: " + eMsg;
- PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, message);
- // Get the specific list of subsystems that failed
- String failedNodeList = null;
- for (String node : dependencyNodes) {
- if (eMsg.contains(node)) {
- if (failedNodeList == null) {
- failedNodeList = node;
- } else {
- failedNodeList = failedNodeList.concat("," + node);
- }
+ response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
+ } catch (Exception e1) {
+ logger.error("Exception occured while sending error in response" + e1);
+ }
+ return;
+ } catch (Exception e) {
+ // A subsystem is not making progress or is not responding
+ String eMsg = e.getMessage();
+ if (eMsg == null) {
+ eMsg = "No Exception Message";
+ }
+ String message = "GET:/pdp/test called and PDP " + pdpResourceName + " has had a subsystem failure."
+ + " Exception Message: " + eMsg;
+ PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, message);
+ // Get the specific list of subsystems that failed
+ String failedNodeList = null;
+ for (String node : dependencyNodes) {
+ if (eMsg.contains(node)) {
+ if (failedNodeList == null) {
+ failedNodeList = node;
+ } else {
+ failedNodeList = failedNodeList.concat("," + node);
}
}
- if (failedNodeList == null) {
- failedNodeList = "UnknownSubSystem";
- }
- response.addHeader("X-ONAP-SubsystemFailure", failedNodeList);
- try {
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
- } catch (Exception e1) {
- logger.error("Exception occured while sending error in response" + e1);
- }
- loggingContext.transactionEnded();
- PolicyLogger.audit("Transaction Failed - See Error.log" + e);
- return;
}
+ if (failedNodeList == null) {
+ failedNodeList = "UnknownSubSystem";
+ }
+ response.addHeader("X-ONAP-SubsystemFailure", failedNodeList);
+ try {
+ response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message);
+ } catch (Exception e1) {
+ logger.error("Exception occured while sending error in response" + e1);
+ }
+ PolicyLogger.audit("Transaction Failed - See Error.log" + e);
+ return;
+ } finally {
+ loggingContext.transactionEnded();
}
}
if (contentType.getMimeType().equalsIgnoreCase(ContentType.APPLICATION_JSON.getMimeType())) {
pdpRequest = JSONRequest.load(incomingRequestString);
} else if (contentType.getMimeType().equalsIgnoreCase(ContentType.APPLICATION_XML.getMimeType())
- || contentType.getMimeType().equalsIgnoreCase("application/xacml+xml")) {
+ || "application/xacml+xml".equalsIgnoreCase(contentType.getMimeType())) {
pdpRequest = DOMRequest.load(incomingRequestString);
}
} catch (Exception e) {
// Did we successfully get and parse a request?
//
if (pdpRequest == null || pdpRequest.getRequestAttributes() == null
- || pdpRequest.getRequestAttributes().size() <= 0) {
+ || pdpRequest.getRequestAttributes().isEmpty()) {
String message = "Zero Attributes found in the request";
logger.error(XACMLErrorConstants.ERROR_DATA_ISSUE + message);
PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, message);
private String blackListEntryType;
private String rawXacmlPolicy;
- public String getRawXacmlPolicy() {
- return rawXacmlPolicy;
- }
-
- public void setRawXacmlPolicy(String rawXacmlPolicy) {
- this.rawXacmlPolicy = rawXacmlPolicy;
- }
-
// Rainy Day Decision
private RainyDayParams rainyday;
private Map<String, String> rainydayMap;
public void setBlackListEntryType(String blackListEntryType) {
this.blackListEntryType = blackListEntryType;
}
+
+ public String getRawXacmlPolicy() {
+ return rawXacmlPolicy;
+ }
+
+ public void setRawXacmlPolicy(String rawXacmlPolicy) {
+ this.rawXacmlPolicy = rawXacmlPolicy;
+ }
}
addEnumClassMap();
}
if (!matchingClass.isEmpty()){
- CheckForMatchingClass();
+ checkForMatchingClass();
}
}
- private void CheckForMatchingClass() {
+ private void checkForMatchingClass() {
HashMap<String, String> tempAttribute = new HashMap<>();
for (Entry<String, String> set : matchingClass.entrySet()){
}
}
- UpdateMatching(tempAttribute, key);
+ updateMatching(tempAttribute, key);
}
}
- private void UpdateMatching(HashMap<String, String> tempAttribute, String key) {
+ private void updateMatching(HashMap<String, String> tempAttribute, String key) {
Map<String, MSAttributeObject> newClass = classMap;
for (Entry<String, MSAttributeObject> updateClass : newClass.entrySet()){
}
public String checkRequiredPattern(int upper, int lower) {
-
String pattern = XACMLProperties.getProperty(XACMLRestProperties.PROP_XCORE_REQUIRED_PATTERN);
-
- if (pattern!=null){
- if (upper == Integer.parseInt(pattern.split(",")[1]) && lower==Integer.parseInt(pattern.split(",")[0])){
- return REQUIREDTRUE;
- }
+ if (pattern!=null && upper == Integer.parseInt(pattern.split(",")[1]) && lower==Integer.parseInt(pattern.split(",")[0])){
+ return REQUIREDTRUE;
}
-
return REQUIREDFALSE;
}
public JSONObject buildJavaObject(Map<String, String> map){
-
return new JSONObject(map);
}
* For TOSCA Model
*/
public String parseTosca(String fileName) {
- LinkedHashMap<String, String> map = new LinkedHashMap<>();
+ Map<String, String> map = new LinkedHashMap<>();
try {
map = load(fileName);
if (map != null && map.get(ERROR) != null) {
}
@SuppressWarnings("unchecked")
- public LinkedHashMap<String, String> load(String fileName) throws IOException, ParserException {
+ public Map<String, String> load(String fileName) throws IOException, ParserException {
File newConfiguration = new File(fileName);
- StringBuffer orderInfo = new StringBuffer("[");
+ StringBuilder orderInfo = new StringBuilder("[");
Yaml yaml = new Yaml();
LinkedHashMap<Object, Object> yamlMap = null;
try (InputStream is = new FileInputStream(newConfiguration)) {
} catch (FileNotFoundException e) {
logger.error(e);
} catch (Exception e) {
+ logger.error(e);
throw new ParserException("Invalid TOSCA Model format. Please make sure it is a valid YAML file");
}
findNode(yamlMap);
- if (!isDuplicatedAttributes && orderedElements != null && orderedElements.size() > 0) {
- orderedElements.stream().forEach((string) -> {
+ if (!isDuplicatedAttributes && orderedElements != null && !orderedElements.isEmpty()) {
+ orderedElements.stream().forEach(string -> {
orderInfo.append(string);
orderInfo.append(",");
logger.info("Content: " + string);
}
- void parseDataAndPolicyNodes(LinkedHashMap<String, String> map) {
+ void parseDataAndPolicyNodes(Map<String, String> map) {
for (String key : map.keySet()) {
if (key.contains("policy.nodes.Root")) {
continue;
logger.info("###############################################################################");
}
- LinkedHashMap<String, String> parseDataNodes(LinkedHashMap<String, String> map) {
+ LinkedHashMap<String, String> parseDataNodes(Map<String, String> map) {
LinkedHashMap<String, String> dataMapForJson = new LinkedHashMap<>();
matchableValues = new HashMap<>();
for (String uniqueDataKey : uniqueDataKeys) {
if (constraintsValue == null) {
break;
} else {
- System.out.println("constraintsValue => " + constraintsValue);
+ logger.info("constraintsValue => " + constraintsValue);
if (constraintsValue.contains("=")) {
constraintsValue = constraintsValue.replace("=", "equal-sign");
}
+ ".description";
String userDefinedValue = map.get(findUserDefined);
String description = map.get(findDescription);
- // String requiredValue = map.get(required);
String trimValue = userDefinedValue.substring(userDefinedValue.lastIndexOf('.') + 1);
StringBuilder referenceIndividualStringBuilder = new StringBuilder();
referenceIndividualStringBuilder.append(trimValue + REQUIREDVALUE);
for (Map.Entry<String, LinkedHashMap<String, String>> entry : mapKey.entrySet()) {
String keySetString = entry.getKey();
LinkedHashMap<String, String> keyValues = mapKey.get(keySetString);
- if (keyValues.get("type") != null && keyValues.get("type").equalsIgnoreCase(STRING)
- || keyValues.get("type") != null && keyValues.get("type").equalsIgnoreCase(INTEGER)
- || keyValues.get("type") != null && keyValues.get("type").equalsIgnoreCase(BOOLEAN)) {
+ if (keyValues.get("type") != null && (STRING.equalsIgnoreCase(keyValues.get("type"))
+ || INTEGER.equalsIgnoreCase(keyValues.get("type"))
+ || BOOLEAN.equalsIgnoreCase(keyValues.get("type")))) {
StringBuilder attributeIndividualStringBuilder = new StringBuilder();
attributeIndividualStringBuilder.append(keySetString + "=");
attributeIndividualStringBuilder.append(keyValues.get("type") + DEFAULTVALUE);
attributeIndividualStringBuilder.append(keyValues.get("required") + MANYFALSE);
attributeIndividualStringBuilder.append(DESCRIPTION_TOKEN + keyValues.get(DESCRIPTION_KEY));
attributeStringBuilder.append(attributeIndividualStringBuilder + ",");
- if (keyValues.get(MATCHABLEKEY) != null && keyValues.get(MATCHABLEKEY).equalsIgnoreCase("true")) {
+ if (keyValues.get(MATCHABLEKEY) != null && "true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))) {
matchableValues.put(keySetString, MATCHINGTRUE);
}
} else if (LIST.equalsIgnoreCase(keyValues.get("type"))) {
-
if ("true".equalsIgnoreCase(keyValues.get(MATCHABLEKEY))) {
matchableValues.put(keySetString, MATCHINGTRUE);
}
- // List Datatype
+ // List Data type
Set<String> keys = keyValues.keySet();
Iterator<String> itr = keys.iterator();
boolean isDefinedType = false;
}
- if (!isDefinedType && LIST.equalsIgnoreCase(keyValues.get("type"))) {
+ if (!isDefinedType && LIST.equalsIgnoreCase(keyValues.get("type"))) {
if (constraints == null || constraints.isEmpty()) {
referenceStringBuilder.append(keySetString + "=MANY-true" + ",");
}
}
}
- if (constraints != null && constraints.isEmpty() == false) {
+ if (constraints != null && !constraints.isEmpty()) {
// List handling.
listBuffer.append(keySetString.toUpperCase() + "=[");
for (String str : constraints) {
if (key.equals(PROPERTIES_KEY) && value instanceof Map) {
saveNodes((LinkedHashMap<?, ?>) value);
if (isDuplicatedAttributes) {
- orderedElements = new ArrayList<String>();
+ orderedElements = new ArrayList<>();
return;
}
}
- if (!key.equals("policy.nodes.Root")) {
+ if (!"policy.nodes.Root".equals(key) && value instanceof Map) {
// value is a Map object, then make a recursive call
- if (value instanceof Map) {
- findNode((LinkedHashMap<Object, Object>) value);
- }
+ findNode((LinkedHashMap<Object, Object>) value);
}
});
if (policy instanceof PolicyType) {
policyElement = new ObjectFactory().createPolicy((PolicyType) policy);
return getByteArrayInputStream(policyElement, PolicyType.class);
- } else if (policy instanceof PolicyType) {
+ } else if (policy instanceof PolicySetType) {
policyElement = new ObjectFactory().createPolicySet((PolicySetType) policy);
return getByteArrayInputStream(policyElement, PolicySetType.class);
}
@RequestMapping("/")
public class DecisionPolicyController extends RestrictedBaseController {
private static final Logger policyLogger = FlexLogger.getLogger(DecisionPolicyController.class);
-
- public DecisionPolicyController() {
- // This constructor is empty
- }
-
+
+ public static final String FUNCTION_NOT = "urn:oasis:names:tc:xacml:1.0:function:not";
+ private static final String BLENTRY = "@blEntry@";
+ private static final String DECISIONRAWTYPE = "@#RuleProvider@#Decision_Raw@#RuleProvider@#";
+ private static final String GUARD_YAML= "GUARD_YAML";
+ private static final String GUARD_BL_YAML= "GUARD_BL_YAML";
+
protected PolicyRestAdapter policyAdapter = null;
- private ArrayList<Object> attributeList;
- private ArrayList<Object> decisionList;
private ArrayList<Object> ruleAlgorithmList;
private ArrayList<Object> treatmentList = null;
protected LinkedList<Integer> ruleAlgoirthmTracker;
- public static final String FUNCTION_NOT = "urn:oasis:names:tc:xacml:1.0:function:not";
- private static final String blEntry = "@blEntry@";
- private static final String decisionRawType = "@#RuleProvider@#Decision_Raw@#RuleProvider@#";
-
+
+ public DecisionPolicyController() {
+ // This constructor is empty
+ }
+
public void rawXACMLPolicy(PolicyRestAdapter policyAdapter, PolicyEntity entity) {
try (InputStream policyXmlStream = XACMLPolicyWriter.getXmlAsInputStream(policyAdapter.getPolicyData())) {
String name = StringUtils.substringAfter(entity.getPolicyName(), "Decision_");
policyAdapter.setPolicyName(name.substring(0, name.indexOf('.')));
policyAdapter.setRuleProvider("Raw");
- policyAdapter.setRawXacmlPolicy(IOUtils.toString(policyXmlStream).replaceAll(decisionRawType, ""));
+ policyAdapter.setRawXacmlPolicy(IOUtils.toString(policyXmlStream).replaceAll(DECISIONRAWTYPE, ""));
} catch (IOException e) {
policyLogger.error("Exception Occured while setting XACML Raw Object" + e);
}
@SuppressWarnings("unchecked")
public void prePopulateDecisionPolicyData(PolicyRestAdapter policyAdapter, PolicyEntity entity) {
- attributeList = new ArrayList<>();
- decisionList = new ArrayList<>();
+ List<Object> attributeList = new ArrayList<>();
+ List<Object> decisionList = new ArrayList<>();
ruleAlgorithmList = new ArrayList<>();
treatmentList = new ArrayList<>();
boolean rawPolicyCheck = false;
if (policyAdapter.getPolicyData() instanceof PolicySetType) {
- rawPolicyCheck = ((PolicySetType) policyAdapter.getPolicyData()).getDescription().contains(decisionRawType);
+ rawPolicyCheck = ((PolicySetType) policyAdapter.getPolicyData()).getDescription().contains(DECISIONRAWTYPE);
} else {
- rawPolicyCheck = ((PolicyType) policyAdapter.getPolicyData()).getDescription().contains(decisionRawType);
+ rawPolicyCheck = ((PolicyType) policyAdapter.getPolicyData()).getDescription().contains(DECISIONRAWTYPE);
}
if (rawPolicyCheck) {
String description = "";
String blackListEntryType = "Use Manual Entry";
try {
- if (policy.getDescription().contains(blEntry)) {
- blackListEntryType = policy.getDescription().substring(policy.getDescription().indexOf(blEntry) + 9,
- policy.getDescription().lastIndexOf(blEntry));
+ if (policy.getDescription().contains(BLENTRY)) {
+ blackListEntryType = policy.getDescription().substring(policy.getDescription().indexOf(BLENTRY) + 9,
+ policy.getDescription().lastIndexOf(BLENTRY));
}
policyAdapter.setBlackListEntryType(blackListEntryType);
description = policy.getDescription().substring(0, policy.getDescription().indexOf("@CreatedBy:"));
.getAdviceExpression().get(0).getAdviceId())) {
policyAdapter.setRuleProvider("AAF");
break;
- } else if ("GUARD_YAML".equalsIgnoreCase(((RuleType) object).getAdviceExpressions()
+ } else if (GUARD_YAML.equalsIgnoreCase(((RuleType) object).getAdviceExpressions()
.getAdviceExpression().get(0).getAdviceId())) {
- policyAdapter.setRuleProvider("GUARD_YAML");
- } else if ("GUARD_BL_YAML".equalsIgnoreCase(((RuleType) object).getAdviceExpressions()
+ policyAdapter.setRuleProvider(GUARD_YAML);
+ } else if (GUARD_BL_YAML.equalsIgnoreCase(((RuleType) object).getAdviceExpressions()
.getAdviceExpression().get(0).getAdviceId())) {
- policyAdapter.setRuleProvider("GUARD_BL_YAML");
+ policyAdapter.setRuleProvider(GUARD_BL_YAML);
}
} else {
policyAdapter.setRuleProvider("Custom");
decisionApply = (ApplyType) decisionApply.getExpression().get(0).getValue();
ruleAlgoirthmTracker = new LinkedList<>();
if (policyAdapter.getRuleProvider() != null
- && ("GUARD_YAML".equals(policyAdapter.getRuleProvider())
- || ("GUARD_BL_YAML".equals(policyAdapter.getRuleProvider())))) {
+ && (GUARD_YAML.equals(policyAdapter.getRuleProvider())
+ || (GUARD_BL_YAML.equals(policyAdapter.getRuleProvider())))) {
YAMLParams yamlParams = new YAMLParams();
for (int i = 0; i < attributeList.size(); i++) {
Map<String, String> map = (Map<String, String>) attributeList.get(i);
yamlParams.setGuardActiveEnd(
((AttributeValueType) apply.getExpression().get(2).getValue()).getContent()
.get(0).toString());
- if ("GUARD_BL_YAML".equals(policyAdapter.getRuleProvider())) {
+ if (GUARD_BL_YAML.equals(policyAdapter.getRuleProvider())) {
apply = (ApplyType) ((ApplyType) ((ApplyType) decisionApply.getExpression()
.get(0).getValue()).getExpression().get(1).getValue()).getExpression()
.get(2).getValue();
Code Review / policy / engine.git / commitdiff