@Override public List<String> listDevices() { FVLog.log(LogLevel.DEBUG, null, "API listDevices() by: " + APIUserCred.getUserName()); FlowVisor fv = FlowVisor.getInstance(); // get list from main flowvisor instance List<String> dpids = new ArrayList<String>(); String dpidStr; /* * if (TopologyController.isConfigured()) { for (Long dpid : * TopologyController.getRunningInstance() .listDevices()) { dpidStr = * HexString.toHexString(dpid); if (!dpids.contains(dpidStr)) * dpids.add(dpidStr); else FVLog.log(LogLevel.WARN, TopologyController * .getRunningInstance(), "duplicate dpid detected: " + dpidStr); } } * else { */ // only list a device is we have a features reply for it for (FVEventHandler handler : fv.getHandlersCopy()) { if (handler instanceof FVClassifier) { OFFeaturesReply featuresReply = ((FVClassifier) handler).getSwitchInfo(); if (featuresReply != null) { dpidStr = FlowSpaceUtil.dpidToString(featuresReply.getDatapathId()); if (!dpids.contains(dpidStr)) dpids.add(dpidStr); else FVLog.log(LogLevel.WARN, handler, "duplicate dpid detected: " + dpidStr); } } } // } return dpids; }
private void updatePortList() { ArrayList<Short> addedPorts = new ArrayList<Short>(); ArrayList<Short> removedPorts = new ArrayList<Short>(); synchronized (FVConfig.class) { // update our local copy this.localFlowSpace = getLocalFlowSpace(); } Set<Short> ports = FlowSpaceUtil.getPortsBySlice( this.fvClassifier.getSwitchInfo().getDatapathId(), this.sliceName, this.localFlowSpace); if (ports.contains(OFPort.OFPP_ALL.getValue())) { // this switch has access to ALL PORTS; feed them in from the // features request ports.clear(); // remove the OFPP_ALL virtual port this.allowAllPorts = true; for (OFPhysicalPort phyPort : this.fvClassifier.getSwitchInfo().getPorts()) ports.add(phyPort.getPortNumber()); } for (Short port : ports) { if (!allowedPorts.keySet().contains(port)) { FVLog.log(LogLevel.DEBUG, this, "adding access to port ", port); allowedPorts.put(port, Boolean.TRUE); addedPorts.add(port); } } for (Iterator<Short> it = allowedPorts.keySet().iterator(); it.hasNext(); ) { Short port = it.next(); if (!ports.contains(port)) { FVLog.log(LogLevel.DEBUG, this, "removing access to port ", port); it.remove(); removedPorts.add(port); } } updatePortStatus(addedPorts, removedPorts); }
@Override public boolean setMaximumFlowMods(String sliceName, String dpid, String maxFlowMods) throws PermissionDeniedException { String user = APIUserCred.getUserName(); if (!APIAuth.transitivelyCreated(user, sliceName) && !FVConfig.isSupervisor(user)) throw new PermissionDeniedException( "User " + user + " does not have perms to set the flow mod limit for slice " + sliceName); Long dp = FlowSpaceUtil.parseDPID(dpid); int limit = Integer.parseInt(maxFlowMods); FVLog.log( LogLevel.DEBUG, null, "Setting flowmod limit for slice " + sliceName + " for dpid " + dpid + " to " + maxFlowMods); try { if (dp == FlowEntry.ALL_DPIDS) SliceImpl.getProxy().setMaxFlowMods(sliceName, limit); else SwitchImpl.getProxy().setMaxFlowMods(sliceName, dp, limit); } catch (ConfigError e) { return false; } return true; }
protected Collection<FlowEntry> getFlowEntries() throws ConfigError { String sliceName = APIUserCred.getUserName(); FVLog.log(LogLevel.DEBUG, null, "API listFlowSpace() by: " + sliceName); FlowMap flowMap; synchronized (FVConfig.class) { if (FVConfig.isSupervisor(sliceName)) flowMap = FVConfig.getFlowSpaceFlowMap(); else flowMap = FlowSpaceUtil.getSliceFlowSpace(sliceName); return flowMap.getRules(); } }
@Override public String getConnectionName() { if (isConnected) return FlowSpaceUtil.connectionToString(sock); else return "NONE (retry in " + this.reconnectSeconds + " seconds: max + " + this.maxReconnectSeconds + ")"; }
@Override public Map<String, String> getSliceInfo(String sliceName) throws PermissionDeniedException, SliceNotFound { /* * relaxed security -- anyone can read slice info for now String user = * APIUserCred.getUserName(); if (!FVConfig.isSupervisor(user) && * !APIAuth.transitivelyCreated(user, sliceName)) throw new * PermissionDeniedException( * "not superuser or transitive slice creator"); */ if (!(doesSliceExist(sliceName))) { throw new SliceNotFound("Slice does not exist: " + sliceName); } HashMap<String, String> map = new HashMap<String, String>(); synchronized (FVConfig.class) { try { map.put("contact_email", FVConfig.getSliceEmail(sliceName)); map.put("controller_hostname", FVConfig.getSliceHost(sliceName)); map.put("controller_port", String.valueOf(FVConfig.getSlicePort(sliceName))); map.put("creator", FVConfig.getSliceCreator(sliceName)); map.put("drop_policy", FVConfig.getSlicePolicy(sliceName)); } catch (ConfigError e) { FVLog.log(LogLevel.CRIT, null, "malformed slice: " + e); e.printStackTrace(); } } long dpid; int connection = 1; // TODO: come back an architect this so we can walk the list of slicers, // not the list of classifiers, and then slicers for (Iterator<FVEventHandler> it = FlowVisor.getInstance().getHandlersCopy().iterator(); it.hasNext(); ) { FVEventHandler eventHandler = it.next(); if (eventHandler instanceof FVClassifier) { FVClassifier classifier = (FVClassifier) eventHandler; if (!classifier.isIdentified()) // only print switches have have // been identified continue; dpid = classifier.getDPID(); FVSlicer fvSlicer = classifier.getSlicerByName(sliceName); if (fvSlicer != null) { map.put( "connection_" + connection++, FlowSpaceUtil.dpidToString(dpid) + "-->" + fvSlicer.getConnectionName()); } } } return map; }
public static void main(String args[]) throws FileNotFoundException, ConfigError { if (args.length < 3) { System.err.println("Usage: <config.xml> <dpid> <ofmatch>"); System.exit(1); } FVConfig.readFromFile(args[0]); long dpid = FlowSpaceUtil.parseDPID(args[1]); FVMatch packet = new FVMatch(); packet.fromString(args[2]); System.err.println( "Looking up packet '" + packet + "' on dpid=" + FlowSpaceUtil.dpidToString(dpid)); List<FlowEntry> entries = FVConfig.getFlowSpaceFlowMap().matches(dpid, packet); System.err.println("Matches found: " + entries.size()); if (entries.size() > 1) System.err.println("WARN: only sending to the first match"); for (FlowEntry flowEntry : entries) { System.out.println(flowEntry); } }
@Override public String getSwitchStats(String dpidStr) throws DPIDNotFound, PermissionDeniedException { long dpid = FlowSpaceUtil.parseDPID(dpidStr); for (Iterator<FVEventHandler> it = FlowVisor.getInstance().getHandlersCopy().iterator(); it.hasNext(); ) { FVEventHandler eventHandler = it.next(); if (eventHandler instanceof FVClassifier) { FVClassifier classifier = (FVClassifier) eventHandler; if (classifier.getDPID() == dpid) return classifier.getStats().combinedString(); } } throw new DPIDNotFound("dpid not found: " + dpidStr); }
public Integer getCurrentFlowMods(String sliceName, String dpid) throws PermissionDeniedException, SliceNotFound, DPIDNotFound { String user = APIUserCred.getUserName(); if (!APIAuth.transitivelyCreated(user, sliceName) && !FVConfig.isSupervisor(user)) throw new PermissionDeniedException( "User " + user + " does not have perms to get the current flow mod value for slice " + sliceName); Long dp = FlowSpaceUtil.parseDPID(dpid); if (dp == FlowEntry.ALL_DPIDS) return getSliceLimits().getSliceFMLimit(sliceName); else return lookupClassifier(dp).getCurrentFlowModCounter(sliceName); }
@Override public String getFloodPerm(String dpidStr) throws PermissionDeniedException { String user = APIUserCred.getUserName(); if (!FVConfig.isSupervisor(user)) throw new PermissionDeniedException( "User " + user + " does not have perms to obtain the flood perms of " + dpidStr); FVLog.log(LogLevel.DEBUG, null, "Setting flood perm for : ", dpidStr); long dpid = FlowSpaceUtil.parseDPID(dpidStr); try { return SwitchImpl.getProxy().getFloodPerm(dpid); } catch (ConfigError e) { FVLog.log(LogLevel.ALERT, null, "Unable to set floodperm", e.getMessage()); } return null; }
@Override public Integer getMaximumFlowMods(String sliceName, String dpid) throws PermissionDeniedException { String user = APIUserCred.getUserName(); if (!APIAuth.transitivelyCreated(user, sliceName) && !FVConfig.isSupervisor(user)) throw new PermissionDeniedException( "User " + user + " does not have perms to get the flow mod limit for slice " + sliceName); Long dp = FlowSpaceUtil.parseDPID(dpid); try { if (dp == FlowEntry.ALL_DPIDS) return SliceImpl.getProxy().getMaxFlowMods(sliceName); else return SwitchImpl.getProxy().getMaxFlowMods(sliceName, dp); } catch (ConfigError e) { FVLog.log(LogLevel.DEBUG, null, "Unable to get flow mod limit; " + e.getMessage()); return null; } }
@Override public Map<String, List<Map<String, String>>> getSliceRewriteDB(String sliceName, String dpidStr) throws DPIDNotFound, SliceNotFound, PermissionDeniedException { long dpid = FlowSpaceUtil.parseDPID(dpidStr); FVSlicer fvSlicer = lookupSlicer(sliceName, dpid); Map<String, List<Map<String, String>>> ret = new HashMap<String, List<Map<String, String>>>(); FlowRewriteDB flowRewriteDB = fvSlicer.getFlowRewriteDB(); synchronized (flowRewriteDB) { for (FlowDBEntry original : flowRewriteDB.originals()) { Map<String, String> originalMap = original.toBracketMap(); List<Map<String, String>> rewrites = new LinkedList<Map<String, String>>(); for (FlowDBEntry rewrite : flowRewriteDB.getRewrites(original)) { rewrites.add(rewrite.toBracketMap()); } ret.put(BracketParse.encode(originalMap), rewrites); } } return ret; }
/* * (non-Javadoc) * * @see org.flowvisor.api.FVUserAPI#getDeviceInfo() */ @Override public Map<String, String> getDeviceInfo(String dpidStr) throws DPIDNotFound { Map<String, String> map = new HashMap<String, String>(); long dpid = HexString.toLong(dpidStr); FVClassifier fvClassifier = null; for (FVEventHandler handler : FlowVisor.getInstance().getHandlersCopy()) { if (handler instanceof FVClassifier) { OFFeaturesReply featuresReply = ((FVClassifier) handler).getSwitchInfo(); if (featuresReply != null && featuresReply.getDatapathId() == dpid) { fvClassifier = (FVClassifier) handler; break; } } } if (fvClassifier == null) throw new DPIDNotFound("dpid does not exist: " + dpidStr + " ::" + String.valueOf(dpid)); OFFeaturesReply config = fvClassifier.getSwitchInfo(); map.put("dpid", FlowSpaceUtil.dpidToString(dpid)); if (config != null) { map.put("nPorts", String.valueOf(config.getPorts().size())); String portList = ""; String portNames = ""; int p; for (Iterator<OFPhysicalPort> it = config.getPorts().iterator(); it.hasNext(); ) { OFPhysicalPort port = it.next(); p = U16.f(port.getPortNumber()); portList += p; portNames += port.getName() + "(" + p + ")"; if (it.hasNext()) { portList += ","; portNames += ","; } } map.put("portList", portList); map.put("portNames", portNames); } else { FVLog.log(LogLevel.WARN, null, "null config for: " + dpidStr); } map.put("remote", String.valueOf(fvClassifier.getConnectionName())); return map; }
@Override public Boolean deleteSlice(String sliceName) throws SliceNotFound, PermissionDeniedException, ConfigError { String changerSlice = APIUserCred.getUserName(); if (!APIAuth.transitivelyCreated(changerSlice, sliceName)) { FVLog.log( LogLevel.WARN, null, "API deletSlice(" + sliceName + ") failed by: " + APIUserCred.getUserName()); throw new PermissionDeniedException( "Slice " + changerSlice + " does not have perms to change the passwd of " + sliceName); } synchronized (FVConfig.class) { FVLog.log( LogLevel.DEBUG, null, "API removeSlice(" + sliceName + ") by: " + APIUserCred.getUserName()); FlowMap flowSpace = FlowSpaceUtil.deleteFlowSpaceBySlice(sliceName); try { // this is also synchronized against FVConfig.class FVConfig.deleteSlice(sliceName); } catch (Exception e) { throw new SliceNotFound("slice does not exist: " + sliceName); } /* * We need to do this because of the linear flowmap, because * it wants the slicers and classifiers to update their * view of the flowspace. * Once linearflowmap is dropped, this should be dropped as * well. * * FIXME */ FlowSpaceImpl.getProxy().notifyChange(flowSpace); // FVConfig.sendUpdates(FVConfig.FLOWSPACE); // signal that FS has changed FlowVisor.getInstance().checkPointConfig(); } return true; }
@Override public Collection<Map<String, String>> getSwitchFlowDB(String dpidStr) throws DPIDNotFound { boolean found = false; long dpid = FlowSpaceUtil.parseDPID(dpidStr); List<Map<String, String>> ret = new LinkedList<Map<String, String>>(); for (Iterator<FVEventHandler> it = FlowVisor.getInstance().getHandlersCopy().iterator(); it.hasNext(); ) { FVEventHandler eventHandler = it.next(); if (eventHandler instanceof FVClassifier) { FVClassifier classifier = (FVClassifier) eventHandler; if (dpid == classifier.getDPID() || dpid == FlowEntry.ALL_DPIDS) { synchronized (classifier) { for (Iterator<FlowDBEntry> it2 = classifier.getFlowDB().iterator(); it2.hasNext(); ) { ret.add(it2.next().toBracketMap()); } } found = true; } } } if (!found) throw new DPIDNotFound("dpid not found: " + dpidStr); return ret; }
/* * In theory, we could return a different flowmap per slice. * Currently the assumption is that either each slice maintains * the flowmap relevant to itself or has a reference to the * entire flowspace. * * If we want to support different flowmaps per slice we simply * need to pass the slice name to this method and adapt the * sql accordingly. * */ @Override public FlowMap getFlowMap() throws ConfigError { if (cachedFlowMap != null) return cachedFlowMap; Connection conn = null; PreparedStatement ps = null; PreparedStatement actions = null; PreparedStatement queues = null; ResultSet set = null; ResultSet actionSet = null; ResultSet queueSet = null; try { conn = settings.getConnection(); ps = conn.prepareStatement(GFLOWMAP); set = ps.executeQuery(); FlowMap map = null; LinkedList<OFAction> actionsList = null; LinkedList<Integer> queueList = null; FlowEntry fe = null; SliceAction act = null; int wildcards = -1; int fsr_id = -1; while (set.next()) { if (map == null) map = FlowSpaceUtil.getNewFlowMap(set.getInt(Slice.FMTYPE)); FVMatch match = new FVMatch(); actionsList = new LinkedList<OFAction>(); queueList = new LinkedList<Integer>(); wildcards = set.getInt(WILDCARDS); fsr_id = set.getInt("id"); match.setInputPort(set.getShort(INPORT)); if ((wildcards & FVMatch.OFPFW_DL_VLAN) == 0) match.setDataLayerVirtualLan(set.getShort(VLAN)); if ((wildcards & FVMatch.OFPFW_DL_VLAN_PCP) == 0) match.setDataLayerVirtualLanPriorityCodePoint(set.getByte(VPCP)); if ((wildcards & FVMatch.OFPFW_DL_SRC) == 0) match.setDataLayerSource(set.getLong(DLSRC)); if ((wildcards & FVMatch.OFPFW_DL_DST) == 0) match.setDataLayerDestination(set.getLong(DLDST)); if ((wildcards & FVMatch.OFPFW_DL_TYPE) == 0) match.setDataLayerType(set.getShort(DLTYPE)); if ((wildcards & FVMatch.OFPFW_NW_SRC_ALL) == 0) match.setNetworkSource(set.getInt(NWSRC)); if ((wildcards & FVMatch.OFPFW_NW_DST_ALL) == 0) match.setNetworkDestination(set.getInt(NWDST)); if ((wildcards & FVMatch.OFPFW_NW_PROTO) == 0) match.setNetworkProtocol(set.getByte(NWPROTO)); if ((wildcards & FVMatch.OFPFW_NW_TOS) == 0) match.setNetworkTypeOfService(set.getByte(NWTOS)); if ((wildcards & FVMatch.OFPFW_TP_SRC) == 0) match.setTransportSource(set.getShort(TPSRC)); if ((wildcards & FVMatch.OFPFW_TP_DST) == 0) match.setTransportDestination(set.getShort(TPDST)); match.setWildcards(wildcards); actions = conn.prepareStatement(GACTIONS); actions.setInt(1, fsr_id); actionSet = actions.executeQuery(); while (actionSet.next()) { act = new SliceAction(actionSet.getString(Slice.SLICE), actionSet.getInt(ACTION)); actionsList.add(act); } queues = conn.prepareStatement(GQUEUES); queues.setInt(1, fsr_id); queueSet = queues.executeQuery(); while (queueSet.next()) { queueList.add(queueSet.getInt(QUEUE)); } fe = new FlowEntry( set.getLong(DPID), match, set.getInt("id"), set.getInt(PRIO), actionsList); fe.setQueueId(queueList); fe.setForcedQueue(set.getInt(FORCED_QUEUE)); map.addRule(fe); } if (map == null) map = new FederatedFlowMap(); cachedFlowMap = map; return map; } catch (SQLException e) { throw new ConfigError("Unable to retrieve flowmap from db : " + e.getMessage()); } finally { close(set); close(ps); close(actionSet); close(actions); close(queueSet); close(queues); close(conn); } }
@Override public HashMap<String, Object> toJson(HashMap<String, Object> output) { Connection conn = null; PreparedStatement ps = null; PreparedStatement actions = null; PreparedStatement queues = null; ResultSet set = null; ResultSet actionSet = null; ResultSet queueSet = null; HashMap<String, Object> fs = new HashMap<String, Object>(); HashMap<String, Object> action = new HashMap<String, Object>(); LinkedList<Object> list = new LinkedList<Object>(); LinkedList<Object> actionList = new LinkedList<Object>(); LinkedList<Integer> queueList = new LinkedList<Integer>(); try { int wildcards = -1; conn = settings.getConnection(); ps = conn.prepareStatement(GFLOWMAP); set = ps.executeQuery(); // writer.name(FS); // writer.beginArray(); while (set.next()) { // writer.beginObject(); wildcards = set.getInt(WILDCARDS); fs.put(DPID, FlowSpaceUtil.dpidToString(set.getLong(DPID))); fs.put(PRIO, set.getInt(PRIO)); if ((wildcards & FVMatch.OFPFW_IN_PORT) == 0) fs.put(INPORT, set.getInt(INPORT)); if ((wildcards & FVMatch.OFPFW_DL_VLAN) == 0) fs.put(VLAN, set.getShort(VLAN)); if ((wildcards & FVMatch.OFPFW_DL_VLAN_PCP) == 0) fs.put(VPCP, set.getShort(VPCP)); if ((wildcards & FVMatch.OFPFW_DL_SRC) == 0) fs.put(DLSRC, FlowSpaceUtil.macToString(set.getLong(DLSRC))); if ((wildcards & FVMatch.OFPFW_DL_DST) == 0) fs.put(DLDST, FlowSpaceUtil.macToString(set.getLong(DLDST))); if ((wildcards & FVMatch.OFPFW_DL_TYPE) == 0) fs.put(DLTYPE, set.getShort(DLTYPE)); if ((wildcards & FVMatch.OFPFW_NW_SRC_ALL) == 0) fs.put(NWSRC, set.getInt(NWSRC)); if ((wildcards & FVMatch.OFPFW_NW_DST_ALL) == 0) fs.put(NWDST, set.getInt(NWDST)); if ((wildcards & FVMatch.OFPFW_NW_PROTO) == 0) fs.put(NWPROTO, set.getShort(NWPROTO)); if ((wildcards & FVMatch.OFPFW_NW_TOS) == 0) fs.put(NWTOS, set.getShort(NWTOS)); if ((wildcards & FVMatch.OFPFW_TP_DST) == 0) fs.put(TPDST, set.getShort(TPDST)); if ((wildcards & FVMatch.OFPFW_TP_SRC) == 0) fs.put(TPSRC, set.getShort(TPSRC)); fs.put(FORCED_QUEUE, set.getInt(FORCED_QUEUE)); fs.put(WILDCARDS, wildcards); // fs.put(QUEUE, set.getInt(QUEUE)); actions = conn.prepareStatement(GACTIONS); actions.setInt(1, set.getInt("id")); actionSet = actions.executeQuery(); // writer.name(ACTION); // writer.beginArray(); while (actionSet.next()) { action.put(actionSet.getString(Slice.SLICE), actionSet.getInt(ACTION)); actionList.add(action.clone()); action.clear(); } fs.put(ACTION, actionList.clone()); actionList.clear(); queues = conn.prepareStatement(GQUEUES); queues.setInt(1, set.getInt("id")); queueSet = queues.executeQuery(); while (queueSet.next()) { queueList.add(queueSet.getInt(QUEUE)); } fs.put(QUEUE, queueList.clone()); queueList.clear(); list.add(fs.clone()); fs.clear(); } output.put(FS, list); } catch (SQLException e) { FVLog.log(LogLevel.CRIT, null, "Failed to write flowspace config : " + e.getMessage()); } finally { close(set); close(ps); close(actionSet); close(actions); close(queueSet); close(queues); close(conn); } return output; }
@SuppressWarnings("unchecked") private void insert(HashMap<String, Object> row) throws IOException { Connection conn = null; PreparedStatement ps = null; ResultSet set = null; int sliceid = -1; int ruleid = -1; try { conn = settings.getConnection(); ps = conn.prepareStatement(SFLOWMAP, Statement.RETURN_GENERATED_KEYS); if (row.get(DPID) == null) ps.setNull(1, Types.BIGINT); else ps.setLong(1, FlowSpaceUtil.parseDPID(((String) row.get(DPID)))); if (row.get(PRIO) == null) ps.setNull(2, Types.INTEGER); else ps.setInt(2, ((Double) row.get(PRIO)).intValue()); if (row.get(INPORT) == null) ps.setNull(3, Types.SMALLINT); else ps.setShort(3, ((Double) row.get(INPORT)).shortValue()); if (row.get(VLAN) == null) ps.setNull(4, Types.SMALLINT); else ps.setShort(4, ((Double) row.get(VLAN)).shortValue()); if (row.get(VPCP) == null) ps.setNull(5, Types.SMALLINT); else ps.setShort(5, ((Double) row.get(VPCP)).shortValue()); if (row.get(DLSRC) == null) ps.setNull(6, Types.BIGINT); else ps.setLong(6, FlowSpaceUtil.parseMac(((String) row.get(DLSRC)))); if (row.get(DLDST) == null) ps.setNull(7, Types.BIGINT); else ps.setLong(7, FlowSpaceUtil.parseMac(((String) row.get(DLDST)))); if (row.get(DLTYPE) == null) ps.setNull(8, Types.SMALLINT); else ps.setShort(8, ((Double) row.get(DLTYPE)).shortValue()); if (row.get(NWSRC) == null) ps.setNull(9, Types.INTEGER); else ps.setInt(9, ((Double) row.get(NWSRC)).intValue()); if (row.get(NWDST) == null) ps.setNull(10, Types.INTEGER); else ps.setInt(10, ((Long) row.get(NWDST)).intValue()); if (row.get(NWPROTO) == null) ps.setNull(11, Types.SMALLINT); else ps.setShort(11, ((Double) row.get(NWPROTO)).shortValue()); if (row.get(NWTOS) == null) ps.setNull(12, Types.SMALLINT); else ps.setShort(12, ((Double) row.get(NWTOS)).shortValue()); if (row.get(TPSRC) == null) ps.setNull(13, Types.SMALLINT); else ps.setShort(13, ((Double) row.get(TPSRC)).shortValue()); if (row.get(TPDST) == null) ps.setNull(14, Types.SMALLINT); else ps.setShort(14, ((Double) row.get(TPDST)).shortValue()); if (row.get(FORCED_QUEUE) == null) ps.setInt(15, -1); else ps.setInt(15, ((Double) row.get(FORCED_QUEUE)).intValue()); if (row.get(WILDCARDS) == null) ps.setNull(16, Types.INTEGER); else ps.setInt(16, ((Double) row.get(WILDCARDS)).intValue()); if (ps.executeUpdate() == 0) FVLog.log(LogLevel.WARN, null, "Flow rule insertion failed... siliently."); set = ps.getGeneratedKeys(); set.next(); ruleid = set.getInt(1); for (HashMap<String, Double> item : ((ArrayList<HashMap<String, Double>>) row.get(ACTION))) { for (Entry<String, Double> entry : item.entrySet()) { ps = conn.prepareStatement(SLICEID); ps.setString(1, entry.getKey()); set = ps.executeQuery(); if (set.next()) sliceid = set.getInt("id"); else { sliceid = -1; System.err.println( "Inserting rule with action on unknown slice " + entry.getKey() + "; hope you know what you are doing..."); } ps = conn.prepareStatement(SACTIONS); ps.setInt(1, ruleid); ps.setInt(2, sliceid); ps.setInt(3, ((Double) entry.getValue()).intValue()); if (ps.executeUpdate() == 0) FVLog.log(LogLevel.WARN, null, "Action insertion failed... siliently."); } } if (row.get(QUEUE) == null) return; ps = conn.prepareStatement(SQUEUES); ps.setInt(1, ruleid); for (Double queue_id : (ArrayList<Double>) row.get(QUEUE)) { ps.setInt(2, queue_id.intValue()); if (ps.executeUpdate() == 0) FVLog.log(LogLevel.WARN, null, "Queue insertion failed... siliently."); } } catch (SQLException e) { e.printStackTrace(); } finally { close(set); close(ps); close(conn); } }
@Override public int addRule(FlowEntry fe) throws ConfigError { Connection conn = null; PreparedStatement ps = null; PreparedStatement slice = null; PreparedStatement queues = null; ResultSet set = null; try { conn = settings.getConnection(); int sliceid = -1; int ruleid = -1; int wildcards = -1; wildcards = fe.getRuleMatch().getWildcards(); ps = conn.prepareStatement(SFLOWMAP, Statement.RETURN_GENERATED_KEYS); ps.setLong(1, fe.getDpid()); ps.setInt(2, fe.getPriority()); ps.setShort(3, fe.getRuleMatch().getInputPort()); if ((wildcards & FVMatch.OFPFW_DL_VLAN) != 0) ps.setNull(4, Types.SMALLINT); else ps.setShort(4, fe.getRuleMatch().getDataLayerVirtualLan()); if ((wildcards & FVMatch.OFPFW_DL_VLAN_PCP) != 0) ps.setNull(5, Types.SMALLINT); else ps.setShort(5, fe.getRuleMatch().getDataLayerVirtualLanPriorityCodePoint()); if ((wildcards & FVMatch.OFPFW_DL_SRC) != 0) ps.setNull(6, Types.BIGINT); else ps.setLong(6, FlowSpaceUtil.toLong(fe.getRuleMatch().getDataLayerSource())); if ((wildcards & FVMatch.OFPFW_DL_DST) != 0) ps.setNull(7, Types.BIGINT); else ps.setLong(7, FlowSpaceUtil.toLong(fe.getRuleMatch().getDataLayerDestination())); if ((wildcards & FVMatch.OFPFW_DL_TYPE) != 0) ps.setNull(8, Types.SMALLINT); else ps.setShort(8, fe.getRuleMatch().getDataLayerType()); if ((wildcards & FVMatch.OFPFW_NW_SRC_ALL) != 0) ps.setNull(9, Types.INTEGER); else ps.setInt(9, fe.getRuleMatch().getNetworkSource()); if ((wildcards & FVMatch.OFPFW_NW_DST_ALL) != 0) ps.setNull(10, Types.INTEGER); else ps.setInt(10, fe.getRuleMatch().getNetworkDestination()); if ((wildcards & FVMatch.OFPFW_NW_PROTO) != 0) ps.setNull(11, Types.SMALLINT); else ps.setShort(11, fe.getRuleMatch().getNetworkProtocol()); if ((wildcards & FVMatch.OFPFW_NW_TOS) != 0) ps.setNull(12, Types.SMALLINT); else ps.setShort(12, fe.getRuleMatch().getNetworkTypeOfService()); if ((wildcards & FVMatch.OFPFW_TP_SRC) != 0) ps.setNull(13, Types.SMALLINT); else ps.setShort(13, fe.getRuleMatch().getTransportSource()); if ((wildcards & FVMatch.OFPFW_TP_DST) != 0) ps.setNull(14, Types.SMALLINT); else ps.setShort(14, fe.getRuleMatch().getTransportDestination()); ps.setInt(15, (int) fe.getForcedQueue()); ps.setInt(16, wildcards); ps.executeUpdate(); set = ps.getGeneratedKeys(); set.next(); ruleid = set.getInt(1); slice = conn.prepareStatement(GSLICEID); ps = conn.prepareStatement(SACTIONS); for (OFAction act : fe.getActionsList()) { slice.setString(1, ((SliceAction) act).getSliceName()); set = slice.executeQuery(); if (set.next()) sliceid = set.getInt("id"); else { FVLog.log( LogLevel.WARN, null, "Slice name " + ((SliceAction) act).getSliceName() + " does not exist... skipping."); continue; } ps.setInt(1, ruleid); ps.setInt(2, sliceid); ps.setInt(3, ((SliceAction) act).getSlicePerms()); // ps.setInt(4, fe.getQueueId()); ps.executeUpdate(); } queues = conn.prepareStatement(SQUEUES); queues.setInt(1, ruleid); for (Integer queue_id : fe.getQueueId()) { queues.setInt(2, queue_id); queues.executeUpdate(); } return ruleid; } catch (SQLException e) { FVLog.log(LogLevel.DEBUG, null, e.getMessage()); throw new ConfigError("Unable to set the flowmap in db"); } finally { close(set); close(ps); close(slice); close(queues); close(conn); } }