import org.opendaylight.controller.sal.utils.ServiceHelper;
import org.opendaylight.controller.sal.utils.Status;
import org.opendaylight.ovsdb.lib.notation.OvsDBSet;
+import org.opendaylight.ovsdb.lib.notation.Row;
import org.opendaylight.ovsdb.lib.notation.UUID;
-import org.opendaylight.ovsdb.lib.table.Bridge;
-import org.opendaylight.ovsdb.lib.table.Interface;
-import org.opendaylight.ovsdb.lib.table.Open_vSwitch;
-import org.opendaylight.ovsdb.lib.table.Port;
-import org.opendaylight.ovsdb.lib.table.internal.Table;
-import org.opendaylight.ovsdb.neutron.provider.ProviderNetworkManager;
+import org.opendaylight.ovsdb.neutron.provider.IProviderNetworkManager;
import org.opendaylight.ovsdb.plugin.IConnectionServiceInternal;
import org.opendaylight.ovsdb.plugin.OVSDBConfigService;
+import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
+import org.opendaylight.ovsdb.schema.openvswitch.Interface;
+import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
+import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TenantNetworkManager {
+public class TenantNetworkManager implements ITenantNetworkManager {
static final Logger logger = LoggerFactory.getLogger(TenantNetworkManager.class);
-
- public static final String EXTERNAL_ID_VM_ID = "vm-id";
- public static final String EXTERNAL_ID_INTERFACE_ID = "iface-id";
- public static final String EXTERNAL_ID_VM_MAC = "attached-mac";
- private static TenantNetworkManager tenantHelper = new TenantNetworkManager();
private ConcurrentMap<String, NodeConfiguration> nodeConfigurationCache = new ConcurrentHashMap<>();
+ // The implementation for each of these services is resolved by the OSGi Service Manager
+ private volatile IProviderNetworkManager providerNetworkManager;
+
private boolean enableContainer = false;
- private TenantNetworkManager() {
+ public TenantNetworkManager() {
String isTenantContainer = System.getProperty("TenantIsContainer");
if (isTenantContainer != null && isTenantContainer.equalsIgnoreCase("true")) {
enableContainer = true;
}
}
- public static TenantNetworkManager getManager() {
- return tenantHelper;
- }
-
+ @Override
public int getInternalVlan(Node node, String networkId) {
String nodeUuid = getNodeUUID(node);
if (nodeUuid == null) {
}
private NodeConfiguration addNodeConfigurationToCache(Node node) {
- NodeConfiguration nodeConfiguration = new NodeConfiguration(node);
+ NodeConfiguration nodeConfiguration = new NodeConfiguration(node, this);
String nodeUuid = getNodeUUID(node);
if (nodeUuid == null) {
logger.error("Cannot get Node UUID for Node {}", node);
return nodeConfigurationCache.get(nodeUuid);
}
- public void reclaimTennantNetworkInternalVlan(Node node, String portUUID, NeutronNetwork network) {
+ @Override
+ public void reclaimTenantNetworkInternalVlan(Node node, String portUUID, NeutronNetwork network) {
String nodeUuid = getNodeUUID(node);
if (nodeUuid == null) {
logger.error("Unable to get UUID for Node {}", node);
logger.debug("Removed Vlan {} on {}", vlan, portUUID);
}
+ @Override
public void networkCreated (String networkId) {
IConnectionServiceInternal connectionService = (IConnectionServiceInternal)ServiceHelper.getGlobalInstance(IConnectionServiceInternal.class, this);
List<Node> nodes = connectionService.getNodes();
String nodeUuid = new String();
OVSDBConfigService ovsdbConfigService = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
try {
- Map<String, Table<?>> ovsTable = ovsdbConfigService.getRows(node, Open_vSwitch.NAME.getName());
+ Map<String, Row> ovsTable = ovsdbConfigService.getRows(node, ovsdbConfigService.getTableName(node, OpenVSwitch.class));
nodeUuid = (String)ovsTable.keySet().toArray()[0];
}
catch (Exception e) {
return nodeUuid;
}
+ @Override
public int networkCreated (Node node, String networkId) {
String nodeUuid = getNodeUUID(node);
if (nodeUuid == null) {
* Are there any TenantNetwork VM present on this Node ?
* This method uses Interface Table's external-id field to locate the VM.
*/
+ @Override
public boolean isTenantNetworkPresentInNode(Node node, String segmentationId) {
String networkId = this.getNetworkIdForSegmentationId(segmentationId);
if (networkId == null) {
logger.debug("Tenant Network not found with Segmenation-id {}",segmentationId);
return false;
}
- if (ProviderNetworkManager.getManager().hasPerTenantTunneling()) {
+ if (providerNetworkManager.getProvider().hasPerTenantTunneling()) {
String nodeUuid = getNodeUUID(node);
if (nodeUuid == null) {
logger.debug("Unable to get UUID for Node {}", node);
try {
/*
// Vlan Tag based identification
- Map<String, Table<?>> portTable = ovsdbTable.getRows(node, Port.NAME.getName());
+ Map<String, Row> portTable = ovsdbTable.getRows(node, Port.NAME.getName());
if (portTable == null) {
logger.debug("Port table is null for Node {} ", node);
return false;
}
- for (Table<?> row : portTable.values()) {
+ for (Row row : portTable.values()) {
Port port = (Port)row;
Set<BigInteger> tags = port.getTag();
if (tags.contains(internalVlan)) {
}
*/
// External-id based more accurate VM Location identification
- Map<String, Table<?>> ifTable = ovsdbTable.getRows(node, Interface.NAME.getName());
+ Map<String, Row> ifTable = ovsdbTable.getRows(node, ovsdbTable.getTableName(node, Interface.class));
if (ifTable == null) {
logger.debug("Interface table is null for Node {} ", node);
return false;
}
- for (Table<?> row : ifTable.values()) {
- Interface intf = (Interface)row;
- Map<String, String> externalIds = intf.getExternal_ids();
+ for (Row row : ifTable.values()) {
+ Interface intf = ovsdbTable.getTypedRow(node, Interface.class, row);
+ Map<String, String> externalIds = intf.getExternalIdsColumn().getData();
if (externalIds != null && externalIds.get(EXTERNAL_ID_INTERFACE_ID) != null) {
if (this.isInterfacePresentInTenantNetwork(externalIds.get(EXTERNAL_ID_INTERFACE_ID), networkId)) {
logger.debug("Tenant Network {} with Segmentation-id {} is present in Node {} / Interface {}",
return false;
}
+ @Override
public String getNetworkIdForSegmentationId (String segmentationId) {
INeutronNetworkCRUD neutronNetworkService = (INeutronNetworkCRUD)ServiceHelper.getGlobalInstance(INeutronNetworkCRUD.class, this);
List <NeutronNetwork> networks = neutronNetworkService.getAllNetworks();
return false;
}
+ @Override
public NeutronNetwork getTenantNetworkForInterface (Interface intf) {
logger.trace("getTenantNetworkForInterface for {}", intf);
if (intf == null) return null;
- Map<String, String> externalIds = intf.getExternal_ids();
+ Map<String, String> externalIds = intf.getExternalIdsColumn().getData();
logger.trace("externalIds {}", externalIds);
if (externalIds == null) return null;
String neutronPortId = externalIds.get(EXTERNAL_ID_INTERFACE_ID);
return neutronNetwork;
}
+ @Override
public void programTenantNetworkInternalVlan(Node node, String portUUID, NeutronNetwork network) {
String nodeUuid = getNodeUUID(node);
return;
}
OVSDBConfigService ovsdbTable = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
- Port port = new Port();
+ Port port = ovsdbTable.createTypedRow(node, Port.class);
OvsDBSet<BigInteger> tags = new OvsDBSet<BigInteger>();
tags.add(BigInteger.valueOf(vlan));
port.setTag(tags);
- ovsdbTable.updateRow(node, Port.NAME.getName(), null, portUUID, port);
+ ovsdbTable.updateRow(node, port.getSchema().getName(), null, portUUID, port.getRow());
if (enableContainer) this.addPortToTenantNetworkContainer(node, portUUID, network);
}
}
OVSDBConfigService ovsdbTable = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
try {
- Port port = (Port)ovsdbTable.getRow(node, Port.NAME.getName(), portUUID);
+ Row portRow = ovsdbTable.getRow(node, ovsdbTable.getTableName(node, Port.class), portUUID);
+ Port port = ovsdbTable.getTypedRow(node, Port.class, portRow);
if (port == null) {
logger.trace("Unable to identify Port with UUID {}", portUUID);
return;
}
- Set<UUID> interfaces = port.getInterfaces();
+ Set<UUID> interfaces = port.getInterfacesColumn().getData();
if (interfaces == null) {
logger.trace("No interfaces available to fetch the OF Port");
return;
logger.debug("Unable to spot Bridge for Port {} in node {}", port, node);
return;
}
- Set<String> dpids = bridge.getDatapath_id();
+ Set<String> dpids = bridge.getDatapathIdColumn().getData();
if (dpids == null || dpids.size() == 0) return;
Long dpidLong = Long.valueOf(HexEncode.stringToLong((String)dpids.toArray()[0]));
for (UUID intfUUID : interfaces) {
- Interface intf = (Interface)ovsdbTable.getRow(node, Interface.NAME.getName(), intfUUID.toString());
+ Interface intf = (Interface)ovsdbTable.getRow(node,ovsdbTable.getTableName(node, Interface.class), intfUUID.toString());
if (intf == null) continue;
- Set<BigInteger> of_ports = intf.getOfport();
+ Set<Integer> of_ports = intf.getOpenFlowPortColumn().getData();
if (of_ports == null) continue;
- for (BigInteger of_port : of_ports) {
+ for (Integer of_port : of_ports) {
ContainerConfig config = new ContainerConfig();
config.setContainer(BaseHandler.convertNeutronIDToKey(network.getID()));
logger.debug("Adding Port {} to Container : {}", port.toString(), config.getContainer());
private Bridge getBridgeIdForPort (Node node, String uuid) {
OVSDBConfigService ovsdbTable = (OVSDBConfigService)ServiceHelper.getGlobalInstance(OVSDBConfigService.class, this);
try {
- Map<String, Table<?>> bridges = ovsdbTable.getRows(node, Bridge.NAME.getName());
+ Map<String, Row> bridges = ovsdbTable.getRows(node, ovsdbTable.getTableName(node, Bridge.class));
if (bridges == null) return null;
for (String bridgeUUID : bridges.keySet()) {
- Bridge bridge = (Bridge)bridges.get(bridgeUUID);
- Set<UUID> portUUIDs = bridge.getPorts();
+ Bridge bridge = ovsdbTable.getTypedRow(node, Bridge.class, bridges.get(bridgeUUID));
+ Set<UUID> portUUIDs = bridge.getPortsColumn().getData();
logger.trace("Scanning Bridge {} to identify Port : {} ",bridge, uuid);
for (UUID portUUID : portUUIDs) {
if (portUUID.toString().equalsIgnoreCase(uuid)) {
return null;
}
+ @Override
public void networkDeleted(String id) {
if (!enableContainer) return;
config.setContainer(networkID);
containerManager.removeContainer(config);
}
-
}
Code Review / ovsdb.git / blobdiff