</dependencies>
<configuration>
<configLocation>src/main/resources/ovsdb_checks.xml</configLocation>
+ <failsOnError>true</failsOnError>
<includes>**/*.java,**/*.xml,**/*.ini,**/*.sh,**/*.bat</includes>
<excludes>**/yang/,**/features/,**/integrationtest/,**/northbound/,
**/openstack/,**/ovs-sfc/,
**/ovsdb-plugin-compatibility-layer/,
- **/plugin/,**/plugin-shell/,**/schemas/,**/southbound/,**/utils/
+ **/plugin/,**/plugin-shell/,
+ **/schema/hardwarevtep/,**/schema/openvswitch/,
+ **/southbound/,**/utils/
</excludes>
</configuration>
</plugin>
<property name="charset" value="UTF-8"/>
<!-- Change to error to fail the build. Having severity here
ignores the FailsOnError setting in the pom.xml -->
- <property name="severity" value="warning"/>
+ <property name="severity" value="error"/>
<!-- Checks for whitespace -->
<!-- See http://checkstyle.sf.net/config_whitespace.html -->
<module name="SuppressWarningsFilter"/>
<module name="TreeWalker">
<module name="SuppressWarningsHolder"/>
+ <module name="UnusedImports"/>
<module name="OuterTypeFilename"/>
<module name="IllegalTokenText">
<property name="tokens" value="STRING_LITERAL, CHAR_LITERAL"/>
import java.util.List;
import org.opendaylight.ovsdb.lib.OvsdbClient;
-import org.opendaylight.ovsdb.lib.impl.OvsdbClientImpl;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import com.google.common.collect.Lists;
<artifactId>opendaylight-l2-types</artifactId>
</dependency>
</dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <configLocation>
+ ${project.basedir}/../../commons/parent/src/main/resources/ovsdb_checks.xml
+ </configLocation>
+ <failsOnError>true</failsOnError>
+ <includes>**/*.java,**/*.xml,**/*.ini,**/*.sh,**/*.bat</includes>
+ <excludes>**/yang/</excludes>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
</project>
<configLocation>
${project.basedir}/../../commons/parent/src/main/resources/ovsdb_checks.xml
</configLocation>
+ <failsOnError>true</failsOnError>
<includes>**/*.java,**/*.xml,**/*.ini,**/*.sh,**/*.bat</includes>
- <excludes>**/yang/,**/southbound/</excludes>
+ <excludes>**/yang/</excludes>
</configuration>
</plugin>
</plugins>
@Override
public boolean equals(Object obj) {
- if (this == obj)
+ if (this == obj) {
return true;
- if (obj == null)
+ }
+ if (obj == null) {
return false;
- if (getClass() != obj.getClass())
+ }
+ if (getClass() != obj.getClass()) {
return false;
+ }
OvsdbClientKey other = (OvsdbClientKey) obj;
if (ipaddress == null) {
- if (other.ipaddress != null)
+ if (other.ipaddress != null) {
return false;
- } else if (!ipaddress.equals(other.ipaddress))
+ }
+ } else if (!ipaddress.equals(other.ipaddress)) {
return false;
+ }
if (port == null) {
- if (other.port != null)
+ if (other.port != null) {
return false;
- } else if (!port.equals(other.port))
+ }
+ } else if (!port.equals(other.port)) {
return false;
+ }
return true;
}
import java.util.Set;
import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.EchoServiceCallbackFilters;
import org.opendaylight.ovsdb.lib.LockAquisitionCallback;
import org.opendaylight.ovsdb.lib.LockStolenCallback;
import org.opendaylight.ovsdb.lib.schema.TableSchema;
import org.opendaylight.ovsdb.lib.schema.typed.TypedBaseTable;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommand;
-import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommandAggregator;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactInvoker;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactInvokerImpl;
import org.opendaylight.ovsdb.southbound.transactions.md.OvsdbNodeCreateCommand;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionInvoker;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
public void transact(TransactCommand command) {
- for(TransactInvoker transactInvoker: transactInvokers.values()) {
+ for (TransactInvoker transactInvoker: transactInvokers.values()) {
transactInvoker.invoke(command);
}
}
this.callback = new OvsdbMonitorCallback(key,txInvoker);
try {
List<String> databases = getDatabases().get();
- if(databases != null) {
+ if (databases != null) {
for (String database : databases) {
DatabaseSchema dbSchema = getSchema(database).get();
- if(dbSchema != null) {
+ if (dbSchema != null) {
transactInvokers.put(dbSchema, new TransactInvokerImpl(this,dbSchema));
monitorAllTables(database, dbSchema);
} else {
private void monitorAllTables(String database, DatabaseSchema dbSchema) {
Set<String> tables = dbSchema.getTables();
- if(tables != null) {
+ if (tables != null) {
List<MonitorRequest<GenericTableSchema>> monitorRequests = Lists.newArrayList();
for (String tableName : tables) {
GenericTableSchema tableSchema = dbSchema.table(tableName, GenericTableSchema.class);
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.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.OvsdbNodeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
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 org.slf4j.Logger;
import com.google.common.util.concurrent.CheckedFuture;
public class OvsdbConnectionManager implements OvsdbConnectionListener, AutoCloseable {
- Map<OvsdbClientKey,OvsdbConnectionInstance> clients = new ConcurrentHashMap<OvsdbClientKey,OvsdbConnectionInstance>();
+ Map<OvsdbClientKey,OvsdbConnectionInstance> clients
+ = new ConcurrentHashMap<OvsdbClientKey,OvsdbConnectionInstance>();
private static final Logger LOG = LoggerFactory.getLogger(OvsdbConnectionManager.class);
private DataBroker db;
public OvsdbClient connect(OvsdbNodeAugmentation ovsdbNode) throws UnknownHostException {
// TODO handle case where we already have a connection
- // TODO use transaction chains to handle ordering issues between disconnected and connected when writing to the operational store
+ // TODO use transaction chains to handle ordering issues between disconnected
+ // and connected when writing to the operational store
InetAddress ip = SouthboundMapper.createInetAddress(ovsdbNode.getIp());
- OvsdbClient client = OvsdbConnectionService.getService().connect(ip, ovsdbNode.getPort().getValue().intValue());
- connected(client); // For connections from the controller to the ovs instance, the library doesn't call this method for us
+ OvsdbClient client = OvsdbConnectionService.getService().connect(ip,
+ ovsdbNode.getPort().getValue().intValue());
+ // For connections from the controller to the ovs instance, the library doesn't call
+ // this method for us
+ connected(client);
return client;
}
@Override
public void close() throws Exception {
- for(OvsdbClient client: clients.values()) {
+ for (OvsdbClient client: clients.values()) {
client.disconnect();
}
}
public OvsdbConnectionInstance getConnectionInstance(OvsdbBridgeAttributes mn) {
Optional<OvsdbNodeAugmentation> optional = SouthboundUtil.getManagingNode(db, mn);
- if(optional.isPresent()) {
+ if (optional.isPresent()) {
return getConnectionInstance(optional.get());
} else {
return null;
Preconditions.checkNotNull(node);
OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
OvsdbBridgeAugmentation ovsdbManagedNode = node.getAugmentation(OvsdbBridgeAugmentation.class);
- if(ovsdbNode != null) {
+ if (ovsdbNode != null) {
return getConnectionInstance(ovsdbNode);
} else if (ovsdbManagedNode != null) {
return getConnectionInstance(ovsdbManagedNode);
}
public OvsdbConnectionInstance getConnectionInstance(InstanceIdentifier<Node> nodePath) {
- try{
+ try {
ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = transaction.read(LogicalDatastoreType.OPERATIONAL, nodePath);
+ CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = transaction.read(
+ LogicalDatastoreType.OPERATIONAL, nodePath);
transaction.close();
Optional<Node> optional = nodeFuture.get();
- if(optional != null && optional.isPresent() && optional.get() instanceof Node) {
+ if (optional != null && optional.isPresent() && optional.get() instanceof Node) {
return this.getConnectionInstance(optional.get());
} else {
LOG.warn("Found non-topological node {} on path {}",optional);
return null;
}
- }catch (Exception e) {
+ } catch (Exception e) {
LOG.warn("Failed to get Ovsdb Node {}",nodePath, e);
return null;
}
import org.slf4j.LoggerFactory;
import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
-import com.google.common.collect.FluentIterable;
import com.google.common.collect.Maps;
public class OvsdbManagedNodeDataChangeListener implements DataChangeListener, AutoCloseable {
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
.child(Node.class)
.augmentation(OvsdbBridgeAugmentation.class);
- registration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, path, this, DataChangeScope.ONE);
+ registration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ path, this, DataChangeScope.ONE);
}
@Override
public void onDataChanged(
AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
- LOG.info("Received change to ovsdbManagedNode: {}", changes);
- for(OvsdbConnectionInstance connectionInstance: connectionInstancesFromChanges(changes)) {
- connectionInstance.transact(new TransactCommandAggregator(
- db,
- new DataChangesManagedByOvsdbNodeEvent(
- SouthboundMapper.createInstanceIdentifier(connectionInstance.getKey()),
- changes)));
- }
+ LOG.info("Received change to ovsdbManagedNode: {}", changes);
+ for (OvsdbConnectionInstance connectionInstance : connectionInstancesFromChanges(changes)) {
+ connectionInstance.transact(new TransactCommandAggregator(
+ db,
+ new DataChangesManagedByOvsdbNodeEvent(
+ SouthboundMapper.createInstanceIdentifier(connectionInstance.getKey()),
+ changes)));
+ }
}
- public Set<OvsdbConnectionInstance> connectionInstancesFromChanges(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
+ public Set<OvsdbConnectionInstance> connectionInstancesFromChanges(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
Set<OvsdbConnectionInstance> result = new HashSet<OvsdbConnectionInstance>();
result.addAll(connectionInstancesFromMap(changes.getCreatedData()));
result.addAll(connectionInstancesFromMap(changes.getUpdatedData()));
public Set<OvsdbConnectionInstance> connectionInstancesFromMap(Map<InstanceIdentifier<?>, DataObject> map) {
Preconditions.checkNotNull(map);
Set<OvsdbConnectionInstance> result = new HashSet<OvsdbConnectionInstance>();
- for( Entry<InstanceIdentifier<?>, DataObject> created : map.entrySet()) {
- if(created.getValue() instanceof OvsdbBridgeAugmentation) {
+ for ( Entry<InstanceIdentifier<?>, DataObject> created : map.entrySet()) {
+ if (created.getValue() instanceof OvsdbBridgeAugmentation) {
LOG.debug("Received request to create {}",created.getValue());
OvsdbConnectionInstance client = cm.getConnectionInstance((OvsdbBridgeAugmentation)created.getValue());
- if(client != null) {
+ if (client != null) {
LOG.debug("Found client for {}", created.getValue());
result.add(client);
} else {
}
@Override
- public void exception(Throwable t) {
- LOG.warn("exception {}",t);
+ public void exception(Throwable exception) {
+ LOG.warn("exception {}", exception);
}
}
}
Map<InstanceIdentifier<?>, DataObject> originalDataObject = changes.getOriginalData();
- Set<InstanceIdentifier<?>> iID = changes.getRemovedPaths();
- for (InstanceIdentifier instanceIdentifier : iID) {
+ Set<InstanceIdentifier<?>> iiD = changes.getRemovedPaths();
+ for (InstanceIdentifier instanceIdentifier : iiD) {
if (originalDataObject.get(instanceIdentifier) instanceof OvsdbNodeAugmentation) {
try {
cm.disconnect((OvsdbNodeAugmentation) originalDataObject.get(instanceIdentifier));
private final String parentTableName;
private final String columnNameInParentTable;
- private OVSDBSCHEMATABLES(final String tableName, final String parentTableName, final String columnNameInParentTable){
+ private OVSDBSCHEMATABLES(final String tableName, final String parentTableName,
+ final String columnNameInParentTable) {
this.tableName = tableName;
this.parentTableName = parentTableName;
this.columnNameInParentTable = columnNameInParentTable;
}
- public String getTableName(){
+ public String getTableName() {
return this.tableName;
}
- public String getParentTableName(){
+ public String getParentTableName() {
return this.parentTableName;
}
- public String getColumnNameInParentTable(){
+ public String getColumnNameInParentTable() {
return this.columnNameInParentTable;
}
}
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.ovsdb.southbound.ovsdb.transact.DataChangesManagedByOvsdbNodeEvent;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.DataChangesTerminationPointEvent;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TerminationPointCreateCommand;
-import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommandAggregator;
-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.OvsdbTerminationPointAugmentation;
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.network.topology.Topology;
.child(Node.class)
.child(TerminationPoint.class)
.augmentation(OvsdbTerminationPointAugmentation.class);
- registration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, path, this, DataChangeScope.ONE);
+ registration = db.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
+ path, this, DataChangeScope.ONE);
}
@Override
public void onDataChanged(
AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
- LOG.info("Received change to ovsdbTerminationPoint: {}", changes);
- for( Entry<InstanceIdentifier<?>, DataObject> created : changes.getCreatedData().entrySet()) {
- // TODO validate we have the correct kind of InstanceIdentifier
- if(created.getValue() instanceof OvsdbTerminationPointAugmentation) {
- InstanceIdentifier<Node> nodePath = created.getKey().firstIdentifierOf(Node.class);
- LOG.debug("Received request to create {}",created.getValue());
- OvsdbConnectionInstance client = cm.getConnectionInstance(nodePath);
- if(client != null) {
- LOG.debug("Found client for {}", created.getValue());
- client.transact(new TerminationPointCreateCommand(
- new DataChangesTerminationPointEvent(
- SouthboundMapper.createInstanceIdentifier(client.getKey()),changes)));
- } else {
- LOG.debug("Did not find client for {}",created.getValue());
- }
- }
- }
+ LOG.info("Received change to ovsdbTerminationPoint: {}", changes);
+ for (Entry<InstanceIdentifier<?>, DataObject> created : changes.getCreatedData().entrySet()) {
+ // TODO validate we have the correct kind of InstanceIdentifier
+ if (created.getValue() instanceof OvsdbTerminationPointAugmentation) {
+ InstanceIdentifier<Node> nodePath = created.getKey().firstIdentifierOf(Node.class);
+ LOG.debug("Received request to create {}",created.getValue());
+ OvsdbConnectionInstance client = cm.getConnectionInstance(nodePath);
+ if (client != null) {
+ LOG.debug("Found client for {}", created.getValue());
+ client.transact(new TerminationPointCreateCommand(
+ new DataChangesTerminationPointEvent(
+ SouthboundMapper.createInstanceIdentifier(client.getKey()),changes)));
+ } else {
+ LOG.debug("Did not find client for {}",created.getValue());
+ }
+ }
+ }
// TODO validate we have the correct kind of InstanceIdentifier
// TODO handle case of updates to ovsdb ports as needed
public static final String BRIDGE_URI_PREFIX = "bridge";
public static final String TP_URI_PREFIX = "terminationpoint";
public static final Integer DEFAULT_OVSDB_PORT = 6640;
- public static final ImmutableBiMap<Class<? extends OvsdbBridgeProtocolBase>,String> OVSDB_PROTOCOL_MAP = new ImmutableBiMap.Builder<Class<? extends OvsdbBridgeProtocolBase>,String>()
+ public static final ImmutableBiMap<Class<? extends OvsdbBridgeProtocolBase>,String> OVSDB_PROTOCOL_MAP
+ = new ImmutableBiMap.Builder<Class<? extends OvsdbBridgeProtocolBase>,String>()
.put(OvsdbBridgeProtocolOpenflow10.class,"OpenFlow10")
.put(OvsdbBridgeProtocolOpenflow11.class,"OpenFlow11")
.put(OvsdbBridgeProtocolOpenflow12.class,"OpenFlow12")
.put(OvsdbBridgeProtocolOpenflow15.class,"OpenFlow15")
.build();
- public static final ImmutableBiMap<Class<? extends OvsdbFailModeBase>,String> OVSDB_FAIL_MODE_MAP = new ImmutableBiMap.Builder<Class<? extends OvsdbFailModeBase>,String>()
+ public static final ImmutableBiMap<Class<? extends OvsdbFailModeBase>,String> OVSDB_FAIL_MODE_MAP
+ = new ImmutableBiMap.Builder<Class<? extends OvsdbFailModeBase>,String>()
.put(OvsdbFailModeStandalone.class,"standalone")
.put(OvsdbFailModeSecure.class,"secure")
.build();
- public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP = new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
+ public static final ImmutableBiMap<String, Class<? extends InterfaceTypeBase>> OVSDB_INTERFACE_TYPE_MAP
+ = new ImmutableBiMap.Builder<String, Class<? extends InterfaceTypeBase>>()
.put("internal", InterfaceTypeInternal.class)
.put("vxlan", InterfaceTypeVxlan.class)
.put("patch", InterfaceTypePatch.class)
.put("dpdkvhost", InterfaceTypeDpdkvhost.class)
.build();
- public static final ImmutableBiMap<Class<? extends DatapathTypeBase>,String> DATAPATH_TYPE_MAP = new ImmutableBiMap.Builder<Class<? extends DatapathTypeBase>,String>()
+ public static final ImmutableBiMap<Class<? extends DatapathTypeBase>,String> DATAPATH_TYPE_MAP
+ = new ImmutableBiMap.Builder<Class<? extends DatapathTypeBase>,String>()
.put(DatapathTypeSystem.class,"system")
.put(DatapathTypeNetdev.class,"netdev")
.build();
public static IpAddress createIpAddress(InetAddress address) {
IpAddress ip = null;
- if(address instanceof Inet4Address) {
+ if (address instanceof Inet4Address) {
ip = createIpAddress((Inet4Address)address);
} else if (address instanceof Inet6Address) {
ip = createIpAddress((Inet6Address)address);
public static NodeId createManagedNodeId(IpAddress ip, PortNumber port, OvsdbBridgeName bridgeName) {
return new NodeId(createNodeId(ip,port).getValue()
- + "/"+SouthboundConstants.BRIDGE_URI_PREFIX+"/"+ bridgeName.getValue());
+ + "/" + SouthboundConstants.BRIDGE_URI_PREFIX + "/" + bridgeName.getValue());
}
public static NodeId createNodeId(IpAddress ip, PortNumber port) {
- String uriString = SouthboundConstants.OVSDB_URI_PREFIX + "://" + new String(ip.getValue()) +
- ":" + port.getValue();
+ String uriString = SouthboundConstants.OVSDB_URI_PREFIX + "://"
+ + new String(ip.getValue()) + ":" + port.getValue();
Uri uri = new Uri(uriString);
NodeId nodeId = new NodeId(uri);
return nodeId;
}
- public static TpId createTerminationPointId(OvsdbConnectionInfo connectionInfo, OvsdbBridgeName bridgeName, String tpName) {
+ public static TpId createTerminationPointId(OvsdbConnectionInfo connectionInfo,
+ OvsdbBridgeName bridgeName, String tpName) {
return createTerminationPointId(createIpAddress(connectionInfo.getRemoteAddress()),
new PortNumber(connectionInfo.getRemotePort()),
bridgeName, tpName);
return createTerminationPointId(key.getIp(),key.getPort(),bridgeName, tpName);
}
- public static TpId createTerminationPointId(IpAddress ip, PortNumber port, OvsdbBridgeName bridgeName, String tpName) {
+ public static TpId createTerminationPointId(IpAddress ip, PortNumber port,
+ OvsdbBridgeName bridgeName, String tpName) {
return new TpId(createNodeId(ip,port).getValue()
- + "/"+SouthboundConstants.BRIDGE_URI_PREFIX+"/"+ bridgeName.getValue()
- + "/"+SouthboundConstants.TP_URI_PREFIX+"/"+ tpName);
+ + "/" + SouthboundConstants.BRIDGE_URI_PREFIX + "/" + bridgeName.getValue()
+ + "/" + SouthboundConstants.TP_URI_PREFIX + "/" + tpName);
}
public static InetAddress createInetAddress(IpAddress ip) throws UnknownHostException {
- if(ip.getIpv4Address() != null) {
+ if (ip.getIpv4Address() != null) {
return InetAddress.getByName(ip.getIpv4Address().getValue());
- } else if(ip.getIpv6Address() != null) {
+ } else if (ip.getIpv6Address() != null) {
return InetAddress.getByName(ip.getIpv6Address().getValue());
} else {
throw new UnknownHostException("IP Address has no value");
public static DatapathId createDatapathId(Bridge bridge) {
Preconditions.checkNotNull(bridge);
- if(bridge.getDatapathIdColumn() == null) {
+ if (bridge.getDatapathIdColumn() == null) {
return null;
} else {
return createDatapathId(bridge.getDatapathIdColumn().getData());
public static DatapathId createDatapathId(Set<String> dpids) {
Preconditions.checkNotNull(dpids);
- if(dpids.isEmpty()) {
+ if (dpids.isEmpty()) {
return null;
} else {
String[] dpidArray = new String[dpids.size()];
if (SouthboundConstants.DATAPATH_TYPE_MAP.get(mdsalbridge.getDatapathType()) != null) {
datapathtype = SouthboundConstants.DATAPATH_TYPE_MAP.get(mdsalbridge.getDatapathType());
} else {
- throw new IllegalArgumentException("Unknown datapath type " + SouthboundConstants.DATAPATH_TYPE_MAP.get(mdsalbridge.getDatapathType()));
+ throw new IllegalArgumentException("Unknown datapath type "
+ + SouthboundConstants.DATAPATH_TYPE_MAP.get(mdsalbridge.getDatapathType()));
}
}
return datapathtype;
public static Class<? extends DatapathTypeBase> createDatapathType(String type) {
Preconditions.checkNotNull(type);
if (type.isEmpty()) {
- return DatapathTypeSystem.class;
+ return DatapathTypeSystem.class;
} else {
- ImmutableBiMap<String, Class<? extends DatapathTypeBase>> mapper = SouthboundConstants.DATAPATH_TYPE_MAP.inverse();
+ ImmutableBiMap<String, Class<? extends DatapathTypeBase>> mapper =
+ SouthboundConstants.DATAPATH_TYPE_MAP.inverse();
return mapper.get(type);
}
}
public static DatapathId createDatapathId(String dpid) {
Preconditions.checkNotNull(dpid);
DatapathId datapath;
- if(dpid.matches("^[0-9a-fA-F]{16}")) {
+ 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)));
public static Set<String> createOvsdbBridgeProtocols(OvsdbBridgeAugmentation ovsdbBridgeNode) {
Set<String> protocols = new HashSet<String>();
- if(ovsdbBridgeNode.getProtocolEntry() != null && ovsdbBridgeNode.getProtocolEntry().size() > 0) {
- for(ProtocolEntry protocol : ovsdbBridgeNode.getProtocolEntry()) {
- if(SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol()) != null) {
+ if (ovsdbBridgeNode.getProtocolEntry() != null && ovsdbBridgeNode.getProtocolEntry().size() > 0) {
+ for (ProtocolEntry protocol : ovsdbBridgeNode.getProtocolEntry()) {
+ if (SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol()) != null) {
protocols.add(SouthboundConstants.OVSDB_PROTOCOL_MAP.get(protocol.getProtocol()));
} else {
throw new IllegalArgumentException("Unknown protocol " + protocol.getProtocol());
public static String createOvsdbInterfaceType(Class<? extends InterfaceTypeBase> mdsaltype) {
Preconditions.checkNotNull(mdsaltype);
- ImmutableBiMap<Class<? extends InterfaceTypeBase>, String> mapper = SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.inverse();
+ ImmutableBiMap<Class<? extends InterfaceTypeBase>, String> mapper =
+ SouthboundConstants.OVSDB_INTERFACE_TYPE_MAP.inverse();
return mapper.get(mdsaltype);
}
public static List<ProtocolEntry> createMdsalProtocols(Bridge bridge) {
Set<String> protocols = bridge.getProtocolsColumn().getData();
List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
- if(protocols != null && protocols.size() >0) {
- ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper = SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
- for(String protocol : protocols) {
- if(protocol != null && mapper.get(protocol) != null) {
- protocolList.add(new ProtocolEntryBuilder().setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get(protocol)).build());
+ if (protocols != null && protocols.size() > 0) {
+ ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
+ SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
+ for (String protocol : protocols) {
+ if (protocol != null && mapper.get(protocol) != null) {
+ protocolList.add(new ProtocolEntryBuilder().
+ setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get(protocol)).build());
}
}
}
return protocolList;
}
- public static List<ControllerEntry> createControllerEntries(Bridge bridge,Map<UUID,Controller> updatedControllerRows) {
+ public static List<ControllerEntry> createControllerEntries(Bridge bridge,Map<UUID,
+ Controller> updatedControllerRows) {
LOG.debug("Bridge: {}, updatedControllerRows: {}",bridge,updatedControllerRows);
Set<UUID> controllerUUIDs = bridge.getControllerColumn().getData();
List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
- for(UUID controllerUUID : controllerUUIDs ) {
+ for (UUID controllerUUID : controllerUUIDs ) {
Controller controller = updatedControllerRows.get(controllerUUID);
- if(controller != null && controller.getTargetColumn() != null
+ if (controller != null && controller.getTargetColumn() != null
&& controller.getTargetColumn() != null) {
String targetString = controller.getTargetColumn().getData();
controllerEntries.add(new ControllerEntryBuilder().setTarget(new Uri(targetString)).build());
public static Map<UUID, Controller> createOvsdbController(OvsdbBridgeAugmentation omn,DatabaseSchema dbSchema) {
List<ControllerEntry> controllerEntries = omn.getControllerEntry();
Map<UUID,Controller> controllerMap = new HashMap<UUID,Controller>();
- if(controllerEntries != null && !controllerEntries.isEmpty()) {
+ if (controllerEntries != null && !controllerEntries.isEmpty()) {
int index = 0;
- for(ControllerEntry controllerEntry : controllerEntries) {
+ for (ControllerEntry controllerEntry : controllerEntries) {
String controllerNamedUUID = "Controller_" + omn.getBridgeName().getValue() + index++;
Controller controller = TyperUtils.getTypedRowWrapper(dbSchema, Controller.class);
controller.setTarget(controllerEntry.getTarget().getValue());
initializeTopology(transaction,type);
CheckedFuture<Optional<Topology>, ReadFailedException> ovsdbTp = transaction.read(type, path);
try {
- if(!ovsdbTp.get().isPresent()) {
+ if (!ovsdbTp.get().isPresent()) {
TopologyBuilder tpb = new TopologyBuilder();
tpb.setTopologyId(SouthboundConstants.OVSDB_TOPOLOGY_ID);
transaction.put(type, path, tpb.build());
}
}
- private void initializeTopology(ReadWriteTransaction t, LogicalDatastoreType type) {
- InstanceIdentifier<NetworkTopology> path = InstanceIdentifier
- .create(NetworkTopology.class);
- CheckedFuture<Optional<NetworkTopology>, ReadFailedException> tp = t.read(type,path);
- try {
- if(!tp.get().isPresent()) {
- NetworkTopologyBuilder ntb = new NetworkTopologyBuilder();
- t.put(type,path,ntb.build());
- }
- } catch (Exception e) {
- LOG.error("Error initializing ovsdb topology {}",e);
- }
+ private void initializeTopology(ReadWriteTransaction transaction, LogicalDatastoreType type) {
+ InstanceIdentifier<NetworkTopology> path = InstanceIdentifier.create(NetworkTopology.class);
+ CheckedFuture<Optional<NetworkTopology>, ReadFailedException> topology = transaction.read(type,path);
+ try {
+ if (!topology.get().isPresent()) {
+ NetworkTopologyBuilder ntb = new NetworkTopologyBuilder();
+ transaction.put(type,path,ntb.build());
+ }
+ } catch (Exception e) {
+ LOG.error("Error initializing ovsdb topology {}",e);
+ }
}
}
Preconditions.checkNotNull(mn);
try {
OvsdbNodeRef ref = mn.getManagedBy();
- if(ref != null && ref.getValue() != null) {
+ if (ref != null && ref.getValue() != null) {
ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
@SuppressWarnings("unchecked") // Note: erasure makes this safe in combination with the typecheck below
InstanceIdentifier<Node> path = (InstanceIdentifier<Node>) ref.getValue();
- CheckedFuture<Optional<Node>, ReadFailedException> nf = transaction.read(LogicalDatastoreType.OPERATIONAL, path);
+ CheckedFuture<Optional<Node>, ReadFailedException> nf = transaction.read(
+ LogicalDatastoreType.OPERATIONAL, path);
transaction.close();
Optional<Node> optional = nf.get();
- if(optional != null && optional.isPresent() && optional.get() instanceof Node) {
+ if (optional != null && optional.isPresent() && optional.get() instanceof Node) {
OvsdbNodeAugmentation ovsdbNode = optional.get().getAugmentation(OvsdbNodeAugmentation.class);
- if(ovsdbNode !=null) {
+ if (ovsdbNode != null) {
return Optional.of(ovsdbNode);
} else {
- LOG.warn("OvsdbManagedNode {} claims to be managed by {} but that OvsdbNode does not exist",mn,ref.getValue());
+ LOG.warn("OvsdbManagedNode {} claims to be managed by {} but "
+ + "that OvsdbNode does not exist", mn,ref.getValue());
return Optional.absent();
}
} else {
LOG.warn("Cannot find client for OvsdbManagedNode without a specified ManagedBy {}",mn);
return Optional.absent();
}
- } catch (Exception e) {
- LOG.warn("Failed to get OvsdbNode that manages OvsdbManagedNode {}",mn, e);
- return Optional.absent();
- }
+ } catch (Exception e) {
+ LOG.warn("Failed to get OvsdbNode that manages OvsdbManagedNode {}", mn, e);
+ return Optional.absent();
+ }
}
}
@Override
public void execute(TransactionBuilder transaction) {
- Map<InstanceIdentifier<Node>, OvsdbBridgeAugmentation> created = TransactUtils.extractOvsdbManagedNodeCreate(changes);
- for(OvsdbBridgeAugmentation ovsdbManagedNode: created.values()) {
+ Map<InstanceIdentifier<Node>, OvsdbBridgeAugmentation> created
+ = TransactUtils.extractOvsdbManagedNodeCreate(changes);
+ for (OvsdbBridgeAugmentation ovsdbManagedNode: created.values()) {
LOG.debug("Received request to create ovsdb bridge name: {} uuid: {}",
ovsdbManagedNode.getBridgeName(),
ovsdbManagedNode.getBridgeUuid());
// Bridge part
Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class);
bridge.setName(ovsdbManagedNode.getBridgeName().getValue());
- if(ovsdbManagedNode.getFailMode() != null &&
- SouthboundConstants.OVSDB_FAIL_MODE_MAP.get(ovsdbManagedNode.getFailMode()) != null ) {
- bridge.setFailMode(Sets.newHashSet(SouthboundConstants.OVSDB_FAIL_MODE_MAP.get(ovsdbManagedNode.getFailMode())));
+ if (ovsdbManagedNode.getFailMode() != null
+ && SouthboundConstants.OVSDB_FAIL_MODE_MAP.get(ovsdbManagedNode.getFailMode()) != null ) {
+ bridge.setFailMode(Sets.newHashSet(
+ SouthboundConstants.OVSDB_FAIL_MODE_MAP.get(ovsdbManagedNode.getFailMode())));
}
bridge.setDatapathType(SouthboundMapper.createDatapathType(ovsdbManagedNode));
- if(SouthboundMapper.createOvsdbBridgeProtocols(ovsdbManagedNode) != null
- && SouthboundMapper.createOvsdbBridgeProtocols(ovsdbManagedNode).size() > 0){
+ if (SouthboundMapper.createOvsdbBridgeProtocols(ovsdbManagedNode) != null
+ && SouthboundMapper.createOvsdbBridgeProtocols(ovsdbManagedNode).size() > 0) {
bridge.setProtocols(SouthboundMapper.createOvsdbBridgeProtocols(ovsdbManagedNode));
}
- Map<UUID,Controller> controllerMap = SouthboundMapper.createOvsdbController(ovsdbManagedNode, transaction.getDatabaseSchema());
- for(Entry<UUID,Controller >entry: controllerMap.entrySet()) {
+ Map<UUID,Controller> controllerMap = SouthboundMapper.createOvsdbController(
+ ovsdbManagedNode, transaction.getDatabaseSchema());
+ for (Entry<UUID,Controller> entry: controllerMap.entrySet()) {
transaction.add(op.insert(entry.getValue()).withId(entry.getKey().toString()));
}
- if(!controllerMap.isEmpty()) {
+ if (!controllerMap.isEmpty()) {
bridge.setController(controllerMap.keySet());
}
bridge.setPorts(Sets.newHashSet(new UUID(portNamedUuid)));
ovs.setBridges(Sets.newHashSet(new UUID(bridgeNamedUuid)));
transaction.add(op.mutate(ovs).addMutation(ovs.getBridgesColumn().getSchema(),
Mutator.INSERT,
- ovs.getBridgesColumn().getData())
- );
+ ovs.getBridgesColumn().getData()));
}
}
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
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.notation.Column;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
-import org.opendaylight.ovsdb.lib.schema.ColumnSchema;
-import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
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.Augmentable;
-import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.CheckedFuture;
-public class BridgeRemovedCommand implements TransactCommand{
+public class BridgeRemovedCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(BridgeRemovedCommand.class);
private AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes;
private DataBroker db;
- public BridgeRemovedCommand(DataBroker db,AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ public BridgeRemovedCommand(DataBroker db, AsyncDataChangeEvent<InstanceIdentifier<?>,
+ OvsdbBridgeAugmentation> changes) {
this.db = db;
this.changes = changes;
}
@Override
public void execute(TransactionBuilder transaction) {
Set<InstanceIdentifier<Node>> removed = TransactUtils.extractOvsdbManagedNodeRemoved(changes);
- Map<InstanceIdentifier<Node>, OvsdbBridgeAugmentation> originals = TransactUtils.extractOvsdbManagedNodeOriginal(changes);
- for(InstanceIdentifier<Node> ovsdbManagedNodeIid: removed) {
+ Map<InstanceIdentifier<Node>, OvsdbBridgeAugmentation> originals
+ = TransactUtils.extractOvsdbManagedNodeOriginal(changes);
+ for (InstanceIdentifier<Node> ovsdbManagedNodeIid: removed) {
LOG.info("Received request to delete ovsdb node {}",ovsdbManagedNodeIid);
OvsdbBridgeAugmentation original = originals.get(ovsdbManagedNodeIid);
Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class,null);
Optional<UUID> bridgeUuidOptional = getBridgeUUID(ovsdbManagedNodeIid);
- if(bridgeUuidOptional.isPresent()) {
+ if (bridgeUuidOptional.isPresent()) {
UUID bridgeUuid = bridgeUuidOptional.get();
- OpenVSwitch ovs = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), OpenVSwitch.class,null);
+ OpenVSwitch ovs = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(),
+ OpenVSwitch.class,null);
transaction.add(op.delete(bridge.getSchema())
.where(bridge.getUuidColumn().getSchema().opEqual(bridgeUuid)).build());
transaction.add(op.comment("Bridge: Deleting " + original.getBridgeName()));
.addMutation(ovs.getBridgesColumn().getSchema(), Mutator.DELETE,
Sets.newHashSet(bridgeUuid)));
transaction.add(op.comment("Open_vSwitch: Mutating " + original.getBridgeName() + " " + bridgeUuid));
- } else {
- LOG.warn("Unable to delete bridge {} because it was not found in the operational store, and thus we cannot retrieve its UUID", ovsdbManagedNodeIid);
- }
+ } else {
+ LOG.warn("Unable to delete bridge {} because it was not found in the operational store, "
+ + "and thus we cannot retrieve its UUID", ovsdbManagedNodeIid);
+ }
}
}
private Optional<UUID> getBridgeUUID(InstanceIdentifier<Node> ovsdbManagedNodeIid) {
Optional<UUID> result = Optional.absent();
ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- CheckedFuture<Optional<Node>, ReadFailedException> future = transaction.read(LogicalDatastoreType.OPERATIONAL, ovsdbManagedNodeIid);
+ CheckedFuture<Optional<Node>, ReadFailedException> future
+ = transaction.read(LogicalDatastoreType.OPERATIONAL, ovsdbManagedNodeIid);
Optional<Node> optional;
try {
optional = future.get();
- if(optional.isPresent()) {
+ if (optional.isPresent()) {
OvsdbBridgeAugmentation bridge = (OvsdbBridgeAugmentation) optional.get();
- if(bridge != null && bridge.getBridgeUuid() != null) {
+ if (bridge != null && bridge.getBridgeUuid() != null) {
result = Optional.of(new UUID(bridge.getBridgeUuid().getValue()));
}
}
private Set<InstanceIdentifier<?>> removedPaths = null;
private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> originalData;
- public DataChangesManagedByOvsdbNodeEvent(InstanceIdentifier<?> iid, AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
+ public DataChangesManagedByOvsdbNodeEvent(InstanceIdentifier<?> iid,
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
this.iid = iid;
this.event = event;
}
- private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> filter(Map<InstanceIdentifier<?>, DataObject> data) {
- Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> result = new HashMap<InstanceIdentifier<?>, OvsdbBridgeAugmentation>();
- for(Entry<InstanceIdentifier<?>, DataObject> created: data.entrySet()) {
- if(created.getValue() != null
+ private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> filter(Map<InstanceIdentifier<?>,
+ DataObject> data) {
+ Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> result
+ = new HashMap<InstanceIdentifier<?>, OvsdbBridgeAugmentation>();
+ for (Entry<InstanceIdentifier<?>, DataObject> created: data.entrySet()) {
+ if (created.getValue() != null
&& created.getValue() instanceof OvsdbBridgeAugmentation
&& ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy() != null
&& ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy().getValue() != null
@Override
public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getCreatedData() {
- if(this.createdData == null) {
+ if (this.createdData == null) {
this.createdData = filter(event.getCreatedData());
}
return this.createdData;
@Override
public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getUpdatedData() {
- if(this.updatedData == null) {
+ if (this.updatedData == null) {
this.updatedData = filter(event.getUpdatedData());
}
return this.updatedData;
@Override
public Set<InstanceIdentifier<?>> getRemovedPaths() {
- if(this.removedPaths == null) {
+ if (this.removedPaths == null) {
this.removedPaths = new HashSet<InstanceIdentifier<?>>();
- for(InstanceIdentifier<?> path: event.getRemovedPaths()) {
+ for (InstanceIdentifier<?> path: event.getRemovedPaths()) {
DataObject original = this.event.getOriginalData().get(path);
- if(original != null
+ if (original != null
&& original instanceof OvsdbBridgeAugmentation) {
OvsdbBridgeAugmentation ovsdbBridgeNode = (OvsdbBridgeAugmentation)original;
OvsdbNodeRef ovsdbNodeRef = ovsdbBridgeNode.getManagedBy();
- if(ovsdbNodeRef != null) {
+ if (ovsdbNodeRef != null) {
InstanceIdentifier<?> ovsdbNodeIid = ovsdbNodeRef.getValue();
- if(ovsdbNodeIid.equals(this.iid)){
+ if (ovsdbNodeIid.equals(this.iid)) {
this.removedPaths.add(path);
}
}
@Override
public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getOriginalData() {
- if(this.originalData == null) {
+ if (this.originalData == null) {
this.originalData = filter(event.getOriginalData());
}
return this.originalData;
@Override
public OvsdbBridgeAugmentation getOriginalSubtree() {
- if(this.event.getOriginalSubtree() instanceof OvsdbBridgeAugmentation) {
+ if (this.event.getOriginalSubtree() instanceof OvsdbBridgeAugmentation) {
return (OvsdbBridgeAugmentation)this.event.getOriginalSubtree();
} else {
return null;
@Override
public OvsdbBridgeAugmentation getUpdatedSubtree() {
- if(this.event.getUpdatedSubtree() instanceof OvsdbBridgeAugmentation) {
+ if (this.event.getUpdatedSubtree() instanceof OvsdbBridgeAugmentation) {
return (OvsdbBridgeAugmentation)this.event.getUpdatedSubtree();
} else {
return null;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class DataChangesTerminationPointEvent implements AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation>{
+public class DataChangesTerminationPointEvent implements AsyncDataChangeEvent<InstanceIdentifier<?>,
+ OvsdbTerminationPointAugmentation> {
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event;
private InstanceIdentifier<?> iid;
private Set<InstanceIdentifier<?>> removedPaths = null;
private Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> originalData;
- public DataChangesTerminationPointEvent(InstanceIdentifier<?> iid, AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
+ public DataChangesTerminationPointEvent(InstanceIdentifier<?> iid,
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
this.iid = iid;
this.event = event;
}
- private Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> filter(Map<InstanceIdentifier<?>, DataObject> data) {
- Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> result = new HashMap<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation>();
- for(Entry<InstanceIdentifier<?>, DataObject> created: data.entrySet()) {
- if(created.getValue() != null
+ private Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> filter(Map<InstanceIdentifier<?>,
+ DataObject> data) {
+ Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> result
+ = new HashMap<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation>();
+ for (Entry<InstanceIdentifier<?>, DataObject> created: data.entrySet()) {
+ if (created.getValue() != null
&& created.getValue() instanceof OvsdbTerminationPointAugmentation
&& ((OvsdbTerminationPointAugmentation)created.getValue()).getAttachedTo() != null
&& ((OvsdbTerminationPointAugmentation)created.getValue()).getAttachedTo().getValue() != null) {
@Override
public Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> getCreatedData() {
- if(this.createdData == null) {
+ if (this.createdData == null) {
this.createdData = filter(event.getCreatedData());
}
return this.createdData;
@Override
public Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> getUpdatedData() {
- if(this.updatedData == null) {
+ if (this.updatedData == null) {
this.updatedData = filter(event.getUpdatedData());
}
return this.updatedData;
@Override
public Set<InstanceIdentifier<?>> getRemovedPaths() {
- if(this.removedPaths != null) {
+ if (this.removedPaths != null) {
this.removedPaths = new HashSet<InstanceIdentifier<?>>();
- for(InstanceIdentifier<?> path: event.getRemovedPaths()) {
+ for (InstanceIdentifier<?> path: event.getRemovedPaths()) {
DataObject original = this.event.getOriginalData().get(path);
- if(original != null
+ if (original != null
&& original instanceof OvsdbTerminationPointAugmentation) {
this.removedPaths.add(path);
}
@Override
public Map<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> getOriginalData() {
- if(this.originalData == null) {
+ if (this.originalData == null) {
this.originalData = filter(event.getOriginalData());
}
return this.originalData;
@Override
public OvsdbTerminationPointAugmentation getOriginalSubtree() {
- if(this.event.getOriginalSubtree() instanceof OvsdbTerminationPointAugmentation) {
+ if (this.event.getOriginalSubtree() instanceof OvsdbTerminationPointAugmentation) {
return (OvsdbTerminationPointAugmentation)this.event.getOriginalSubtree();
} else {
return null;
@Override
public OvsdbTerminationPointAugmentation getUpdatedSubtree() {
- if(this.event.getUpdatedSubtree() instanceof OvsdbTerminationPointAugmentation) {
+ if (this.event.getUpdatedSubtree() instanceof OvsdbTerminationPointAugmentation) {
return (OvsdbTerminationPointAugmentation)this.event.getUpdatedSubtree();
} else {
return null;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
-import java.util.StringTokenizer;
-
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Interface;
-import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
private AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> changes;
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
- public TerminationPointCreateCommand(AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbTerminationPointAugmentation> changes){
+ public TerminationPointCreateCommand(AsyncDataChangeEvent<InstanceIdentifier<?>,
+ OvsdbTerminationPointAugmentation> changes) {
this.changes = changes;
}
@Override
public void execute(TransactionBuilder transaction) {
- for(OvsdbTerminationPointAugmentation terminationPoint: changes.getCreatedData().values()){
+ for (OvsdbTerminationPointAugmentation terminationPoint: changes.getCreatedData().values()) {
LOG.debug("Received request to create termination point {} at managed node {}",
terminationPoint.getName(),
terminationPoint.getAttachedTo().getValue().firstIdentifierOf(Node.class));
ovsInterface.setName(terminationPoint.getName());
ovsInterface.setType(SouthboundMapper.createOvsdbInterfaceType(terminationPoint.getInterfaceType()));
Integer ofPort = terminationPoint.getOfport();
- if(ofPort != null) {
+ if (ofPort != null) {
ovsInterface.setOpenFlowPort(Sets.newHashSet(ofPort));
}
Integer ofPortRequest = terminationPoint.getOfportRequest();
- if(ofPortRequest != null) {
+ if (ofPortRequest != null) {
ovsInterface.setOpenFlowPortRequest(Sets.newHashSet(ofPortRequest));
}
//Configure optional input
if (terminationPoint.getOptions() != null) {
- for(Options option : terminationPoint.getOptions()){
+ for (Options option : terminationPoint.getOptions()) {
ovsInterface.setOptions(ImmutableMap.of(option.getOption(),option.getValue()));
}
}
private AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes;
private DataBroker db;
- public TransactCommandAggregator(DataBroker db,AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ public TransactCommandAggregator(DataBroker db,AsyncDataChangeEvent<InstanceIdentifier<?>,
+ OvsdbBridgeAugmentation> changes) {
this.db = db;
- this.changes=changes;
+ this.changes = changes;
commands.add(new BridgeCreateCommand(changes));
commands.add(new BridgeRemovedCommand(db,changes));
}
@Override
public void execute(TransactionBuilder transaction) {
- for(TransactCommand command:commands) {
+ for (TransactCommand command:commands) {
command.execute(transaction);
}
}
private DatabaseSchema dbSchema;
public TransactInvokerImpl(OvsdbConnectionInstance connectionInstance, DatabaseSchema dbSchema) {
- this.connectionInstance =connectionInstance;
+ this.connectionInstance = connectionInstance;
this.dbSchema = dbSchema;
}
try {
List<OperationResult> got = result.get();
LOG.debug("Results of create bridge request",got);
- } catch (Exception e){
+ } catch (Exception e) {
LOG.warn("Transact execution exception: ",e);
}
}
return extractOvsdbManagedNode(changes.getUpdatedData());
}
- public static Set<InstanceIdentifier<Node>> extractOvsdbManagedNodeRemoved(AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ public static Set<InstanceIdentifier<Node>> extractOvsdbManagedNodeRemoved(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
Set<InstanceIdentifier<Node>> result = new HashSet<InstanceIdentifier<Node>>();
- for(InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
- if(iid.getTargetType().equals(OvsdbBridgeAugmentation.class)) {
+ for (InstanceIdentifier<?> iid : changes.getRemovedPaths()) {
+ if (iid.getTargetType().equals(OvsdbBridgeAugmentation.class)) {
@SuppressWarnings("unchecked") // Actually checked above
InstanceIdentifier<Node> iidn = (InstanceIdentifier<Node>)iid;
result.add(iidn);
return result;
}
- public static Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> extractOvsdbManagedNodeOriginal(AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ public static Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> extractOvsdbManagedNodeOriginal(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
return extractOvsdbManagedNode(changes.getOriginalData());
}
public static Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> extractOvsdbManagedNode(
Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
- Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> result = new HashMap<InstanceIdentifier<Node>,OvsdbBridgeAugmentation>();
- for( Entry<InstanceIdentifier<?>, OvsdbBridgeAugmentation> created : changes.entrySet()) {
+ Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> result
+ = new HashMap<InstanceIdentifier<Node>,OvsdbBridgeAugmentation>();
+ for (Entry<InstanceIdentifier<?>, OvsdbBridgeAugmentation> created : changes.entrySet()) {
OvsdbBridgeAugmentation value = created.getValue();
Class<?> type = created.getKey().getTargetType();
- if(type.equals(OvsdbBridgeAugmentation.class)) {
+ if (type.equals(OvsdbBridgeAugmentation.class)) {
@SuppressWarnings("unchecked") // Actually checked above
InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) created.getKey();
OvsdbBridgeAugmentation ovsdbManagedNode = (OvsdbBridgeAugmentation) value;
import com.google.common.base.Optional;
-public class OpenVSwitchUpdateCommand extends AbstractTransactionCommand{
+public class OpenVSwitchUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OpenVSwitchUpdateCommand.class);
public OpenVSwitchUpdateCommand(OvsdbClientKey key, TableUpdates updates,
- DatabaseSchema dbSchema){
+ DatabaseSchema dbSchema) {
super(key,updates,dbSchema);
}
Map<UUID,OpenVSwitch> updatedOpenVSwitchRows =
TyperUtils.extractRowsUpdated(OpenVSwitch.class, getUpdates(), getDbSchema());
- for (Entry<UUID, OpenVSwitch> entry : updatedOpenVSwitchRows.entrySet()){
+ for (Entry<UUID, OpenVSwitch> entry : updatedOpenVSwitchRows.entrySet()) {
OpenVSwitch openVSwitch = entry.getValue();
final InstanceIdentifier<Node> nodePath = getKey().toInstanceIndentifier();
Optional<Node> node = Optional.absent();
} catch (final ReadFailedException e) {
LOG.debug("Read Operational/DS for Node fail! {}", nodePath, e);
}
- if (node.isPresent()){
+ if (node.isPresent()) {
LOG.debug("Node {} is present",node);
OvsdbNodeAugmentation ovsdbNode = SouthboundMapper.createOvsdbAugmentation(getKey());
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
@Override
public void execute(ReadWriteTransaction transaction) {
- Collection<Bridge> removedRows = TyperUtils.extractRowsRemoved(Bridge.class, getUpdates(), getDbSchema()).values();
- for(Bridge bridge : removedRows) {
- InstanceIdentifier<Node> bridgeIid = SouthboundMapper.createInstanceIdentifier(getKey(), new OvsdbBridgeName(bridge.getName()));
+ Collection<Bridge> removedRows = TyperUtils.extractRowsRemoved(Bridge.class,
+ getUpdates(), getDbSchema()).values();
+ for (Bridge bridge : removedRows) {
+ InstanceIdentifier<Node> bridgeIid = SouthboundMapper.createInstanceIdentifier(getKey(),
+ new OvsdbBridgeName(bridge.getName()));
InstanceIdentifier<ManagedNodeEntry> mnIid = SouthboundMapper.createInstanceIdentifier(getKey())
.augmentation(OvsdbNodeAugmentation.class)
.child(ManagedNodeEntry.class, new ManagedNodeEntryKey(new OvsdbBridgeRef(bridgeIid)));
@Override
public void execute(ReadWriteTransaction transaction) {
Map<UUID,Bridge> updatedBridgeRows = TyperUtils.extractRowsUpdated(Bridge.class, getUpdates(), getDbSchema());
- Map<UUID,Controller> updatedControllerRows = TyperUtils.extractRowsUpdated(Controller.class, getUpdates(), getDbSchema());
- for(Entry<UUID, Bridge> entry : updatedBridgeRows.entrySet()) {
+ Map<UUID,Controller> updatedControllerRows = TyperUtils.extractRowsUpdated(Controller.class,
+ getUpdates(), getDbSchema());
+ for (Entry<UUID, Bridge> entry : updatedBridgeRows.entrySet()) {
Bridge bridge = entry.getValue();
final InstanceIdentifier<Node> nodePath = getKey().toInstanceIndentifier();
Optional<Node> node = Optional.absent();
- try{
+ try {
node = transaction.read(LogicalDatastoreType.OPERATIONAL, nodePath).checkedGet();
- }catch (final ReadFailedException e) {
+ } catch (final ReadFailedException e) {
LOG.debug("Read Operational/DS for Node fail! {}", nodePath, e);
}
- if(node.isPresent()){
+ if (node.isPresent()) {
LOG.debug("Node {} is present",node);
NodeBuilder managedNodeBuilder = new NodeBuilder();
- NodeId manageNodeId = SouthboundMapper.createManagedNodeId(getKey(), new OvsdbBridgeName(bridge.getName()));
+ NodeId manageNodeId = SouthboundMapper.createManagedNodeId(getKey(),
+ new OvsdbBridgeName(bridge.getName()));
managedNodeBuilder.setNodeId(manageNodeId);
OvsdbBridgeAugmentationBuilder ovsdbManagedNodeBuilder = new OvsdbBridgeAugmentationBuilder();
ovsdbManagedNodeBuilder.setBridgeName(new OvsdbBridgeName(bridge.getName()));
ovsdbManagedNodeBuilder.setBridgeUuid(new Uuid(bridge.getUuid().toString()));
- DatapathId dpid= SouthboundMapper.createDatapathId(bridge);
- if(dpid != null) {
+ DatapathId dpid = SouthboundMapper.createDatapathId(bridge);
+ if (dpid != null) {
ovsdbManagedNodeBuilder.setDatapathId(dpid);
}
- ovsdbManagedNodeBuilder.setDatapathType(SouthboundMapper.createDatapathType(bridge.getDatapathTypeColumn().getData()));
- if(SouthboundMapper.createMdsalProtocols(bridge) != null
+ ovsdbManagedNodeBuilder.setDatapathType(
+ SouthboundMapper.createDatapathType(bridge.getDatapathTypeColumn().getData()));
+ if (SouthboundMapper.createMdsalProtocols(bridge) != null
&& SouthboundMapper.createMdsalProtocols(bridge).size() > 0) {
ovsdbManagedNodeBuilder.setProtocolEntry(SouthboundMapper.createMdsalProtocols(bridge));
}
- if(!SouthboundMapper.createControllerEntries(bridge, updatedControllerRows).isEmpty()) {
- ovsdbManagedNodeBuilder.setControllerEntry(SouthboundMapper.createControllerEntries(bridge, updatedControllerRows));
+ if (!SouthboundMapper.createControllerEntries(bridge, updatedControllerRows).isEmpty()) {
+ ovsdbManagedNodeBuilder.setControllerEntry(
+ SouthboundMapper.createControllerEntries(bridge, updatedControllerRows));
}
- if(bridge.getFailModeColumn() != null &&
- bridge.getFailModeColumn().getData() != null &&
- !bridge.getFailModeColumn().getData().isEmpty()) {
+ if (bridge.getFailModeColumn() != null
+ && bridge.getFailModeColumn().getData() != null
+ && !bridge.getFailModeColumn().getData().isEmpty()) {
String[] failmodeArray = new String[bridge.getFailModeColumn().getData().size()];
bridge.getFailModeColumn().getData().toArray(failmodeArray);
- ovsdbManagedNodeBuilder.setFailMode(SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get(failmodeArray[0]));
+ ovsdbManagedNodeBuilder.setFailMode(
+ SouthboundConstants.OVSDB_FAIL_MODE_MAP.inverse().get(failmodeArray[0]));
}
ovsdbManagedNodeBuilder.setManagedBy(new OvsdbNodeRef(nodePath));
managedNodeBuilder.addAugmentation(OvsdbBridgeAugmentation.class, ovsdbManagedNodeBuilder.build());
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
List<ManagedNodeEntry> managedNodes = new ArrayList<ManagedNodeEntry>();
- ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder().setBridgeRef(new OvsdbBridgeRef(managedNodePath)).build();
+ ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder().setBridgeRef(
+ new OvsdbBridgeRef(managedNodePath)).build();
managedNodes.add(managedNodeEntry);
ovsdbNodeBuilder.setManagedNodeEntry(managedNodes);
@Override
public void execute(ReadWriteTransaction transaction) {
- CheckedFuture<Optional<Node>, ReadFailedException> ovsdbNodeFuture = transaction.read(LogicalDatastoreType.OPERATIONAL, getKey().toInstanceIndentifier());
+ CheckedFuture<Optional<Node>, ReadFailedException> ovsdbNodeFuture = transaction.read(
+ LogicalDatastoreType.OPERATIONAL, getKey().toInstanceIndentifier());
Optional<Node> ovsdbNodeOptional;
try {
ovsdbNodeOptional = ovsdbNodeFuture.get();
- if(ovsdbNodeOptional.isPresent()) {
+ if (ovsdbNodeOptional.isPresent()) {
Node ovsdbNode = ovsdbNodeOptional.get();
OvsdbNodeAugmentation ovsdbNodeAugmentation = ovsdbNode.getAugmentation(OvsdbNodeAugmentation.class);
if (ovsdbNodeAugmentation.getManagedNodeEntry() != null) {
@Override
public void execute(ReadWriteTransaction transaction) {
- for(TransactionCommand command: commands) {
+ for (TransactionCommand command: commands) {
command.execute(transaction);
}
}
import java.util.Collection;
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.schema.DatabaseSchema;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.ovsdb.southbound.OvsdbClientKey;
-import org.opendaylight.ovsdb.southbound.SouthboundMapper;
-//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.ManagedNodeEntry;
-//import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryKey;
-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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public void execute(ReadWriteTransaction transaction) {
Collection<Port> removedRows = TyperUtils.extractRowsRemoved(Port.class, getUpdates(), getDbSchema()).values();
- for(Port port : removedRows) {
+ for (Port port : removedRows) {
//InstanceIdentifier<Node> portIid = SouthboundMapper.createInstanceIdentifier(getKey(), port.getUuid());
// InstanceIdentifier<ManagedNodeEntry> mnIid = SouthboundMapper.createInstanceIndentifier(getKey())
// .augmentation(OvsdbTerminationPointAugmentation.class)
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.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
-import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
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 static final Logger LOG = LoggerFactory.getLogger(OvsdbPortUpdateCommand.class);
public OvsdbPortUpdateCommand(OvsdbClientKey key, TableUpdates updates,
DatabaseSchema dbSchema) {
NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setNodeId(bridgeId);
- OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = new OvsdbTerminationPointAugmentationBuilder();
+ OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder
+ = new OvsdbTerminationPointAugmentationBuilder();
List<TerminationPoint> tpList = new ArrayList<TerminationPoint>();
TerminationPointBuilder entry = new TerminationPointBuilder();
TpId tpId = SouthboundMapper
port.getUuid().toString()));
Column<GenericTableSchema, Set<UUID>> iface = port.getInterfacesColumn();
Set<UUID> ifUuid = iface.getData();
- Collection<Interface> ifUpdateRows = TyperUtils.extractRowsUpdated(Interface.class, getUpdates(), getDbSchema()).values();
+ Collection<Interface> ifUpdateRows = TyperUtils.extractRowsUpdated(
+ Interface.class, getUpdates(), getDbSchema()).values();
for (UUID ifIter : ifUuid) {
for (Interface interfIter : ifUpdateRows) {
Column<GenericTableSchema, String> typeColumn = interfIter.getTypeColumn();
String type = typeColumn.getData();
if ((interfIter.getUuid()).equals(ifIter)) {
- ovsdbTerminationPointBuilder.setInterfaceUuid(new Uuid(interfIter.getUuid().toString()));
- ovsdbTerminationPointBuilder.setInterfaceType(SouthboundMapper.createInterfaceType(type));
+ ovsdbTerminationPointBuilder.setInterfaceUuid(
+ new Uuid(interfIter.getUuid().toString()));
+ ovsdbTerminationPointBuilder.setInterfaceType(
+ SouthboundMapper.createInterfaceType(type));
break;
}
}
}
entry.addAugmentation(
- (Class<? extends Augmentation<TerminationPoint>>) OvsdbTerminationPointAugmentation.class,
+ OvsdbTerminationPointAugmentation.class,
ovsdbTerminationPointBuilder.build());
tpList.add(entry.build());
private BindingTransactionChain chain;
private DataBroker db;
private BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<TransactionCommand>(QUEUE_SIZE);
- private BlockingQueue<ReadWriteTransaction> successfulTransactionQueue = new LinkedBlockingQueue<ReadWriteTransaction>(QUEUE_SIZE);
- private BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue = new LinkedBlockingQueue<AsyncTransaction<?, ?>>(QUEUE_SIZE);
+ private BlockingQueue<ReadWriteTransaction> successfulTransactionQueue
+ = new LinkedBlockingQueue<ReadWriteTransaction>(QUEUE_SIZE);
+ private BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue
+ = new LinkedBlockingQueue<AsyncTransaction<?, ?>>(QUEUE_SIZE);
private ExecutorService executor;
- private Map<ReadWriteTransaction,TransactionCommand> transactionToCommand = new HashMap<ReadWriteTransaction,TransactionCommand>();
+ private Map<ReadWriteTransaction,TransactionCommand> transactionToCommand
+ = new HashMap<ReadWriteTransaction,TransactionCommand>();
private List<ReadWriteTransaction> pendingTransactions = new ArrayList<ReadWriteTransaction>();
public TransactionInvokerImpl(DataBroker db) {
@Override
public void run() {
- while(true) {
+ while (true) {
forgetSuccessfulTransactions();
try {
List<TransactionCommand> commands = extractCommands();
- for(TransactionCommand command: commands) {
+ for (TransactionCommand command: commands) {
final ReadWriteTransaction transaction = chain.newReadWriteTransaction();
recordPendingTransaction(command, transaction);
command.execute(transaction);
}
@Override
- public void onFailure(final Throwable t) {
+ public void onFailure(final Throwable throwable) {
// NOOP - handled by failure of transaction chain
}
});
}
} catch (Exception e) {
- LOG.warn("Exception invoking Transaction: ",e);
+ LOG.warn("Exception invoking Transaction: ", e);
}
}
}
private List<TransactionCommand> extractResubmitCommands() {
AsyncTransaction<?, ?> transaction = failedTransactionQueue.poll();
List<TransactionCommand> commands = new ArrayList<TransactionCommand>();
- if(transaction != null) {
+ if (transaction != null) {
int index = pendingTransactions.lastIndexOf(transaction);
- List<ReadWriteTransaction> transactions = pendingTransactions.subList(index, pendingTransactions.size()-1);
- for(ReadWriteTransaction tx: transactions) {
+ List<ReadWriteTransaction> transactions =
+ pendingTransactions.subList(index, pendingTransactions.size() - 1);
+ for (ReadWriteTransaction tx: transactions) {
commands.add(transactionToCommand.get(tx));
}
resetTransactionQueue();
private List<TransactionCommand> extractCommandsFromQueue() throws InterruptedException {
List<TransactionCommand> result = new ArrayList<TransactionCommand>();
TransactionCommand command = inputQueue.take();
- while(command != null) {
+ while (command != null) {
result.add(command);
command = inputQueue.poll();
}
private void forgetSuccessfulTransactions() {
ReadWriteTransaction transaction = successfulTransactionQueue.poll();
- while(transaction != null) {
+ while (transaction != null) {
pendingTransactions.remove(transaction);
transactionToCommand.remove(transaction);
transaction = successfulTransactionQueue.poll();
@Override
public void close() throws Exception {
- this.executor.shutdown();
+ this.executor.shutdown();
}
}
Code Review / ovsdb.git / commitdiff