import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
import org.opendaylight.ovsdb.openstack.netvirt.api.SecurityServicesManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
+import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
+import org.opendaylight.ovsdb.openstack.netvirt.api.StatusWithUuid;
import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
-import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
-import org.opendaylight.ovsdb.plugin.api.Status;
-import org.opendaylight.ovsdb.plugin.api.StatusCode;
-import org.opendaylight.ovsdb.plugin.api.StatusWithUuid;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Interface;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
private volatile ConfigurationService configurationService;
private volatile BridgeConfigurationManager bridgeConfigurationManager;
private volatile TenantNetworkManager tenantNetworkManager;
- private volatile OvsdbConfigurationService ovsdbConfigurationService;
- private volatile OvsdbConnectionService connectionService;
private volatile MdsalConsumer mdsalConsumer;
private volatile SecurityServicesManager securityServicesManager;
private volatile IngressAclProvider ingressAclProvider;
}
private boolean isTunnelPresent(Node node, String tunnelName, String bridgeUUID) throws Exception {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
Row bridgeRow = ovsdbConfigurationService
.getRow(node, ovsdbConfigurationService.getTableName(node, Bridge.class), bridgeUUID);
Port port = ovsdbConfigurationService.getTypedRow(node, Port.class, portRow);
if (port != null && tunnelName.equalsIgnoreCase(port.getName())) return true;
}
- }
+ }*/
return false;
}
private String getPortUuid(Node node, String name, String bridgeUUID) throws Exception {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
Row bridgeRow = ovsdbConfigurationService
.getRow(node, ovsdbConfigurationService.getTableName(node, Bridge.class), bridgeUUID);
Port port = ovsdbConfigurationService.getTypedRow(node, Port.class, portRow);
if (port != null && name.equalsIgnoreCase(port.getName())) return portUUID.toString();
}
- }
+ }*/
return null;
}
private Status addTunnelPort (Node node, String tunnelType, InetAddress src, InetAddress dst) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
String bridgeUUID = null;
} catch (Exception e) {
logger.error("Exception in addTunnelPort", e);
return new Status(StatusCode.INTERNALERROR);
- }
+ }*/
+ return new Status(StatusCode.INTERNALERROR);
}
/* delete port from ovsdb port table */
private Status deletePort(Node node, String bridgeName, String portName) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
String bridgeUUID = null;
} catch (Exception e) {
logger.error("Exception in deletePort", e);
return new Status(StatusCode.INTERNALERROR);
- }
+ }*/
+ return new Status(StatusCode.INTERNALERROR);
}
private Status deleteTunnelPort(Node node, String tunnelType, InetAddress src, InetAddress dst) {
}
private Long getDpid (Node node, String bridgeUuid) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
Row bridgeRow = ovsdbConfigurationService
} catch (Exception e) {
logger.error("Error finding Bridge's OF DPID", e);
return 0L;
- }
+ }*/ return 0L;
}
private Long getIntegrationBridgeOFDPID (Node node) {
private void programTunnelRules (String tunnelType, String segmentationId, InetAddress dst, Node node,
Interface intf, boolean local) {
-
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
} catch (Exception e) {
logger.error("", e);
}
+ */
}
private void removeTunnelRules (String tunnelType, String segmentationId, InetAddress dst, Node node,
Interface intf, boolean local, boolean isLastInstanceOnNode) {
-
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
}
} catch (Exception e) {
logger.error("", e);
- }
+ }*/
}
private void programVlanRules (NeutronNetwork network, Node node, Interface intf) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
logger.debug("Program vlan rules for interface {}", intf.getName());
try {
}
} catch (Exception e) {
logger.error("", e);
- }
+ }*/
}
private void removeVlanRules (NeutronNetwork network, Node node,
Interface intf, boolean isLastInstanceOnNode) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
logger.debug("Remove vlan rules for interface {}", intf.getName());
}
} catch (Exception e) {
logger.error("", e);
- }
+ }*/
}
@Override
public Status handleInterfaceUpdate(NeutronNetwork network, Node srcNode, Interface intf) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(connectionService);
List<Node> nodes = connectionService.getNodes();
nodes.remove(srcNode);
dst != null ? dst.getHostAddress() : "null");
}
}
- }
+ }*/
return new Status(StatusCode.SUCCESS);
}
private Status triggerInterfaceUpdates(Node node) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
Map<String, Row> intfs = ovsdbConfigurationService.getRows(node, ovsdbConfigurationService.getTableName(node, Interface.class));
} 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
@Override
public Status handleInterfaceDelete(String tunnelType, NeutronNetwork network, Node srcNode, Interface intf,
boolean isLastInstanceOnNode) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(connectionService);
Status status = new Status(StatusCode.SUCCESS);
List<Node> nodes = connectionService.getNodes();
List<String> phyIfName = bridgeConfigurationManager.getAllPhysicalInterfaceNames(srcNode);
if (intf.getTypeColumn().getData().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_VXLAN)
|| intf.getTypeColumn().getData().equalsIgnoreCase(NetworkHandler.NETWORK_TYPE_GRE)) {
- /* Delete tunnel port */
+ // Delete tunnel port
try {
Map<String, String> options = intf.getOptionsColumn().getData();
InetAddress src = InetAddress.getByName(options.get("local_ip"));
} else if (phyIfName.contains(intf.getName())) {
deletePhysicalPort(srcNode, intf.getName());
} else {
- /* delete all other interfaces */
+ // delete all other interfaces
this.removeLocalRules(network.getProviderNetworkType(), network.getProviderSegmentationID(),
srcNode, intf);
}
}
}
- }
- return status;
+ }*/
+ //return status;
+ return new Status(StatusCode.SUCCESS);
}
@Override
@Override
public void initializeOFFlowRules(Node openflowNode) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(connectionService);
List<Node> ovsNodes = connectionService.getNodes();
if (ovsNodes == null) return;
this.initializeFlowRules(ovsNode, configurationService.getIntegrationBridgeName());
this.triggerInterfaceUpdates(ovsNode);
}
- }
+ }*/
}
@Override
}
private String getInternalBridgeUUID (Node node, String bridgeName) {
+ /* TODO SB_MIGRATION
Preconditions.checkNotNull(ovsdbConfigurationService);
try {
Map<String, Row> bridgeTable = ovsdbConfigurationService.getRows(node, ovsdbConfigurationService.getTableName(node, Bridge.class));
}
} catch (Exception e) {
logger.error("Error getting Bridge Identifier for {} / {}", node, bridgeName, e);
- }
+ }*/
return null;
}
}