}
@Override
- public void initializeOFFlowRules(org.opendaylight.controller.sal.core.Node openflowNode) {
+ public void initializeOFFlowRules(Node openflowNode) {
}
}
*/
package org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13;
+import com.google.common.collect.Lists;
+import java.util.List;
import java.util.Map;
+import java.util.Set;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+//import org.opendaylight.ovsdb.openstack.netvirt.NodeUtils;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
import org.opendaylight.ovsdb.utils.servicehelper.ServiceHelper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
public class FlowCapableNodeDataChangeListener implements DataChangeListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FlowCapableNodeDataChangeListener.class);
private ListenerRegistration<DataChangeListener> registration;
+ private List<Node> nodeCache = Lists.newArrayList();
public static final InstanceIdentifier<FlowCapableNode> createFlowCapableNodePath () {
return InstanceIdentifier.builder(Nodes.class)
LOG.debug("onDataChanged: {}", changes);
for( Map.Entry<InstanceIdentifier<?>, DataObject> created : changes.getCreatedData().entrySet()) {
- InstanceIdentifier<?> iiD = created.getKey();
+ InstanceIdentifier<?> iID = created.getKey();
+ String openflowId = iID.firstKeyOf(Node.class, NodeKey.class).getId().getValue();
LOG.debug(">>>>> created iiD: {} - first: {} - NodeKey: {}",
- iiD,
- iiD.firstIdentifierOf(Node.class),
- iiD.firstKeyOf(Node.class, NodeKey.class).getId().getValue());
+ iID,
+ iID.firstIdentifierOf(Node.class),
+ openflowId);
PipelineOrchestrator pipelineOrchestrator =
(PipelineOrchestrator) ServiceHelper.getGlobalInstance(PipelineOrchestrator.class, this);
- pipelineOrchestrator.enqueue(iiD.firstKeyOf(Node.class, NodeKey.class).getId().getValue());
+ pipelineOrchestrator.enqueue(openflowId);
+
+ notifyNodeUpdated(NodeUtils.getOpenFlowNode(openflowId));
+ }
+
+ //TODO: how to get the removed node id
+ Map<InstanceIdentifier<?>, DataObject> originalDataObject = changes.getOriginalData();
+ Set<InstanceIdentifier<?>> iID = changes.getRemovedPaths();
+ for (InstanceIdentifier instanceIdentifier : iID) {
+ notifyNodeUpdated(NodeUtils.getOpenFlowNode(null));
+ }
+ }
+
+ public void notifyNodeUpdated (Node openFlowNode) {
+ LOG.debug("notifyNodeUpdated: Node {} update from Controller's inventory Service",
+ openFlowNode.getId().getValue());
+
+ // Add the Node Type check back once the Consistency issue is resolved between MD-SAL and AD-SAL
+ if (!nodeCache.contains(openFlowNode)) {
+ nodeCache.add(openFlowNode);
+ NetworkingProviderManager networkingProviderManager =
+ (NetworkingProviderManager) ServiceHelper.getGlobalInstance(NetworkingProviderManager.class,
+ this);
+ networkingProviderManager.getProvider(openFlowNode).initializeOFFlowRules(openFlowNode);
}
}
+
+ public void notifyNodeRemoved (Node openFlowNode) {
+ LOG.debug("notifyNodeRemoved: Node {} update from Controller's inventory Service",
+ openFlowNode.getId().getValue());
+
+ nodeCache.remove(null);//openFlowNode);
+ }
}
*
* Authors : Sam Hague
*/
-package org.opendaylight.ovsdb.openstack.netvirt;
+package org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13;
import java.util.ArrayList;
import java.util.List;
return id;
}
+ public static Node getOpenFlowNode (String identifier) {
+ NodeId nodeId = new NodeId(identifier);
+ NodeKey nodeKey = new NodeKey(nodeId);
+ Node node = new NodeBuilder()
+ .setId(nodeId)
+ .setKey(nodeKey)
+ .build();
+
+ return node;
+ }
+
public static Node getMdsalNode (org.opendaylight.controller.sal.core.Node salNode) {
String identifier = salNode.getNodeIDString();
}
@Override
- public void initializeOFFlowRules(org.opendaylight.controller.sal.core.Node openflowNode) {
+ public void initializeOFFlowRules(Node openflowNode) {
Preconditions.checkNotNull(connectionService);
List<Node> ovsNodes = connectionService.getNodes();
if (ovsNodes == null) return;
for (Node ovsNode : ovsNodes) {
Long brIntDpid = this.getIntegrationBridgeOFDPID(ovsNode);
Long brExDpid = this.getExternalBridgeDpid(ovsNode);
- logger.debug("Compare openflowNode to OVS node {} vs {} and {}", openflowNode.getID(), brIntDpid, brExDpid);
- String openflowID = openflowNode.getID().toString();
+ logger.debug("Compare openflowNode to OVS node {} vs {} and {}",
+ openflowNode.getId().getValue(), brIntDpid, brExDpid);
+ String openflowID = openflowNode.getId().getValue();
if (openflowID.contains(brExDpid.toString())) {
this.initializeFlowRules(ovsNode, configurationService.getExternalBridgeName());
this.triggerInterfaceUpdates(ovsNode);
southboundHandlerProperties.put(Constants.EVENT_HANDLER_TYPE_PROPERTY, AbstractEvent.HandlerType.SOUTHBOUND);
manager.add(createComponent()
- .setInterface(new String[]{OvsdbInventoryListener.class.getName(), IInventoryListener.class.getName(),
+ .setInterface(new String[]{OvsdbInventoryListener.class.getName(),
AbstractHandler.class.getName()},
southboundHandlerProperties)
.setImplementation(SouthboundHandler.class)
*/
package org.opendaylight.ovsdb.openstack.netvirt;
-import org.opendaylight.controller.sal.core.NodeConnector;
-import org.opendaylight.controller.sal.core.Property;
-import org.opendaylight.controller.sal.core.UpdateType;
-import org.opendaylight.controller.switchmanager.IInventoryListener;
import org.opendaylight.neutron.spi.NeutronNetwork;
import org.opendaylight.ovsdb.lib.notation.Row;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
-public class SouthboundHandler extends AbstractHandler implements OvsdbInventoryListener,
- IInventoryListener {
+public class SouthboundHandler extends AbstractHandler implements OvsdbInventoryListener {
static final Logger logger = LoggerFactory.getLogger(SouthboundHandler.class);
//private Thread eventThread;
- List<org.opendaylight.controller.sal.core.Node> nodeCache;
// The implementation for each of these services is resolved by the OSGi Service Manager
private volatile ConfigurationService configurationService;
private volatile NeutronL3Adapter neutronL3Adapter;
void init() {
- nodeCache = Lists.newArrayList();
}
void start() {
return null;
}
- @Override
- public void notifyNode(org.opendaylight.controller.sal.core.Node openFlowNode,
- UpdateType type, Map<String, Property> propMap) {
- logger.debug("notifyNode: Node {} update {} from Controller's inventory Service", openFlowNode, type);
-
- // Add the Node Type check back once the Consistency issue is resolved between MD-SAL and AD-SAL
- if (!type.equals(UpdateType.REMOVED) && !nodeCache.contains(openFlowNode)) {
- nodeCache.add(openFlowNode);
- networkingProviderManager.getProvider(NodeUtils.getMdsalNode(openFlowNode))
- .initializeOFFlowRules(openFlowNode);
- } else if (type.equals(UpdateType.REMOVED)){
- nodeCache.remove(openFlowNode);
- }
- }
-
- @Override
- public void notifyNodeConnector(NodeConnector nodeConnector, UpdateType type, Map<String, Property> propMap) {
- //We are not interested in the nodeConnectors at this moment
- }
-
private void triggerUpdates() {
List<Node> nodes = connectionService.getNodes();
if (nodes == null) return;
/**
* Initialize the Flow rules for a given OpenFlow node
*/
- public void initializeOFFlowRules(org.opendaylight.controller.sal.core.Node openflowNode);
+ public void initializeOFFlowRules(Node openflowNode);
}