import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
-
+import com.google.common.util.concurrent.MoreExecutors;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.common.api.clustering.CandidateAlreadyRegisteredException;
externalClient.getConnectionInfo().getRemotePort(),
externalClient.getConnectionInfo().getLocalAddress(),
externalClient.getConnectionInfo().getLocalPort());
- List<String> databases = new ArrayList<>();
try {
- databases = externalClient.getDatabases().get(DB_FETCH_TIMEOUT, TimeUnit.MILLISECONDS);
+ List<String> databases = externalClient.getDatabases().get(DB_FETCH_TIMEOUT, TimeUnit.MILLISECONDS);
if (databases.contains(SouthboundConstants.OPEN_V_SWITCH)) {
OvsdbConnectionInstance client = connectedButCallBacksNotRegistered(externalClient);
// Register Cluster Ownership for ConnectionInfo
}
Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
@Override
- public void onSuccess(@Nullable Optional<Node> node) {
+ public void onSuccess(@Nonnull Optional<Node> node) {
if (node.isPresent()) {
LOG.info("Disconnected/Failed connection {} was controller initiated, attempting "
+ "reconnection", ovsdbNode.getConnectionInfo());
public void onFailure(Throwable throwable) {
LOG.warn("Read Config/DS for Node failed! {}", iid, throwable);
}
- });
+ }, MoreExecutors.directExecutor());
break;
}
default:
reconciliationManager.enqueue(task);
}
- private class OvsdbDeviceEntityOwnershipListener implements EntityOwnershipListener {
+ private static class OvsdbDeviceEntityOwnershipListener implements EntityOwnershipListener {
private final OvsdbConnectionManager cm;
private final EntityOwnershipListenerRegistration listenerRegistration;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
-
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
-
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.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipListener;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipListenerRegistration;
import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
-import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
return db;
}
+ // FIXME: get rid of this static
+ @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD")
private static DataBroker db;
private OvsdbConnectionManager cm;
private TransactionInvoker txInvoker;
private final OvsdbConnection ovsdbConnection;
private final InstanceIdentifierCodec instanceIdentifierCodec;
private static final String SKIP_MONITORING_MANAGER_STATUS_PARAM = "skip-monitoring-manager-status";
- private AtomicBoolean registered = new AtomicBoolean(false);
+ private final AtomicBoolean registered = new AtomicBoolean(false);
private ListenerRegistration<SouthboundProvider> operTopologyRegistration;
public SouthboundProvider(final DataBroker dataBroker,
//register instance entity to get the ownership of the provider
Entity instanceEntity = new Entity(ENTITY_TYPE, ENTITY_TYPE);
try {
- Optional<EntityOwnershipState> ownershipStateOpt = entityOwnershipService.getOwnershipState(instanceEntity);
registration = entityOwnershipService.registerCandidate(instanceEntity);
} catch (CandidateAlreadyRegisteredException e) {
LOG.warn("OVSDB Southbound Provider instance entity {} was already "
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));
DataTreeIdentifier<Topology> treeId =
- new DataTreeIdentifier<Topology>(LogicalDatastoreType.OPERATIONAL, path);
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, path);
LOG.trace("Registering listener for path {}", treeId);
operTopologyRegistration = db.registerDataTreeChangeListener(treeId, this);
}
}
- private class SouthboundPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
+ private static class SouthboundPluginInstanceEntityOwnershipListener implements EntityOwnershipListener {
private final SouthboundProvider sp;
private final EntityOwnershipListenerRegistration listenerRegistration;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import com.google.common.base.Optional;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@SuppressFBWarnings("UPM_UNCALLED_PRIVATE_METHOD")
public class AutoAttachRemovedCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(AutoAttachRemovedCommand.class);
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import com.google.common.base.Optional;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@SuppressFBWarnings("UPM_UNCALLED_PRIVATE_METHOD")
public class AutoAttachUpdateCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(AutoAttachUpdateCommand.class);
try (ReadOnlyTransaction transaction = db.newReadOnlyTransaction()) {
Map<InstanceIdentifier<Node>, Node> nodeCreateOrUpdate =
TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, Node.class);
- if (nodeCreateOrUpdate != null) {
- for (Entry<InstanceIdentifier<Node>, Node> entry: nodeCreateOrUpdate.entrySet()) {
- CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
- transaction.read(LogicalDatastoreType.OPERATIONAL, entry.getKey());
- try {
- Optional<Node> nodeOptional = nodeFuture.get();
- if (nodeOptional.isPresent()) {
- operationalNodes.put(entry.getKey(), nodeOptional.get());
- }
- } catch (InterruptedException | ExecutionException e) {
- LOG.warn("Error reading from datastore",e);
+ for (Entry<InstanceIdentifier<Node>, Node> entry: nodeCreateOrUpdate.entrySet()) {
+ CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
+ transaction.read(LogicalDatastoreType.OPERATIONAL, entry.getKey());
+ try {
+ Optional<Node> nodeOptional = nodeFuture.get();
+ if (nodeOptional.isPresent()) {
+ operationalNodes.put(entry.getKey(), nodeOptional.get());
}
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Error reading from datastore",e);
}
}
}
*/
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Collection;
Uuid operQosUuid = getQosEntryUuid(operNode.getQosEntries(), qosEntry.getQosId());
if (operQosUuid == null) {
UUID namedUuid = new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX
- + TransactUtils.bytesToHexString(qosEntry.getQosId().getValue().getBytes()));
- transaction.add(op.insert(qos).withId(namedUuid.toString())).build();
+ + TransactUtils.bytesToHexString(qosEntry.getQosId().getValue().getBytes(UTF_8)));
+ transaction.add(op.insert(qos).withId(namedUuid.toString()));
LOG.info("Added QoS Uuid: {} for node : {} ", namedUuid, operNode.getConnectionInfo());
} else {
UUID uuid = new UUID(operQosUuid.getValue());
.where(extraQos.getUuidColumn().getSchema().opEqual(uuid)).build());
LOG.info("Updated QoS Uuid : {} for node : {} ", operQosUuid, operNode.getConnectionInfo());
}
- transaction.build();
}
}
}
}
return SouthboundConstants.QUEUE_NAMED_UUID_PREFIX
- + TransactUtils.bytesToHexString(queueKey.getQueueId().getValue().getBytes());
+ + TransactUtils.bytesToHexString(queueKey.getQueueId().getValue().getBytes(UTF_8));
}
private Uuid getQosEntryUuid(List<QosEntries> operQosEntries, Uri qosId) {
*/
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
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.UUID;
if (queueEntry.getDscp() != null) {
try {
Set<Long> dscpSet = new HashSet<>();
- if (dscpSet.add(new Long(queueEntry.getDscp().toString()))) {
+ if (dscpSet.add(Long.valueOf(queueEntry.getDscp().toString()))) {
queue.setDscp(dscpSet);
}
} catch (NumberFormatException e) {
Uuid operQueueUuid = getQueueEntryUuid(operNode.getQueues(), queueEntry.getQueueId());
if (operQueueUuid == null) {
UUID namedUuid = new UUID(SouthboundConstants.QUEUE_NAMED_UUID_PREFIX
- + TransactUtils.bytesToHexString(queueEntry.getQueueId().getValue().getBytes()));
- transaction.add(op.insert(queue).withId(namedUuid.toString())).build();
+ + TransactUtils.bytesToHexString(queueEntry.getQueueId().getValue().getBytes(UTF_8)));
+ transaction.add(op.insert(queue).withId(namedUuid.toString()));
LOG.info("Added queue Uuid : {} for Ovsdb Node : {}",
namedUuid, operNode);
} else {
LOG.info("Updated queue entries: {} for Ovsdb Node : {}",
queue, operNode);
}
- transaction.build();
}
}
*/
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import static java.nio.charset.StandardCharsets.UTF_8;
import static org.opendaylight.ovsdb.lib.operations.Operations.op;
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
}
if (uuidSet.size() == 0) {
uuidSet.add(new UUID(SouthboundConstants.QOS_NAMED_UUID_PREFIX
- + TransactUtils.bytesToHexString(qosId.getValue().getBytes())));
+ + TransactUtils.bytesToHexString(qosId.getValue().getBytes(UTF_8))));
}
}
port.setQos(uuidSet);
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.google.common.util.concurrent.UncheckedExecutionException;
-
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
-
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.DataTreeIdentifier;
}
}
- private class NodeConnectionMetadata {
- Node node;
- InstanceIdentifier<?> nodeIid;
- OvsdbConnectionManager connectionManager;
- OvsdbConnectionInstance connectionInstance;
+ private static class NodeConnectionMetadata {
+ private final Node node;
+ private InstanceIdentifier<?> nodeIid;
+ private final OvsdbConnectionManager connectionManager;
+ private final OvsdbConnectionInstance connectionInstance;
NodeConnectionMetadata(Node node,
OvsdbConnectionManager connectionManager,
private static final Logger LOG = LoggerFactory.getLogger(ConnectionReconciliationTask.class);
- private static final int RETRY_INTERVAL_FACTOR = 10000;
+ private static final long RETRY_INTERVAL_FACTOR = 10000;
private static final int MAX_ATTEMPT = 10;
- private AtomicInteger connectionAttempt = new AtomicInteger(0);
+ private final AtomicInteger connectionAttempt = new AtomicInteger(0);
public ConnectionReconciliationTask(ReconciliationManager reconciliationManager, OvsdbConnectionManager
connectionManager, InstanceIdentifier<?> nodeIid, DataObject configData) {
oldOtherConfigs = oldEntry.getOtherConfigColumn().getData();
}
- if ((oldOtherConfigs != null) && (!oldOtherConfigs.isEmpty())) {
+ if (oldOtherConfigs != null && !oldOtherConfigs.isEmpty()) {
removeOldConfigs(transaction, oldOtherConfigs, openVSwitch);
}
- if ((otherConfigs != null) && (!otherConfigs.isEmpty())) {
+ if (otherConfigs != null && !otherConfigs.isEmpty()) {
setNewOtherConfigs(ovsdbNodeBuilder, otherConfigs);
}
}
private void setNewOtherConfigs(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder,
Map<String, String> otherConfigs) {
- Set<String> otherConfigKeys = otherConfigs.keySet();
List<OpenvswitchOtherConfigs> otherConfigsList = new ArrayList<>();
- String otherConfigValue;
- for (String otherConfigKey : otherConfigKeys) {
- otherConfigValue = otherConfigs.get(otherConfigKey);
+ for (Entry<String, String> entry : otherConfigs.entrySet()) {
+ String otherConfigKey = entry.getKey();
+ String otherConfigValue = entry.getValue();
if (otherConfigKey != null && otherConfigValue != null) {
otherConfigsList.add(new OpenvswitchOtherConfigsBuilder().setOtherConfigKey(otherConfigKey)
.setOtherConfigValue(otherConfigValue).build());
if (oldEntry != null && oldEntry.getExternalIdsColumn() != null) {
oldExternalIds = oldEntry.getExternalIdsColumn().getData();
}
- if ((oldExternalIds == null) || oldExternalIds.isEmpty()) {
+ if (oldExternalIds == null || oldExternalIds.isEmpty()) {
setNewExternalIds(ovsdbNodeBuilder, externalIds);
} else if (externalIds != null && !externalIds.isEmpty()) {
removeExternalIds(transaction, oldExternalIds, openVSwitch);
private void setNewExternalIds(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder,
Map<String, String> externalIds) {
- Set<String> externalIdKeys = externalIds.keySet();
List<OpenvswitchExternalIds> externalIdsList = new ArrayList<>();
- String externalIdValue;
- for (String externalIdKey : externalIdKeys) {
- externalIdValue = externalIds.get(externalIdKey);
+ for (Entry<String, String> entry : externalIds.entrySet()) {
+ String externalIdKey = entry.getKey();
+ String externalIdValue = entry.getValue();
if (externalIdKey != null && externalIdValue != null) {
externalIdsList.add(new OpenvswitchExternalIdsBuilder().setExternalIdKey(externalIdKey)
.setExternalIdValue(externalIdValue).build());
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.controller.md.sal.common.api.data.ReadFailedException;
public class OvsdbAutoAttachUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbAutoAttachUpdateCommand.class);
- private Map<UUID, AutoAttach> updatedAutoAttachRows;
- private Map<UUID, AutoAttach> oldAutoAttachRows;
+ private final Map<UUID, AutoAttach> updatedAutoAttachRows;
+ private final Map<UUID, AutoAttach> oldAutoAttachRows;
public OvsdbAutoAttachUpdateCommand(OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
}
final AutoattachBuilder autoAttachBuilder =
- (currentAutoattach != null) ? new AutoattachBuilder(currentAutoattach)
+ currentAutoattach != null ? new AutoattachBuilder(currentAutoattach)
: new AutoattachBuilder()
.setAutoattachUuid(new Uuid(entry.getKey().toString()))
.setAutoattachId(uri)
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());
+ for (final Entry<Long, Long> entry : mappings.entrySet()) {
+ final Long mappingsKey = entry.getKey();
+ final Integer mappingsValue = Integer.valueOf(entry.getValue().intValue());
if (mappingsKey != null) {
mappingsList.add(new MappingsBuilder()
.setKey(new MappingsKey(mappingsKey))
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
public class OvsdbBridgeUpdateCommand extends AbstractTransactionCommand {
private static final Logger LOG = LoggerFactory.getLogger(OvsdbBridgeUpdateCommand.class);
private final InstanceIdentifierCodec instanceIdentifierCodec;
- private Map<UUID,Bridge> updatedBridgeRows;
- private Map<UUID, Bridge> oldBridgeRows;
+ private final Map<UUID,Bridge> updatedBridgeRows;
+ private final Map<UUID, Bridge> oldBridgeRows;
public OvsdbBridgeUpdateCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
Map<String, String> otherConfigs = bridge
.getOtherConfigColumn().getData();
if (otherConfigs != null && !otherConfigs.isEmpty()) {
- Set<String> otherConfigKeys = otherConfigs.keySet();
List<BridgeOtherConfigs> otherConfigList = new ArrayList<>();
- String otherConfigValue;
- for (String otherConfigKey : otherConfigKeys) {
- otherConfigValue = otherConfigs.get(otherConfigKey);
+ for (Entry<String, String> entry : otherConfigs.entrySet()) {
+ String otherConfigKey = entry.getKey();
+ String otherConfigValue = entry.getValue();
if (otherConfigKey != null && otherConfigValue != null) {
otherConfigList.add(new BridgeOtherConfigsBuilder()
.setBridgeOtherConfigKey(otherConfigKey)
Map<String, String> externalIds = bridge.getExternalIdsColumn()
.getData();
if (externalIds != null && !externalIds.isEmpty()) {
- Set<String> externalIdKeys = externalIds.keySet();
List<BridgeExternalIds> externalIdsList = new ArrayList<>();
- String externalIdValue;
- for (String externalIdKey : externalIdKeys) {
- externalIdValue = externalIds.get(externalIdKey);
+ for (Entry<String, String> entry : externalIds.entrySet()) {
+ String externalIdKey = entry.getKey();
+ String externalIdValue = entry.getValue();
if (externalIdKey != null && externalIdValue != null) {
externalIdsList.add(new BridgeExternalIdsBuilder()
.setBridgeExternalIdKey(externalIdKey)
private void setProtocol(OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder,
Bridge bridge) {
- if (SouthboundMapper.createMdsalProtocols(bridge) != null
- && SouthboundMapper.createMdsalProtocols(bridge).size() > 0) {
- ovsdbBridgeAugmentationBuilder.setProtocolEntry(SouthboundMapper.createMdsalProtocols(bridge));
+ final List<ProtocolEntry> protocols = SouthboundMapper.createMdsalProtocols(bridge);
+ if (!protocols.isEmpty()) {
+ ovsdbBridgeAugmentationBuilder.setProtocolEntry(protocols);
}
}
&& controllerEntry.isIsConnected() != null && controllerEntry.isIsConnected()) {
String [] controllerTarget = controllerEntry.getTarget().getValue().split(":");
IpAddress bridgeControllerIpAddress = null;
- PortNumber bridgeControllerPortNumber = null;
for (String targetElement : controllerTarget) {
if (InetAddresses.isInetAddress(targetElement)) {
bridgeControllerIpAddress = new IpAddress(targetElement.toCharArray());
continue;
}
if (NumberUtils.isNumber(targetElement)) {
- bridgeControllerPortNumber = new PortNumber(
- Integer.valueOf(String.valueOf(targetElement)));
continue;
}
}
import java.util.Collection;
import java.util.Map;
-
+import java.util.Map.Entry;
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;
continue;
}
Bridge updatedBridgeData = null;
- for (UUID bridgeUuid : bridgeUpdatedOldRows.keySet()) {
- Bridge oldBridgeData = bridgeUpdatedOldRows.get(bridgeUuid);
+ for (Entry<UUID, Bridge> entry : bridgeUpdatedOldRows.entrySet()) {
+ UUID bridgeUuid = entry.getKey();
+ Bridge oldBridgeData = entry.getValue();
if (oldBridgeData.getPortsColumn() != null
&& oldBridgeData.getPortsColumn().getData().contains(port.getUuidColumn().getData())
- && (! bridgeUpdatedRows.isEmpty())) {
+ && ! bridgeUpdatedRows.isEmpty()) {
updatedBridgeData = bridgeUpdatedRows.get(bridgeUuid);
break;
}
bridgeIid = getTerminationPointBridge(transaction, node, portName);
}
if (bridgeIid.isPresent()) {
- NodeId bridgeId = SouthboundMapper.createManagedNodeId(bridgeIid.get());
TerminationPointKey tpKey = new TerminationPointKey(new TpId(portName));
TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
tpBuilder.setKey(tpKey);
}
private Optional<InstanceIdentifier<Node>> getTerminationPointBridge(UUID portUuid) {
- for (UUID bridgeUuid : this.bridgeUpdatedRows.keySet()) {
- if (this.bridgeUpdatedRows.get(bridgeUuid).getPortsColumn().getData().contains(portUuid)) {
+ for (Entry<UUID, Bridge> entry : this.bridgeUpdatedRows.entrySet()) {
+ UUID bridgeUuid = entry.getKey();
+ if (entry.getValue().getPortsColumn().getData().contains(portUuid)) {
return Optional.of(
SouthboundMapper.createInstanceIdentifier(instanceIdentifierCodec, getOvsdbConnectionInstance(),
this.bridgeUpdatedRows.get(bridgeUuid)));
InstanceIdentifier<QosEntry> oldPortQosIid = tpPath
.augmentation(OvsdbTerminationPointAugmentation.class)
.child(QosEntry.class,
- new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY)));
+ new QosEntryKey(Long.valueOf(SouthboundConstants.PORT_QOS_LIST_KEY)));
transaction.delete(LogicalDatastoreType.OPERATIONAL, oldPortQosIid);
}
}
List<QosEntry> qosList = new ArrayList<>();
OvsdbQosRef qosRef = new OvsdbQosRef(qosIid);
qosList.add(new QosEntryBuilder()
- .setKey(new QosEntryKey(new Long(SouthboundConstants.PORT_QOS_LIST_KEY)))
+ .setKey(new QosEntryKey(Long.valueOf(SouthboundConstants.PORT_QOS_LIST_KEY)))
.setQosRef(qosRef).build());
ovsdbTerminationPointBuilder.setQosEntry(qosList);
}
Map<String, String> interfaceExternalIds =
interf.getExternalIdsColumn().getData();
if (interfaceExternalIds != null && !interfaceExternalIds.isEmpty()) {
- Set<String> externalIdKeys = interfaceExternalIds.keySet();
- List<InterfaceExternalIds> externalIdsList =
- new ArrayList<>();
- String externalIdValue;
- for (String externalIdKey : externalIdKeys) {
- externalIdValue = interfaceExternalIds.get(externalIdKey);
+ List<InterfaceExternalIds> externalIdsList = new ArrayList<>();
+ for (Entry<String, String> entry : interfaceExternalIds.entrySet()) {
+ String externalIdKey = entry.getKey();
+ String externalIdValue = entry.getValue();
if (externalIdKey != null && externalIdValue != null) {
externalIdsList.add(new InterfaceExternalIdsBuilder()
.setExternalIdKey(externalIdKey)
Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
if (portExternalIds != null && !portExternalIds.isEmpty()) {
- Set<String> externalIdKeys = portExternalIds.keySet();
List<PortExternalIds> externalIdsList = new ArrayList<>();
- String externalIdValue;
- for (String externalIdKey : externalIdKeys) {
- externalIdValue = portExternalIds.get(externalIdKey);
+ for (Entry<String, String> entry : portExternalIds.entrySet()) {
+ String externalIdKey = entry.getKey();
+ String externalIdValue = entry.getValue();
if (externalIdKey != null && externalIdValue != null) {
externalIdsList.add(new PortExternalIdsBuilder()
.setExternalIdKey(externalIdKey)
Map<String, String> optionsMap = interf.getOptionsColumn().getData();
if (optionsMap != null && !optionsMap.isEmpty()) {
List<Options> options = new ArrayList<>();
- String optionsValueString;
- OptionsKey optionsKey;
- for (String optionsKeyString : optionsMap.keySet()) {
- optionsValueString = optionsMap.get(optionsKeyString);
+ for (Entry<String, String> entry : optionsMap.entrySet()) {
+ String optionsKeyString = entry.getKey();
+ String optionsValueString = entry.getValue();
if (optionsKeyString != null && optionsValueString != null) {
- optionsKey = new OptionsKey(optionsKeyString);
+ OptionsKey optionsKey = new OptionsKey(optionsKeyString);
options.add(new OptionsBuilder()
.setKey(optionsKey)
.setValue(optionsValueString).build());
Map<String, String> portOtherConfigMap = port.getOtherConfigColumn().getData();
if (portOtherConfigMap != null && !portOtherConfigMap.isEmpty()) {
List<PortOtherConfigs> portOtherConfigs = new ArrayList<>();
- String portOtherConfigValueString;
- for (String portOtherConfigKeyString : portOtherConfigMap.keySet()) {
- portOtherConfigValueString = portOtherConfigMap.get(portOtherConfigKeyString);
+ for (Entry<String, String> entry : portOtherConfigMap.entrySet()) {
+ String portOtherConfigKeyString = entry.getKey();
+ String portOtherConfigValueString = entry.getValue();
if (portOtherConfigKeyString != null && portOtherConfigValueString != null) {
portOtherConfigs.add(new PortOtherConfigsBuilder()
.setOtherConfigKey(portOtherConfigKeyString)
Map<String, String> interfaceLldpMap = interf.getLldpColumn().getData();
if (interfaceLldpMap != null && !interfaceLldpMap.isEmpty()) {
List<InterfaceLldp> interfaceLldpList = new ArrayList<>();
- for (String interfaceLldpKeyString : interfaceLldpMap.keySet()) {
- String interfaceLldpValueString = interfaceLldpMap.get(interfaceLldpKeyString);
+ for (Entry<String, String> entry : interfaceLldpMap.entrySet()) {
+ String interfaceLldpKeyString = entry.getKey();
+ String interfaceLldpValueString = entry.getValue();
if (interfaceLldpKeyString != null && interfaceLldpValueString != null) {
interfaceLldpList.add(new InterfaceLldpBuilder()
.setKey(new InterfaceLldpKey(interfaceLldpKeyString))
Map<String, String> interfaceOtherConfigMap = interf.getOtherConfigColumn().getData();
if (interfaceOtherConfigMap != null && !interfaceOtherConfigMap.isEmpty()) {
List<InterfaceOtherConfigs> interfaceOtherConfigs = new ArrayList<>();
- String interfaceOtherConfigValueString;
- for (String interfaceOtherConfigKeyString : interfaceOtherConfigMap.keySet()) {
- interfaceOtherConfigValueString = interfaceOtherConfigMap.get(interfaceOtherConfigKeyString);
+ for (Entry<String, String> entry : interfaceOtherConfigMap.entrySet()) {
+ String interfaceOtherConfigKeyString = entry.getKey();
+ String interfaceOtherConfigValueString = entry.getValue();
if (interfaceOtherConfigKeyString != null && interfaceOtherConfigValueString != null) {
interfaceOtherConfigs.add(new InterfaceOtherConfigsBuilder()
.setOtherConfigKey(interfaceOtherConfigKeyString)
Map<String, String> interfaceBfdStatusMap = interf.getBfdStatusColumn().getData();
if (interfaceBfdStatusMap != null && !interfaceBfdStatusMap.isEmpty()) {
List<InterfaceBfdStatus> interfaceBfdStatusList = new ArrayList<>();
- for (String interfaceBfdStatusKeyString : interfaceBfdStatusMap.keySet()) {
- String interfaceBfdStatusValueString = interfaceBfdStatusMap.get(interfaceBfdStatusKeyString);
+ for (Entry<String, String> entry : interfaceBfdStatusMap.entrySet()) {
+ String interfaceBfdStatusKeyString = entry.getKey();
+ String interfaceBfdStatusValueString = entry.getValue();
if (interfaceBfdStatusKeyString != null && interfaceBfdStatusValueString != null) {
interfaceBfdStatusList.add(new InterfaceBfdStatusBuilder()
.setKey(new InterfaceBfdStatusKey(interfaceBfdStatusKeyString))
Map<String, String> interfaceBfdMap = interf.getBfdColumn().getData();
if (interfaceBfdMap != null && !interfaceBfdMap.isEmpty()) {
List<InterfaceBfd> interfaceBfdList = new ArrayList<>();
- for (String interfaceBfdKeyString : interfaceBfdMap.keySet()) {
- String interfaceBfdValueString = interfaceBfdMap.get(interfaceBfdKeyString);
+ for (Entry<String, String> entry : interfaceBfdMap.entrySet()) {
+ String interfaceBfdKeyString = entry.getKey();
+ String interfaceBfdValueString = entry.getValue();
if (interfaceBfdKeyString != null && interfaceBfdValueString != null) {
interfaceBfdList.add(new InterfaceBfdBuilder()
.setKey(new InterfaceBfdKey(interfaceBfdKeyString))
private final InstanceIdentifierCodec instanceIdentifierCodec;
- private Map<UUID, Qos> updatedQosRows;
- private Map<UUID, Qos> oldQosRows;
- private Map<UUID, Queue> updatedQueueRows;
+ private final Map<UUID, Qos> updatedQosRows;
+ private final Map<UUID, Qos> oldQosRows;
+ private final Map<UUID, Queue> updatedQueueRows;
public OvsdbQosUpdateCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
if (oldQos != null && oldQos.getOtherConfigColumn() != null) {
oldOtherConfigs = oldQos.getOtherConfigColumn().getData();
}
- if ((oldOtherConfigs != null) && !oldOtherConfigs.isEmpty()) {
+ if (oldOtherConfigs != null && !oldOtherConfigs.isEmpty()) {
removeOldConfigs(transaction, qosEntryBuilder, oldOtherConfigs, qos, nodeIId);
}
if (otherConfigs != null && !otherConfigs.isEmpty()) {
private void setNewOtherConfigs(QosEntriesBuilder qosEntryBuilder,
Map<String, String> otherConfig) {
- Set<String> otherConfigKeys = otherConfig.keySet();
List<QosOtherConfig> otherConfigList = new ArrayList<>();
- String otherConfigValue;
- for (String otherConfigKey : otherConfigKeys) {
- otherConfigValue = otherConfig.get(otherConfigKey);
+ for (Entry<String, String> entry : otherConfig.entrySet()) {
+ String otherConfigKey = entry.getKey();
+ String otherConfigValue = entry.getValue();
if (otherConfigKey != null && otherConfigValue != null) {
otherConfigList.add(new QosOtherConfigBuilder().setOtherConfigKey(otherConfigKey)
.setOtherConfigValue(otherConfigValue).build());
if (oldQos != null && oldQos.getExternalIdsColumn() != null) {
oldExternalIds = oldQos.getExternalIdsColumn().getData();
}
- if ((oldExternalIds != null) && !oldExternalIds.isEmpty()) {
+ if (oldExternalIds != null && !oldExternalIds.isEmpty()) {
removeOldExternalIds(transaction, qosEntryBuilder, oldExternalIds, qos, nodeIId);
}
if (externalIds != null && !externalIds.isEmpty()) {
private void setNewExternalIds(QosEntriesBuilder qosEntryBuilder,
Map<String, String> externalIds) {
- Set<String> externalIdsKeys = externalIds.keySet();
List<QosExternalIds> externalIdsList = new ArrayList<>();
- String extIdValue;
- for (String extIdKey : externalIdsKeys) {
- extIdValue = externalIds.get(extIdKey);
+ for (Entry<String, String> entry : externalIds.entrySet()) {
+ String extIdKey = entry.getKey();
+ String extIdValue = entry.getValue();
if (extIdKey != null && extIdValue != null) {
externalIdsList.add(new QosExternalIdsBuilder().setQosExternalIdKey(extIdKey)
.setQosExternalIdValue(extIdValue).build());
if (oldQos != null && oldQos.getQueuesColumn() != null) {
oldQueueList = oldQos.getQueuesColumn().getData();
}
- if ((oldQueueList != null) && !oldQueueList.isEmpty()) {
+ if (oldQueueList != null && !oldQueueList.isEmpty()) {
removeOldQueues(transaction, qosEntryBuilder, oldQueueList, qos, nodeIId);
}
if (queueList != null && !queueList.isEmpty()) {
Collection<Long> queueListKeys = oldQueueList.keySet();
for (Long queueListKey : queueListKeys) {
KeyedInstanceIdentifier<QueueList, QueueListKey> otherIId =
- qosIId
- .child(QueueList.class, new QueueListKey(new Long(queueListKey.toString())));
+ qosIId.child(QueueList.class, new QueueListKey(Long.valueOf(queueListKey.toString())));
transaction.delete(LogicalDatastoreType.OPERATIONAL, otherIId);
}
}
private final InstanceIdentifierCodec instanceIdentifierCodec;
- private Map<UUID, Queue> updatedQueueRows;
- private Map<UUID, Queue> oldQueueRows;
+ private final Map<UUID, Queue> updatedQueueRows;
+ private final Map<UUID, Queue> oldQueueRows;
public OvsdbQueueUpdateCommand(InstanceIdentifierCodec instanceIdentifierCodec, OvsdbConnectionInstance key,
TableUpdates updates, DatabaseSchema dbSchema) {
if (oldQueue != null && oldQueue.getOtherConfigColumn() != null) {
oldOtherConfigs = oldQueue.getOtherConfigColumn().getData();
}
- if ((oldOtherConfigs != null) && !oldOtherConfigs.isEmpty()) {
+ if (oldOtherConfigs != null && !oldOtherConfigs.isEmpty()) {
removeOldConfigs(transaction, queuesBuilder, oldOtherConfigs, queue, nodeIId);
}
if (otherConfigs != null && !otherConfigs.isEmpty()) {
private void setNewOtherConfigs(QueuesBuilder queuesBuilder,
Map<String, String> otherConfig) {
- Set<String> otherConfigKeys = otherConfig.keySet();
List<QueuesOtherConfig> otherConfigList = new ArrayList<>();
- String otherConfigValue;
- for (String otherConfigKey : otherConfigKeys) {
- otherConfigValue = otherConfig.get(otherConfigKey);
+ for (Entry<String, String> entry : otherConfig.entrySet()) {
+ String otherConfigKey = entry.getKey();
+ String otherConfigValue = entry.getValue();
if (otherConfigKey != null && otherConfigValue != null) {
otherConfigList.add(new QueuesOtherConfigBuilder().setQueueOtherConfigKey(otherConfigKey)
.setQueueOtherConfigValue(otherConfigValue).build());
if (oldQueue != null && oldQueue.getExternalIdsColumn() != null) {
oldExternalIds = oldQueue.getExternalIdsColumn().getData();
}
- if ((oldExternalIds != null) && !oldExternalIds.isEmpty()) {
+ if (oldExternalIds != null && !oldExternalIds.isEmpty()) {
removeOldExternalIds(transaction, queuesBuilder, oldExternalIds, queue, nodeIId);
}
if (externalIds != null && !externalIds.isEmpty()) {
private void setNewExternalIds(QueuesBuilder queuesBuilder,
Map<String, String> externalIds) {
- Set<String> externalIdsKeys = externalIds.keySet();
List<QueuesExternalIds> externalIdsList = new ArrayList<>();
- String externalIdValue;
- for (String extIdKey : externalIdsKeys) {
- externalIdValue = externalIds.get(extIdKey);
+ for (Entry<String, String> entry : externalIds.entrySet()) {
+ String extIdKey = entry.getKey();
+ String externalIdValue = entry.getValue();
if (extIdKey != null && externalIdValue != null) {
externalIdsList.add(new QueuesExternalIdsBuilder().setQueuesExternalIdKey(extIdKey)
.setQueuesExternalIdValue(externalIdValue).build());
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import java.util.ArrayList;
import java.util.HashMap;
private static final Logger LOG = LoggerFactory.getLogger(TransactionInvokerImpl.class);
private static final int QUEUE_SIZE = 10000;
private BindingTransactionChain chain;
- private DataBroker db;
- private BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
- private BlockingQueue<ReadWriteTransaction> successfulTransactionQueue
+ private final DataBroker db;
+ private final BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
+ private final BlockingQueue<ReadWriteTransaction> successfulTransactionQueue
= new LinkedBlockingQueue<>(QUEUE_SIZE);
- private BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue
+ private final BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQueue
= new LinkedBlockingQueue<>(QUEUE_SIZE);
- private ExecutorService executor;
+ private final ExecutorService executor;
private Map<ReadWriteTransaction,TransactionCommand> transactionToCommand
= new HashMap<>();
private List<ReadWriteTransaction> pendingTransactions = new ArrayList<>();
this.chain = db.createTransactionChain(this);
ThreadFactory threadFact = new ThreadFactoryBuilder().setNameFormat("transaction-invoker-impl-%d").build();
executor = Executors.newSingleThreadExecutor(threadFact);
- executor.submit(this);
+ executor.execute(this);
}
@Override
public void invoke(final TransactionCommand command) {
// TODO what do we do if queue is full?
- inputQueue.offer(command);
+ if (!inputQueue.offer(command)) {
+ LOG.error("inputQueue is full (size: {}) - could not offer {}", inputQueue.size(), command);
+ }
}
@Override
public void onTransactionChainFailed(TransactionChain<?, ?> chainArg,
AsyncTransaction<?, ?> transaction, Throwable cause) {
- failedTransactionQueue.offer(transaction);
+ offerFailedTransaction(transaction);
}
@Override
Futures.addCallback(transaction.submit(), new FutureCallback<Void>() {
@Override
public void onSuccess(final Void result) {
- successfulTransactionQueue.offer(transaction);
+ if (!successfulTransactionQueue.offer(transaction)) {
+ LOG.error("successfulTransactionQueue is full (size: {}) - could not offer {}",
+ successfulTransactionQueue.size(), transaction);
+ }
}
@Override
public void onFailure(final Throwable throwable) {
// NOOP - handled by failure of transaction chain
}
- });
+ }, MoreExecutors.directExecutor());
}
} catch (IllegalStateException e) {
if (transactionInFlight != null) {
// retried from exceptions on which the command should NOT be retried.
// Then it should retry only the commands which should be retried, otherwise
// this method will retry commands which will never be successful forever.
- failedTransactionQueue.offer(transactionInFlight);
+ offerFailedTransaction(transactionInFlight);
}
LOG.warn("Failed to process an update notification from OVS.", e);
}
}
}
+ private void offerFailedTransaction(AsyncTransaction<?, ?> transaction) {
+ if (!failedTransactionQueue.offer(transaction)) {
+ LOG.warn("failedTransactionQueue is full (size: {})", failedTransactionQueue.size());
+ }
+ }
+
private List<TransactionCommand> extractResubmitCommands() {
AsyncTransaction<?, ?> transaction = failedTransactionQueue.poll();
List<TransactionCommand> commands = new ArrayList<>();