import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.DataModification;
+import org.opendaylight.controller.networkconfig.neutron.NeutronNetwork;
import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
import org.opendaylight.controller.sal.core.Node;
import org.opendaylight.controller.sal.utils.HexEncode;
import org.opendaylight.controller.sal.utils.ServiceHelper;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.controller.sal.utils.StatusCode;
+import org.opendaylight.controller.switchmanager.ISwitchManager;
import org.opendaylight.ovsdb.lib.notation.OvsDBMap;
import org.opendaylight.ovsdb.lib.notation.OvsDBSet;
import org.opendaylight.ovsdb.lib.notation.UUID;
* Action: Drop w/ a low priority
*/
- writeDropSrcIface(dpid, localPort);
+ // TODO : Drop flows causing problems with other existing flows. Commenting them out for now till it is fixed.
+
+ // writeDropSrcIface(dpid, localPort);
/*
* Table(2) Rule #1
* table=2,priority=8192,tun_id=0x5 actions=drop
*/
- writeLocalTableMiss(dpid, TABLE_2_LOCAL_FORWARD, segmentationId);
+ // TODO : Drop flows causing problems with other existing flows. Commenting them out for now till it is fixed.
+ // writeLocalTableMiss(dpid, TABLE_2_LOCAL_FORWARD, segmentationId);
}
private void programLocalIngressTunnelBridgeRules(Node node, Long dpid, String segmentationId, String attachedMac, long tunnelOFPort, long localPort) {
writeTunnelFloodOut(dpid, TABLE_1_ISOLATE_TENANT, TABLE_2_LOCAL_FORWARD, segmentationId, tunnelOFPort);
}
- private void programLocalRules (String tunnelType, String segmentationId, Node node, Interface intf) {
+ private Long getIntegrationBridgeOFDPID (Node node) {
try {
-
String bridgeName = AdminConfigManager.getManager().getIntegrationBridgeName();
String brIntId = this.getInternalBridgeUUID(node, bridgeName);
if (brIntId == null) {
logger.error("Unable to spot Bridge Identifier for {} in {}", bridgeName, node);
- return;
+ return 0L;
}
OVSDBConfigService ovsdbTable = (OVSDBConfigService) ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
Bridge bridge = (Bridge) ovsdbTable.getRow(node, Bridge.NAME.getName(), brIntId);
Set<String> dpids = bridge.getDatapath_id();
- if (dpids == null || dpids.size() == 0) return;
- Long dpid = Long.valueOf(HexEncode.stringToLong((String) dpids.toArray()[0]));
+ if (dpids == null || dpids.size() == 0) return 0L;
+ return Long.valueOf(HexEncode.stringToLong((String) dpids.toArray()[0]));
+ } catch (Exception e) {
+ logger.error("Error finding Integration Bridge's OF DPID", e);
+ return 0L;
+ }
+ }
+ private void programLocalRules (String tunnelType, String segmentationId, Node node, Interface intf) {
+ try {
+ Long dpid = this.getIntegrationBridgeOFDPID(node);
+ if (dpid == 0L) {
+ logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
+ return;
+ }
Set<BigInteger> of_ports = intf.getOfport();
if (of_ports == null || of_ports.size() <= 0) {
Interface intf, boolean local) {
try {
- String bridgeName = AdminConfigManager.getManager().getIntegrationBridgeName();
- String brIntId = this.getInternalBridgeUUID(node, bridgeName);
- if (brIntId == null) {
- logger.error("Unable to spot Bridge Identifier for {} in {}", bridgeName, node);
+ Long dpid = this.getIntegrationBridgeOFDPID(node);
+ if (dpid == 0L) {
+ logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
return;
}
-
OVSDBConfigService ovsdbTable = (OVSDBConfigService) ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
- Bridge bridge = (Bridge) ovsdbTable.getRow(node, Bridge.NAME.getName(), brIntId);
- Set<String> dpids = bridge.getDatapath_id();
- if (dpids == null || dpids.size() == 0) return;
- Long dpid = Long.valueOf(HexEncode.stringToLong((String) dpids.toArray()[0]));
Set<BigInteger> of_ports = intf.getOfport();
if (of_ports == null || of_ports.size() <= 0) {
@Override
public Status handleInterfaceUpdate(String tunnelType, String tunnelKey, Node srcNode, Interface intf) {
+ ISwitchManager switchManager = (ISwitchManager) ServiceHelper.getInstance(ISwitchManager.class, "default", this);
+ if (switchManager == null) {
+ logger.error("Unable to identify SwitchManager");
+ } else {
+ Long dpid = this.getIntegrationBridgeOFDPID(srcNode);
+ if (dpid == 0L) {
+ logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", srcNode);
+ return new Status(StatusCode.NOTFOUND);
+ }
+ Set<Node> ofNodes = switchManager.getNodes();
+ boolean ofNodeFound = false;
+ if (ofNodes != null) {
+ for (Node ofNode : ofNodes) {
+ if (ofNode.toString().contains(dpid+"")) {
+ logger.info("Identified the Openflow node via toString {}", ofNode);
+ ofNodeFound = true;
+ break;
+ }
+ }
+ } else {
+ logger.error("Unable to find any Node from SwitchManager");
+ }
+ if (!ofNodeFound) {
+ logger.error("Unable to find OF Node for {} with update {} on node {}", dpid, intf, srcNode);
+ return new Status(StatusCode.NOTFOUND);
+ }
+ }
+
IConnectionServiceInternal connectionService = (IConnectionServiceInternal)ServiceHelper.getGlobalInstance(IConnectionServiceInternal.class, this);
List<Node> nodes = connectionService.getNodes();
nodes.remove(srcNode);
this.programLocalRules(tunnelType, tunnelKey, srcNode, intf);
+
for (Node dstNode : nodes) {
Status status = getTunnelReadinessStatus(dstNode, tunnelKey);
if (!status.isSuccess()) continue;
this.programTunnelRules(tunnelType, tunnelKey, src, dstNode, intf, false);
}
}
+
return new Status(StatusCode.SUCCESS);
}
+ private Status triggerInterfaceUpdates(Node node) {
+ try {
+ OVSDBConfigService ovsdbTable = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
+ Map<String, org.opendaylight.ovsdb.lib.table.internal.Table<?>> intfs = ovsdbTable.getRows(node, Interface.NAME.getName());
+ if (intfs != null) {
+ for (org.opendaylight.ovsdb.lib.table.internal.Table<?> row : intfs.values()) {
+ Interface intf = (Interface)row;
+ NeutronNetwork network = TenantNetworkManager.getManager().getTenantNetworkForInterface(intf);
+ logger.debug("Trigger Interface update for {}", intf);
+ if (network != null) {
+ this.handleInterfaceUpdate(network.getProviderNetworkType(), network.getProviderSegmentationID(), node, intf);
+ }
+ }
+ }
+ } catch (Exception e) {
+ logger.error("Error Triggering the lost interface updates for "+ node, e);
+ return new Status(StatusCode.INTERNALERROR, e.getLocalizedMessage());
+ }
+ return new Status(StatusCode.SUCCESS);
+ }
@Override
public Status handleInterfaceUpdate(String tunnelType, String tunnelKey) {
// TODO Auto-generated method stub
@Override
public void initializeFlowRules(Node node) {
this.initializeFlowRules(node, AdminConfigManager.getManager().getIntegrationBridgeName());
+ this.triggerInterfaceUpdates(node);
}
/**
* @param bridgeName
*/
private void initializeFlowRules(Node node, String bridgeName) {
-
- // TODO : 3 second sleep hack is to make sure the OF connection is established.
- // Correct fix is to check the MD-SAL inventory before proceeding and listen
- // to Inventory update for processing.
- try {
- Thread.sleep(3000);
- } catch (InterruptedException e1) {
- logger.error("Sleep Thread interrupted ",e1);
- }
-
- String brIntId = this.getInternalBridgeUUID(node, bridgeName);
- if (brIntId == null) {
- logger.error("Failed to initialize Flow Rules for {}", node);
+ Long dpid = this.getIntegrationBridgeOFDPID(node);
+ if (dpid == 0L) {
+ logger.debug("Openflow Datapath-ID not set for the integration bridge in {}", node);
return;
}
- try {
- OVSDBConfigService ovsdbTable = (OVSDBConfigService) ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
- Bridge bridge = (Bridge) ovsdbTable.getRow(node, Bridge.NAME.getName(), brIntId);
- Set<String> dpids = bridge.getDatapath_id();
- if (dpids == null || dpids.size() == 0) return;
- Long dpid = Long.valueOf(HexEncode.stringToLong((String) dpids.toArray()[0]));
-
- /*
- * Table(0) Rule #1
- * ----------------
- * Match: LLDP (0x88CCL)
- * Action: Packet_In to Controller Reserved Port
- */
+ /*
+ * Table(0) Rule #1
+ * ----------------
+ * Match: LLDP (0x88CCL)
+ * Action: Packet_In to Controller Reserved Port
+ */
- writeLLDPRule(dpid);
- } catch (Exception e) {
- logger.error("Failed to initialize Flow Rules for " + node.toString()+ " Bridge "+bridgeName, e);
- }
+ writeLLDPRule(dpid);
}
/*
@Override
public void initializeOFFlowRules(Node openflowNode) {
+ IConnectionServiceInternal connectionService = (IConnectionServiceInternal)ServiceHelper.getGlobalInstance(IConnectionServiceInternal.class, this);
+ List<Node> ovsNodes = connectionService.getNodes();
+ if (ovsNodes == null) return;
+ for (Node ovsNode : ovsNodes) {
+ Long dpid = this.getIntegrationBridgeOFDPID(ovsNode);
+ logger.debug("Compare openflowNode to OVS br-int node {} vs {}", openflowNode.getID(), dpid);
+ String openflowID = (String)openflowNode.getID();
+ if (openflowID.contains(""+dpid)) {
+ this.initializeFlowRules(ovsNode, AdminConfigManager.getManager().getIntegrationBridgeName());
+ this.triggerInterfaceUpdates(ovsNode);
+ }
+ }
}
private NodeBuilder createNodeBuilder(String nodeId) {
import org.opendaylight.ovsdb.lib.message.OvsdbRPC;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.message.UpdateNotification;
+import org.opendaylight.ovsdb.lib.notation.OvsDBSet;
import org.opendaylight.ovsdb.lib.table.Bridge;
import org.opendaylight.ovsdb.lib.table.Controller;
import org.opendaylight.ovsdb.lib.table.Open_vSwitch;
return false;
}
- if (connection != null) {
- List<InetAddress> ofControllerAddrs = this.getControllerIPAddresses(connection);
- short ofControllerPort = getControllerOFPort();
- for (InetAddress ofControllerAddress : ofControllerAddrs) {
- String newController = "tcp:"+ofControllerAddress.getHostAddress()+":"+ofControllerPort;
- Controller controllerRow = new Controller();
- controllerRow.setTarget(newController);
- OVSDBConfigService ovsdbTable = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
- if (ovsdbTable != null) {
- ovsdbTable.insertRow(node, Controller.NAME.getName(), bridgeUUID, controllerRow);
- }
+ OVSDBConfigService ovsdbTable = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
+ OvsDBSet<String> protocols = new OvsDBSet<String>();
+ if (Boolean.getBoolean("OF1.3_Provider")) {
+ protocols.add("OpenFlow13");
+ } else {
+ protocols.add("OpenFlow10");
+ }
+ Bridge bridge = new Bridge();
+ bridge.setProtocols(protocols);
+ Status status = ovsdbTable.updateRow(node, Bridge.NAME.getName(), null, bridgeUUID, bridge);
+ logger.info("Bridge {} updated to {} with Status {}", bridgeUUID, protocols.toArray()[0], status);
+
+ List<InetAddress> ofControllerAddrs = this.getControllerIPAddresses(connection);
+ short ofControllerPort = getControllerOFPort();
+ for (InetAddress ofControllerAddress : ofControllerAddrs) {
+ String newController = "tcp:"+ofControllerAddress.getHostAddress()+":"+ofControllerPort;
+ Controller controllerRow = new Controller();
+ controllerRow.setTarget(newController);
+ if (ovsdbTable != null) {
+ ovsdbTable.insertRow(node, Controller.NAME.getName(), bridgeUUID, controllerRow);
}
}
return true;
Code Review / ovsdb.git / commitdiff