| package net.onrc.onos.core.intent.runtime; |
| |
| import java.lang.ref.WeakReference; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.WeakHashMap; |
| import java.util.concurrent.ExecutionException; |
| |
| import net.floodlightcontroller.core.IFloodlightProviderService; |
| import net.floodlightcontroller.core.IOFSwitch; |
| import net.floodlightcontroller.core.internal.OFMessageFuture; |
| import net.onrc.onos.core.flowprogrammer.IFlowPusherService; |
| import net.onrc.onos.core.intent.FlowEntry; |
| import net.onrc.onos.core.util.Pair; |
| |
| import org.openflow.protocol.OFBarrierReply; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * This class is responsible for installing plans (lists of sets of FlowEntries) into local switches. |
| * In this context, a local switch is a switch for which this ONOS instance is the master. |
| * It also is responsible for sending barrier messages between sets. |
| */ |
| |
| public class PlanInstallRuntime { |
| |
| IFlowPusherService pusher; |
| IFloodlightProviderService provider; |
| private static final Logger log = LoggerFactory.getLogger(PlanInstallRuntime.class); |
| |
| /** |
| * Constructor. |
| * |
| * @param provider the FloodlightProviderService for list of local switches |
| * @param pusher the FlowPusherService to use for FlowEntry installation |
| */ |
| public PlanInstallRuntime(IFloodlightProviderService provider, |
| IFlowPusherService pusher) { |
| this.provider = provider; |
| this.pusher = pusher; |
| } |
| |
| /** |
| * This class is a temporary class for collecting FlowMod installation information. It is |
| * largely used for debugging purposes, and it should not be depended on for other purposes. |
| * <p> |
| * TODO: This class should be wrapped into a more generic debugging framework when available. |
| */ |
| private static class FlowModCount { |
| WeakReference<IOFSwitch> sw; |
| long modFlows = 0; |
| long delFlows = 0; |
| long errors = 0; |
| |
| /** |
| * Constructor. |
| * |
| * @param sw the switch for FlowMod statistics collection |
| */ |
| FlowModCount(IOFSwitch sw) { |
| this.sw = new WeakReference<>(sw); |
| } |
| |
| /** |
| * Include the FlowEntry in this switch statistics object. |
| * |
| * @param entry the FlowEntry to count |
| */ |
| void addFlowEntry(FlowEntry entry) { |
| switch (entry.getOperator()) { |
| case ADD: |
| modFlows++; |
| break; |
| case ERROR: |
| errors++; |
| break; |
| case REMOVE: |
| delFlows++; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| /** |
| * Returns a string representation of this object. |
| * |
| * @return string representation of this object |
| */ |
| @Override |
| public String toString() { |
| final IOFSwitch swTemp = sw.get(); |
| return "sw:" + ((swTemp == null) ? "disconnected" : swTemp.getStringId()) |
| + ": modify " + modFlows + " delete " + delFlows + " error " + errors; |
| } |
| |
| static Map<IOFSwitch, FlowModCount> map = new WeakHashMap<>(); |
| |
| /** |
| * This function is used for collecting statistics information. It should be called for |
| * every FlowEntry that is pushed to the switch for accurate statistics. |
| * <p> |
| * This class maintains a map of Switches and FlowModCount collection objects, which |
| * are used for collection. |
| * <p> |
| * TODO: This should be refactored to use a more generic mechanism when available. |
| * |
| * @param sw the switch that entry is being pushed to |
| * @param entry the FlowEntry being pushed |
| */ |
| static void countFlowEntry(IOFSwitch sw, FlowEntry entry) { |
| FlowModCount count = map.get(sw); |
| if (count == null) { |
| count = new FlowModCount(sw); |
| map.put(sw, count); |
| } |
| count.addFlowEntry(entry); |
| } |
| |
| /** |
| * Reset the statistics collection. It should be called when required for debugging. |
| */ |
| static void startCount() { |
| map.clear(); |
| } |
| |
| /** |
| * Print out the statistics information when required for debugging. |
| */ |
| static void printCount() { |
| StringBuilder result = new StringBuilder(); |
| |
| result.append("FLOWMOD COUNT:\n"); |
| for (FlowModCount count : map.values()) { |
| result.append(count.toString() + '\n'); |
| } |
| if (map.values().isEmpty()) { |
| result.append("No flow mods installed\n"); |
| } |
| log.debug(result.toString()); |
| } |
| } |
| |
| /** |
| * This function should be called to install the FlowEntries in the plan. |
| * <p> |
| * Each set of FlowEntries can be installed together, but all entries should be installed |
| * proceeded to the next set. |
| * <p> |
| * TODO: This method lack coordination between the other ONOS instances before proceeded |
| * with the next set of entries |
| * |
| * @param plan list of set of FlowEntries for installation on local switches |
| * @return true (we assume installation is successful) |
| */ |
| public boolean installPlan(List<Set<FlowEntry>> plan) { |
| long start = System.nanoTime(); |
| Map<Long, IOFSwitch> switches = provider.getSwitches(); |
| |
| log.debug("IOFSwitches: {}", switches); |
| FlowModCount.startCount(); |
| for (Set<FlowEntry> phase : plan) { |
| Set<Pair<IOFSwitch, net.onrc.onos.core.util.FlowEntry>> entries = new HashSet<>(); |
| Set<IOFSwitch> modifiedSwitches = new HashSet<>(); |
| |
| long step1 = System.nanoTime(); |
| // convert flow entries and create pairs |
| for (FlowEntry entry : phase) { |
| IOFSwitch sw = switches.get(entry.getSwitch()); |
| if (sw == null) { |
| // no active switch, skip this flow entry |
| log.debug("Skipping flow entry: {}", entry); |
| continue; |
| } |
| entries.add(new Pair<>(sw, entry.getFlowEntry())); |
| modifiedSwitches.add(sw); |
| FlowModCount.countFlowEntry(sw, entry); |
| } |
| long step2 = System.nanoTime(); |
| |
| // push flow entries to switches |
| log.debug("Pushing flow entries: {}", entries); |
| pusher.pushFlowEntries(entries); |
| long step3 = System.nanoTime(); |
| |
| // insert a barrier after each phase on each modifiedSwitch |
| // wait for confirmation messages before proceeding |
| List<Pair<IOFSwitch, OFMessageFuture<OFBarrierReply>>> barriers = new ArrayList<>(); |
| for (IOFSwitch sw : modifiedSwitches) { |
| barriers.add(new Pair<>(sw, pusher.barrierAsync(sw))); |
| } |
| for (Pair<IOFSwitch, OFMessageFuture<OFBarrierReply>> pair : barriers) { |
| IOFSwitch sw = pair.getFirst(); |
| OFMessageFuture<OFBarrierReply> future = pair.getSecond(); |
| try { |
| future.get(); |
| } catch (InterruptedException | ExecutionException e) { |
| log.error("Barrier message not received for sw: {}", sw); |
| } |
| } |
| long step4 = System.nanoTime(); |
| log.debug("MEASUREMENT: convert: {} ns, push: {} ns, barrierWait: {} ns", |
| step2 - step1, step3 - step2, step4 - step3); |
| |
| } |
| long end = System.nanoTime(); |
| log.debug("MEASUREMENT: Install plan: {} ns", (end - start)); |
| FlowModCount.printCount(); |
| |
| // TODO: we assume that the plan installation succeeds for now |
| return true; |
| } |
| } |