| package net.floodlightcontroller.staticflowentry; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import net.floodlightcontroller.core.FloodlightContext; |
| import net.floodlightcontroller.core.IFloodlightProviderService; |
| import net.floodlightcontroller.core.IFloodlightProviderService.Role; |
| import net.floodlightcontroller.core.IHAListener; |
| import net.floodlightcontroller.core.IOFMessageListener; |
| import net.floodlightcontroller.core.IOFSwitch; |
| import net.floodlightcontroller.core.IOFSwitchListener; |
| import net.floodlightcontroller.core.annotations.LogMessageCategory; |
| import net.floodlightcontroller.core.annotations.LogMessageDoc; |
| import net.floodlightcontroller.core.module.FloodlightModuleContext; |
| import net.floodlightcontroller.core.module.FloodlightModuleException; |
| import net.floodlightcontroller.core.module.IFloodlightModule; |
| import net.floodlightcontroller.core.module.IFloodlightService; |
| import net.floodlightcontroller.core.util.AppCookie; |
| import net.floodlightcontroller.restserver.IRestApiService; |
| import net.floodlightcontroller.staticflowentry.web.StaticFlowEntryWebRoutable; |
| |
| import org.openflow.protocol.OFFlowMod; |
| import org.openflow.protocol.OFFlowRemoved; |
| import org.openflow.protocol.OFMatch; |
| import org.openflow.protocol.OFMessage; |
| import org.openflow.protocol.OFType; |
| import org.openflow.protocol.factory.BasicFactory; |
| import org.openflow.util.HexString; |
| import org.openflow.util.U16; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| @LogMessageCategory("Static Flow Pusher") |
| /** |
| * This module is responsible for maintaining a set of static flows on |
| * switches. This is just a big 'ol dumb list of flows and something external |
| * is responsible for ensuring they make sense for the network. |
| */ |
| public class StaticFlowEntryPusher |
| implements IOFSwitchListener, IFloodlightModule, IStaticFlowEntryPusherService, |
| /*IStorageSourceListener,*/ IOFMessageListener, IHAListener { |
| protected final static Logger log = LoggerFactory.getLogger(StaticFlowEntryPusher.class); |
| public static final String StaticFlowName = "staticflowentry"; |
| |
| public static final int STATIC_FLOW_APP_ID = 10; |
| |
| public static final String TABLE_NAME = "controller_staticflowtableentry"; |
| public static final String COLUMN_NAME = "name"; |
| public static final String COLUMN_SWITCH = "switch_id"; |
| public static final String COLUMN_ACTIVE = "active"; |
| public static final String COLUMN_IDLE_TIMEOUT = "idle_timeout"; |
| public static final String COLUMN_HARD_TIMEOUT = "hard_timeout"; |
| public static final String COLUMN_PRIORITY = "priority"; |
| public static final String COLUMN_COOKIE = "cookie"; |
| public static final String COLUMN_WILDCARD = "wildcards"; |
| public static final String COLUMN_IN_PORT = "in_port"; |
| public static final String COLUMN_DL_SRC = "dl_src"; |
| public static final String COLUMN_DL_DST = "dl_dst"; |
| public static final String COLUMN_DL_VLAN = "dl_vlan"; |
| public static final String COLUMN_DL_VLAN_PCP = "dl_vlan_pcp"; |
| public static final String COLUMN_DL_TYPE = "dl_type"; |
| public static final String COLUMN_NW_TOS = "nw_tos"; |
| public static final String COLUMN_NW_PROTO = "nw_proto"; |
| public static final String COLUMN_NW_SRC = "nw_src"; // includes CIDR-style |
| // netmask, e.g. |
| // "128.8.128.0/24" |
| public static final String COLUMN_NW_DST = "nw_dst"; |
| public static final String COLUMN_TP_DST = "tp_dst"; |
| public static final String COLUMN_TP_SRC = "tp_src"; |
| public static final String COLUMN_ACTIONS = "actions"; |
| public static String ColumnNames[] = { COLUMN_NAME, COLUMN_SWITCH, |
| COLUMN_ACTIVE, COLUMN_IDLE_TIMEOUT, COLUMN_HARD_TIMEOUT, |
| COLUMN_PRIORITY, COLUMN_COOKIE, COLUMN_WILDCARD, COLUMN_IN_PORT, |
| COLUMN_DL_SRC, COLUMN_DL_DST, COLUMN_DL_VLAN, COLUMN_DL_VLAN_PCP, |
| COLUMN_DL_TYPE, COLUMN_NW_TOS, COLUMN_NW_PROTO, COLUMN_NW_SRC, |
| COLUMN_NW_DST, COLUMN_TP_DST, COLUMN_TP_SRC, COLUMN_ACTIONS }; |
| |
| |
| protected IFloodlightProviderService floodlightProvider; |
| //protected IStorageSourceService storageSource; |
| protected IRestApiService restApi; |
| |
| // Map<DPID, Map<Name, FlowMod>> ; FlowMod can be null to indicate non-active |
| protected Map<String, Map<String, OFFlowMod>> entriesFromStorage; |
| // Entry Name -> DPID of Switch it's on |
| protected Map<String, String> entry2dpid; |
| |
| private BasicFactory ofMessageFactory; |
| |
| // Class to sort FlowMod's by priority, from lowest to highest |
| class FlowModSorter implements Comparator<String> { |
| private String dpid; |
| public FlowModSorter(String dpid) { |
| this.dpid = dpid; |
| } |
| @Override |
| public int compare(String o1, String o2) { |
| OFFlowMod f1 = entriesFromStorage.get(dpid).get(o1); |
| OFFlowMod f2 = entriesFromStorage.get(dpid).get(o2); |
| if (f1 == null || f2 == null) // sort active=false flows by key |
| return o1.compareTo(o2); |
| return U16.f(f1.getPriority()) - U16.f(f2.getPriority()); |
| } |
| }; |
| |
| /** |
| * used for debugging and unittests |
| * @return the number of static flow entries as cached from storage |
| */ |
| public int countEntries() { |
| int size = 0; |
| if (entriesFromStorage == null) |
| return 0; |
| for (String ofswitch : entriesFromStorage.keySet()) |
| size += entriesFromStorage.get(ofswitch).size(); |
| return size; |
| } |
| |
| public IFloodlightProviderService getFloodlightProvider() { |
| return floodlightProvider; |
| } |
| |
| public void setFloodlightProvider(IFloodlightProviderService floodlightProvider) { |
| this.floodlightProvider = floodlightProvider; |
| } |
| |
| /* |
| public void setStorageSource(IStorageSourceService storageSource) { |
| this.storageSource = storageSource; |
| } |
| */ |
| |
| /** |
| * Reads from our entriesFromStorage for the specified switch and |
| * sends the FlowMods down to the controller in <b>sorted</b> order. |
| * |
| * Sorted is important to maintain correctness of the switch: |
| * if a packet would match both a lower and a higher priority |
| * rule, then we want it to match the higher priority or nothing, |
| * but never just the lower priority one. Inserting from high to |
| * low priority fixes this. |
| * |
| * TODO consider adding a "block all" flow mod and then removing it |
| * while starting up. |
| * |
| * @param sw The switch to send entries to |
| */ |
| protected void sendEntriesToSwitch(IOFSwitch sw) { |
| String dpid = sw.getStringId(); |
| |
| if ((entriesFromStorage != null) && (entriesFromStorage.containsKey(dpid))) { |
| Map<String, OFFlowMod> entries = entriesFromStorage.get(dpid); |
| List<String> sortedList = new ArrayList<String>(entries.keySet()); |
| // weird that Collections.sort() returns void |
| Collections.sort( sortedList, new FlowModSorter(dpid)); |
| for (String entryName : sortedList) { |
| OFFlowMod flowMod = entries.get(entryName); |
| if (flowMod != null) { |
| if (log.isDebugEnabled()) { |
| log.debug("Pushing static entry {} for {}", dpid, entryName); |
| } |
| writeFlowModToSwitch(sw, flowMod); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Used only for bundle-local indexing |
| * |
| * @param map |
| * @return |
| */ |
| |
| protected Map<String, String> computeEntry2DpidMap( |
| Map<String, Map<String, OFFlowMod>> map) { |
| Map<String, String> ret = new HashMap<String, String>(); |
| for(String dpid : map.keySet()) { |
| for( String entry: map.get(dpid).keySet()) |
| ret.put(entry, dpid); |
| } |
| return ret; |
| } |
| |
| /** |
| * Read entries from storageSource, and store them in a hash |
| * |
| * @return |
| */ |
| /* |
| @LogMessageDoc(level="ERROR", |
| message="failed to access storage: {reason}", |
| explanation="Could not retrieve static flows from the system " + |
| "database", |
| recommendation=LogMessageDoc.CHECK_CONTROLLER) |
| private Map<String, Map<String, OFFlowMod>> readEntriesFromStorage() { |
| Map<String, Map<String, OFFlowMod>> entries = new ConcurrentHashMap<String, Map<String, OFFlowMod>>(); |
| try { |
| Map<String, Object> row; |
| // null1=no predicate, null2=no ordering |
| IResultSet resultSet = storageSource.executeQuery(TABLE_NAME, |
| ColumnNames, null, null); |
| for (Iterator<IResultSet> it = resultSet.iterator(); it.hasNext();) { |
| row = it.next().getRow(); |
| parseRow(row, entries); |
| } |
| } catch (StorageException e) { |
| log.error("failed to access storage: {}", e.getMessage()); |
| // if the table doesn't exist, then wait to populate later via |
| // setStorageSource() |
| } |
| return entries; |
| } |
| */ |
| |
| /** |
| * Take a single row, turn it into a flowMod, and add it to the |
| * entries{$dpid}.{$entryName}=FlowMod |
| * |
| * IF an entry is in active, mark it with FlowMod = null |
| * |
| * @param row |
| * @param entries |
| */ |
| |
| void parseRow(Map<String, Object> row, |
| Map<String, Map<String, OFFlowMod>> entries) { |
| String switchName = null; |
| String entryName = null; |
| |
| StringBuffer matchString = new StringBuffer(); |
| if (ofMessageFactory == null) // lazy init |
| ofMessageFactory = new BasicFactory(); |
| |
| OFFlowMod flowMod = (OFFlowMod) ofMessageFactory |
| .getMessage(OFType.FLOW_MOD); |
| |
| if (!row.containsKey(COLUMN_SWITCH) || !row.containsKey(COLUMN_NAME)) { |
| log.debug( |
| "skipping entry with missing required 'switch' or 'name' entry: {}", |
| row); |
| return; |
| } |
| // most error checking done with ClassCastException |
| try { |
| // first, snag the required entries, for debugging info |
| switchName = (String) row.get(COLUMN_SWITCH); |
| entryName = (String) row.get(COLUMN_NAME); |
| if (!entries.containsKey(switchName)) |
| entries.put(switchName, new HashMap<String, OFFlowMod>()); |
| StaticFlowEntries.initDefaultFlowMod(flowMod, entryName); |
| |
| for (String key : row.keySet()) { |
| if (row.get(key) == null) |
| continue; |
| if ( key.equals(COLUMN_SWITCH) || key.equals(COLUMN_NAME) |
| || key.equals("id")) |
| continue; // already handled |
| // explicitly ignore timeouts and wildcards |
| if ( key.equals(COLUMN_HARD_TIMEOUT) || key.equals(COLUMN_IDLE_TIMEOUT) || |
| key.equals(COLUMN_WILDCARD)) |
| continue; |
| if ( key.equals(COLUMN_ACTIVE)) { |
| if (! Boolean.valueOf((String) row.get(COLUMN_ACTIVE))) { |
| log.debug("skipping inactive entry {} for switch {}", |
| entryName, switchName); |
| entries.get(switchName).put(entryName, null); // mark this an inactive |
| return; |
| } |
| } else if ( key.equals(COLUMN_ACTIONS)){ |
| StaticFlowEntries.parseActionString(flowMod, (String) row.get(COLUMN_ACTIONS), log); |
| } else if ( key.equals(COLUMN_COOKIE)) { |
| flowMod.setCookie( |
| StaticFlowEntries.computeEntryCookie(flowMod, |
| Integer.valueOf((String) row.get(COLUMN_COOKIE)), |
| entryName) |
| ); |
| } else if ( key.equals(COLUMN_PRIORITY)) { |
| flowMod.setPriority(U16.t(Integer.valueOf((String) row.get(COLUMN_PRIORITY)))); |
| } else { // the rest of the keys are for OFMatch().fromString() |
| if (matchString.length() > 0) |
| matchString.append(","); |
| matchString.append(key + "=" + row.get(key).toString()); |
| } |
| } |
| } catch (ClassCastException e) { |
| if (entryName != null && switchName != null) |
| log.debug( |
| "skipping entry {} on switch {} with bad data : " |
| + e.getMessage(), entryName, switchName); |
| else |
| log.debug("skipping entry with bad data: {} :: {} ", |
| e.getMessage(), e.getStackTrace()); |
| } |
| |
| OFMatch ofMatch = new OFMatch(); |
| String match = matchString.toString(); |
| try { |
| ofMatch.fromString(match); |
| } catch (IllegalArgumentException e) { |
| log.debug( |
| "ignoring flow entry {} on switch {} with illegal OFMatch() key: " |
| + match, entryName, switchName); |
| return; |
| } |
| flowMod.setMatch(ofMatch); |
| |
| entries.get(switchName).put(entryName, flowMod); |
| } |
| |
| @Override |
| public void addedSwitch(IOFSwitch sw) { |
| log.debug("addedSwitch {}; processing its static entries", sw); |
| sendEntriesToSwitch(sw); |
| } |
| |
| @Override |
| public void removedSwitch(IOFSwitch sw) { |
| log.debug("removedSwitch {}", sw); |
| // do NOT delete from our internal state; we're tracking the rules, |
| // not the switches |
| } |
| |
| @Override |
| public void switchPortChanged(Long switchId) { |
| // no-op |
| } |
| |
| /** |
| * This handles both rowInsert() and rowUpdate() |
| */ |
| /* |
| @Override |
| public void rowsModified(String tableName, Set<Object> rowKeys) { |
| log.debug("Modifying Table {}", tableName); |
| |
| HashMap<String, Map<String, OFFlowMod>> entriesToAdd = |
| new HashMap<String, Map<String, OFFlowMod>>(); |
| // build up list of what was added |
| for(Object key: rowKeys) { |
| IResultSet resultSet = storageSource.getRow(tableName, key); |
| for (Iterator<IResultSet> it = resultSet.iterator(); it.hasNext();) { |
| Map<String, Object> row = it.next().getRow(); |
| parseRow(row, entriesToAdd); |
| } |
| } |
| // batch updates by switch and blast them out |
| for (String dpid : entriesToAdd.keySet()) { |
| if (!entriesFromStorage.containsKey(dpid)) |
| entriesFromStorage.put(dpid, new HashMap<String, OFFlowMod>()); |
| List<OFMessage> outQueue = new ArrayList<OFMessage>(); |
| for(String entry : entriesToAdd.get(dpid).keySet()) { |
| OFFlowMod newFlowMod = entriesToAdd.get(dpid).get(entry); |
| OFFlowMod oldFlowMod = entriesFromStorage.get(dpid).get(entry); |
| if (oldFlowMod != null) { // remove any pre-existing rule |
| oldFlowMod.setCommand(OFFlowMod.OFPFC_DELETE_STRICT); |
| outQueue.add(oldFlowMod); |
| } |
| if (newFlowMod != null) { |
| entriesFromStorage.get(dpid).put(entry, newFlowMod); |
| outQueue.add(newFlowMod); |
| entry2dpid.put(entry, dpid); |
| } else { |
| entriesFromStorage.get(dpid).remove(entry); |
| entry2dpid.remove(entry); |
| } |
| } |
| |
| writeOFMessagesToSwitch(HexString.toLong(dpid), outQueue); |
| } |
| } |
| |
| @Override |
| public void rowsDeleted(String tableName, Set<Object> rowKeys) { |
| if (log.isDebugEnabled()) { |
| log.debug("deleting from Table {}", tableName); |
| } |
| |
| for(Object obj : rowKeys) { |
| if (!(obj instanceof String)) { |
| log.debug("tried to delete non-string key {}; ignoring", obj); |
| continue; |
| } |
| deleteStaticFlowEntry((String) obj); |
| } |
| } |
| */ |
| |
| @LogMessageDoc(level="ERROR", |
| message="inconsistent internal state: no switch has rule {rule}", |
| explanation="Inconsistent internat state discovered while " + |
| "deleting a static flow rule", |
| recommendation=LogMessageDoc.REPORT_CONTROLLER_BUG) |
| private boolean deleteStaticFlowEntry(String entryName) { |
| String dpid = entry2dpid.get(entryName); |
| if (log.isDebugEnabled()) { |
| log.debug("Deleting flow {} for switch {}", entryName, dpid); |
| } |
| if (dpid == null) { |
| log.error("inconsistent internal state: no switch has rule {}", |
| entryName); |
| return false; |
| } |
| |
| // send flow_mod delete |
| OFFlowMod flowMod = entriesFromStorage.get(dpid).get(entryName); |
| flowMod.setCommand(OFFlowMod.OFPFC_DELETE_STRICT); |
| |
| if (entriesFromStorage.containsKey(dpid) && |
| entriesFromStorage.get(dpid).containsKey(entryName)) { |
| entriesFromStorage.get(dpid).remove(entryName); |
| } else { |
| log.debug("Tried to delete non-existent entry {} for switch {}", |
| entryName, dpid); |
| return false; |
| } |
| |
| writeFlowModToSwitch(HexString.toLong(dpid), flowMod); |
| return true; |
| } |
| |
| /** |
| * Writes a list of OFMessages to a switch |
| * @param dpid The datapath ID of the switch to write to |
| * @param messages The list of OFMessages to write. |
| */ |
| @LogMessageDoc(level="ERROR", |
| message="Tried to write to switch {switch} but got {error}", |
| explanation="An I/O error occured while trying to write a " + |
| "static flow to a switch", |
| recommendation=LogMessageDoc.CHECK_SWITCH) |
| private void writeOFMessagesToSwitch(long dpid, List<OFMessage> messages) { |
| IOFSwitch ofswitch = floodlightProvider.getSwitches().get(dpid); |
| if (ofswitch != null) { // is the switch connected |
| try { |
| if (log.isDebugEnabled()) { |
| log.debug("Sending {} new entries to {}", messages.size(), dpid); |
| } |
| ofswitch.write(messages, null); |
| ofswitch.flush(); |
| } catch (IOException e) { |
| log.error("Tried to write to switch {} but got {}", dpid, e.getMessage()); |
| } |
| } |
| } |
| |
| /** |
| * Writes an OFFlowMod to a switch. It checks to make sure the switch |
| * exists before it sends |
| * @param dpid The data to write the flow mod to |
| * @param flowMod The OFFlowMod to write |
| */ |
| private void writeFlowModToSwitch(long dpid, OFFlowMod flowMod) { |
| Map<Long,IOFSwitch> switches = floodlightProvider.getSwitches(); |
| IOFSwitch ofSwitch = switches.get(dpid); |
| if (ofSwitch == null) { |
| if (log.isDebugEnabled()) { |
| log.debug("Not deleting key {} :: switch {} not connected", |
| dpid); |
| } |
| return; |
| } |
| writeFlowModToSwitch(ofSwitch, flowMod); |
| } |
| |
| /** |
| * Writes an OFFlowMod to a switch |
| * @param sw The IOFSwitch to write to |
| * @param flowMod The OFFlowMod to write |
| */ |
| @LogMessageDoc(level="ERROR", |
| message="Tried to write OFFlowMod to {switch} but got {error}", |
| explanation="An I/O error occured while trying to write a " + |
| "static flow to a switch", |
| recommendation=LogMessageDoc.CHECK_SWITCH) |
| private void writeFlowModToSwitch(IOFSwitch sw, OFFlowMod flowMod) { |
| try { |
| sw.write(flowMod, null); |
| sw.flush(); |
| } catch (IOException e) { |
| log.error("Tried to write OFFlowMod to {} but failed: {}", |
| HexString.toHexString(sw.getId()), e.getMessage()); |
| } |
| } |
| |
| @Override |
| public String getName() { |
| return StaticFlowName; |
| } |
| |
| @Override |
| @LogMessageDoc(level="ERROR", |
| message="Got a FlowRemove message for a infinite " + |
| "timeout flow: {flow} from switch {switch}", |
| explanation="Flows with infinite timeouts should not expire. " + |
| "The switch has expired the flow anyway.", |
| recommendation=LogMessageDoc.REPORT_SWITCH_BUG) |
| public Command receive(IOFSwitch sw, OFMessage msg, FloodlightContext cntx) { |
| switch (msg.getType()) { |
| case FLOW_REMOVED: |
| break; |
| default: |
| return Command.CONTINUE; |
| } |
| OFFlowRemoved flowRemoved = (OFFlowRemoved) msg; |
| long cookie = flowRemoved.getCookie(); |
| /** |
| * This is just to sanity check our assumption that static flows |
| * never expire. |
| */ |
| if( AppCookie.extractApp(cookie) == STATIC_FLOW_APP_ID) { |
| if (flowRemoved.getReason() != |
| OFFlowRemoved.OFFlowRemovedReason.OFPRR_DELETE) |
| log.error("Got a FlowRemove message for a infinite " + |
| "timeout flow: {} from switch {}", msg, sw); |
| return Command.STOP; // only for us |
| } else |
| return Command.CONTINUE; |
| } |
| |
| @Override |
| public boolean isCallbackOrderingPrereq(OFType type, String name) { |
| return false; // no dependency for non-packet in |
| } |
| |
| @Override |
| public boolean isCallbackOrderingPostreq(OFType type, String name) { |
| return false; // no dependency for non-packet in |
| } |
| |
| // IFloodlightModule |
| |
| @Override |
| public Collection<Class<? extends IFloodlightService>> getModuleServices() { |
| Collection<Class<? extends IFloodlightService>> l = |
| new ArrayList<Class<? extends IFloodlightService>>(); |
| l.add(IStaticFlowEntryPusherService.class); |
| return l; |
| } |
| |
| @Override |
| public Map<Class<? extends IFloodlightService>, IFloodlightService> getServiceImpls() { |
| Map<Class<? extends IFloodlightService>, |
| IFloodlightService> m = |
| new HashMap<Class<? extends IFloodlightService>, |
| IFloodlightService>(); |
| m.put(IStaticFlowEntryPusherService.class, this); |
| return m; |
| } |
| |
| @Override |
| public Collection<Class<? extends IFloodlightService>> getModuleDependencies() { |
| Collection<Class<? extends IFloodlightService>> l = |
| new ArrayList<Class<? extends IFloodlightService>>(); |
| l.add(IFloodlightProviderService.class); |
| //l.add(IStorageSourceService.class); |
| l.add(IRestApiService.class); |
| return l; |
| } |
| |
| @Override |
| public void init(FloodlightModuleContext context) |
| throws FloodlightModuleException { |
| floodlightProvider = |
| context.getServiceImpl(IFloodlightProviderService.class); |
| //storageSource = |
| //context.getServiceImpl(IStorageSourceService.class); |
| restApi = |
| context.getServiceImpl(IRestApiService.class); |
| } |
| |
| @Override |
| public void startUp(FloodlightModuleContext context) { |
| floodlightProvider.addOFMessageListener(OFType.FLOW_REMOVED, this); |
| floodlightProvider.addOFSwitchListener(this); |
| floodlightProvider.addHAListener(this); |
| |
| // assumes no switches connected at startup() |
| //storageSource.createTable(TABLE_NAME, null); |
| //storageSource.setTablePrimaryKeyName(TABLE_NAME, COLUMN_NAME); |
| //storageSource.addListener(TABLE_NAME, this); |
| //entriesFromStorage = readEntriesFromStorage(); |
| //entry2dpid = computeEntry2DpidMap(entriesFromStorage); |
| restApi.addRestletRoutable(new StaticFlowEntryWebRoutable()); |
| } |
| |
| // IStaticFlowEntryPusherService methods |
| |
| @Override |
| public void addFlow(String name, OFFlowMod fm, String swDpid) { |
| Map<String, Object> fmMap = StaticFlowEntries.flowModToStorageEntry(fm, swDpid, name); |
| entry2dpid.put(name, swDpid); |
| Map<String, OFFlowMod> switchEntries = entriesFromStorage.get(swDpid); |
| if (switchEntries == null) { |
| switchEntries = new HashMap<String, OFFlowMod>(); |
| entriesFromStorage.put(swDpid, switchEntries); |
| } |
| switchEntries.put(name, fm); |
| //storageSource.insertRowAsync(TABLE_NAME, fmMap); |
| } |
| |
| @Override |
| public void deleteFlow(String name) { |
| //storageSource.deleteRowAsync(TABLE_NAME, name); |
| // TODO - What if there is a delay in storage? |
| } |
| |
| @Override |
| public void deleteAllFlows() { |
| for (String entry : entry2dpid.keySet()) { |
| deleteFlow(entry); |
| } |
| } |
| |
| @Override |
| public void deleteFlowsForSwitch(long dpid) { |
| String sDpid = HexString.toHexString(dpid); |
| |
| for (Entry<String, String> e : entry2dpid.entrySet()) { |
| if (e.getValue().equals(sDpid)) |
| deleteFlow(e.getKey()); |
| } |
| } |
| |
| @Override |
| public Map<String, Map<String, OFFlowMod>> getFlows() { |
| return entriesFromStorage; |
| } |
| |
| @Override |
| public Map<String, OFFlowMod> getFlows(String dpid) { |
| return entriesFromStorage.get(dpid); |
| } |
| |
| |
| // IHAListener |
| |
| @Override |
| public void roleChanged(Role oldRole, Role newRole) { |
| switch(newRole) { |
| case MASTER: |
| if (oldRole == Role.SLAVE) { |
| log.debug("Re-reading static flows from storage due " + |
| "to HA change from SLAVE->MASTER"); |
| //entriesFromStorage = readEntriesFromStorage(); |
| entry2dpid = computeEntry2DpidMap(entriesFromStorage); |
| } |
| break; |
| case SLAVE: |
| log.debug("Clearing in-memory flows due to " + |
| "HA change to SLAVE"); |
| entry2dpid.clear(); |
| entriesFromStorage.clear(); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| @Override |
| public void controllerNodeIPsChanged( |
| Map<String, String> curControllerNodeIPs, |
| Map<String, String> addedControllerNodeIPs, |
| Map<String, String> removedControllerNodeIPs) { |
| // ignore |
| } |
| |
| } |