<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-checkstyle-plugin</artifactId>
<configuration>
- <failsOnError>true</failsOnError>
+ <propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
</configuration>
</plugin>
<plugin>
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.clustering.Entity;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipCandidateRegistration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.ListenableFuture;
-
public class OvsdbConnectionInstance implements OvsdbClient {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbConnectionInstance.class);
private OvsdbClient client;
}
}
+ public ListenableFuture<List<OperationResult>> transact(
+ DatabaseSchema dbSchema, List<Operation> operations) {
+ return client.transact(dbSchema, operations);
+ }
+
public void registerCallbacks() {
if ( this.callback == null) {
if (this.initialCreateData != null ) {
try {
transactInvokers = new HashMap<>();
DatabaseSchema dbSchema = getSchema(SouthboundConstants.OPEN_V_SWITCH).get();
- if(dbSchema != null) {
+ if (dbSchema != null) {
transactInvokers.put(dbSchema, new TransactInvokerImpl(this,dbSchema));
}
} catch (InterruptedException | ExecutionException e) {
return client.transactBuilder(dbSchema);
}
- public ListenableFuture<List<OperationResult>> transact(
- DatabaseSchema dbSchema, List<Operation> operations) {
- return client.transact(dbSchema, operations);
+ @Override
+ public <E extends TableSchema<E>> TableUpdates monitor(
+ DatabaseSchema schema, List<MonitorRequest> monitorRequests,
+ MonitorHandle monitorHandle, MonitorCallBack callback) {
+ return null;
}
public <E extends TableSchema<E>> TableUpdates monitor(
this.instanceIdentifier = iid;
}
- @Override
- public <E extends TableSchema<E>> TableUpdates monitor(
- DatabaseSchema schema, List<MonitorRequest> monitorRequests,
- MonitorHandle monitorHandle, MonitorCallBack callback) {
- return null;
- }
-
public Entity getConnectedEntity() {
return this.connectedEntity;
}
public OvsdbNodeAugmentation getOvsdbNodeAugmentation() {
return this.initialCreateData;
}
+
public void setOvsdbNodeAugmentation(OvsdbNodeAugmentation ovsdbNodeCreateData) {
this.initialCreateData = ovsdbNodeCreateData;
}
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class OvsdbConnectionManager implements OvsdbConnectionListener, AutoCloseable {
private Map<ConnectionInfo, OvsdbConnectionInstance> clients =
new ConcurrentHashMap<>();
List<String> databases = new ArrayList<>();
try {
databases = externalClient.getDatabases().get(1000, TimeUnit.MILLISECONDS);
- if(databases.contains(SouthboundConstants.OPEN_V_SWITCH)) {
+ if (databases.contains(SouthboundConstants.OPEN_V_SWITCH)) {
OvsdbConnectionInstance client = connectedButCallBacksNotRegistered(externalClient);
// Register Cluster Ownership for ConnectionInfo
registerEntityForOwnership(client);
instanceIdentifiers.remove(connectionInfo);
}
- public OvsdbConnectionInstance getConnectionInstance(ConnectionInfo key) {
+ public InstanceIdentifier<Node> getInstanceIdentifier(ConnectionInfo key) {
ConnectionInfo connectionInfo = SouthboundMapper.suppressLocalIpPort(key);
- return clients.get(connectionInfo);
+ return instanceIdentifiers.get(connectionInfo);
}
- public InstanceIdentifier<Node> getInstanceIdentifier(ConnectionInfo key) {
+ public OvsdbConnectionInstance getConnectionInstance(ConnectionInfo key) {
ConnectionInfo connectionInfo = SouthboundMapper.suppressLocalIpPort(key);
- return instanceIdentifiers.get(connectionInfo);
+ return clients.get(connectionInfo);
}
public OvsdbConnectionInstance getConnectionInstance(OvsdbBridgeAttributes mn) {
return ovsdbConnectionInstance.getHasDeviceOwnership();
}
- public void reconcileConnection(InstanceIdentifier<Node> iid, OvsdbNodeAugmentation ovsdbNode){
+ public void reconcileConnection(InstanceIdentifier<Node> iid, OvsdbNodeAugmentation ovsdbNode) {
this.retryConnection(iid, ovsdbNode,
ConnectionReconciliationTriggers.ON_CONTROLLER_INITIATED_CONNECTION_FAILURE);
if (ownershipChange.isOwner() == ovsdbConnectionInstance.getHasDeviceOwnership()) {
LOG.info("handleOwnershipChanged: no change in ownership for {}. Ownership status is : {}",
ovsdbConnectionInstance.getConnectionInfo(), ovsdbConnectionInstance.getHasDeviceOwnership()
- ? SouthboundConstants.OWNERSHIPSTATES.OWNER.getState()
- : SouthboundConstants.OWNERSHIPSTATES.NONOWNER.getState());
+ ? SouthboundConstants.OwnershipStates.OWNER.getState()
+ : SouthboundConstants.OwnershipStates.NONOWNER.getState());
return;
}
}
return openVSwitchRow;
}
+
private Entity getEntityFromConnectionInstance(@Nonnull OvsdbConnectionInstance ovsdbConnectionInstance) {
InstanceIdentifier<Node> iid = ovsdbConnectionInstance.getInstanceIdentifier();
if ( iid == null ) {
iid,
ovsdbNode);
- if(reconciliationManager.isEnqueued(task)){
+ if (reconciliationManager.isEnqueued(task)) {
return;
}
- switch(trigger){
+ switch (trigger) {
case ON_CONTROLLER_INITIATED_CONNECTION_FAILURE:
reconciliationManager.enqueueForRetry(task);
break;
@Override
public void onSuccess(@Nullable Optional<Node> node) {
if (node.isPresent()) {
- LOG.info("Disconnected/Failed connection {} was controller initiated, attempting " +
- "reconnection", ovsdbNode.getConnectionInfo());
+ LOG.info("Disconnected/Failed connection {} was controller initiated, attempting "
+ + "reconnection", ovsdbNode.getConnectionInfo());
reconciliationManager.enqueue(task);
} else {
- LOG.debug("Connection {} was switch initiated, no reconciliation is required"
- , iid.firstKeyOf(Node.class).getNodeId());
+ LOG.debug("Connection {} was switch initiated, no reconciliation is required",
+ iid.firstKeyOf(Node.class).getNodeId());
}
}
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Read Config/DS for Node failed! {}", iid, t);
+ public void onFailure(Throwable throwable) {
+ LOG.warn("Read Config/DS for Node failed! {}", iid, throwable);
}
});
break;
this.cm = cm;
listenerRegistration = entityOwnershipService.registerListener(ENTITY_TYPE, this);
}
+
public void close() {
listenerRegistration.close();
}
+
@Override
public void ownershipChanged(EntityOwnershipChange ownershipChange) {
cm.handleOwnershipChanged(ownershipChange);
import java.net.UnknownHostException;
import java.util.Collection;
import java.util.HashMap;
-import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
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.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
new HashMap<>();
for (DataTreeModification<Node> change : changes) {
OvsdbConnectionInstance client = null;
- Node node = change.getRootNode().getDataAfter() != null?
- change.getRootNode().getDataAfter() : change.getRootNode().getDataBefore();
+ Node node = change.getRootNode().getDataAfter() != null
+ ? change.getRootNode().getDataAfter() : change.getRootNode().getDataBefore();
if (node != null) {
InstanceIdentifier<Node> nodeIid;
- Augmentation nodeAug = node.getAugmentation(OvsdbNodeAugmentation.class) !=null?
- node.getAugmentation(OvsdbNodeAugmentation.class):node.getAugmentation(OvsdbBridgeAugmentation.class);
+ Augmentation nodeAug = node.getAugmentation(OvsdbNodeAugmentation.class) != null
+ ? node.getAugmentation(OvsdbNodeAugmentation.class)
+ : node.getAugmentation(OvsdbBridgeAugmentation.class);
- if(nodeAug instanceof OvsdbNodeAugmentation) {
+ if (nodeAug instanceof OvsdbNodeAugmentation) {
OvsdbNodeAugmentation ovsdbNode = (OvsdbNodeAugmentation) nodeAug;
- if(ovsdbNode.getConnectionInfo() != null) {
+ if (ovsdbNode.getConnectionInfo() != null) {
client = cm.getConnectionInstance(ovsdbNode.getConnectionInfo());
- }else {
+ } else {
client = cm.getConnectionInstance(SouthboundMapper.createInstanceIdentifier(node.getNodeId()));
}
}
- if(nodeAug instanceof OvsdbBridgeAugmentation) {
+ if (nodeAug instanceof OvsdbBridgeAugmentation) {
OvsdbBridgeAugmentation bridgeAugmentation = (OvsdbBridgeAugmentation)nodeAug;
- if(bridgeAugmentation.getManagedBy() != null) {
+ if (bridgeAugmentation.getManagedBy() != null) {
nodeIid = (InstanceIdentifier<Node>) bridgeAugmentation.getManagedBy().getValue();
client = cm.getConnectionInstance(nodeIid);
}
}
- if( client == null ) {
+ if (client == null) {
//Try getting from change root identifier
client = cm.getConnectionInstance(change.getRootPath().getRootIdentifier());
}
*/
package org.opendaylight.ovsdb.southbound;
-/**
- *
- * @author Anil Vishnoi (avishnoi@brocade.com)
- *
- */
public class OvsdbSchemaContants {
public static final String databaseName = "Open_vSwitch";
- public enum OVSDBSCHEMATABLES {
+
+ public enum OvsdbSchemaTables {
OPENVSWITCH("Open_vSwitch",null,null),
BRIDGE("Bridge", "Open_vSwitch", "bridges"),
PORT("Port", "Bridge", "ports"),
private final String parentTableName;
private final String columnNameInParentTable;
- OVSDBSCHEMATABLES(
+ OvsdbSchemaTables(
final String tableName, final String parentTableName,
final String columnNameInParentTable) {
this.tableName = tableName;
*/
package org.opendaylight.ovsdb.southbound;
+import com.google.common.collect.ImmutableBiMap;
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.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypePatch;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeSystem;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlanGpe;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeTap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdk;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkr;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkvhost;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkvhostuser;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGeneve;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGre;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeIpsecGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeGre64;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeIpsecGre;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeIpsecGre64;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeLisp;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdk;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkr;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkvhost;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeDpdkvhostuser;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypePatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeStt;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeSystem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeTap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlanGpe;
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.OvsdbBridgeProtocolOpenflow10;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolOpenflow11;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeSecure;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeStandalone;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeEgressPolicer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxHfsc;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxHtb;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxCodel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxFqCodel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxHfsc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxHtb;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.QosTypeLinuxSfq;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
-import com.google.common.collect.ImmutableBiMap;
-
public class SouthboundConstants {
public static final String OPEN_V_SWITCH = "Open_vSwitch";
public static final TopologyId OVSDB_TOPOLOGY_ID = new TopologyId(new Uri("ovsdb:1"));
public static final String IID_EXTERNAL_ID_KEY = "opendaylight-iid";
public static final String AUTOATTACH_ID_EXTERNAL_ID_KEY = "opendaylight-autoattach-id";
- public enum VLANMODES {
+ public enum VlanModes {
ACCESS("access"),
NATIVE_TAGGED("native-tagged"),
NATIVE_UNTAGGED("native-untagged"),
private final String mode;
- VLANMODES(String mode) {
+ VlanModes(String mode) {
this.mode = mode;
}
+
@Override
public String toString() {
return mode;
}
}
- public enum OWNERSHIPSTATES {
+ public enum OwnershipStates {
OWNER("OWNER"),
NONOWNER("NON-OWNER");
private final String state;
- OWNERSHIPSTATES(String state) {
+ OwnershipStates(String state) {
this.state = state;
}
+
@Override
public String toString() {
return state;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Joiner;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.common.net.InetAddresses;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.util.List;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Joiner;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Splitter;
-import com.google.common.collect.ImmutableBiMap;
-import com.google.common.net.InetAddresses;
-
public class SouthboundMapper {
private static final Logger LOG = LoggerFactory.getLogger(SouthboundMapper.class);
private static final String N_CONNECTIONS_STR = "n_connections";
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
}
+ public static InstanceIdentifier<OvsdbBridgeAugmentation>
+ createBridgeInstanceIdentifier(OvsdbConnectionInstance client, String bridgeName) {
+ return createInstanceIdentifier(client, bridgeName).augmentation(OvsdbBridgeAugmentation.class);
+ }
+
public static InstanceIdentifier<Node> createInstanceIdentifier(NodeId nodeId) {
return createTopologyInstanceIdentifier()
.child(Node.class,new NodeKey(nodeId));
}
- public static InstanceIdentifier<OvsdbBridgeAugmentation> createBridgeInstanceIdentifier(OvsdbConnectionInstance client, String bridgeName) {
- return createInstanceIdentifier(client, bridgeName)
- .augmentation(OvsdbBridgeAugmentation.class);
- }
-
+ @SuppressWarnings("unchecked")
public static InstanceIdentifier<Node> createInstanceIdentifier(OvsdbConnectionInstance client,Bridge bridge) {
InstanceIdentifier<Node> iid;
if (bridge.getExternalIdsColumn() != null
return iid;
}
+ @SuppressWarnings("unchecked")
public static InstanceIdentifier<Node> createInstanceIdentifier(
OvsdbConnectionInstance client, Controller controller, String bridgeName) {
InstanceIdentifier<Node> iid;
}
}
+ public static DatapathId createDatapathId(String dpid) {
+ Preconditions.checkNotNull(dpid);
+ DatapathId datapath;
+ if (dpid.matches("^[0-9a-fA-F]{16}")) {
+ Splitter splitter = Splitter.fixedLength(2);
+ Joiner joiner = Joiner.on(":");
+ datapath = new DatapathId(joiner.join(splitter.split(dpid)));
+ } else {
+ datapath = new DatapathId(dpid);
+ }
+ return datapath;
+ }
+
public static String createDatapathType(OvsdbBridgeAugmentation mdsalbridge) {
String datapathtype = SouthboundConstants.DATAPATH_TYPE_MAP.get(DatapathTypeSystem.class);
}
}
- public static DatapathId createDatapathId(String dpid) {
- Preconditions.checkNotNull(dpid);
- DatapathId datapath;
- if (dpid.matches("^[0-9a-fA-F]{16}")) {
- Splitter splitter = Splitter.fixedLength(2);
- Joiner joiner = Joiner.on(":");
- datapath = new DatapathId(joiner.join(splitter.split(dpid)));
- } else {
- datapath = new DatapathId(dpid);
- }
- return datapath;
- }
-
public static Set<String> createOvsdbBridgeProtocols(OvsdbBridgeAugmentation ovsdbBridgeNode) {
Set<String> protocols = new HashSet<>();
if (ovsdbBridgeNode.getProtocolEntry() != null && ovsdbBridgeNode.getProtocolEntry().size() > 0) {
SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
for (String protocol : protocols) {
if (protocol != null && mapper.get(protocol) != null) {
- protocolList.add(new ProtocolEntryBuilder().
- setProtocol(mapper.get(protocol)).build());
+ protocolList.add(new ProtocolEntryBuilder().setProtocol(mapper.get(protocol)).build());
}
}
}
LOG.debug("createControllerEntries Bridge: {}\n, updatedControllerRows: {}",
bridge, updatedControllerRows);
- final Set<UUID> controllerUUIDs = bridge.getControllerColumn().getData();
+ final Set<UUID> controllerUuids = bridge.getControllerColumn().getData();
final List<ControllerEntry> controllerEntries = new ArrayList<>();
- for (UUID controllerUUID : controllerUUIDs ) {
- final Controller controller = updatedControllerRows.get(controllerUUID);
+ for (UUID controllerUuid : controllerUuids ) {
+ final Controller controller = updatedControllerRows.get(controllerUuid);
addControllerEntries(controllerEntries, controller);
}
LOG.debug("controllerEntries: {}", controllerEntries);
Map<UUID,Controller> controllerMap = new HashMap<>();
if (controllerEntries != null && !controllerEntries.isEmpty()) {
for (ControllerEntry controllerEntry : controllerEntries) {
- String controllerNamedUUID = "Controller_" + getRandomUUID();
+ String controllerNamedUuid = "Controller_" + getRandomUuid();
Controller controller = TyperUtils.getTypedRowWrapper(dbSchema, Controller.class);
controller.setTarget(controllerEntry.getTarget().getValue());
- controllerMap.put(new UUID(controllerNamedUUID), controller);
+ controllerMap.put(new UUID(controllerNamedUuid), controller);
}
}
return controllerMap;
}
- public static String getRandomUUID() {
+ public static String getRandomUuid() {
return "Random_" + java.util.UUID.randomUUID().toString().replace("-", "");
}
+
public static ConnectionInfo createConnectionInfo(OvsdbClient client) {
ConnectionInfoBuilder connectionInfoBuilder = new ConnectionInfoBuilder();
connectionInfoBuilder.setRemoteIp(createIpAddress(client.getConnectionInfo().getRemoteAddress()));
LOG.debug("createManagerEntries OpenVSwitch: {}\n, updatedManagerRows: {}",
ovsdbNode, updatedManagerRows);
- final Set<UUID> managerUUIDs = ovsdbNode.getManagerOptionsColumn().getData();
+ final Set<UUID> managerUuids = ovsdbNode.getManagerOptionsColumn().getData();
final List<ManagerEntry> managerEntries = new ArrayList<>();
- for (UUID managerUUID : managerUUIDs ) {
- final Manager manager = updatedManagerRows.get(managerUUID);
+ for (UUID managerUuid : managerUuids) {
+ final Manager manager = updatedManagerRows.get(managerUuid);
addManagerEntries(managerEntries, manager);
}
LOG.debug("managerEntries: {}", managerEntries);
}
/**
- * Return the MD-SAL QoS type class corresponding to the QoS type {@link Qos}
+ * Return the MD-SAL QoS type class corresponding to the QoS type {@link Qos}.
*
* @param type the QoS type to match {@link String}
* @return class matching the input QoS type {@link QosTypeBase}
*/
package org.opendaylight.ovsdb.southbound;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.clustering.CandidateAlreadyRegisteredException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class SouthboundProvider implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(SouthboundProvider.class);
public void handleOwnershipChange(EntityOwnershipChange ownershipChange) {
if (ownershipChange.isOwner()) {
LOG.info("*This* instance of OVSDB southbound provider is set as a MASTER instance");
- LOG.info("Initialize OVSDB topology {} in operational and config data store if not already present"
- ,SouthboundConstants.OVSDB_TOPOLOGY_ID);
+ LOG.info("Initialize OVSDB topology {} in operational and config data store if not already present",
+ SouthboundConstants.OVSDB_TOPOLOGY_ID);
initializeOvsdbTopology(LogicalDatastoreType.OPERATIONAL);
initializeOvsdbTopology(LogicalDatastoreType.CONFIGURATION);
} else {
public void close() {
this.listenerRegistration.close();
}
+
@Override
public void ownershipChanged(EntityOwnershipChange ownershipChange) {
sp.handleOwnershipChange(ownershipChange);
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
-
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
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.schema.DatabaseSchema;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAttributes;
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.OvsdbNodeRef;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class AutoAttachRemovedCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(AutoAttachRemovedCommand.class);
Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> original,
Map<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> updated) {
- for (final Map.Entry<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originalEntry : original.entrySet()) {
+ for (final Map.Entry<InstanceIdentifier<OvsdbNodeAugmentation>, OvsdbNodeAugmentation> originalEntry :
+ original.entrySet()) {
final InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeIid = originalEntry.getKey();
final OvsdbNodeAugmentation ovsdbNodeAugmentation = originalEntry.getValue();
final OvsdbNodeAugmentation deletedOvsdbNodeAugmentation = updated.get(ovsdbNodeIid);
if (ovsdbNodeAugmentation != null && deletedOvsdbNodeAugmentation != null) {
final List<Autoattach> origAutoattachList = ovsdbNodeAugmentation.getAutoattach();
final List<Autoattach> deletedAutoattachList = deletedOvsdbNodeAugmentation.getAutoattach();
- if(origAutoattachList != null && !origAutoattachList.isEmpty() &&
- (deletedAutoattachList == null || deletedAutoattachList.isEmpty())) {
+ if (origAutoattachList != null && !origAutoattachList.isEmpty()
+ && (deletedAutoattachList == null || deletedAutoattachList.isEmpty())) {
if (true) {
// FIXME: Remove if loop after ovs community supports external_ids column in AutoAttach Table
final OvsdbBridgeAugmentation bridgeAugmentation = getBridge(ovsdbNodeIid, autoattachUuid);
if (autoattachUuid != null && bridgeAugmentation != null) {
final UUID uuid = new UUID(autoattachUuid.getValue());
- final AutoAttach autoattach = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), AutoAttach.class, null);
+ final AutoAttach autoattach =
+ TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), AutoAttach.class, null);
transaction.add(op.delete(autoattach.getSchema())
.where(autoattach.getUuidColumn().getSchema().opEqual(uuid))
.build());
try (ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
final Optional<Node> nodeOptional = transaction.read(LogicalDatastoreType.OPERATIONAL, nodeIid).get();
if (nodeOptional.isPresent()) {
- final List<ManagedNodeEntry> managedNodes = nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
+ final List<ManagedNodeEntry> managedNodes =
+ nodeOptional.get().getAugmentation(OvsdbNodeAugmentation.class).getManagedNodeEntry();
for (final ManagedNodeEntry managedNode : managedNodes) {
final OvsdbBridgeRef ovsdbBridgeRef = managedNode.getBridgeRef();
final InstanceIdentifier<OvsdbBridgeAugmentation> brIid = ovsdbBridgeRef.getValue()
.firstIdentifierOf(Node.class).augmentation(OvsdbBridgeAugmentation.class);
- final Optional<OvsdbBridgeAugmentation> optionalBridge = transaction.read(LogicalDatastoreType.OPERATIONAL, brIid).get();
+ final Optional<OvsdbBridgeAugmentation> optionalBridge =
+ transaction.read(LogicalDatastoreType.OPERATIONAL, brIid).get();
bridge = optionalBridge.orNull();
- if(bridge != null && bridge.getAutoAttach() != null
+ if (bridge != null && bridge.getAutoAttach() != null
&& bridge.getAutoAttach().equals(aaUuid)) {
return bridge;
}
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class AutoAttachUpdateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(AutoAttachUpdateCommand.class);
return;
}
- final OvsdbNodeAugmentation currentOvsdbNode = state.getBridgeNode(iid).get().getAugmentation(OvsdbNodeAugmentation.class);
+ final OvsdbNodeAugmentation currentOvsdbNode =
+ state.getBridgeNode(iid).get().getAugmentation(OvsdbNodeAugmentation.class);
final List<Autoattach> currentAutoAttach = currentOvsdbNode.getAutoattach();
for (final Autoattach autoAttach : autoAttachList) {
- final AutoAttach autoAttachWrapper = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), AutoAttach.class);
+ final AutoAttach autoAttachWrapper =
+ TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), AutoAttach.class);
if (autoAttach.getSystemName() != null) {
autoAttachWrapper.setSystemName(autoAttach.getSystemName());
}
final Map<String, String> externalIdsMap = new HashMap<>();
if (externalIds != null) {
for (final AutoattachExternalIds externalId : externalIds) {
- externalIdsMap.put(externalId.getAutoattachExternalIdKey(), externalId.getAutoattachExternalIdValue());
+ externalIdsMap.put(externalId.getAutoattachExternalIdKey(),
+ externalId.getAutoattachExternalIdValue());
}
}
- externalIdsMap.put(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY, autoAttach.getAutoattachId().getValue());
+ externalIdsMap.put(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY,
+ autoAttach.getAutoattachId().getValue());
// FIXME: To be uncommented when Open vSwitch supports external_ids column
// try {
// autoAttachWrapper.setExternalIds(ImmutableMap.copyOf(externalIdsMap));
transaction.add(op.comment("Updating AutoAttach table: " + uuid));
} else {
final Uri bridgeUri = autoAttach.getBridgeId();
- final String namedUuid = SouthboundMapper.getRandomUUID();
+ final String namedUuid = SouthboundMapper.getRandomUuid();
final Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
transaction.add(op.insert(autoAttachWrapper).withId(namedUuid));
final OvsdbBridgeAugmentation ovsdbBridgeAugmentation = getBridge(iid, bridgeUri);
if (ovsdbBridgeAugmentation != null) {
bridge.setName(ovsdbBridgeAugmentation.getBridgeName().getValue());
bridge.setAutoAttach(Sets.newHashSet(new UUID(namedUuid)));
- LOG.trace("Create Autoattach table {}, "
- + "and mutate the bridge {}", autoAttach.getAutoattachId(), getBridge(iid, bridgeUri).getBridgeName().getValue());
+ LOG.trace("Create Autoattach table {}, and mutate the bridge {}",
+ autoAttach.getAutoattachId(), getBridge(iid, bridgeUri).getBridgeName().getValue());
transaction.add(op.mutate(bridge)
.addMutation(bridge.getAutoAttachColumn().getSchema(),
Mutator.INSERT,bridge.getAutoAttachColumn().getData())
.where(bridge.getNameColumn().getSchema()
.opEqual(bridge.getNameColumn().getData())).build());
- transaction.add(op.comment("Bridge: Mutating " + ovsdbBridgeAugmentation.getBridgeName().getValue()
+ transaction.add(
+ op.comment("Bridge: Mutating " + ovsdbBridgeAugmentation.getBridgeName().getValue()
+ " to add autoattach column " + namedUuid));
}
}
OvsdbBridgeAugmentation bridge = null;
try (ReadOnlyTransaction transaction = SouthboundProvider.getDb().newReadOnlyTransaction()) {
- final Optional<OvsdbBridgeAugmentation> bridgeOptional = transaction.read(LogicalDatastoreType.OPERATIONAL, bridgeIid).get();
+ final Optional<OvsdbBridgeAugmentation> bridgeOptional =
+ transaction.read(LogicalDatastoreType.OPERATIONAL, bridgeIid).get();
if (bridgeOptional.isPresent()) {
bridge = bridgeOptional.get();
}
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class BridgeOperationalState {
private static final Logger LOG = LoggerFactory.getLogger(BridgeOperationalState.class);
private Map<InstanceIdentifier<Node>, Node> operationalNodes = new HashMap<>();
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class BridgeRemovedCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(BridgeRemovedCommand.class);
TransactUtils.extractOriginal(modifications, OvsdbBridgeAugmentation.class));
}
- private void execute(TransactionBuilder transaction, BridgeOperationalState state, Set<InstanceIdentifier<OvsdbBridgeAugmentation>> removed,
+ private void execute(TransactionBuilder transaction, BridgeOperationalState state,
+ Set<InstanceIdentifier<OvsdbBridgeAugmentation>> removed,
Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> originals) {
for (InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbManagedNodeIid: removed) {
LOG.info("Received request to delete ovsdb node {}",ovsdbManagedNodeIid);
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
-
import javax.annotation.Nonnull;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class BridgeUpdateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(BridgeUpdateCommand.class);
LOG.debug("Received request to create ovsdb bridge name: {} uuid: {}",
ovsdbManagedNode.getBridgeName(),
ovsdbManagedNode.getBridgeUuid());
- Optional<OvsdbBridgeAugmentation> operationalBridgeOptional =
- state.getOvsdbBridgeAugmentation(iid);
Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
setFailMode(bridge, ovsdbManagedNode);
setDataPathType(bridge, ovsdbManagedNode);
setOpenDaylightExternalIds(bridge, iid, ovsdbManagedNode);
setOpenDaylightOtherConfig(bridge, ovsdbManagedNode);
+ Optional<OvsdbBridgeAugmentation> operationalBridgeOptional =
+ state.getOvsdbBridgeAugmentation(iid);
if (!operationalBridgeOptional.isPresent()) {
setName(bridge, ovsdbManagedNode,operationalBridgeOptional);
setPort(transaction, bridge, ovsdbManagedNode);
Insert<GenericTableSchema> interfaceInsert = setInterface(transaction,ovsdbManagedNode);
// Port part
- String portNamedUuid = "Port_" + SouthboundMapper.getRandomUUID();
+ String portNamedUuid = "Port_" + SouthboundMapper.getRandomUuid();
Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
port.setName(ovsdbManagedNode.getBridgeName().getValue());
port.setInterfaces(Sets.newHashSet(TransactUtils.extractNamedUuid(interfaceInsert)));
private Insert<GenericTableSchema> setInterface(TransactionBuilder transaction,
OvsdbBridgeAugmentation ovsdbManagedNode) {
// Interface part
- String interfaceNamedUuid = "Interface_" + SouthboundMapper.getRandomUUID();
+ String interfaceNamedUuid = "Interface_" + SouthboundMapper.getRandomUuid();
Interface interfaceOvs = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
interfaceOvs.setName(ovsdbManagedNode.getBridgeName().getValue());
interfaceOvs.setType(SouthboundMapper.createOvsdbInterfaceType(InterfaceTypeInternal.class));
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class ControllerRemovedCommand implements TransactCommand {
@Override
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Controller controller =
TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Controller.class);
controller.setTarget(entry.getValue().getTarget().getValue());
- String controllerNamedUuidString = SouthboundMapper.getRandomUUID();
+ String controllerNamedUuidString = SouthboundMapper.getRandomUuid();
UUID controllerNamedUuid = new UUID(controllerNamedUuidString);
transaction.add(op.insert(controller).withId(controllerNamedUuidString));
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
-import com.google.common.base.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.List;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
-
-import com.google.common.collect.Sets;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class ProtocolRemovedCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(ProtocolRemovedCommand.class);
TransactUtils.extractCreatedOrUpdatedOrRemoved(modifications, OvsdbBridgeAugmentation.class));
}
- private void execute(TransactionBuilder transaction, BridgeOperationalState state, Set<InstanceIdentifier<ProtocolEntry>> removed,
+ private void execute(TransactionBuilder transaction, BridgeOperationalState state,
+ Set<InstanceIdentifier<ProtocolEntry>> removed,
Map<InstanceIdentifier<OvsdbBridgeAugmentation>, OvsdbBridgeAugmentation> updatedBridges) {
for (InstanceIdentifier<ProtocolEntry> protocolIid : removed) {
InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid =
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
public class ProtocolUpdateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(ProtocolUpdateCommand.class);
.where(qos.getUuidColumn().getSchema().opEqual(new UUID(qosUuid.getValue())))
.build());
} else {
- LOG.warn(
- "Unable to delete QoS{} for node {} because it was not found in the " +
- "operational store, "
- + "and thus we cannot retrieve its UUID", origQosEntry.getQosId(),
- ovsdbNodeIid);
+ LOG.warn("Unable to delete QoS{} for node {} because it was not found in the "
+ + "operational store, and thus we cannot retrieve its UUID",
+ origQosEntry.getQosId(), ovsdbNodeIid);
}
}
}
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.UUID;
}
List<QueueList> queueList = qosEntry.getQueueList();
- Map<Long, UUID>newQueueList = new HashMap<>();
+ Map<Long, UUID> newQueueList = new HashMap<>();
if (queueList != null && !queueList.isEmpty()) {
for (QueueList queue : queueList) {
if (queue.getQueueRef() != null) {
- newQueueList.put(queue.getQueueNumber(), new UUID(getQueueUuid(queue.getQueueRef(), operNode)));
+ newQueueList.put(queue.getQueueNumber(),
+ new UUID(getQueueUuid(queue.getQueueRef(), operNode)));
} else if (queue.getQueueUuid() != null) {
newQueueList.put(queue.getQueueNumber(), new UUID(queue.getQueueUuid().getValue()));
}
Uuid operQosUuid = getQosEntryUuid(operQosEntries, qosEntry.getQosId());
if (operQosUuid == null) {
- UUID namedUuid = new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX +
- TransactUtils.bytesToHexString(qosEntry.getQosId().getValue().getBytes()));
+ UUID namedUuid = new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX
+ + TransactUtils.bytesToHexString(qosEntry.getQosId().getValue().getBytes()));
transaction.add(op.insert(qos).withId(namedUuid.toString())).build();
} else {
UUID uuid = new UUID(operQosUuid.getValue());
}
}
}
- return SouthboundConstants.QUEUE_NAMED_UUID_PREFIX +
- TransactUtils.bytesToHexString(queueKey.getQueueId().getValue().getBytes());
+ return SouthboundConstants.QUEUE_NAMED_UUID_PREFIX
+ + TransactUtils.bytesToHexString(queueKey.getQueueId().getValue().getBytes());
}
private Uuid getQosEntryUuid(List<QosEntries> operQosEntries, Uri qosId) {
new UUID(queueUuid.getValue())))
.build());
} else {
- LOG.warn(
- "Unable to delete Queue{} for node {} because it was not found in the " +
- "operational store, "
- + "and thus we cannot retrieve its UUID", ovsdbNodeIid,
- origQueue.getQueueId());
+ LOG.warn("Unable to delete Queue{} for node {} because it was not found in the "
+ + "operational store, and thus we cannot retrieve its UUID",
+ ovsdbNodeIid, origQueue.getQueueId());
}
}
}
if (queueEntry.getDscp() != null) {
try {
Set<Long> dscpSet = new HashSet<>();
- if (dscpSet.add(new Long(queueEntry.getDscp().toString()))) {
+ if (dscpSet.add(new Long(queueEntry.getDscp().toString()))) {
queue.setDscp(dscpSet);
}
} catch (NumberFormatException e) {
Uuid operQueueUuid = getQueueEntryUuid(operQueues, queueEntry.getQueueId());
if (operQueueUuid == null) {
- UUID namedUuid = new UUID(SouthboundConstants.QUEUE_NAMED_UUID_PREFIX +
- TransactUtils.bytesToHexString(queueEntry.getQueueId().getValue().getBytes()));
+ UUID namedUuid = new UUID(SouthboundConstants.QUEUE_NAMED_UUID_PREFIX
+ + TransactUtils.bytesToHexString(queueEntry.getQueueId().getValue().getBytes()));
transaction.add(op.insert(queue).withId(namedUuid.toString())).build();
} else {
UUID uuid = new UUID(operQueueUuid.getValue());
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.concurrent.ExecutionException;
import java.util.Set;
-
+import java.util.concurrent.ExecutionException;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class TerminationPointCreateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
@Override
public void execute(TransactionBuilder transaction, BridgeOperationalState state,
Collection<DataTreeModification<Node>> modifications) {
- execute(transaction, state, TransactUtils.extractCreated(modifications, OvsdbTerminationPointAugmentation.class),
+ execute(transaction, state,
+ TransactUtils.extractCreated(modifications, OvsdbTerminationPointAugmentation.class),
TransactUtils.extractCreatedOrUpdated(modifications, Node.class));
}
state.getBridgeTerminationPoint(terminationPointIid);
if (!terminationPointOptional.isPresent()) {
// Configure interface
- String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUUID();
+ String interfaceUuid = "Interface_" + SouthboundMapper.getRandomUuid();
Interface ovsInterface =
TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Interface.class);
createInterface(terminationPoint, ovsInterface);
stampInstanceIdentifier(transaction, entry.getKey(), ovsInterface.getName());
// Configure port with the above interface details
- String portUuid = "Port_" + SouthboundMapper.getRandomUUID();
+ String portUuid = "Port_" + SouthboundMapper.getRandomUuid();
Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class);
createPort(terminationPoint, port, interfaceUuid);
transaction.add(op.insert(port).withId(portUuid));
if (terminationPoint.getVlanMode() != null) {
Set<String> portVlanMode = new HashSet<>();
VlanMode modelVlanMode = terminationPoint.getVlanMode();
- portVlanMode.add(SouthboundConstants.VLANMODES.values()[modelVlanMode.getIntValue() - 1].getMode());
+ portVlanMode.add(SouthboundConstants.VlanModes.values()[modelVlanMode.getIntValue() - 1].getMode());
port.setVlanMode(portVlanMode);
}
}
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-
/**
- * @author avishnoi@brocade.com (Anil Vishnoi)
+ * Transaction handler for the TerminationPoints.
*
+ * @author avishnoi@brocade.com (Anil Vishnoi)
*/
public class TerminationPointDeleteCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointDeleteCommand.class);
}
private void execute(TransactionBuilder transaction, BridgeOperationalState state,
- Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> originals,
+ Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
+ OvsdbTerminationPointAugmentation> originals,
Map<InstanceIdentifier<Node>, Node> originalNodes,
Set<InstanceIdentifier<OvsdbTerminationPointAugmentation>> removedTps) {
for (InstanceIdentifier<OvsdbTerminationPointAugmentation> removedTpIid: removedTps) {
OvsdbBridgeAugmentation originalOvsdbBridgeAugmentation =
originalNode.getAugmentation(OvsdbBridgeAugmentation.class);
String bridgeName = null;
- if(originalOvsdbBridgeAugmentation != null) {
+ if (originalOvsdbBridgeAugmentation != null) {
bridgeName = originalOvsdbBridgeAugmentation.getBridgeName().getValue();
} else {
Optional<OvsdbBridgeAugmentation> bridgeAug = state.getOvsdbBridgeAugmentation(removedTpIid);
- if(bridgeAug.isPresent()) {
+ if (bridgeAug.isPresent()) {
bridgeName = bridgeAug.get().getBridgeName().getValue();
} else {
LOG.error("Bridge does not exist for termination point {}", removedTpIid);
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
+import com.google.common.collect.Sets;
+import com.google.common.util.concurrent.CheckedFuture;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ExecutionException;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Interface;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
-import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundProvider;
import org.opendaylight.ovsdb.utils.yang.YangUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
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.OvsdbPortInterfaceAttributes.VlanMode;
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.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQosRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceBfd;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceLldp;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class TerminationPointUpdateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointUpdateCommand.class);
@Override
public void execute(TransactionBuilder transaction, BridgeOperationalState state,
AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> events) {
- execute(transaction, state, TransactUtils.extractCreatedOrUpdated(events, OvsdbTerminationPointAugmentation.class));
+ execute(transaction, state,
+ TransactUtils.extractCreatedOrUpdated(events, OvsdbTerminationPointAugmentation.class));
}
@Override
OvsdbTerminationPointAugmentation> createdOrUpdated) {
LOG.trace("TerminationPointUpdateCommand called");
for (Entry<InstanceIdentifier<OvsdbTerminationPointAugmentation>,
- OvsdbTerminationPointAugmentation> terminationPointEntry : createdOrUpdated.entrySet()) {
- updateTerminationPoint(transaction, state, terminationPointEntry.getKey(), terminationPointEntry.getValue());
+ OvsdbTerminationPointAugmentation> terminationPointEntry : createdOrUpdated.entrySet()) {
+ updateTerminationPoint(transaction, state, terminationPointEntry.getKey(),
+ terminationPointEntry.getValue());
}
}
iid.firstIdentifierOf(OvsdbTerminationPointAugmentation.class), terminationPoint.getName());
// Update port
- OvsdbBridgeAugmentation operBridge = state.getBridgeNode(iid).get().getAugmentation(OvsdbBridgeAugmentation.class);
+ OvsdbBridgeAugmentation operBridge =
+ state.getBridgeNode(iid).get().getAugmentation(OvsdbBridgeAugmentation.class);
Port port = TyperUtils.getTypedRowWrapper(
transaction.getDatabaseSchema(), Port.class);
updatePort(terminationPoint, port, operBridge);
OvsdbQosRef qosRef = terminationPoint.getQosEntry().iterator().next().getQosRef();
Uri qosId = qosRef.getValue().firstKeyOf(QosEntries.class).getQosId();
OvsdbNodeAugmentation operNode = getOperNode(operBridge);
- if (operNode != null && operNode.getQosEntries() != null &&
- !operNode.getQosEntries().isEmpty()) {
+ if (operNode != null && operNode.getQosEntries() != null
+ && !operNode.getQosEntries().isEmpty()) {
for (QosEntries qosEntry : operNode.getQosEntries()) {
if (qosEntry.getQosId().equals(qosId)) {
uuidSet.add(new UUID(qosEntry.getQosUuid().getValue()));
}
}
if (uuidSet.size() == 0) {
- uuidSet.add(new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX +
- TransactUtils.bytesToHexString(qosId.getValue().getBytes())));
+ uuidSet.add(new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX
+ + TransactUtils.bytesToHexString(qosId.getValue().getBytes())));
}
} else {
// Second check if Qos is present and use that (deprecated)
if (terminationPoint.getVlanMode() != null) {
Set<String> portVlanMode = new HashSet<>();
VlanMode modelVlanMode = terminationPoint.getVlanMode();
- portVlanMode.add(SouthboundConstants.VLANMODES.values()[modelVlanMode.getIntValue() - 1].getMode());
+ portVlanMode.add(SouthboundConstants.VlanModes.values()[modelVlanMode.getIntValue() - 1].getMode());
port.setVlanMode(portVlanMode);
}
}
private static final Class<? extends TransactCommand>[] COMMAND_CLASSES =
new Class[] {
- BridgeUpdateCommand.class,
- OpenVSwitchBridgeAddCommand.class,
- ControllerUpdateCommand.class,
- ControllerRemovedCommand.class,
- ProtocolUpdateCommand.class,
- ProtocolRemovedCommand.class,
- BridgeRemovedCommand.class,
- TerminationPointCreateCommand.class,
- TerminationPointDeleteCommand.class,
- OvsdbNodeUpdateCommand.class,
- AutoAttachUpdateCommand.class,
- AutoAttachRemovedCommand.class,
- QosUpdateCommand.class,
- QosRemovedCommand.class,
- QueueUpdateCommand.class,
- QueueRemovedCommand.class,
- TerminationPointUpdateCommand.class,
+ BridgeUpdateCommand.class,
+ OpenVSwitchBridgeAddCommand.class,
+ ControllerUpdateCommand.class,
+ ControllerRemovedCommand.class,
+ ProtocolUpdateCommand.class,
+ ProtocolRemovedCommand.class,
+ BridgeRemovedCommand.class,
+ TerminationPointCreateCommand.class,
+ TerminationPointDeleteCommand.class,
+ OvsdbNodeUpdateCommand.class,
+ AutoAttachUpdateCommand.class,
+ AutoAttachRemovedCommand.class,
+ QosUpdateCommand.class,
+ QosRemovedCommand.class,
+ QueueUpdateCommand.class,
+ QueueRemovedCommand.class,
+ TerminationPointUpdateCommand.class,
};
@Override
*/
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collection;
import java.util.List;
-
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.ListenableFuture;
-
public class TransactInvokerImpl implements TransactInvoker {
private static final Logger LOG = LoggerFactory.getLogger(TransactInvokerImpl.class);
private OvsdbConnectionInstance connectionInstance;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
-
import javax.annotation.Nullable;
-
-import com.google.common.base.Predicate;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-
import org.opendaylight.yangtools.yang.binding.ChildOf;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-import com.google.common.base.Predicates;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
public class TransactUtils {
private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataBefore() {
return new Predicate<DataObjectModification<T>>() {
};
}
- private static <T extends DataObject> Predicate<DataObjectModification<T>> modificationIsDeletionAndHasDataBefore
- () {
+ private static <T extends DataObject> Predicate<DataObjectModification<T>>
+ modificationIsDeletionAndHasDataBefore() {
return new Predicate<DataObjectModification<T>>() {
@Override
public boolean apply(@Nullable DataObjectModification<T> input) {
return extractCreatedOrUpdated(changes, clazz, hasNoDataBefore());
}
+ public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractUpdated(
+ AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
+ return extract(changes.getUpdatedData(),klazz);
+ }
+
+ /**
+ * Extract all the instances of {@code clazz} which were updated in the given set of modifications.
+ *
+ * @param changes The changes to process.
+ * @param clazz The class we're interested in.
+ * @param <T> The type of changes we're interested in.
+ * @param <U> The type of changes to process.
+ * @return The updated instances, mapped by instance identifier.
+ */
+ public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractUpdated(
+ Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+ return extractCreatedOrUpdated(changes, clazz, hasDataBeforeAndDataAfter());
+ }
+
/**
* Extract all the instance of {@code clazz} which were created or updated in the given set of modifications, and
* which satisfy the given filter.
return result;
}
- public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractUpdated(
- AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
- return extract(changes.getUpdatedData(),klazz);
- }
-
- /**
- * Extract all the instances of {@code clazz} which were updated in the given set of modifications.
- *
- * @param changes The changes to process.
- * @param clazz The class we're interested in.
- * @param <T> The type of changes we're interested in.
- * @param <U> The type of changes to process.
- * @return The updated instances, mapped by instance identifier.
- */
- public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractUpdated(
- Collection<DataTreeModification<U>> changes, Class<T> clazz) {
- return extractCreatedOrUpdated(changes, clazz, hasDataBeforeAndDataAfter());
- }
-
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractCreatedOrUpdated(
AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
Map<InstanceIdentifier<T>,T> result = extractUpdated(changes,klazz);
* @return The created, updated or removed instances, mapped by instance identifier.
*/
public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T>
- extractCreatedOrUpdatedOrRemoved(
+ extractCreatedOrUpdatedOrRemoved(
Collection<DataTreeModification<U>> changes, Class<T> clazz) {
Map<InstanceIdentifier<T>, T> result = extractCreatedOrUpdated(changes, clazz);
result.putAll(extractRemovedObjects(changes, clazz));
* @return The modifications, mapped by instance identifier.
*/
private static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, DataObjectModification<T>>
- extractDataObjectModifications(
- Collection<DataTreeModification<U>> changes, Class<T> clazz,
- Predicate<DataObjectModification<T>> filter) {
+ extractDataObjectModifications(Collection<DataTreeModification<U>> changes, Class<T> clazz,
+ Predicate<DataObjectModification<T>> filter) {
List<DataObjectModification<? extends DataObject>> dataObjectModifications = new ArrayList<>();
List<InstanceIdentifier<? extends DataObject>> paths = new ArrayList<>();
if (changes != null) {
* @return The modifications, mapped by instance identifier.
*/
private static <T extends DataObject> Map<InstanceIdentifier<T>, DataObjectModification<T>>
- extractDataObjectModifications(
+ extractDataObjectModifications(
Collection<DataObjectModification<? extends DataObject>> changes,
Collection<InstanceIdentifier<? extends DataObject>> paths, Class<T> clazz,
Predicate<DataObjectModification<T>> filter) {
* @return The extended path.
*/
private static <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>, T extends DataObject>
- InstanceIdentifier<? extends DataObject> extendPath(
+ InstanceIdentifier<? extends DataObject> extendPath(
InstanceIdentifier path,
DataObjectModification child) {
Class<N> item = (Class<N>) child.getDataType();
*/
public static UUID extractNamedUuid(Insert insert) {
String uuidString = insert.getUuidName() != null
- ? insert.getUuidName() : SouthboundMapper.getRandomUUID();
+ ? insert.getUuidName() : SouthboundMapper.getRandomUuid();
insert.setUuidName(uuidString);
return new UUID(uuidString);
}
/**
* This method builds a string by concatenating the 2 character
* hexadecimal representation of each byte from the input byte array.
- *
+ * <p>
* For example: an input byte array containing:
* bytes[0] = 'a'
* bytes[1] = 'b'
* bytes[5] = '2'
* bytes[6] = '3'
* returns the string "6162632d313233"
- *
+ * </p>
* @param bytes
* The byte array to convert to string
* @return The hexadecimal representation of the byte array. If bytes is
package org.opendaylight.ovsdb.southbound.reconciliation;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.concurrent.*;
-
/**
* This class provides the implementation of ovsdb southbound plugins
* configuration reconciliation engine. This engine provide interfaces
* if task is ready for execution.
* Ideally, addition of any type of reconciliation task should not require
* any change in this reconciliation manager execution engine.
- *
+ * <p>
* 3-Node Cluster:
* Reconciliation manager is agnostic of whether it's running in single
* node cluster or 3-node cluster. It's a responsibility of the task
* Reconciliation of controller initiated connection should be done by all
* the 3-nodes in the cluster, because connection to individual controller
* can be interrupted for various reason.
- *
- * Created by Anil Vishnoi (avishnoi@Brocade.com) on 3/9/16.
+ * </p>
*/
public class ReconciliationManager implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(ReconciliationManager.class);
public ReconciliationManager(final DataBroker db) {
this.db = db;
- reconcilers = SpecialExecutors.newBoundedCachedThreadPool(NO_OF_RECONCILER, RECON_TASK_QUEUE_SIZE, "ovsdb-reconciler");
+ reconcilers = SpecialExecutors.newBoundedCachedThreadPool(NO_OF_RECONCILER, RECON_TASK_QUEUE_SIZE,
+ "ovsdb-reconciler");
ThreadFactory threadFact = new ThreadFactoryBuilder()
.setNameFormat("ovsdb-recon-task-triager-%d").build();
* Abstract implementation of a reconciliation task. Each new type of
* resource configuration reconciliation task should extend this class
* and implement the abstract methods.
- * Created by Anil Vishnoi (avishnoi@Brocade.com) on 3/9/16.
*/
public abstract class ReconciliationTask implements Runnable {
}
@Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) {
+ public boolean equals(Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (obj == null || getClass() != obj.getClass()) {
return false;
}
- ReconciliationTask that = (ReconciliationTask) o;
+ ReconciliationTask that = (ReconciliationTask) obj;
return nodeIid.equals(that.nodeIid);
-
}
@Override
@Override
public String toString() {
- return "ReconciliationTask{ type=" + getClass().toString()+
- ", nodeIid=" + nodeIid +
- '}';
+ return "ReconciliationTask{ type=" + getClass().toString() + ", nodeIid=" + nodeIid + '}';
}
}
*/
package org.opendaylight.ovsdb.southbound.reconciliation;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Future;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* This class is a task cache manager that provides a cache to store
* is submitted to the reconciliation manager, it will be cached in
* the cache. If the reconciliation is successful or it's done with
* all the attempt of reconciliation,
- *
+ * <p>
* Caching of the task is required, because reconciliation task might
* require longer duration to reconcile and there is a possibility that
* meanwhile user can change the configuration in config data store while
* task is queued for the reconciliation. In that scenario, reconciliation
* manager should not attempt any further reconciliation attempt for that
* task. ReconciliationManager will call cancelTask() to cancel the task.
- *
+ * </p>
* Created by Anil Vishnoi (avishnoi@Brocade.com) on 3/15/16.
*/
class ReconciliationTaskManager {
public boolean isTaskQueued(ReconciliationTask task) {
return reconciliationTaskCache.containsKey(task);
}
+
public boolean cancelTask(ReconciliationTask task) {
- if(reconciliationTaskCache.containsKey(task)){
+ if (reconciliationTaskCache.containsKey(task)) {
Future<?> taskFuture = reconciliationTaskCache.remove(task);
- if( !taskFuture.isDone() && !taskFuture.isCancelled() ) {
- LOG.info("Reconciliation task is cancelled : {}",task);
+ if (!taskFuture.isDone() && !taskFuture.isCancelled()) {
+ LOG.info("Reconciliation task is cancelled : {}", task);
return taskFuture.cancel(true);
}
}
return false;
}
+
public void cacheTask(ReconciliationTask task, Future<?> taskFuture) {
reconciliationTaskCache.put(task,taskFuture);
}
package org.opendaylight.ovsdb.southbound.reconciliation.configuration;
+import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationManager;
import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationTask;
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.ovsdb.bridge.attributes.BridgeOtherConfigs;
-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.ControllerEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
-import javax.annotation.Nullable;
-
-import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
-
/**
* Configuration Reconciliation task to reconcile existing bridge configurations in the config datastore and the
* switch when the latter is up and connected to the controller.
* Created by Vinh Nguyen (vinh.nguyen@hcl.com) on 3/21/16.
*/
-public class BridgeConfigReconciliationTask extends ReconciliationTask{
+public class BridgeConfigReconciliationTask extends ReconciliationTask {
private static final Logger LOG = LoggerFactory.getLogger(BridgeConfigReconciliationTask.class);
private final OvsdbConnectionInstance connectionInstance;
Futures.addCallback(readTopologyFuture, new FutureCallback<Optional<Topology>>() {
@Override
public void onSuccess(@Nullable Optional<Topology> optionalTopology) {
- if (optionalTopology.isPresent()) {
- InstanceIdentifier<Node> nIid = (InstanceIdentifier<Node>) nodeIid;
+ if (optionalTopology != null && optionalTopology.isPresent()) {
+ @SuppressWarnings("unchecked")
+ InstanceIdentifier<Node> ndIid = (InstanceIdentifier<Node>) nodeIid;
Topology topology = optionalTopology.get();
if (topology.getNode() != null) {
final Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
for (Node node : topology.getNode()) {
OvsdbBridgeAugmentation bridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
- if (bridge != null && bridge.getManagedBy() != null && bridge.getManagedBy().getValue().equals(nIid)) {
+ if (bridge != null && bridge.getManagedBy() != null
+ && bridge.getManagedBy().getValue().equals(ndIid)) {
changes.putAll(extractBridgeConfigurationChanges(node, bridge));
}
}
}
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Read Config/DS for Topology failed! {}", nodeIid, t);
+ public void onFailure(Throwable throwable) {
+ LOG.warn("Read Config/DS for Topology failed! {}", nodeIid, throwable);
}
});
*/
package org.opendaylight.ovsdb.southbound.reconciliation.connection;
+import java.net.UnknownHostException;
+import java.util.concurrent.atomic.AtomicInteger;
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionManager;
import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.net.UnknownHostException;
-import java.util.concurrent.atomic.AtomicInteger;
-
-/**
- * Created by Anil Vishnoi (avishnoi@Brocade.com) on 3/9/16.
- */
public class ConnectionReconciliationTask extends ReconciliationTask {
private static final Logger LOG = LoggerFactory.getLogger(ConnectionReconciliationTask.class);
public boolean reconcileConfiguration(OvsdbConnectionManager connectionManager) {
boolean result = false;
connectionAttempt.incrementAndGet();
- InstanceIdentifier<Node> nIid = (InstanceIdentifier<Node>) nodeIid;
+ InstanceIdentifier<Node> ndIid = (InstanceIdentifier<Node>) nodeIid;
OvsdbNodeAugmentation ovsdbNode = (OvsdbNodeAugmentation)configData;
LOG.info("Retry({}) connection to Ovsdb Node {} ", connectionAttempt.get(), ovsdbNode.getConnectionInfo());
OvsdbClient client = null;
try {
- client = connectionManager.connect(nIid, ovsdbNode);
+ client = connectionManager.connect(ndIid, ovsdbNode);
if (client != null) {
LOG.info("Successfully connected to Ovsdb Node {} ", ovsdbNode.getConnectionInfo());
result = true;
@Override
public void doRetry(boolean wasLastAttemptSuccessful) {
- if( !wasLastAttemptSuccessful && connectionAttempt.get() <= MAX_ATTEMPT ) {
+ if (!wasLastAttemptSuccessful && connectionAttempt.get() <= MAX_ATTEMPT) {
reconciliationManager.enqueueForRetry(ConnectionReconciliationTask.this);
} else {
reconciliationManager.dequeue(this);
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.error.SchemaVersionMismatchException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
-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.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+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;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
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.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.slf4j.Logger;
for (Entry<UUID, OpenVSwitch> entry : updatedOpenVSwitchRows.entrySet()) {
OpenVSwitch openVSwitch = entry.getValue();
- OpenVSwitch oldEntry = deletedOpenVSwitchRows.get(entry.getKey());
final InstanceIdentifier<Node> nodePath = getInstanceIdentifier(openVSwitch);
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
setVersion(ovsdbNodeBuilder, openVSwitch);
setDataPathTypes(ovsdbNodeBuilder, openVSwitch);
setInterfaceTypes(ovsdbNodeBuilder, openVSwitch);
+ OpenVSwitch oldEntry = deletedOpenVSwitchRows.get(entry.getKey());
setExternalIds(transaction, ovsdbNodeBuilder, oldEntry, openVSwitch);
setOtherConfig(transaction, ovsdbNodeBuilder, oldEntry, openVSwitch);
ovsdbNodeBuilder.setConnectionInfo(getConnectionInfo());
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbAutoAttachRemovedCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbAutoAttachRemovedCommand.class);
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-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.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Autoattach;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.AutoattachBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.AutoattachKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIds;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.AutoattachExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.Mappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.MappingsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.autoattach.MappingsKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbAutoAttachUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbAutoAttachUpdateCommand.class);
for (final Entry<UUID, AutoAttach> entry : updatedAutoAttachRows.entrySet()) {
final AutoAttach autoAttach = entry.getValue();
final AutoAttach oldAutoAttach = oldAutoAttachRows.get(entry.getKey());
- final Uri uri = new Uri(SouthboundConstants.AUTOATTACH_URI_PREFIX + "://" + autoAttach.getUuid().toString());
+ final Uri uri =
+ new Uri(SouthboundConstants.AUTOATTACH_URI_PREFIX + "://" + autoAttach.getUuid().toString());
// FIXME: To be uncommented when Open vSwitch supports external_ids column
// Uri uri = new Uri(getAutoAttachId(autoAttach));
.augmentation(OvsdbNodeAugmentation.class)
.child(Autoattach.class, new AutoattachKey(new Uri(oldAutoAttach
.getUuidColumn().getData().toString())));
- // FIXME: To be uncommented and replaced to currentIid when Open vSwitch supports external_ids column
+ // FIXME: To be uncommented and replaced to currentIid when
+ // Open vSwitch supports external_ids column
// InstanceIdentifier<Autoattach> currentIid = nodeIId
// .augmentation(OvsdbNodeAugmentation.class)
// .child(Autoattach.class, new AutoattachKey(new Uri(oldAutoAttach
LOG.debug("AutoAttach table entries not found in operational datastore, need to create it.", e);
}
- final AutoattachBuilder autoAttachBuilder = (currentAutoattach != null) ? new AutoattachBuilder(currentAutoattach)
- : new AutoattachBuilder()
- .setAutoattachUuid(new Uuid(entry.getKey().toString()))
- .setAutoattachId(uri)
- .setKey(new AutoattachKey(uri));
+ final AutoattachBuilder autoAttachBuilder =
+ (currentAutoattach != null) ? new AutoattachBuilder(currentAutoattach)
+ : new AutoattachBuilder()
+ .setAutoattachUuid(new Uuid(entry.getKey().toString()))
+ .setAutoattachId(uri)
+ .setKey(new AutoattachKey(uri));
if (autoAttach.getSystemNameColumn() != null
&& autoAttach.getSystemNameColumn().getData() != null
}
}
- private void setMappings (AutoattachBuilder autoAttachBuilder,
+ private void setMappings(AutoattachBuilder autoAttachBuilder,
AutoAttach autoAttach) {
final Map<Long, Long> mappings = autoAttach.getMappingsColumn().getData();
final Set<Long> mappingsKeys = mappings.keySet();
final List<Mappings> mappingsList = new ArrayList<>();
for (final Long mappingsKey : mappingsKeys) {
final Integer mappingsValue = new Integer(mappings.get(mappingsKey).toString());
- if (mappingsKey != null && mappingsValue != null) {
+ if (mappingsKey != null) {
mappingsList.add(new MappingsBuilder()
.setKey(new MappingsKey(mappingsKey))
.setMappingsKey(mappingsKey)
// private String getAutoAttachId(AutoAttach autoAttach) {
// if (autoAttach.getExternalIdsColumn() != null
// && autoAttach.getExternalIdsColumn().getData() != null
-// && autoAttach.getExternalIdsColumn().getData().containsKey(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY)) {
+// && autoAttach.getExternalIdsColumn().getData()
+// .containsKey(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY)) {
// return autoAttach.getExternalIdsColumn().getData().get(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY);
// } else {
// return SouthboundConstants.AUTOATTACH_URI_PREFIX + "://" + autoAttach.getUuid().toString();
// }
// }
// } else {
-// externalIdsList.add(new AutoattachExternalIdsBuilder().setAutoattachExternalIdKey(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY)
+// externalIdsList.add(new AutoattachExternalIdsBuilder()
+// .setAutoattachExternalIdKey(SouthboundConstants.AUTOATTACH_ID_EXTERNAL_ID_KEY)
// .setAutoattachExternalIdValue(autoAttach.getUuid().toString()).build());
// }
// autoAttachBuilder.setAutoattachExternalIds(externalIdsList);
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.net.InetAddresses;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.ArrayList;
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.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<UUID,Bridge> updatedBridgeRows;
}
}
}
+
private InstanceIdentifier<Node> getInstanceIdentifier(Bridge bridge) {
return SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
bridge);
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Preconditions;
-
public class OvsdbControllerRemovedCommand extends AbstractTransactionCommand {
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
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;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+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.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-
-import com.google.common.base.Optional;
public class OvsdbControllerUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbControllerUpdateCommand.class);
* Find all the {@link Node} bridge nodes for the given connection.
*
* @param transaction the {@link ReadWriteTransaction}
- * @return
+ * @return map of nodes
*/
private Map<InstanceIdentifier<Node>, Node> getBridgeNodes(ReadWriteTransaction transaction) {
Map<InstanceIdentifier<Node>, Node> bridgeNodes = new HashMap<>();
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Preconditions;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import com.google.common.base.Preconditions;
-
public class OvsdbManagersRemovedCommand extends AbstractTransactionCommand {
private Map<UUID, OpenVSwitch> oldOpenVSwitchRows;
*/
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbManagersUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbManagersUpdateCommand.class);
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class OvsdbNodeRemoveCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbNodeRemoveCommand.class);
private static final long ONE_CONNECTED_MANAGER = 1;
commands.add(new OvsdbPortUpdateCommand(key, updates, dbSchema));
commands.add(new OvsdbPortRemoveCommand(key, updates, dbSchema));
- if(dbSchema.getVersion().compareTo(Version.fromString(SouthboundConstants.AUTOATTACH_SUPPORTED_OVS_SCHEMA_VERSION)) >= 0) {
+ if (dbSchema.getVersion().compareTo(
+ Version.fromString(SouthboundConstants.AUTOATTACH_SUPPORTED_OVS_SCHEMA_VERSION)) >= 0) {
commands.add(new OvsdbAutoAttachUpdateCommand(key, updates, dbSchema));
commands.add(new OvsdbAutoAttachRemovedCommand(key, updates, dbSchema));
} else {
- LOG.debug("UNSUPPORTED FUNCTIONALITY: AutoAttach not supported in OVS schema version {}", dbSchema.getVersion().toString());
+ LOG.debug("UNSUPPORTED FUNCTIONALITY: AutoAttach not supported in OVS schema version {}",
+ dbSchema.getVersion().toString());
}
}
Bridge.class, getUpdates(), getDbSchema());
for (Port port : portRemovedRows) {
Bridge updatedBridgeData = null;
- for (UUID bridgeUUID : bridgeUpdatedOldRows.keySet()) {
- Bridge oldBridgeData = bridgeUpdatedOldRows.get(bridgeUUID);
+ for (UUID bridgeUuid : bridgeUpdatedOldRows.keySet()) {
+ Bridge oldBridgeData = bridgeUpdatedOldRows.get(bridgeUuid);
if (oldBridgeData.getPortsColumn() != null
&& oldBridgeData.getPortsColumn().getData().contains(port.getUuidColumn().getData())
&& (! bridgeUpdatedRows.isEmpty())) {
- updatedBridgeData = bridgeUpdatedRows.get(bridgeUUID);
+ updatedBridgeData = bridgeUpdatedRows.get(bridgeUuid);
break;
}
}
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbPortUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
private Map<UUID, Port> portUpdatedRows;
private Map<UUID, Interface> interfaceOldRows;
private Map<UUID, Bridge> bridgeUpdatedRows;
private Map<UUID, Qos> qosUpdatedRows;
+
public OvsdbPortUpdateCommand(OvsdbConnectionInstance key, TableUpdates updates,
DatabaseSchema dbSchema) {
super(key, updates, dbSchema);
updateTerminationPoints(transaction, node.get());
}
}
+
private void updateTerminationPoints(ReadWriteTransaction transaction, Node node) {
for (Entry<UUID, Port> portUpdate : portUpdatedRows.entrySet()) {
String portName = null;
OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder =
new OvsdbTerminationPointAugmentationBuilder();
buildTerminationPoint(transaction, tpPath, tpAugmentationBuilder, node, portUpdate);
- UUID interfaceUUID = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
- if (interfaceUpdatedRows.containsKey(interfaceUUID)) {
- buildTerminationPoint(tpAugmentationBuilder,
- interfaceUpdatedRows.get(interfaceUUID));
- interfaceUpdatedRows.remove(interfaceUUID);
- interfaceOldRows.remove(interfaceUUID);
+ UUID interfaceUuid = (UUID)portUpdate.getValue().getInterfacesColumn().getData().toArray()[0];
+ if (interfaceUpdatedRows.containsKey(interfaceUuid)) {
+ buildTerminationPoint(tpAugmentationBuilder, interfaceUpdatedRows.get(interfaceUuid));
+ interfaceUpdatedRows.remove(interfaceUuid);
+ interfaceOldRows.remove(interfaceUuid);
}
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
if (portOldRows.containsKey(portUpdate.getKey()) && !portQosCleared(portUpdate)) {
interfaceName = interfaceUpdatedRows.get(interfaceUpdate.getKey()).getNameColumn().getData();
Optional<InstanceIdentifier<Node>> bridgeIid = getTerminationPointBridge( transaction, node, interfaceName);
if (bridgeIid.isPresent()) {
- NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
TerminationPointKey tpKey = new TerminationPointKey(new TpId(interfaceName));
- InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
- .create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
- .child(Node.class,new NodeKey(bridgeId))
- .child(TerminationPoint.class,tpKey);
TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
tpBuilder.setKey(tpKey);
tpBuilder.setTpId(tpKey.getTpId());
new OvsdbTerminationPointAugmentationBuilder();
buildTerminationPoint(tpAugmentationBuilder, interfaceUpdate.getValue());
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
+ NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
+ InstanceIdentifier<TerminationPoint> tpPath = InstanceIdentifier
+ .create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class,new NodeKey(bridgeId))
+ .child(TerminationPoint.class,tpKey);
transaction.merge(LogicalDatastoreType.OPERATIONAL,
tpPath, tpBuilder.build());
}
}
}
+
private void buildTerminationPoint(ReadWriteTransaction transaction,
InstanceIdentifier<TerminationPoint> tpPath,
OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder,
return node;
}
- private Optional<InstanceIdentifier<Node>> getTerminationPointBridge( UUID portUUID) {
- for (UUID bridgeUUID : this.bridgeUpdatedRows.keySet()) {
- if (this.bridgeUpdatedRows.get(bridgeUUID).getPortsColumn().getData().contains(portUUID)) {
+ private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(UUID portUuid) {
+ for (UUID bridgeUuid : this.bridgeUpdatedRows.keySet()) {
+ if (this.bridgeUpdatedRows.get(bridgeUuid).getPortsColumn().getData().contains(portUuid)) {
return Optional.of(SouthboundMapper.createInstanceIdentifier(getOvsdbConnectionInstance(),
- this.bridgeUpdatedRows.get(bridgeUUID)));
+ this.bridgeUpdatedRows.get(bridgeUuid)));
}
}
return Optional.absent();
}
+
+ @SuppressWarnings("unchecked")
private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(
final ReadWriteTransaction transaction, Node node, String tpName) {
OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
List<ManagedNodeEntry> managedNodes = ovsdbNode.getManagedNodeEntry();
TpId tpId = new TpId(tpName);
for ( ManagedNodeEntry managedNodeEntry : managedNodes ) {
- @SuppressWarnings("unchecked")
- Node managedNode = readNode(transaction
- ,(InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue()).get();
+ Node managedNode = readNode(transaction,
+ (InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue()).get();
for (TerminationPoint tpEntry : managedNode.getTerminationPoint()) {
if (tpId.equals(tpEntry.getTpId())) {
return Optional.of((InstanceIdentifier<Node>)managedNodeEntry.getBridgeRef().getValue());
if (!vlanMode.isEmpty()) {
Iterator<String> itr = vlanMode.iterator();
String vlanType = itr.next();
- if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) {
+ if (vlanType.equals(SouthboundConstants.VlanModes.ACCESS.getMode())) {
ovsdbTerminationPointBuilder
.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
- } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) {
+ } else if (vlanType.equals(SouthboundConstants.VlanModes.NATIVE_TAGGED.getMode())) {
ovsdbTerminationPointBuilder
.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
- } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) {
+ } else if (vlanType.equals(SouthboundConstants.VlanModes.NATIVE_UNTAGGED.getMode())) {
ovsdbTerminationPointBuilder
.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
- } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) {
+ } else if (vlanType.equals(SouthboundConstants.VlanModes.TRUNK.getMode())) {
ovsdbTerminationPointBuilder
.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
} else {
}
}
- private void updateQos(final ReadWriteTransaction transaction, final Node node, InstanceIdentifier<TerminationPoint> tpPath,
- final Entry<UUID, Port> port, final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
+ @SuppressWarnings("unchecked")
+ private void updateQos(final ReadWriteTransaction transaction, final Node node,
+ InstanceIdentifier<TerminationPoint> tpPath, final Entry<UUID, Port> port,
+ final OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder) {
if (port.getValue() == null) {
return;
}
OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
// Delete an older QoS entry
- if (portOldRows.containsKey(port.getKey()) &&
- portOldRows.get(port.getKey()).getQosColumn() != null) {
+ if (portOldRows.containsKey(port.getKey()) && portOldRows.get(port.getKey()).getQosColumn() != null) {
Collection<UUID> oldQos = portOldRows.get(port.getKey()).getQosColumn().getData();
if (!oldQos.isEmpty()) {
UUID oldQosUuid = oldQos.iterator().next();
}
}
+ @SuppressWarnings("unchecked")
private InstanceIdentifier<QosEntries> getQosIid(NodeId nodeId, OvsdbNodeAugmentation ovsdbNode, UUID qosUuid) {
// Search for the QoS entry first in the operational datastore
for (QosEntries qosEntry : ovsdbNode.getQosEntries()) {
List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
for (String interfaceLldpKeyString : interfaceLldpMap.keySet()) {
String interfaceLldpValueString = interfaceLldpMap.get(interfaceLldpKeyString);
- if (interfaceLldpKeyString != null && interfaceLldpValueString!=null) {
+ if (interfaceLldpKeyString != null && interfaceLldpValueString != null) {
interfaceLldpList.add(new InterfaceLldpBuilder()
.setKey(new InterfaceLldpKey(interfaceLldpKeyString))
.setLldpKey(interfaceLldpKeyString)
List<InterfaceBfdStatus> interfaceBfdStatusList = new ArrayList<>();
for (String interfaceBfdStatusKeyString : interfaceBfdStatusMap.keySet()) {
String interfaceBfdStatusValueString = interfaceBfdStatusMap.get(interfaceBfdStatusKeyString);
- if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString!=null) {
+ if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString != null) {
interfaceBfdStatusList.add(new InterfaceBfdStatusBuilder()
.setKey(new InterfaceBfdStatusKey(interfaceBfdStatusKeyString))
.setBfdStatusKey(interfaceBfdStatusKeyString)
List<InterfaceBfd> interfaceBfdList = new ArrayList<>();
for (String interfaceBfdKeyString : interfaceBfdMap.keySet()) {
String interfaceBfdValueString = interfaceBfdMap.get(interfaceBfdKeyString);
- if (interfaceBfdKeyString != null && interfaceBfdValueString!=null) {
+ if (interfaceBfdKeyString != null && interfaceBfdValueString != null) {
interfaceBfdList.add(new InterfaceBfdBuilder()
.setKey(new InterfaceBfdKey(interfaceBfdKeyString))
.setBfdKey(interfaceBfdKeyString)
}
}
+ @SuppressWarnings("unchecked")
private InstanceIdentifier<TerminationPoint> getInstanceIdentifier(InstanceIdentifier<Node> bridgeIid,Port port) {
if (port.getExternalIdsColumn() != null
&& port.getExternalIdsColumn().getData() != null
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
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.Qos;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
+import org.opendaylight.ovsdb.schema.openvswitch.Qos;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbQosRemovedCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQueueUpdateCommand.class);
return null;
}
Iterator<QosEntries> itr = qosList.iterator();
- Uuid qUuid = new Uuid(qosUuid.toString());
+ Uuid quUuid = new Uuid(qosUuid.toString());
while (itr.hasNext()) {
QosEntries qos = itr.next();
- if (qos.getQosUuid().equals(qUuid)) {
+ if (qos.getQosUuid().equals(quUuid)) {
return qos.getKey();
}
}
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import java.util.Map.Entry;
-
+import java.util.Set;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
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.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
+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.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbQueueRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntries;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QosEntriesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.qos.entries.QosExternalIdsKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbQosUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQosUpdateCommand.class);
if (ovsdbNode.isPresent()) {
for (Entry<UUID, Qos> entry : updatedQosRows.entrySet()) {
Qos qos = entry.getValue();
- Qos oldQos = oldQosRows.get(entry.getKey());
QosEntriesBuilder qosEntryBuilder = new QosEntriesBuilder();
qosEntryBuilder.setQosId(new Uri(getQosId(qos)));
qosEntryBuilder.setQosUuid(new Uuid(entry.getKey().toString()));
qosEntryBuilder.setQosType(
SouthboundMapper.createQosType(qos.getTypeColumn().getData().toString()));
+ Qos oldQos = oldQosRows.get(entry.getKey());
setOtherConfig(transaction, qosEntryBuilder, oldQos, qos, nodeIId);
setExternalIds(transaction, qosEntryBuilder, oldQos, qos, nodeIId);
setQueueList(transaction, qosEntryBuilder, oldQos, qos, nodeIId, ovsdbNode.get());
}
}
+ @SuppressWarnings("unchecked")
private String getQosId(Qos qos) {
if (qos.getExternalIdsColumn() != null
&& qos.getExternalIdsColumn().getData() != null
&& qos.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
- InstanceIdentifier<QosEntries> qosIid = (InstanceIdentifier<QosEntries>) SouthboundUtil.deserializeInstanceIdentifier(
- qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
+ InstanceIdentifier<QosEntries> qosIid =
+ (InstanceIdentifier<QosEntries>) SouthboundUtil.deserializeInstanceIdentifier(
+ qos.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
if (qosIid != null) {
QosEntriesKey qosEntriesKey = qosIid.firstKeyOf(QosEntries.class);
if (qosEntriesKey != null) {
return SouthboundConstants.QOS_URI_PREFIX + "://" + qos.getUuid().toString();
}
- private Queue getQueue(UUID queueUuid)
- {
+ private Queue getQueue(UUID queueUuid) {
for (Entry<UUID, Queue> entry : updatedQueueRows.entrySet()) {
if (entry.getKey().equals(queueUuid)) {
return entry.getValue();
return null;
}
+ @SuppressWarnings("unchecked")
private InstanceIdentifier<Queues> getQueueIid(UUID queueUuid, Node ovsdbNode) {
Queue queue = getQueue(queueUuid);
if (queue != null && queue.getExternalIdsColumn() != null
for (Entry<Long, UUID> queueEntry : queueEntries) {
InstanceIdentifier<Queues> queueIid = getQueueIid(queueEntry.getValue(), ovsdbNode);
if (queueIid != null) {
- newQueueList.add(
+ newQueueList.add(
new QueueListBuilder()
.setQueueNumber(queueEntry.getKey())
.setQueueRef(new OvsdbQueueRef(queueIid))
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbQueueRemovedCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQueueUpdateCommand.class);
return null;
}
Iterator<Queues> itr = queueList.iterator();
- Uuid qUuid = new Uuid(queueUuid.toString());
+ Uuid quUuid = new Uuid(queueUuid.toString());
while (itr.hasNext()) {
Queues queue = itr.next();
- if (queue.getQueueUuid().equals(qUuid)) {
+ if (queue.getQueueUuid().equals(quUuid)) {
return queue.getKey();
}
}
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import java.util.Set;
import java.util.Map.Entry;
-
+import java.util.Set;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
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.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.Queues;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.QueuesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.queues.QueuesExternalIdsKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class OvsdbQueueUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbQueueUpdateCommand.class);
* </p>
*
* @param transaction the {@link ReadWriteTransaction}
- * @param updatedQueueRows updated {@link Queue} rows
-
*/
private void updateQueue(ReadWriteTransaction transaction) {
if (ovsdbNode.isPresent()) {
for (Entry<UUID, Queue> entry : updatedQueueRows.entrySet()) {
Queue queue = entry.getValue();
- Queue oldQueue = oldQueueRows.get(entry.getKey());
QueuesBuilder queuesBuilder = new QueuesBuilder();
queuesBuilder.setQueueId(new Uri(getQueueId(queue)));
queuesBuilder.setQueueUuid(new Uuid(entry.getKey().toString()));
if (!dscp.isEmpty()) {
queuesBuilder.setDscp(dscp.iterator().next().shortValue());
}
+ Queue oldQueue = oldQueueRows.get(entry.getKey());
setOtherConfig(transaction, queuesBuilder, oldQueue, queue, nodeIId);
setExternalIds(transaction, queuesBuilder, oldQueue, queue, nodeIId);
}
}
+ @SuppressWarnings("unchecked")
private String getQueueId(Queue queue) {
if (queue.getExternalIdsColumn() != null
&& queue.getExternalIdsColumn().getData() != null
&& queue.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) {
- InstanceIdentifier<Queues> queueIid = (InstanceIdentifier<Queues>) SouthboundUtil.deserializeInstanceIdentifier(
- queue.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
+ InstanceIdentifier<Queues> queueIid =
+ (InstanceIdentifier<Queues>) SouthboundUtil.deserializeInstanceIdentifier(
+ queue.getExternalIdsColumn().getData().get(SouthboundConstants.IID_EXTERNAL_ID_KEY));
if (queueIid != null) {
QueuesKey queuesKey = queueIid.firstKeyOf(Queues.class);
if (queuesKey != null) {
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
-
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-
public class TransactionInvokerImpl implements TransactionInvoker,TransactionChainListener, Runnable, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(TransactionInvokerImpl.class);
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.ovsdb.southbound.OvsdbSchemaContants.OVSDBSCHEMATABLES;
+import org.opendaylight.ovsdb.southbound.OvsdbSchemaContants.OvsdbSchemaTables;
public class OvsdbSchemaContantsTest {
}
@Test
public void testGetTableName() {
- assertEquals("Error getTableName() did not return correct value", "Open_vSwitch", OVSDBSCHEMATABLES.OPENVSWITCH.getTableName());
+ assertEquals("Error getTableName() did not return correct value", "Open_vSwitch", OvsdbSchemaTables.OPENVSWITCH.getTableName());
}
@Test
public void testGetParentTableName() {
- assertEquals("Error getTableName() did not return correct value", null, OVSDBSCHEMATABLES.OPENVSWITCH.getParentTableName());
+ assertEquals("Error getTableName() did not return correct value", null, OvsdbSchemaTables.OPENVSWITCH.getParentTableName());
}
@Test
public void testGetColumnNameInParentTable() {
- assertEquals("Error getTableName() did not return correct value", null, OVSDBSCHEMATABLES.OPENVSWITCH.getColumnNameInParentTable());
+ assertEquals("Error getTableName() did not return correct value", null, OvsdbSchemaTables.OPENVSWITCH.getColumnNameInParentTable());
}
}
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.mockito.stubbing.OngoingStubbing;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutation;
import org.opendaylight.ovsdb.lib.notation.Mutator;
Insert insert = mock(Insert.class);
when(insert.getUuidName()).thenReturn(UUID_NAME);
PowerMockito.mockStatic(SouthboundMapper.class);
- PowerMockito.when(SouthboundMapper.getRandomUUID()).thenReturn(UUID_NAME);
+ PowerMockito.when(SouthboundMapper.getRandomUuid()).thenReturn(UUID_NAME);
doNothing().when(insert).setUuidName(anyString());
UUID uuid = mock(UUID.class);
Code Review / ovsdb.git / commitdiff