private Rule createRule(int order, SecurityRule secRule, ActionChoice action) { return new RuleBuilder().setName(SecRuleNameDecoder.getRuleName(secRule)) .setOrder(order) .setActionRef(ImmutableList.of(SecRuleEntityDecoder.createActionRefFromActionChoice(action))) .setClassifierRef(ImmutableList.<ClassifierRef>of(classifierRef)) .build(); }
private boolean isSameDirection(Direction direction, Rule rule) { for (ClassifierRef classifier : rule.getClassifierRef()) { if (direction.equals(classifier.getDirection()) || direction.equals(Direction.Bidirectional) || Direction.Bidirectional.equals(classifier.getDirection())) { return true; } } return false; }
private List<SecurityRule> getSecurityRules(Contract contract, SubjectName subjectRef, List<Rule> subRules) { List<SecurityRule> securityRules = new ArrayList<>(); for (Rule rule : subRules) { List<ClassifierRef> classifierRefs = rule.getClassifierRef(); List<RuleClassifier> pClassifiers = null; if (classifierRefs == null || classifierRefs.isEmpty()) { LOG.warn("Rule {} in Subject {} in Contract {} doesn't have classifiers", rule.getName(), subjectRef, contract.getId()); } else { if (pClassifiers == null || pClassifiers.isEmpty()) { LOG.warn("Rule {} in Subject {} in Contract {} doesn't have classifiers -- Will ignore this rule", rule.getName(), subjectRef, contract.getId()); List<ActionRef> actionRefs = rule.getActionRef(); List<RuleAction> pActions = null; if (actionRefs == null || actionRefs.isEmpty()) { LOG.warn("Rule {} in Subject {} in Contract {} doesn't have actions", rule.getName(), subjectRef, contract.getId()); } else { pActions = getActions(contract, actionRefs); if (pActions == null || pActions.isEmpty()) { LOG.warn("Rule {} in Subject {} in Contract {} doesn't have actions", rule.getName(), subjectRef, contract.getId()); securityRules.add(new SecurityRuleBuilder().setName(new Name(rule.getName().getValue())) .setOrder(rule.getOrder()) .setRuleClassifier(pClassifiers) .setRuleAction(pActions)
Map<String, ParameterValue> paramsFromClassifier = new HashMap<>(); Set<ClassifierDefinitionId> classifiers = new HashSet<>(); for (ClassifierRef cr : rule.getClassifierRef()) { throw new IllegalArgumentException("Classification error in rule: " + rule.getName() + ".\nCause: " + "Classification conflict detected at parameter " + v.getName()); if (!result.isSuccessfull()) { throw new IllegalArgumentException("Classification conflict detected in rule: " + rule.getName() + ".\nCause: " + result.getErrorMessage());
private List<String> resolveSymetricChainActions(Direction direction, Rule rule, IndexedTenant tenant, List<Rule> reversedProvidedRules, List<Rule> consumedRules) { List<String> chainNames = new ArrayList<>(); if (rule.getActionRef() != null) { for (ActionRef actionRef : rule.getActionRef()) { ActionInstance actionInstance = tenant.getAction(actionRef.getName()); if (actionInstance == null) { if (oppositeRule.getActionRef() == null) { continue; for (ActionRef oppositeActionRef : oppositeRule.getActionRef()) { ActionInstance oppositeActionInstance = tenant.getAction(oppositeActionRef.getName()); if (oppositeActionInstance == null) {
public SingleRuleContract(SecurityRule secRule, SingleClassifierRule singleClassifierRule, @Nullable Description contractDescription) { checkNotNull(secRule); this.singleClassifierRule = checkNotNull(singleClassifierRule); this.rule = singleClassifierRule.getRule(); this.subject = new SubjectBuilder().setName(SecRuleNameDecoder.getSubjectName(secRule)) .setOrder(singleClassifierRule.getRule().getOrder()) .setRule(ImmutableList.of(rule)) .build(); this.clause = SecRuleEntityDecoder.getClause(secRule); this.contract = new ContractBuilder().setId(SecRuleEntityDecoder.getContractId(secRule)) .setSubject(ImmutableList.of(subject)) .setClause(ImmutableList.of(clause)) .setDescription(contractDescription) .build(); }
private static Rule createRuleAllow(ClassifierName classifierName, Direction direction) { ClassifierName name = new ClassifierName(direction.name() + MappingUtils.NAME_DOUBLE_DELIMETER + classifierName.getValue()); ClassifierRef classifierRef = new ClassifierRefBuilder().setName(name) .setInstanceName(classifierName) .setDirection(direction) .build(); return new RuleBuilder().setName(new RuleName(name)) .setActionRef(ImmutableList.<ActionRef>of(MappingUtils.ACTION_REF_ALLOW)) .setClassifierRef(ImmutableList.of(classifierRef)) .build(); }
private List<ActionBuilder> createActions(OfWriter ofWriter, NetworkElements netElements, Direction direction, IndexedTenant contractTenant, Rule rule, List<String> resolvedSymmetricChains) { List<ActionBuilder> actionBuilderList = new ArrayList<>(); if (rule.getActionRef() != null) { List<ActionRef> actionRefList = new ArrayList<>(rule.getActionRef()); Collections.sort(actionRefList, ActionRefComparator.INSTANCE);