protected List<FilteringObjective> updateFilterSequential(FilteringObjective filteringObjective) { List<FilteringObjective> leftUpdates = this.leftChild.updateFilter(filteringObjective); List<FilteringObjective> rightUpdates = this.rightChild.updateFilter(filteringObjective); return this.filterTable.updateFilter(leftUpdates); }
public FlowObjectiveCompositionTree(short applicationId) { this.operator = FlowObjectiveCompositionManager.PolicyOperator.Application; this.leftChild = null; this.rightChild = null; this.applicationId = applicationId; this.filterTable = new FilterTable(); this.forwardTable = new ForwardTable(); this.nextTable = new NextTable(); this.priorityMultiplier = 10; this.priorityAddend = 10; }
public ForwardUpdateTable updateForward(List<ForwardingObjective> forwardingObjectives) { ForwardUpdateTable updates = new ForwardUpdateTable(); for (ForwardingObjective forwardingObjective : forwardingObjectives) { updates.addUpdateTable(this.updateForward(forwardingObjective)); } return updates; }
protected List<FilteringObjective> updateFilter(FilteringObjective filteringObjective) { switch (this.operator) { case Parallel: return updateFilterParallel(filteringObjective); case Sequential: return updateFilterSequential(filteringObjective); case Override: return updateFilterOverride(filteringObjective); case Application: if (filteringObjective.appId().id() == this.applicationId) { return this.filterTable.updateFilter(filteringObjective); } else { return new ArrayList<>(); } default: return new ArrayList<>(); } }
@Override public void forward(DeviceId deviceId, ForwardingObjective forwardingObjective) { checkPermission(FLOWRULE_WRITE); if (queueObjective(deviceId, forwardingObjective)) { return; } List<ForwardingObjective> forwardingObjectives = this.deviceCompositionTreeMap.get(deviceId).updateForward(forwardingObjective); for (ForwardingObjective tmp : forwardingObjectives) { executorService.execute(new ObjectiveInstaller(deviceId, tmp)); } }
public ForwardUpdateTable updateForwardNode(ForwardingObjective forwardingObjective) { switch (this.operator) { case Parallel: case Sequential: case Override: return updateForwardComposition(forwardingObjective); case Application: if (forwardingObjective.appId().id() == this.applicationId) { return this.forwardTable.updateForward(forwardingObjective); } else { return (new ForwardUpdateTable()); } default: return (new ForwardUpdateTable()); } }
public List<ForwardingObjective> updateForward(ForwardingObjective forwardingObjective) { return this.updateForwardNode(forwardingObjective).toForwardingObjectiveList(); }
public static FlowObjectiveCompositionTree parsePolicyString(String policy) { List<FlowObjectiveCompositionTree> postfix = transformToPostfixForm(policy); return buildPolicyTree(postfix); }
protected List<NextObjective> updateNextComposition(NextObjective nextObjective) { List<NextObjective> leftUpdates = this.leftChild.updateNext(nextObjective); List<NextObjective> rightUpdates = this.rightChild.updateNext(nextObjective); List<NextObjective> updates = new ArrayList<>(); updates.addAll(leftUpdates); updates.addAll(rightUpdates); return this.nextTable.updateNext(updates); }
@Override public void filter(DeviceId deviceId, FilteringObjective filteringObjective) { checkPermission(FLOWRULE_WRITE); List<FilteringObjective> filteringObjectives = this.deviceCompositionTreeMap.get(deviceId).updateFilter(filteringObjective); for (FilteringObjective tmp : filteringObjectives) { executorService.execute(new ObjectiveInstaller(deviceId, tmp)); } }
@Override public void next(DeviceId deviceId, NextObjective nextObjective) { checkPermission(FLOWRULE_WRITE); List<NextObjective> nextObjectives = this.deviceCompositionTreeMap.get(deviceId).updateNext(nextObjective); for (NextObjective tmp : nextObjectives) { executorService.execute(new ObjectiveInstaller(deviceId, tmp)); } }
public List<NextObjective> updateNext(NextObjective nextObjective) { switch (this.operator) { case Parallel: case Sequential: case Override: return updateNextComposition(nextObjective); case Application: if (nextObjective.appId().id() == this.applicationId) { return this.nextTable.updateNext(nextObjective); } else { return new ArrayList<>(); } default: return new ArrayList<>(); } }
public void deleteGeneratedParentForwardingObjective(List<ForwardingObjective> children) { for (ForwardingObjective fo : children) { this.generatedParentForwardingObjectiveMap.remove(forwardingObjectiveHash(fo)); } }
public List<FilteringObjective> updateFilter(List<FilteringObjective> filteringObjectives) { List<FilteringObjective> updates = new ArrayList<>(); for (FilteringObjective filteringObjective : filteringObjectives) { updates.addAll(this.updateFilter(filteringObjective)); } return updates; }
public List<NextObjective> updateNext(List<NextObjective> nextObjectives) { List<NextObjective> updates = new ArrayList<>(); for (NextObjective nextObjective : nextObjectives) { updates.addAll(this.updateNext(nextObjective)); } return updates; }
public FlowObjectiveCompositionTree(Character ch) { switch (ch) { case '+': this.operator = FlowObjectiveCompositionManager.PolicyOperator.Parallel; break; case '>': this.operator = FlowObjectiveCompositionManager.PolicyOperator.Sequential; break; case '/': this.operator = FlowObjectiveCompositionManager.PolicyOperator.Override; break; default: this.operator = FlowObjectiveCompositionManager.PolicyOperator.Application; break; } this.leftChild = null; this.rightChild = null; this.applicationId = (short) -1; this.filterTable = new FilterTable(); this.forwardTable = new ForwardTable(); this.nextTable = new NextTable(); this.priorityMultiplier = 10; this.priorityAddend = 10; }
protected List<FilteringObjective> updateFilterOverride(FilteringObjective filteringObjective) { List<FilteringObjective> leftUpdates = this.leftChild.updateFilter(filteringObjective); List<FilteringObjective> rightUpdates = this.rightChild.updateFilter(filteringObjective); return this.filterTable.updateFilter(leftUpdates); }
private List<ForwardingObjective> getGeneratedParentForwardingObjective(ForwardingObjective child) { return this.generatedParentForwardingObjectiveMap.get(forwardingObjectiveHash(child)); }
protected List<FilteringObjective> updateFilterParallel(FilteringObjective filteringObjective) { List<FilteringObjective> leftUpdates = this.leftChild.updateFilter(filteringObjective); List<FilteringObjective> rightUpdates = this.rightChild.updateFilter(filteringObjective); List<FilteringObjective> updates = new ArrayList<>(); updates.addAll(leftUpdates); updates.addAll(rightUpdates); return this.filterTable.updateFilter(updates); }
public void addGeneratedParentForwardingObjective(ForwardingObjective child, ForwardingObjective parent) { this.generatedParentForwardingObjectiveMap.get(forwardingObjectiveHash(child)).add(parent); }