X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=southbound%2Fsouthbound-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fovsdb%2Fsouthbound%2Ftransactions%2Fmd%2FOvsdbBridgeUpdateCommand.java;h=47767f9da1f5c12613bcbc8ad0c3f854aaccdbb9;hb=df08ae0d239824f7bce568a5dbaa7de48ad9ae31;hp=1e51f816c2db822b975363a0c2bd71699d993eea;hpb=d138c9331de7b1bf6a6eb97191bfe2a991d284de;p=ovsdb.git diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbBridgeUpdateCommand.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbBridgeUpdateCommand.java index 1e51f816c..47767f9da 100644 --- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbBridgeUpdateCommand.java +++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbBridgeUpdateCommand.java @@ -1,141 +1,372 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + package org.opendaylight.ovsdb.southbound.transactions.md; +import java.net.InetAddress; +import java.net.NetworkInterface; import java.util.ArrayList; +import java.util.Enumeration; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import org.apache.commons.lang3.math.NumberUtils; import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException; +import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException; import org.opendaylight.ovsdb.lib.message.TableUpdates; import org.opendaylight.ovsdb.lib.notation.UUID; import org.opendaylight.ovsdb.lib.schema.DatabaseSchema; import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils; import org.opendaylight.ovsdb.schema.openvswitch.Bridge; import org.opendaylight.ovsdb.schema.openvswitch.Controller; -import org.opendaylight.ovsdb.southbound.OvsdbClientKey; +import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance; import org.opendaylight.ovsdb.southbound.SouthboundConstants; import org.opendaylight.ovsdb.southbound.SouthboundMapper; +import org.opendaylight.ovsdb.southbound.SouthboundUtil; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId; 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.OvsdbBridgeAugmentationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIdsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIdsKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigsKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder; import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId; 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.NodeBuilder; +import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey; +import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.net.InetAddresses; public class OvsdbBridgeUpdateCommand extends AbstractTransactionCommand { private static final Logger LOG = LoggerFactory.getLogger(OvsdbBridgeUpdateCommand.class); + private Map updatedBridgeRows; + private Map oldBridgeRows; - public OvsdbBridgeUpdateCommand(OvsdbClientKey key, TableUpdates updates, + public OvsdbBridgeUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates, DatabaseSchema dbSchema) { super(key,updates,dbSchema); + updatedBridgeRows = TyperUtils.extractRowsUpdated(Bridge.class, getUpdates(), getDbSchema()); + oldBridgeRows = TyperUtils.extractRowsOld(Bridge.class, getUpdates(), getDbSchema()); } @Override public void execute(ReadWriteTransaction transaction) { - Map updatedBridgeRows = TyperUtils.extractRowsUpdated(Bridge.class, getUpdates(), getDbSchema()); - Map updatedControllerRows = TyperUtils.extractRowsUpdated(Controller.class, - getUpdates(), getDbSchema()); for (Entry entry : updatedBridgeRows.entrySet()) { - Bridge bridge = entry.getValue(); - final InstanceIdentifier nodePath = getKey().toInstanceIndentifier(); - Optional node = Optional.absent(); - try { - node = transaction.read(LogicalDatastoreType.OPERATIONAL, nodePath).checkedGet(); - } catch (final ReadFailedException e) { - LOG.debug("Read Operational/DS for Node fail! {}", nodePath, e); - } - if (node.isPresent()) { - LOG.debug("Node {} is present",node); - NodeBuilder managedNodeBuilder = new NodeBuilder(); - InstanceIdentifier managedNodePath = SouthboundMapper.createInstanceIdentifier(getKey(),bridge); - NodeId manageNodeId = SouthboundMapper.createManagedNodeId(managedNodePath); - managedNodeBuilder.setNodeId(manageNodeId); - OvsdbBridgeAugmentationBuilder ovsdbManagedNodeBuilder = new OvsdbBridgeAugmentationBuilder(); - ovsdbManagedNodeBuilder.setBridgeName(new OvsdbBridgeName(bridge.getName())); - ovsdbManagedNodeBuilder.setBridgeUuid(new Uuid(bridge.getUuid().toString())); - DatapathId dpid = SouthboundMapper.createDatapathId(bridge); - if (dpid != null) { - ovsdbManagedNodeBuilder.setDatapathId(dpid); + updateBridge(transaction, entry.getValue()); + } + } + + private void updateBridge(ReadWriteTransaction transaction, + Bridge bridge) { + final InstanceIdentifier connectionIId = getOvsdbConnectionInstance().getInstanceIdentifier(); + Optional connection = SouthboundUtil.readNode(transaction, connectionIId); + if (connection.isPresent()) { + LOG.debug("Connection {} is present",connection); + + // Update the connection node to let it know it manages this bridge + Node connectionNode = buildConnectionNode(bridge); + transaction.merge(LogicalDatastoreType.OPERATIONAL, connectionIId, connectionNode); + + // Update the bridge node with whatever data we are getting + InstanceIdentifier bridgeIid = getInstanceIdentifier(bridge); + Node bridgeNode = buildBridgeNode(bridge); + transaction.merge(LogicalDatastoreType.OPERATIONAL, bridgeIid, bridgeNode); + deleteEntries(transaction, protocolEntriesToRemove(bridgeIid,bridge)); + deleteEntries(transaction, externalIdsToRemove(bridgeIid,bridge)); + deleteEntries(transaction, bridgeOtherConfigsToRemove(bridgeIid,bridge)); + } + } + + private void deleteEntries(ReadWriteTransaction transaction, + List> entryIids) { + for (InstanceIdentifier entryIid: entryIids) { + transaction.delete(LogicalDatastoreType.OPERATIONAL, entryIid); + } + } + + private List> bridgeOtherConfigsToRemove( + InstanceIdentifier bridgeIid, Bridge bridge) { + Preconditions.checkNotNull(bridgeIid); + Preconditions.checkNotNull(bridge); + List> result = new ArrayList<>(); + + Bridge oldBridge = oldBridgeRows.get(bridge.getUuid()); + + if (oldBridge != null && oldBridge.getOtherConfigColumn() != null) { + for (Entry otherConfig: + oldBridge.getOtherConfigColumn().getData().entrySet()) { + if (bridge.getOtherConfigColumn() == null + || !bridge.getOtherConfigColumn().getData().containsKey(otherConfig.getKey())) { + InstanceIdentifier iid = bridgeIid + .augmentation(OvsdbBridgeAugmentation.class) + .child(BridgeOtherConfigs.class, + new BridgeOtherConfigsKey(otherConfig.getKey())); + result.add(iid); } - ovsdbManagedNodeBuilder.setDatapathType( - SouthboundMapper.createDatapathType(bridge.getDatapathTypeColumn().getData())); - if (SouthboundMapper.createMdsalProtocols(bridge) != null - && SouthboundMapper.createMdsalProtocols(bridge).size() > 0) { - ovsdbManagedNodeBuilder.setProtocolEntry(SouthboundMapper.createMdsalProtocols(bridge)); + } + } + return result; + } + + private List> externalIdsToRemove( + InstanceIdentifier bridgeIid, Bridge bridge) { + Preconditions.checkNotNull(bridgeIid); + Preconditions.checkNotNull(bridge); + List> result = new ArrayList<>(); + + Bridge oldBridge = oldBridgeRows.get(bridge.getUuid()); + + if (oldBridge != null && oldBridge.getExternalIdsColumn() != null) { + for (Entry externalId: + oldBridge.getExternalIdsColumn().getData().entrySet()) { + if (bridge.getExternalIdsColumn() == null + || !bridge.getExternalIdsColumn().getData().containsKey(externalId.getKey())) { + InstanceIdentifier iid = bridgeIid + .augmentation(OvsdbBridgeAugmentation.class) + .child(BridgeExternalIds.class, + new BridgeExternalIdsKey(externalId.getKey())); + result.add(iid); } + } + } + return result; + } - Map externalIds = bridge.getExternalIdsColumn() - .getData(); - if (externalIds != null && !externalIds.isEmpty()) { - Set externalIdKeys = externalIds.keySet(); - List externalIdsList = new ArrayList(); - String externalIdValue; - for (String externalIdKey : externalIdKeys) { - externalIdValue = externalIds.get(externalIdKey); - if (externalIdKey != null && externalIdValue != null) { - externalIdsList.add(new BridgeExternalIdsBuilder() - .setBridgeExternalIdKey(externalIdKey) - .setBridgeExternalIdValue(externalIdValue) - .build()); - } + private List> protocolEntriesToRemove( + InstanceIdentifier bridgeIid, Bridge bridge) { + Preconditions.checkNotNull(bridgeIid); + Preconditions.checkNotNull(bridge); + List> result = new ArrayList<>(); + Bridge oldBridge = oldBridgeRows.get(bridge.getUuid()); + + try { + if (oldBridge != null && oldBridge.getProtocolsColumn() != null) { + for (String protocol : oldBridge.getProtocolsColumn().getData()) { + if (bridge.getProtocolsColumn() == null || !bridge.getProtocolsColumn().getData() + .contains(protocol)) { + Class proto = SouthboundConstants.OVSDB_PROTOCOL_MAP + .inverse().get(protocol); + InstanceIdentifier iid = bridgeIid + .augmentation(OvsdbBridgeAugmentation.class) + .child(ProtocolEntry.class, + new ProtocolEntryKey(proto)); + result.add(iid); } - ovsdbManagedNodeBuilder.setBridgeExternalIds(externalIdsList); } + } + } catch (SchemaVersionMismatchException e) { + // We don't care about the exception stack trace here + LOG.warn("protocol not supported by this version of ovsdb: {}", e.getMessage()); + } + return result; + } - if (!SouthboundMapper.createControllerEntries(bridge, updatedControllerRows).isEmpty()) { - ovsdbManagedNodeBuilder.setControllerEntry( - SouthboundMapper.createControllerEntries(bridge, updatedControllerRows)); - } + private Node buildConnectionNode( + Bridge bridge) { + //Update node with managed node reference + NodeBuilder connectionNode = new NodeBuilder(); + connectionNode.setNodeId(getOvsdbConnectionInstance().getNodeId()); - if (bridge.getFailModeColumn() != null - && bridge.getFailModeColumn().getData() != null - && !bridge.getFailModeColumn().getData().isEmpty()) { - String[] failmodeArray = new String[bridge.getFailModeColumn().getData().size()]; - bridge.getFailModeColumn().getData().toArray(failmodeArray); - ovsdbManagedNodeBuilder.setFailMode( - SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get(failmodeArray[0])); - } - ovsdbManagedNodeBuilder.setManagedBy(new OvsdbNodeRef(nodePath)); - managedNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbManagedNodeBuilder.build()); + OvsdbNodeAugmentationBuilder ovsdbConnectionAugmentationBuilder = new OvsdbNodeAugmentationBuilder(); + List managedBridges = new ArrayList<>(); + InstanceIdentifier bridgeIid = SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(), + bridge); + ManagedNodeEntry managedBridge = new ManagedNodeEntryBuilder().setBridgeRef( + new OvsdbBridgeRef(bridgeIid)).build(); + managedBridges.add(managedBridge); + ovsdbConnectionAugmentationBuilder.setManagedNodeEntry(managedBridges); + + connectionNode.addAugmentation(OvsdbNodeAugmentation.class, ovsdbConnectionAugmentationBuilder.build()); - LOG.debug("Store managed node augmentation data {}",ovsdbManagedNodeBuilder.toString()); - transaction.merge(LogicalDatastoreType.OPERATIONAL, managedNodePath, managedNodeBuilder.build()); + LOG.debug("Update node with bridge node ref {}", + ovsdbConnectionAugmentationBuilder.getManagedNodeEntry().iterator().next()); + return connectionNode.build(); + } + + private Node buildBridgeNode(Bridge bridge) { + NodeBuilder bridgeNodeBuilder = new NodeBuilder(); + NodeId bridgeNodeId = getNodeId(bridge); + bridgeNodeBuilder.setNodeId(bridgeNodeId); + OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder(); + ovsdbBridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName(bridge.getName())); + ovsdbBridgeAugmentationBuilder.setBridgeUuid(new Uuid(bridge.getUuid().toString())); + setDataPath(ovsdbBridgeAugmentationBuilder, bridge); + setDataPathType(ovsdbBridgeAugmentationBuilder, bridge); + setProtocol(ovsdbBridgeAugmentationBuilder, bridge); + setExternalIds(ovsdbBridgeAugmentationBuilder, bridge); + setOtherConfig(ovsdbBridgeAugmentationBuilder, bridge); + setFailMode(ovsdbBridgeAugmentationBuilder, bridge); + setOpenFlowNodeRef(ovsdbBridgeAugmentationBuilder, bridge); + setManagedBy(ovsdbBridgeAugmentationBuilder); + bridgeNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbBridgeAugmentationBuilder.build()); + + LOG.debug("Built with the intent to store bridge data {}", + ovsdbBridgeAugmentationBuilder.build()); + return bridgeNodeBuilder.build(); + } + + private void setManagedBy(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder) { + InstanceIdentifier connectionNodePath = getOvsdbConnectionInstance().getInstanceIdentifier(); + ovsdbBridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(connectionNodePath)); + } + + private void setDataPathType(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + ovsdbBridgeAugmentationBuilder.setDatapathType( + SouthboundMapper.createDatapathType(bridge.getDatapathTypeColumn().getData())); + } - //Update node with managed node reference - NodeBuilder nodeBuilder = new NodeBuilder(); - nodeBuilder.setNodeId(SouthboundMapper.createNodeId(getKey().getIp(),getKey().getPort())); + private void setFailMode(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + if (bridge.getFailModeColumn() != null + && bridge.getFailModeColumn().getData() != null + && !bridge.getFailModeColumn().getData().isEmpty()) { + String[] failmodeArray = new String[bridge.getFailModeColumn().getData().size()]; + bridge.getFailModeColumn().getData().toArray(failmodeArray); + ovsdbBridgeAugmentationBuilder.setFailMode( + SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get(failmodeArray[0])); + } + } + + private void setOtherConfig(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + Map otherConfigs = bridge + .getOtherConfigColumn().getData(); + if (otherConfigs != null && !otherConfigs.isEmpty()) { + Set otherConfigKeys = otherConfigs.keySet(); + List otherConfigList = new ArrayList<>(); + String otherConfigValue; + for (String otherConfigKey : otherConfigKeys) { + otherConfigValue = otherConfigs.get(otherConfigKey); + if (otherConfigKey != null && otherConfigValue != null) { + otherConfigList.add(new BridgeOtherConfigsBuilder() + .setBridgeOtherConfigKey(otherConfigKey) + .setBridgeOtherConfigValue(otherConfigValue) + .build()); + } + } + ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(otherConfigList); + } + } - OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder(); - List managedNodes = new ArrayList(); - ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder().setBridgeRef( - new OvsdbBridgeRef(managedNodePath)).build(); - managedNodes.add(managedNodeEntry); - ovsdbNodeBuilder.setManagedNodeEntry(managedNodes); + private void setExternalIds(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + Map externalIds = bridge.getExternalIdsColumn() + .getData(); + if (externalIds != null && !externalIds.isEmpty()) { + Set externalIdKeys = externalIds.keySet(); + List externalIdsList = new ArrayList<>(); + String externalIdValue; + for (String externalIdKey : externalIdKeys) { + externalIdValue = externalIds.get(externalIdKey); + if (externalIdKey != null && externalIdValue != null) { + externalIdsList.add(new BridgeExternalIdsBuilder() + .setBridgeExternalIdKey(externalIdKey) + .setBridgeExternalIdValue(externalIdValue) + .build()); + } + } + ovsdbBridgeAugmentationBuilder.setBridgeExternalIds(externalIdsList); + } + } - nodeBuilder.addAugmentation(OvsdbNodeAugmentation.class, ovsdbNodeBuilder.build()); + private void setProtocol(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + if (SouthboundMapper.createMdsalProtocols(bridge) != null + && SouthboundMapper.createMdsalProtocols(bridge).size() > 0) { + ovsdbBridgeAugmentationBuilder.setProtocolEntry(SouthboundMapper.createMdsalProtocols(bridge)); + } + } - LOG.debug("Update node with managed node ref {}",ovsdbNodeBuilder.toString()); - transaction.merge(LogicalDatastoreType.OPERATIONAL, nodePath, nodeBuilder.build()); + private void setDataPath(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + DatapathId dpid = SouthboundMapper.createDatapathId(bridge); + if (dpid != null) { + ovsdbBridgeAugmentationBuilder.setDatapathId(dpid); + } + } + private void setOpenFlowNodeRef(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder, + Bridge bridge) { + Map updatedControllerRows = + TyperUtils.extractRowsUpdated(Controller.class, getUpdates(), getDbSchema()); + LOG.debug("setOpenFlowNodeRef: updatedControllerRows: {}", updatedControllerRows); + for (ControllerEntry controllerEntry: SouthboundMapper.createControllerEntries(bridge, updatedControllerRows)) { + if (controllerEntry != null + && controllerEntry.isIsConnected() != null && controllerEntry.isIsConnected()) { + String [] controllerTarget = controllerEntry.getTarget().getValue().split(":"); + IpAddress bridgeControllerIpAddress = null; + PortNumber bridgeControllerPortNumber = null; + for (String targetElement : controllerTarget) { + if (InetAddresses.isInetAddress(targetElement)) { + bridgeControllerIpAddress = new IpAddress(targetElement.toCharArray()); + continue; + } + if (NumberUtils.isNumber(targetElement)) { + bridgeControllerPortNumber = new PortNumber( + Integer.valueOf(String.valueOf(targetElement))); + continue; + } + } + try { + Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces(); + networkInterfacesLoop: + while (networkInterfaces.hasMoreElements()) { + NetworkInterface networkInterface = networkInterfaces.nextElement(); + Enumeration networkInterfaceAddresses = networkInterface.getInetAddresses(); + while (networkInterfaceAddresses.hasMoreElements()) { + InetAddress networkInterfaceAddress = networkInterfaceAddresses.nextElement(); + if (bridgeControllerIpAddress.getIpv4Address().getValue() + .equals(networkInterfaceAddress.getHostAddress())) { + ovsdbBridgeAugmentationBuilder.setBridgeOpenflowNodeRef( + getOvsdbConnectionInstance().getInstanceIdentifier()); + break networkInterfacesLoop; + } + } + } + } catch (Exception e) { + LOG.warn("Error getting local ip address {}", e); + } } } } + private InstanceIdentifier getInstanceIdentifier(Bridge bridge) { + return SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(), + bridge); + } + + private NodeId getNodeId(Bridge bridge) { + NodeKey nodeKey = getInstanceIdentifier(bridge).firstKeyOf(Node.class, NodeKey.class); + return nodeKey.getNodeId(); + } }