import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.neutron.spi.NeutronNetwork;
+import org.opendaylight.neutron.spi.NeutronPort;
+import org.opendaylight.neutron.spi.NeutronSecurityGroup;
+import org.opendaylight.neutron.spi.Neutron_IPs;
import org.opendaylight.ovsdb.openstack.netvirt.MdsalHelper;
import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.IngressAclProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
import org.opendaylight.ovsdb.openstack.netvirt.api.SecurityServicesManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Southbound;
import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
-import org.opendaylight.ovsdb.openstack.netvirt.MdsalUtils;
+import org.opendaylight.ovsdb.openstack.netvirt.providers.ConfigInterface;
+import org.opendaylight.ovsdb.openstack.netvirt.providers.NetvirtProvidersProvider;
import org.opendaylight.ovsdb.utils.mdsal.openflow.InstructionUtils;
+import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.GroupActionCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* @author Dave Tucker
* @author Sam Hague
*/
-public class OF13Provider implements NetworkingProvider {
+public class OF13Provider implements ConfigInterface, NetworkingProvider {
private static final Logger logger = LoggerFactory.getLogger(OF13Provider.class);
- private DataBroker dataBroker;
private static final short TABLE_0_DEFAULT_INGRESS = 0;
private static final short TABLE_1_ISOLATE_TENANT = 10;
private static final short TABLE_2_LOCAL_FORWARD = 20;
private static Long groupId = 1L;
+ private DataBroker dataBroker = null;
private volatile ConfigurationService configurationService;
private volatile BridgeConfigurationManager bridgeConfigurationManager;
private volatile TenantNetworkManager tenantNetworkManager;
private volatile SecurityServicesManager securityServicesManager;
- //private volatile OvsdbConnectionService connectionService;
- private volatile MdsalConsumer mdsalConsumer;
private volatile ClassifierProvider classifierProvider;
private volatile IngressAclProvider ingressAclProvider;
private volatile EgressAclProvider egressAclProvider;
private volatile L2ForwardingProvider l2ForwardingProvider;
public static final String NAME = "OF13Provider";
+ private volatile NetworkingProviderManager networkingProviderManager;
+ private volatile BundleContext bundleContext;
+ private volatile Southbound southbound;
- public void init() {
- logger.info(">>>>>> init OF13Provider {}", this.getClass());
+ public OF13Provider() {
+ this.dataBroker = NetvirtProvidersProvider.getDataBroker();
}
@Override
String tunnelBridgeName = configurationService.getIntegrationBridgeName();
String portName = getTunnelName(tunnelType, dst);
logger.info("addTunnelPort enter: portName: {}", portName);
- if (MdsalUtils.extractTerminationPointAugmentation(node, portName) != null
- || MdsalUtils.isTunnelTerminationPointExist(node,tunnelBridgeName,portName)) {
- logger.info("Tunnel {} is present in {} of {}", portName, tunnelBridgeName, node);
+ if (southbound.extractTerminationPointAugmentation(node, portName) != null
+ || southbound.isTunnelTerminationPointExist(node, tunnelBridgeName, portName)) {
+ logger.info("Tunnel {} is present in {} of {}", portName, tunnelBridgeName, node.getNodeId().getValue());
return true;
}
options.put("local_ip", src.getHostAddress());
options.put("remote_ip", dst.getHostAddress());
- if (!MdsalUtils.addTunnelTerminationPoint(node, tunnelBridgeName, portName, tunnelType, options)) {
+ if (!southbound.addTunnelTerminationPoint(node, tunnelBridgeName, portName, tunnelType, options)) {
logger.error("Failed to insert Tunnel port {} in {}", portName, tunnelBridgeName);
return false;
}
- logger.info("addTunnelPort exit: portName: {}", portName);
+ logger.info("addTunnelPort exit: portName: {}", portName);
return true;
}
private boolean deletePort(Node node, String bridgeName, String portName) {
// TODO SB_MIGRATION
// might need to convert from ovsdb node to bridge node
- return MdsalUtils.deleteTerminationPoint(node, portName);
+ return southbound.deleteTerminationPoint(node, portName);
}
private boolean deleteTunnelPort(Node node, String tunnelType, InetAddress src, InetAddress dst) {
private Long getDpid(Node node) {
Long dpid = 0L;
- dpid = MdsalUtils.getDataPathId(node);
+ dpid = southbound.getDataPathId(node);
if (dpid == 0) {
logger.warn("getDpid: dpid not found: {}", node);
}
private Long getIntegrationBridgeOFDPID(Node node) {
Long dpid = 0L;
- if (MdsalUtils.getBridgeName(node).equals(configurationService.getIntegrationBridgeName())) {
+ if (southbound.getBridgeName(node).equals(configurationService.getIntegrationBridgeName())) {
dpid = getDpid(node);
}
return dpid;
private Long getExternalBridgeDpid(Node node) {
Long dpid = 0L;
- if (MdsalUtils.getBridgeName(node).equals(configurationService.getExternalBridgeName())) {
+ if (southbound.getBridgeName(node).equals(configurationService.getExternalBridgeName())) {
dpid = getDpid(node);
}
return dpid;
}
+ /**
+ * Returns true is the network if of type GRE or VXLAN
+ *
+ * @param networkType The type of the network
+ * @return returns true if the network is a tunnel
+ */
+ private boolean isTunnel(String networkType)
+ {
+ return (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) || networkType.equalsIgnoreCase
+ (NetworkHandler.NETWORK_TYPE_VXLAN))? true:false;
+ }
+
+ /**
+ * Returns true if the network is of type vlan.
+ *
+ * @param networkType The type of the network
+ * @return returns true if the network is a vlan
+ */
+ private boolean isVlan(String networkType)
+ {
+ return networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)? true:false;
+ }
+
private void programLocalRules (String networkType, String segmentationId, Node node,
OvsdbTerminationPointAugmentation intf) {
logger.debug("programLocalRules: node: {}, intf: {}, networkType: {}, segmentationId: {}",
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
- logger.info("programLocalRules: could not find ofPort");
+ logger.info("programLocalRules: could not find ofPort for Port {} on Node {}",intf.getName(), node.getNodeId());
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.warn("No AttachedMac seen in {}", intf);
return;
}
/* Program local rules based on network type */
- if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
+ if (isVlan(networkType)) {
logger.debug("Program local vlan rules for interface {}", intf.getName());
programLocalVlanRules(node, dpid, segmentationId, attachedMac, localPort);
}
+ if ((isTunnel(networkType)|| isVlan(networkType))) {
+ logger.debug("programLocalRules: Program fixed security group rules for interface {}", intf.getName());
+ // Get the DHCP port for the subnet to which the interface belongs to.
+ NeutronPort dhcpPort = securityServicesManager.getDHCPServerPort(intf);
+ if (null != dhcpPort) {
+ boolean isComputePort =securityServicesManager.isComputePort(intf);
+ boolean isLastPortinBridge = securityServicesManager.isLastPortinBridge(node, intf);
+ boolean isLastPortinSubnet =false;
+ List<Neutron_IPs> srcAddressList = null;
+ if(isComputePort) {
+ isLastPortinSubnet = securityServicesManager.isLastPortinSubnet(node, intf);
+ srcAddressList = securityServicesManager.getIpAddress(node, intf);
+ if (null == srcAddressList) {
+ logger.warn("programLocalRules: No Ip address assigned {}", intf);
+ return;
+ }
+ }
+ ingressAclProvider.programFixedSecurityACL(dpid,segmentationId, dhcpPort.getMacAddress(), localPort,
+ isLastPortinSubnet,isComputePort, true);
+ egressAclProvider.programFixedSecurityACL(dpid, segmentationId, attachedMac, localPort,
+ srcAddressList, isLastPortinBridge, isComputePort,true);
+ } else {
+ logger.warn("programLocalRules: No DCHP port seen in network of {}", intf);
+ }
+ }
/* If the network type is tunnel based (VXLAN/GRRE/etc) with Neutron Port Security ACLs */
/* TODO SB_MIGRATION */
/*if ((networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) || networkType.equalsIgnoreCase
egressAclProvider.programPortSecurityACL(dpid, segmentationId, attachedMac, localPort,
securityGroupInPort);
}*/
- if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) ||
- networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)) {
+ if (isTunnel(networkType)) {
logger.debug("Program local bridge rules for interface {}, "
+ "dpid: {}, segmentationId: {}, attachedMac: {}, localPort: {}",
intf.getName(), dpid, segmentationId, attachedMac, localPort);
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.info("removeLocalRules: could not find ofPort");
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.warn("No AttachedMac seen in {}", intf);
return;
}
/* Program local rules based on network type */
- if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
+ if (isVlan(networkType)) {
logger.debug("Remove local vlan rules for interface {}", intf.getName());
removeLocalVlanRules(node, dpid, segmentationId, attachedMac, localPort);
- } else if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE) ||
- networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)) {
+ } else if (isTunnel(networkType)) {
logger.debug("Remove local bridge rules for interface {}", intf.getName());
removeLocalBridgeRules(node, dpid, segmentationId, attachedMac, localPort);
}
+ if (isTunnel(networkType)|| isVlan(networkType)) {
+ logger.debug("removeLocalRules: Remove fixed security group rules for interface {}", intf.getName());
+ NeutronPort dhcpPort = securityServicesManager.getDHCPServerPort(intf);
+ if (null != dhcpPort) {
+ List<Neutron_IPs> srcAddressList = securityServicesManager.getIpAddress(node, intf);
+ if (null == srcAddressList) {
+ logger.warn("removeLocalRules: No Ip address assigned {}", intf);
+ return;
+ }
+ boolean isLastPortinBridge = securityServicesManager.isLastPortinBridge(node, intf);
+ boolean isComputePort =securityServicesManager.isComputePort(intf);
+ boolean isLastPortinSubnet =false;
+ if (isComputePort)
+ {
+ isLastPortinSubnet = securityServicesManager.isLastPortinSubnet(node, intf);
+ }
+ ingressAclProvider.programFixedSecurityACL(dpid, segmentationId, dhcpPort.getMacAddress(), localPort,
+ isLastPortinSubnet, isComputePort, false);
+ egressAclProvider.programFixedSecurityACL(dpid, segmentationId, attachedMac, localPort,
+ srcAddressList, isLastPortinBridge, isComputePort, false);
+ }else{
+ logger.warn("removeLocalRules: No DCHP port seen in network of {}", intf);
+ }
+ }
} catch (Exception e) {
logger.error("Exception in removing Local Rules for "+intf+" on "+node, e);
}
OvsdbTerminationPointAugmentation intf, boolean local) {
logger.debug("programTunnelRules: node: {}, intf: {}, local: {}, tunnelType: {}, "
+ "segmentationId: {}, dstAddr: {}",
- node.getNodeId(), intf.getName(), local, tunnelType, segmentationId, dst);
+ node.getNodeId(), intf.getName(), local, tunnelType, segmentationId, dst.getHostAddress());
try {
Long dpid = getIntegrationBridgeOFDPID(node);
if (dpid == 0L) {
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
- logger.info("programTunnelRules: could not find ofPort");
+ logger.info("programTunnelRules: could not find ofPort for Port {} on Node{}",intf.getName(),node.getNodeId());
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.warn("programTunnelRules: No AttachedMac seen in {}", intf);
return;
}
- List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
- for (OvsdbTerminationPointAugmentation tunIntf : intfs) {
- if (tunIntf.getName().equals(getTunnelName(tunnelType, dst))) {
- long tunnelOFPort = MdsalUtils.getOFPort(tunIntf);
- if (tunnelOFPort == 0) {
- logger.error("programTunnelRules: Could not Identify Tunnel port {} -> OF ({}) on {}",
- tunIntf.getName(), tunnelOFPort, node);
- return;
- }
- logger.debug("programTunnelRules: Identified Tunnel port {} -> OF ({}) on {}",
- tunIntf.getName(), tunnelOFPort, node);
+ OvsdbTerminationPointAugmentation tunnelPort= southbound.getTerminationPointOfBridge(node, getTunnelName(tunnelType, dst));
+ if(tunnelPort != null){
+ long tunnelOFPort = southbound.getOFPort(tunnelPort);
+ if (tunnelOFPort == 0) {
+ logger.error("programTunnelRules: Could not Identify Tunnel port {} -> OF ({}) on {}",
+ tunnelPort.getName(), tunnelOFPort, node);
+ return;
+ }
+ logger.debug("programTunnelRules: Identified Tunnel port {} -> OF ({}) on {}",
+ tunnelPort.getName(), tunnelOFPort, node);
+
+ if (!local) {
+ logger.trace("programTunnelRules: program remote egress tunnel rules: node {}, intf {}",
+ node.getNodeId().getValue(), intf.getName());
+ programRemoteEgressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
+ tunnelOFPort, localPort);
+ }
- if (!local) {
- logger.trace("programTunnelRules: program remote egress tunnel rules: node {}, intf {}",
+ if (local) {
+ logger.trace("programTunnelRules: program local ingress tunnel rules: node {}, intf {}",
node.getNodeId().getValue(), intf.getName());
- programRemoteEgressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
- tunnelOFPort, localPort);
- }
-
- if (local) {
- logger.trace("programTunnelRules: program local ingress tunnel rules: node {}, intf {}",
- node.getNodeId().getValue(), intf.getName());
- programLocalIngressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
- tunnelOFPort, localPort);
- }
- return;
+ programLocalIngressTunnelBridgeRules(node, dpid, segmentationId, attachedMac,
+ tunnelOFPort, localPort);
}
+ return;
}
} catch (Exception e) {
- logger.error("", e);
+ logger.trace("", e);
}
}
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.info("removeTunnelRules: could not find ofPort");
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.error("removeTunnelRules: No AttachedMac seen in {}", intf);
return;
}
- List<OvsdbTerminationPointAugmentation> intfs = MdsalUtils.getTerminationPointsOfBridge(node);
+ List<OvsdbTerminationPointAugmentation> intfs = southbound.getTerminationPointsOfBridge(node);
for (OvsdbTerminationPointAugmentation tunIntf : intfs) {
if (tunIntf.getName().equals(getTunnelName(tunnelType, dst))) {
- long tunnelOFPort = MdsalUtils.getOFPort(tunIntf);
- if (tunnelOFPort == -1) {
+ long tunnelOFPort = southbound.getOFPort(tunIntf);
+ if (tunnelOFPort == 0) {
logger.error("Could not Identify Tunnel port {} -> OF ({}) on {}",
tunIntf.getName(), tunnelOFPort, node);
return;
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.debug("programVlanRules: could not find ofPort for {}", intf.getName());
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.debug("programVlanRules: No AttachedMac seen in {}", intf);
return;
String phyIfName =
bridgeConfigurationManager.getPhysicalInterfaceName(node, network.getProviderPhysicalNetwork());
- long ethOFPort = MdsalUtils.getOFPort(node, phyIfName);
+ long ethOFPort = southbound.getOFPort(node, phyIfName);
if (ethOFPort == 0) {
logger.warn("programVlanRules: could not find ofPort for physical port {}", phyIfName);
return;
return;
}
- long localPort = MdsalUtils.getOFPort(intf);
+ long localPort = southbound.getOFPort(intf);
if (localPort == 0) {
logger.debug("removeVlanRules: programVlanRules: could not find ofPort for {}", intf.getName());
return;
}
- String attachedMac = MdsalUtils.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
+ String attachedMac = southbound.getInterfaceExternalIdsValue(intf, Constants.EXTERNAL_ID_VM_MAC);
if (attachedMac == null) {
logger.debug("removeVlanRules: No AttachedMac seen in {}", intf);
return;
String phyIfName =
bridgeConfigurationManager.getPhysicalInterfaceName(node, network.getProviderPhysicalNetwork());
- long ethOFPort = MdsalUtils.getOFPort(node, phyIfName);
+ long ethOFPort = southbound.getOFPort(node, phyIfName);
if (ethOFPort == 0) {
logger.warn("removeVlanRules: could not find ofPort for physical port {}", phyIfName);
return;
Preconditions.checkNotNull(nodeCacheManager);
Map<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId,Node> nodes =
nodeCacheManager.getOvsdbNodes();
- nodes.remove(MdsalUtils.extractBridgeOvsdbNodeId(srcNode));
+ nodes.remove(southbound.extractBridgeOvsdbNodeId(srcNode));
String networkType = network.getProviderNetworkType();
String segmentationId = network.getProviderSegmentationID();
- Node srcBridgeNode = MdsalUtils.getBridgeNode(srcNode,configurationService.getIntegrationBridgeName());
+ Node srcBridgeNode = southbound.getBridgeNode(srcNode, configurationService.getIntegrationBridgeName());
programLocalRules(networkType, network.getProviderSegmentationID(), srcBridgeNode, intf);
- if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
+ if (isVlan(networkType)) {
programVlanRules(network, srcNode, intf);
- } else if (networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE)
- || networkType.equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)){
+ } else if (isTunnel(networkType)){
+
+ boolean sourceTunnelStatus = false;
+ boolean destTunnelStatus = false;
for (Node dstNode : nodes.values()) {
InetAddress src = configurationService.getTunnelEndPoint(srcNode);
InetAddress dst = configurationService.getTunnelEndPoint(dstNode);
if ((src != null) && (dst != null)) {
- Node dstBridgeNode = MdsalUtils.getBridgeNode(dstNode,
+ sourceTunnelStatus = addTunnelPort(srcBridgeNode, networkType, src, dst);
+
+ Node dstBridgeNode = southbound.getBridgeNode(dstNode,
configurationService.getIntegrationBridgeName());
- if (addTunnelPort(srcBridgeNode, networkType, src, dst)) {
+
+ if(dstBridgeNode != null){
+ destTunnelStatus = addTunnelPort(dstBridgeNode, networkType, dst, src);
+ }
+
+ if (sourceTunnelStatus) {
programTunnelRules(networkType, segmentationId, dst, srcBridgeNode, intf, true);
}
- if (addTunnelPort(dstBridgeNode, networkType, dst, src)) {
+ if (destTunnelStatus) {
programTunnelRules(networkType, segmentationId, src, dstBridgeNode, intf, false);
}
} else {
}
private void triggerInterfaceUpdates(Node node) {
- logger.warn("enter triggerInterfaceUpdates for {}", node.getNodeId());
- List<OvsdbTerminationPointAugmentation> ports = MdsalUtils.extractTerminationPointAugmentations(node);
+ logger.debug("enter triggerInterfaceUpdates for {}", node.getNodeId());
+ List<OvsdbTerminationPointAugmentation> ports = southbound.extractTerminationPointAugmentations(node);
if (ports != null && !ports.isEmpty()) {
for (OvsdbTerminationPointAugmentation port : ports) {
NeutronNetwork neutronNetwork = tenantNetworkManager.getTenantNetwork(port);
handleInterfaceUpdate(neutronNetwork, node, port);
}
}
- /*
- List<TerminationPoint> tps = MdsalUtils.extractTerminationPoints(node);
- if (tps != null) {
- for (TerminationPoint tp : tps) {
- OvsdbTerminationPointAugmentation port = tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
- if (port != null) {
- NeutronNetwork neutronNetwork = tenantNetworkManager.getTenantNetwork(port);
- if (neutronNetwork != null) {
- logger.warn("Trigger Interface update for {}", port);
- handleInterfaceUpdate(neutronNetwork, node, port);
- }
- }
- }
- */
} else {
logger.warn("triggerInterfaceUpdates: tps are null");
}
- logger.warn("exit triggerInterfaceUpdates for {}", node.getNodeId());
+ logger.debug("exit triggerInterfaceUpdates for {}", node.getNodeId());
}
@Override
OvsdbTerminationPointAugmentation intf, boolean isLastInstanceOnNode) {
Map<org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId,Node> nodes =
nodeCacheManager.getOvsdbNodes();
- nodes.remove(MdsalUtils.extractBridgeOvsdbNodeId(srcNode));
+ nodes.remove(southbound.extractBridgeOvsdbNodeId(srcNode));
logger.info("Delete intf " + intf.getName() + " isLastInstanceOnNode " + isLastInstanceOnNode);
List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(srcNode);
- if (MdsalUtils.isTunnel(intf)) {
+ if (southbound.isTunnel(intf)) {
// Delete tunnel port
try {
InetAddress src = InetAddress.getByName(
- MdsalUtils.getOptionsValue(intf.getOptions(), "local_ip"));
+ southbound.getOptionsValue(intf.getOptions(), "local_ip"));
InetAddress dst = InetAddress.getByName(
- MdsalUtils.getOptionsValue(intf.getOptions(), "remote_ip"));
+ southbound.getOptionsValue(intf.getOptions(), "remote_ip"));
deleteTunnelPort(srcNode,
MdsalHelper.createOvsdbInterfaceType(intf.getInterfaceType()),
src, dst);
removeLocalRules(network.getProviderNetworkType(), network.getProviderSegmentationID(),
srcNode, intf);
- if (network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VLAN)) {
+ if (isVlan(network.getProviderNetworkType())) {
removeVlanRules(network, srcNode, intf, isLastInstanceOnNode);
- } else if (network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE)
- || network.getProviderNetworkType().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)) {
+ } else if (isTunnel(network.getProviderNetworkType())) {
for (Node dstNode : nodes.values()) {
InetAddress src = configurationService.getTunnelEndPoint(srcNode);
+ intf.getName() + " on srcNode " + srcNode.getNodeId().getValue());
removeTunnelRules(tunnelType, network.getProviderSegmentationID(),
dst, srcNode, intf, true, isLastInstanceOnNode);
- Node dstBridgeNode = MdsalUtils.getBridgeNode(dstNode, Constants.INTEGRATION_BRIDGE);
+ Node dstBridgeNode = southbound.getBridgeNode(dstNode, Constants.INTEGRATION_BRIDGE);
if(dstBridgeNode != null){
logger.info("Remove tunnel rules for interface "
+ intf.getName() + " on dstNode " + dstNode.getNodeId().getValue());
}
private void initializeFlowRules(Node node, String bridgeName) {
- Long dpid = MdsalUtils.getDataPathId(node);
- String datapathId = MdsalUtils.getDatapathId(node);
+ Long dpid = southbound.getDataPathId(node);
+ String datapathId = southbound.getDatapathId(node);
logger.info("initializeFlowRules: bridgeName: {}, dpid: {} - {}",
bridgeName, dpid, datapathId);
}
private Group getGroup(GroupBuilder groupBuilder, NodeBuilder nodeBuilder) {
- Preconditions.checkNotNull(mdsalConsumer);
- if (mdsalConsumer == null) {
- logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
- return null;
- }
-
- dataBroker = mdsalConsumer.getDataBroker();
- if (dataBroker == null) {
- logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
- return null;
- }
-
InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
.rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Group.class,
new GroupKey(groupBuilder.getGroupId())).build();
}
private void writeGroup(GroupBuilder groupBuilder, NodeBuilder nodeBuilder) {
- Preconditions.checkNotNull(mdsalConsumer);
- if (mdsalConsumer == null) {
- logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
- return;
- }
-
- dataBroker = mdsalConsumer.getDataBroker();
- if (dataBroker == null) {
- logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
- return;
- }
-
ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
.rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Group.class,
}
private void removeGroup(GroupBuilder groupBuilder, NodeBuilder nodeBuilder) {
- Preconditions.checkNotNull(mdsalConsumer);
- if (mdsalConsumer == null) {
- logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
- return;
- }
-
- dataBroker = mdsalConsumer.getDataBroker();
- if (dataBroker == null) {
- logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
- return;
- }
-
WriteTransaction modification = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<Group> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
.rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Group.class,
}
private Flow getFlow(FlowBuilder flowBuilder, NodeBuilder nodeBuilder) {
- Preconditions.checkNotNull(mdsalConsumer);
- if (mdsalConsumer == null) {
- logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
- return null;
- }
-
- dataBroker = mdsalConsumer.getDataBroker();
- if (dataBroker == null) {
- logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
- return null;
- }
-
InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
.rev130819.nodes.Node.class, nodeBuilder.getKey()).augmentation(FlowCapableNode.class).child(Table.class,
new TableKey(flowBuilder.getTableId())).child(Flow.class, flowBuilder.getKey()).build();
}
private void writeFlow(FlowBuilder flowBuilder, NodeBuilder nodeBuilder) {
- Preconditions.checkNotNull(mdsalConsumer);
- logger.debug("writeFlow: flowBuilder: {}, nodeBuilder: {}",
- flowBuilder.build(), nodeBuilder.build());
- if (mdsalConsumer == null) {
- logger.error("ERROR finding MDSAL Service. Its possible that writeFlow is called too soon ?");
- return;
- }
-
- dataBroker = mdsalConsumer.getDataBroker();
- if (dataBroker == null) {
- logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
- return;
- }
-
ReadWriteTransaction modification = dataBroker.newReadWriteTransaction();
InstanceIdentifier<Flow> path1 =
InstanceIdentifier.builder(Nodes.class).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
}
private void removeFlow(FlowBuilder flowBuilder, NodeBuilder nodeBuilder) {
- Preconditions.checkNotNull(mdsalConsumer);
- if (mdsalConsumer == null) {
- logger.error("ERROR finding MDSAL Service.");
- return;
- }
-
- dataBroker = mdsalConsumer.getDataBroker();
- if (dataBroker == null) {
- logger.error("ERROR finding reference for DataBroker. Please check MD-SAL support on the Controller.");
- return;
- }
-
WriteTransaction modification = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<Flow> path1 = InstanceIdentifier.builder(Nodes.class)
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory
@Override
public void initializeOFFlowRules(Node openflowNode) {
- String bridgeName = MdsalUtils.getBridgeName(openflowNode);
+ String bridgeName = southbound.getBridgeName(openflowNode);
logger.info("initializeOFFlowRules: bridgeName: {}", bridgeName);
if (bridgeName.equals(configurationService.getIntegrationBridgeName())) {
initializeFlowRules(openflowNode, configurationService.getIntegrationBridgeName());
builder.setKey(new NodeKey(builder.getId()));
return builder;
}
+
+ @Override
+ public void setDependencies(BundleContext bundleContext, ServiceReference serviceReference) {
+ this.bundleContext = bundleContext;
+ configurationService =
+ (ConfigurationService) ServiceHelper.getGlobalInstance(ConfigurationService.class, this);
+ tenantNetworkManager =
+ (TenantNetworkManager) ServiceHelper.getGlobalInstance(TenantNetworkManager.class, this);
+ bridgeConfigurationManager =
+ (BridgeConfigurationManager) ServiceHelper.getGlobalInstance(BridgeConfigurationManager.class, this);
+ nodeCacheManager =
+ (NodeCacheManager) ServiceHelper.getGlobalInstance(NodeCacheManager.class, this);
+ classifierProvider =
+ (ClassifierProvider) ServiceHelper.getGlobalInstance(ClassifierProvider.class, this);
+ ingressAclProvider =
+ (IngressAclProvider) ServiceHelper.getGlobalInstance(IngressAclProvider.class, this);
+ egressAclProvider =
+ (EgressAclProvider) ServiceHelper.getGlobalInstance(EgressAclProvider.class, this);
+ l2ForwardingProvider =
+ (L2ForwardingProvider) ServiceHelper.getGlobalInstance(L2ForwardingProvider.class, this);
+ securityServicesManager =
+ (SecurityServicesManager) ServiceHelper.getGlobalInstance(SecurityServicesManager.class, this);
+ southbound =
+ (Southbound) ServiceHelper.getGlobalInstance(Southbound.class, this);
+ }
+
+ @Override
+ public void setDependencies(Object impl) {
+ if (impl instanceof NetworkingProviderManager) {
+ networkingProviderManager = (NetworkingProviderManager)impl;
+ networkingProviderManager.providerAdded(
+ bundleContext.getServiceReference(NetworkingProvider.class.getName()),this);
+ }
+ }
}
Code Review / ovsdb.git / blobdiff