import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+
+import java.net.ConnectException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
-
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-
-import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationManager;
import org.opendaylight.ovsdb.southbound.reconciliation.ReconciliationTask;
+import org.opendaylight.ovsdb.southbound.reconciliation.configuration.BridgeConfigReconciliationTask;
import org.opendaylight.ovsdb.southbound.reconciliation.connection.ConnectionReconciliationTask;
import org.opendaylight.ovsdb.southbound.transactions.md.OvsdbNodeRemoveCommand;
import org.opendaylight.ovsdb.southbound.transactions.md.TransactionCommand;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class OvsdbConnectionManager implements OvsdbConnectionListener, AutoCloseable {
private Map<ConnectionInfo, OvsdbConnectionInstance> clients =
new ConcurrentHashMap<>();
private static final Logger LOG = LoggerFactory.getLogger(OvsdbConnectionManager.class);
private static final String ENTITY_TYPE = "ovsdb";
+ private static final int DB_FETCH_TIMEOUT = 1000;
private DataBroker db;
private TransactionInvoker txInvoker;
externalClient.getConnectionInfo().getLocalPort());
List<String> databases = new ArrayList<>();
try {
- databases = externalClient.getDatabases().get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.warn("Unable to fetch database list");
+ 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
+ registerEntityForOwnership(client);
+ }
+ } catch (InterruptedException | ExecutionException | TimeoutException e) {
+ LOG.warn("Unable to fetch Database list from device {}. Disconnecting from the device.",
+ externalClient.getConnectionInfo().getRemoteAddress(), e);
+ externalClient.disconnect();
}
- if(databases.contains(SouthboundConstants.OPEN_V_SWITCH)) {
- OvsdbConnectionInstance client = connectedButCallBacksNotRegistered(externalClient);
- // Register Cluster Ownership for ConnectionInfo
- registerEntityForOwnership(client);
- }
}
public OvsdbConnectionInstance connectedButCallBacksNotRegistered(final OvsdbClient externalClient) {
ovsdbConnectionInstance.disconnect();
removeConnectionInstance(key);
+
+ stopBridgeConfigReconciliationIfActive(ovsdbConnectionInstance.getInstanceIdentifier());
}
ovsdbConnectionInstance = new OvsdbConnectionInstance(key, externalClient, txInvoker,
//Controller initiated connection can be terminated from switch side.
//So cleanup the instance identifier cache.
removeInstanceIdentifier(key);
+ stopBridgeConfigReconciliationIfActive(ovsdbConnectionInstance.getInstanceIdentifier());
retryConnection(ovsdbConnectionInstance.getInstanceIdentifier(),
ovsdbConnectionInstance.getOvsdbNodeAugmentation(),
ConnectionReconciliationTriggers.ON_DISCONNECT);
LOG.warn("disconnected : Connection instance not found for OVSDB Node {} ", key);
}
LOG.trace("OvsdbConnectionManager: exit disconnected client: {}", client);
-
}
public OvsdbClient connect(InstanceIdentifier<Node> iid,
- OvsdbNodeAugmentation ovsdbNode) throws UnknownHostException {
+ OvsdbNodeAugmentation ovsdbNode) throws UnknownHostException, ConnectException {
LOG.info("Connecting to {}", SouthboundUtil.connectionInfoToString(ovsdbNode.getConnectionInfo()));
// TODO handle case where we already have a connection
client.disconnect();
removeInstanceIdentifier(ovsdbNode.getConnectionInfo());
+
+ stopBridgeConfigReconciliationIfActive(client.getInstanceIdentifier());
} else {
LOG.debug("disconnect : connection instance not found for {}",ovsdbNode.getConnectionInfo());
}
ovsdbDeviceEntityOwnershipListener.close();
}
- for (OvsdbClient client: clients.values()) {
+ for (OvsdbConnectionInstance client: clients.values()) {
client.disconnect();
}
}
instanceIdentifiers.remove(connectionInfo);
}
- public OvsdbConnectionInstance getConnectionInstance(ConnectionInfo key) {
+ public InstanceIdentifier<Node> getInstanceIdentifier(ConnectionInfo key) {
ConnectionInfo connectionInfo = SouthboundMapper.suppressLocalIpPort(key);
- return clients.get(connectionInfo);
+ return instanceIdentifiers.get(connectionInfo);
}
- public InstanceIdentifier<Node> getInstanceIdentifier(ConnectionInfo key) {
+ public OvsdbConnectionInstance getConnectionInstance(ConnectionInfo key) {
ConnectionInfo connectionInfo = SouthboundMapper.suppressLocalIpPort(key);
- return instanceIdentifiers.get(connectionInfo);
+ return clients.get(connectionInfo);
}
public OvsdbConnectionInstance getConnectionInstance(OvsdbBridgeAttributes mn) {
LogicalDatastoreType.OPERATIONAL, nodePath);
transaction.close();
Optional<Node> optional = nodeFuture.get();
- if (optional != null && optional.isPresent() && optional.get() != null) {
+ if (optional.isPresent()) {
return this.getConnectionInstance(optional.get());
} else {
- LOG.warn("Found non-topological node {} on path {}",optional);
+ LOG.debug("Node was not found on the path in the operational DS: {}", nodePath);
return null;
}
- } catch (Exception e) {
+ } catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to get Ovsdb Node {}",nodePath, e);
return null;
}
}
public OvsdbClient getClient(ConnectionInfo connectionInfo) {
- return getConnectionInstance(connectionInfo);
+ return getConnectionInstance(connectionInfo).getOvsdbClient();
}
public OvsdbClient getClient(OvsdbBridgeAttributes mn) {
- return getConnectionInstance(mn);
+ return getConnectionInstance(mn).getOvsdbClient();
}
public OvsdbClient getClient(Node node) {
- return getConnectionInstance(node);
+ return getConnectionInstance(node).getOvsdbClient();
}
public Boolean getHasDeviceOwnership(ConnectionInfo connectionInfo) {
return ovsdbConnectionInstance.getHasDeviceOwnership();
}
- public void reconcileConnection(InstanceIdentifier<Node> iid, OvsdbNodeAugmentation ovsdbNode){
+ public void reconcileConnection(InstanceIdentifier<Node> iid, OvsdbNodeAugmentation ovsdbNode) {
this.retryConnection(iid, ovsdbNode,
ConnectionReconciliationTriggers.ON_CONTROLLER_INITIATED_CONNECTION_FAILURE);
ovsdbNode);
reconciliationManager.dequeue(task);
}
+
+ public void stopBridgeConfigReconciliationIfActive(InstanceIdentifier<?> iid) {
+ final ReconciliationTask task = new BridgeConfigReconciliationTask(
+ reconciliationManager,
+ this,
+ iid,
+ null);
+ reconciliationManager.dequeue(task);
+ reconciliationManager.cancelTerminationPointReconciliation();
+ }
+
private void handleOwnershipChanged(EntityOwnershipChange ownershipChange) {
OvsdbConnectionInstance ovsdbConnectionInstance = getConnectionInstanceFromEntity(ownershipChange.getEntity());
LOG.debug("handleOwnershipChanged: {} event received for device {}",
if (ownershipChange.isOwner() == ovsdbConnectionInstance.getHasDeviceOwnership()) {
LOG.info("handleOwnershipChanged: no change in ownership for {}. Ownership status is : {}",
ovsdbConnectionInstance.getConnectionInfo(), ovsdbConnectionInstance.getHasDeviceOwnership()
- ? SouthboundConstants.OWNERSHIPSTATES.OWNER.getState()
- : SouthboundConstants.OWNERSHIPSTATES.NONOWNER.getState());
+ ? SouthboundConstants.OwnershipStates.OWNER.getState()
+ : SouthboundConstants.OwnershipStates.NONOWNER.getState());
return;
}
//so register for monitor callbacks
ovsdbConnectionInstance.registerCallbacks();
+ reconcileBridgeConfigurations(ovsdbConnectionInstance);
} else {
//You were owner of the device, but now you are not. With the current ownership
//grant mechanism, this scenario should not occur. Because this scenario will occur
DatabaseSchema dbSchema = null;
OpenVSwitch openVSwitchRow = null;
try {
- dbSchema = connectionInstance.getSchema(OvsdbSchemaContants.databaseName).get();
+ dbSchema = connectionInstance.getSchema(OvsdbSchemaContants.DATABASE_NAME).get();
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Not able to fetch schema for database {} from device {}",
- OvsdbSchemaContants.databaseName,connectionInstance.getConnectionInfo(),e);
+ OvsdbSchemaContants.DATABASE_NAME,connectionInstance.getConnectionInfo(),e);
}
if (dbSchema != null) {
GenericTableSchema openVSwitchSchema = TyperUtils.getTableSchema(dbSchema, OpenVSwitch.class);
}
return openVSwitchRow;
}
+
private Entity getEntityFromConnectionInstance(@Nonnull OvsdbConnectionInstance ovsdbConnectionInstance) {
InstanceIdentifier<Node> iid = ovsdbConnectionInstance.getInstanceIdentifier();
if ( iid == null ) {
iid,
ovsdbNode);
- if(reconciliationManager.isEnqueued(task)){
+ if (reconciliationManager.isEnqueued(task)) {
return;
}
- switch(trigger){
+ switch (trigger) {
case ON_CONTROLLER_INITIATED_CONNECTION_FAILURE:
reconciliationManager.enqueueForRetry(task);
break;
@Override
public void onSuccess(@Nullable Optional<Node> node) {
if (node.isPresent()) {
- LOG.info("Disconnected/Failed connection {} was controller initiated, attempting " +
- "reconnection", ovsdbNode.getConnectionInfo());
+ LOG.info("Disconnected/Failed connection {} was controller initiated, attempting "
+ + "reconnection", ovsdbNode.getConnectionInfo());
reconciliationManager.enqueue(task);
} else {
- LOG.debug("Connection {} was switch initiated, no reconciliation is required"
- , iid.firstKeyOf(Node.class).getNodeId());
+ LOG.debug("Connection {} was switch initiated, no reconciliation is required",
+ iid.firstKeyOf(Node.class).getNodeId());
}
}
@Override
- public void onFailure(Throwable t) {
- LOG.warn("Read Config/DS for Node failed! {}", iid, t);
+ public void onFailure(Throwable throwable) {
+ LOG.warn("Read Config/DS for Node failed! {}", iid, throwable);
}
});
break;
}
}
+ private void reconcileBridgeConfigurations(final OvsdbConnectionInstance client) {
+ final InstanceIdentifier<Node> nodeIid = client.getInstanceIdentifier();
+ final ReconciliationTask task = new BridgeConfigReconciliationTask(
+ reconciliationManager, OvsdbConnectionManager.this, nodeIid, client);
+
+ reconciliationManager.enqueue(task);
+ }
+
private class OvsdbDeviceEntityOwnershipListener implements EntityOwnershipListener {
private OvsdbConnectionManager cm;
private EntityOwnershipListenerRegistration listenerRegistration;
this.cm = cm;
listenerRegistration = entityOwnershipService.registerListener(ENTITY_TYPE, this);
}
+
public void close() {
listenerRegistration.close();
}
+
@Override
public void ownershipChanged(EntityOwnershipChange ownershipChange) {
cm.handleOwnershipChanged(ownershipChange);