2 * Copyright (c) 2015, 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.ovsdb.hwvtepsouthbound;
11 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
13 import com.google.common.base.Optional;
14 import com.google.common.base.Preconditions;
15 import com.google.common.util.concurrent.CheckedFuture;
16 import com.google.common.util.concurrent.FutureCallback;
17 import com.google.common.util.concurrent.Futures;
18 import com.google.common.util.concurrent.MoreExecutors;
19 import java.net.ConnectException;
20 import java.net.InetAddress;
21 import java.net.UnknownHostException;
22 import java.util.ArrayList;
23 import java.util.Collections;
24 import java.util.List;
26 import java.util.concurrent.ConcurrentHashMap;
27 import java.util.concurrent.ExecutionException;
28 import java.util.concurrent.TimeUnit;
29 import java.util.concurrent.TimeoutException;
30 import org.eclipse.jdt.annotation.NonNull;
31 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
32 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
33 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
34 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
35 import org.opendaylight.mdsal.eos.binding.api.Entity;
36 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
37 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipChange;
38 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListener;
39 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipListenerRegistration;
40 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
41 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
42 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
43 import org.opendaylight.ovsdb.hwvtepsouthbound.events.ClientConnected;
44 import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.ReconciliationManager;
45 import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.ReconciliationTask;
46 import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.configuration.HwvtepReconciliationTask;
47 import org.opendaylight.ovsdb.hwvtepsouthbound.reconciliation.connection.ConnectionReconciliationTask;
48 import org.opendaylight.ovsdb.hwvtepsouthbound.transact.DependencyQueue;
49 import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.HwvtepGlobalRemoveCommand;
50 import org.opendaylight.ovsdb.hwvtepsouthbound.transactions.md.TransactionInvoker;
51 import org.opendaylight.ovsdb.lib.OvsdbClient;
52 import org.opendaylight.ovsdb.lib.OvsdbConnection;
53 import org.opendaylight.ovsdb.lib.OvsdbConnectionListener;
54 import org.opendaylight.ovsdb.lib.operations.Operation;
55 import org.opendaylight.ovsdb.lib.operations.OperationResult;
56 import org.opendaylight.ovsdb.lib.operations.Select;
57 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
58 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
59 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
60 import org.opendaylight.ovsdb.schema.hardwarevtep.Global;
61 import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionHistory;
62 import org.opendaylight.ovsdb.utils.mdsal.utils.TransactionType;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepGlobalAugmentation;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.HwvtepPhysicalSwitchAttributes;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.hwvtep.global.attributes.ConnectionInfo;
67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
68 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
69 import org.slf4j.Logger;
70 import org.slf4j.LoggerFactory;
72 public class HwvtepConnectionManager implements OvsdbConnectionListener, AutoCloseable {
73 private final Map<ConnectionInfo, HwvtepConnectionInstance> clients = new ConcurrentHashMap<>();
74 private static final Logger LOG = LoggerFactory.getLogger(HwvtepConnectionManager.class);
75 private static final String ENTITY_TYPE = "hwvtep";
76 private static final int DB_FETCH_TIMEOUT = 1000;
77 private static final int TRANSACTION_HISTORY_CAPACITY = 10000;
78 private static final int TRANSACTION_HISTORY_WATERMARK = 7500;
80 private final DataBroker db;
81 private final TransactionInvoker txInvoker;
82 private final Map<ConnectionInfo,InstanceIdentifier<Node>> instanceIdentifiers = new ConcurrentHashMap<>();
83 private final Map<Entity, HwvtepConnectionInstance> entityConnectionMap = new ConcurrentHashMap<>();
84 private final EntityOwnershipService entityOwnershipService;
85 private final HwvtepDeviceEntityOwnershipListener hwvtepDeviceEntityOwnershipListener;
86 private final ReconciliationManager reconciliationManager;
87 private final Map<InstanceIdentifier<Node>, HwvtepConnectionInstance> nodeIidVsConnectionInstance =
88 new ConcurrentHashMap<>();
89 private final HwvtepOperGlobalListener hwvtepOperGlobalListener;
90 private final Map<InstanceIdentifier<Node>, TransactionHistory> controllerTxHistory = new ConcurrentHashMap<>();
91 private final Map<InstanceIdentifier<Node>, TransactionHistory> deviceUpdateHistory = new ConcurrentHashMap<>();
92 private final OvsdbConnection ovsdbConnectionService;
94 public HwvtepConnectionManager(final DataBroker db, final TransactionInvoker txInvoker,
95 final EntityOwnershipService entityOwnershipService, final OvsdbConnection ovsdbConnectionService) {
97 this.txInvoker = txInvoker;
98 this.entityOwnershipService = entityOwnershipService;
99 this.hwvtepDeviceEntityOwnershipListener = new HwvtepDeviceEntityOwnershipListener(this,entityOwnershipService);
100 this.reconciliationManager = new ReconciliationManager(db);
101 this.hwvtepOperGlobalListener = new HwvtepOperGlobalListener(db, this);
102 this.ovsdbConnectionService = ovsdbConnectionService;
106 public void close() throws Exception {
107 if (hwvtepDeviceEntityOwnershipListener != null) {
108 hwvtepDeviceEntityOwnershipListener.close();
111 for (HwvtepConnectionInstance client: clients.values()) {
114 DependencyQueue.close();
118 public void connected(final OvsdbClient externalClient) {
119 LOG.info("Library connected {} from {}:{} to {}:{}",
120 externalClient.getConnectionInfo().getType(),
121 externalClient.getConnectionInfo().getRemoteAddress(),
122 externalClient.getConnectionInfo().getRemotePort(),
123 externalClient.getConnectionInfo().getLocalAddress(),
124 externalClient.getConnectionInfo().getLocalPort());
126 List<String> databases = externalClient.getDatabases().get(DB_FETCH_TIMEOUT, TimeUnit.MILLISECONDS);
127 if (databases.contains(HwvtepSchemaConstants.HARDWARE_VTEP)) {
128 HwvtepConnectionInstance hwClient = connectedButCallBacksNotRegistered(externalClient);
129 registerEntityForOwnership(hwClient);
131 } catch (InterruptedException | ExecutionException | TimeoutException e) {
132 LOG.warn("Unable to fetch Database list from device {}. Disconnecting from the device.",
133 externalClient.getConnectionInfo().getRemoteAddress(), e);
134 externalClient.disconnect();
139 public void disconnected(final OvsdbClient client) {
140 LOG.info("Library disconnected {} from {}:{} to {}:{}. Cleaning up the operational data store",
141 client.getConnectionInfo().getType(),
142 client.getConnectionInfo().getRemoteAddress(),
143 client.getConnectionInfo().getRemotePort(),
144 client.getConnectionInfo().getLocalAddress(),
145 client.getConnectionInfo().getLocalPort());
146 ConnectionInfo key = HwvtepSouthboundMapper.createConnectionInfo(client);
147 HwvtepConnectionInstance hwvtepConnectionInstance = getConnectionInstance(key);
148 if (hwvtepConnectionInstance != null) {
149 if (hwvtepConnectionInstance.getInstanceIdentifier() != null) {
150 deviceUpdateHistory.get(hwvtepConnectionInstance.getInstanceIdentifier()).addToHistory(
151 TransactionType.DELETE, new ClientConnected(client.getConnectionInfo().getRemotePort()));
155 // Unregister Entity ownership as soon as possible ,so this instance should
156 // not be used as a candidate in Entity election (given that this instance is
157 // about to disconnect as well), if current owner get disconnected from
159 if (hwvtepConnectionInstance.getHasDeviceOwnership()) {
160 unregisterEntityForOwnership(hwvtepConnectionInstance);
161 txInvoker.invoke(new HwvtepGlobalRemoveCommand(hwvtepConnectionInstance, null, null));
163 unregisterEntityForOwnership(hwvtepConnectionInstance);
164 //Do not delete if client disconnected from follower HwvtepGlobalRemoveCommand
167 removeConnectionInstance(key);
169 //Controller initiated connection can be terminated from switch side.
170 //So cleanup the instance identifier cache.
171 removeInstanceIdentifier(key);
172 removeConnectionInstance(hwvtepConnectionInstance.getInstanceIdentifier());
173 retryConnection(hwvtepConnectionInstance.getInstanceIdentifier(),
174 hwvtepConnectionInstance.getHwvtepGlobalAugmentation(),
175 ConnectionReconciliationTriggers.ON_DISCONNECT);
177 LOG.warn("HWVTEP disconnected event did not find connection instance for {}", key);
179 LOG.trace("HwvtepConnectionManager exit disconnected client: {}", client);
182 public OvsdbClient connect(final InstanceIdentifier<Node> iid, final HwvtepGlobalAugmentation hwvtepGlobal)
183 throws UnknownHostException, ConnectException {
184 LOG.info("Connecting to {}", HwvtepSouthboundUtil.connectionInfoToString(hwvtepGlobal.getConnectionInfo()));
185 InetAddress ip = HwvtepSouthboundMapper.createInetAddress(hwvtepGlobal.getConnectionInfo().getRemoteIp());
186 OvsdbClient client = ovsdbConnectionService
187 .connect(ip, hwvtepGlobal.getConnectionInfo().getRemotePort().getValue().toJava());
188 if (client != null) {
189 putInstanceIdentifier(hwvtepGlobal.getConnectionInfo(), iid.firstIdentifierOf(Node.class));
190 HwvtepConnectionInstance hwvtepConnectionInstance = connectedButCallBacksNotRegistered(client);
191 hwvtepConnectionInstance.setHwvtepGlobalAugmentation(hwvtepGlobal);
192 hwvtepConnectionInstance.setInstanceIdentifier(iid.firstIdentifierOf(Node.class));
194 // Register Cluster Ownership for ConnectionInfo
195 registerEntityForOwnership(hwvtepConnectionInstance);
197 LOG.warn("Failed to connect to OVSDB node: {}", hwvtepGlobal.getConnectionInfo());
202 public void disconnect(final HwvtepGlobalAugmentation ovsdbNode) throws UnknownHostException {
203 LOG.info("Diconnecting from {}", HwvtepSouthboundUtil.connectionInfoToString(ovsdbNode.getConnectionInfo()));
204 HwvtepConnectionInstance client = getConnectionInstance(ovsdbNode.getConnectionInfo());
205 if (client != null) {
207 // Unregister Cluster Ownership for ConnectionInfo
208 unregisterEntityForOwnership(client);
209 removeInstanceIdentifier(ovsdbNode.getConnectionInfo());
213 public HwvtepConnectionInstance connectedButCallBacksNotRegistered(final OvsdbClient externalClient) {
214 LOG.info("OVSDB Connection from {}:{}",externalClient.getConnectionInfo().getRemoteAddress(),
215 externalClient.getConnectionInfo().getRemotePort());
216 ConnectionInfo key = HwvtepSouthboundMapper.createConnectionInfo(externalClient);
217 HwvtepConnectionInstance hwvtepConnectionInstance = getConnectionInstance(key);
219 // Check if existing hwvtepConnectionInstance for the OvsdbClient present.
220 // In such cases, we will see if the hwvtepConnectionInstance has same externalClient.
221 if (hwvtepConnectionInstance != null) {
222 if (hwvtepConnectionInstance.hasOvsdbClient(externalClient)) {
223 LOG.warn("HWVTEP Connection Instance {} already exists for client {}", key, externalClient);
224 return hwvtepConnectionInstance;
226 LOG.warn("HWVTEP Connection Instance {} being replaced with client {}", key, externalClient);
227 hwvtepConnectionInstance.disconnect();
229 // Unregister Cluster Ownership for ConnectionInfo
230 // Because the hwvtepConnectionInstance is about to be completely replaced!
231 unregisterEntityForOwnership(hwvtepConnectionInstance);
233 removeConnectionInstance(key);
236 hwvtepConnectionInstance = new HwvtepConnectionInstance(this, key, externalClient, getInstanceIdentifier(key),
238 hwvtepConnectionInstance.createTransactInvokers();
239 return hwvtepConnectionInstance;
242 private void putConnectionInstance(final ConnectionInfo key,final HwvtepConnectionInstance instance) {
243 ConnectionInfo connectionInfo = HwvtepSouthboundMapper.suppressLocalIpPort(key);
244 clients.put(connectionInfo, instance);
245 LOG.info("Clients after put: {}", clients);
248 void putConnectionInstance(final InstanceIdentifier<Node> nodeIid,
249 final HwvtepConnectionInstance connectionInstance) {
250 nodeIidVsConnectionInstance.put(nodeIid, connectionInstance);
253 public HwvtepConnectionInstance getConnectionInstanceFromNodeIid(final InstanceIdentifier<Node> nodeIid) {
254 HwvtepConnectionInstance hwvtepConnectionInstance = nodeIidVsConnectionInstance.get(nodeIid);
255 if (hwvtepConnectionInstance != null) {
256 return hwvtepConnectionInstance;
258 InstanceIdentifier<Node> globalNodeIid = HwvtepSouthboundUtil.getGlobalNodeIid(nodeIid);
259 if (globalNodeIid != null) {
260 return nodeIidVsConnectionInstance.get(globalNodeIid);
265 public HwvtepConnectionInstance getConnectionInstance(final ConnectionInfo key) {
269 ConnectionInfo connectionInfo = HwvtepSouthboundMapper.suppressLocalIpPort(key);
270 return clients.get(connectionInfo);
273 public HwvtepConnectionInstance getConnectionInstance(final Node node) {
274 Preconditions.checkNotNull(node);
275 HwvtepGlobalAugmentation hwvtepGlobal = node.augmentation(HwvtepGlobalAugmentation.class);
276 PhysicalSwitchAugmentation switchNode = node.augmentation(PhysicalSwitchAugmentation.class);
277 if (hwvtepGlobal != null) {
278 if (hwvtepGlobal.getConnectionInfo() != null) {
279 return getConnectionInstance(hwvtepGlobal.getConnectionInfo());
281 //TODO: Case of user configured connection for now
282 //TODO: We could get it from Managers also.
286 else if (switchNode != null) {
287 return getConnectionInstance(switchNode);
289 LOG.warn("This is not a node that gives any hint how to find its OVSDB Manager: {}",node);
294 public HwvtepConnectionInstance getConnectionInstance(final HwvtepPhysicalSwitchAttributes node) {
295 Optional<HwvtepGlobalAugmentation> optional = HwvtepSouthboundUtil.getManagingNode(db, node);
296 if (optional.isPresent()) {
297 return getConnectionInstance(optional.get().getConnectionInfo());
303 public void stopConfigurationReconciliation(final InstanceIdentifier<Node> nodeIid) {
304 final ReconciliationTask task = new HwvtepReconciliationTask(
305 reconciliationManager, HwvtepConnectionManager.this, nodeIid, null, null, db);
307 reconciliationManager.dequeue(task);
310 public void reconcileConfigurations(final HwvtepConnectionInstance client, final Node psNode) {
311 final InstanceIdentifier<Node> nodeIid = client.getInstanceIdentifier();
312 final ReconciliationTask task = new HwvtepReconciliationTask(
313 reconciliationManager, HwvtepConnectionManager.this, nodeIid, psNode, client, db);
315 reconciliationManager.enqueue(task);
318 private void removeConnectionInstance(final ConnectionInfo key) {
319 ConnectionInfo connectionInfo = HwvtepSouthboundMapper.suppressLocalIpPort(key);
320 clients.remove(connectionInfo);
321 LOG.info("Clients after remove: {}", clients);
324 private void removeConnectionInstance(final InstanceIdentifier<Node> nodeIid) {
325 if (nodeIid != null) {
326 nodeIidVsConnectionInstance.remove(nodeIid);
330 private void putInstanceIdentifier(final ConnectionInfo key,final InstanceIdentifier<Node> iid) {
331 ConnectionInfo connectionInfo = HwvtepSouthboundMapper.suppressLocalIpPort(key);
332 instanceIdentifiers.put(connectionInfo, iid);
335 public InstanceIdentifier<Node> getInstanceIdentifier(final ConnectionInfo key) {
336 ConnectionInfo connectionInfo = HwvtepSouthboundMapper.suppressLocalIpPort(key);
337 return instanceIdentifiers.get(connectionInfo);
340 private void removeInstanceIdentifier(final ConnectionInfo key) {
341 ConnectionInfo connectionInfo = HwvtepSouthboundMapper.suppressLocalIpPort(key);
342 instanceIdentifiers.remove(connectionInfo);
345 public OvsdbClient getClient(final ConnectionInfo connectionInfo) {
346 return getConnectionInstance(connectionInfo).getOvsdbClient();
349 private void registerEntityForOwnership(final HwvtepConnectionInstance hwvtepConnectionInstance) {
351 Entity candidateEntity = getEntityFromConnectionInstance(hwvtepConnectionInstance);
352 if (entityConnectionMap.get(candidateEntity) != null) {
353 disconnected(entityConnectionMap.get(candidateEntity).getOvsdbClient());
354 putConnectionInstance(hwvtepConnectionInstance.getInstanceIdentifier(), hwvtepConnectionInstance);
356 entityConnectionMap.put(candidateEntity, hwvtepConnectionInstance);
357 hwvtepConnectionInstance.setConnectedEntity(candidateEntity);
360 EntityOwnershipCandidateRegistration registration =
361 entityOwnershipService.registerCandidate(candidateEntity);
362 hwvtepConnectionInstance.setDeviceOwnershipCandidateRegistration(registration);
363 LOG.info("HWVTEP entity {} is registered for ownership.", candidateEntity);
365 //If entity already has owner, it won't get notification from EntityOwnershipService
366 //so cache the connection instances.
367 handleOwnershipState(candidateEntity, hwvtepConnectionInstance);
368 } catch (CandidateAlreadyRegisteredException e) {
369 LOG.warn("OVSDB entity {} was already registered for ownership", candidateEntity, e);
374 private void handleOwnershipState(final Entity candidateEntity,
375 final HwvtepConnectionInstance hwvtepConnectionInstance) {
376 //If entity already has owner, it won't get notification from EntityOwnershipService
377 //so cache the connection instances.
378 java.util.Optional<EntityOwnershipState> ownershipStateOpt =
379 entityOwnershipService.getOwnershipState(candidateEntity);
380 if (ownershipStateOpt.isPresent()) {
381 EntityOwnershipState ownershipState = ownershipStateOpt.get();
382 putConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo(), hwvtepConnectionInstance);
383 if (ownershipState != EntityOwnershipState.NO_OWNER) {
384 hwvtepConnectionInstance.setHasDeviceOwnership(ownershipState == EntityOwnershipState.IS_OWNER);
385 if (ownershipState != EntityOwnershipState.IS_OWNER) {
386 LOG.info("HWVTEP entity {} is already owned by other southbound plugin "
387 + "instance, so *this* instance is NOT an OWNER of the device",
388 hwvtepConnectionInstance.getConnectionInfo());
390 afterTakingOwnership(hwvtepConnectionInstance);
396 private void afterTakingOwnership(final HwvtepConnectionInstance hwvtepConnectionInstance) {
397 txInvoker.invoke(new HwvtepGlobalRemoveCommand(hwvtepConnectionInstance, null, null));
398 putConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo(), hwvtepConnectionInstance);
399 hwvtepConnectionInstance.setHasDeviceOwnership(true);
400 hwvtepConnectionInstance.registerCallbacks();
403 private static Global getHwvtepGlobalTableEntry(final HwvtepConnectionInstance connectionInstance) {
404 final DatabaseSchema dbSchema;
406 dbSchema = connectionInstance.getSchema(HwvtepSchemaConstants.HARDWARE_VTEP).get();
407 } catch (InterruptedException | ExecutionException e) {
408 LOG.warn("Not able to fetch schema for database {} from device {}",
409 HwvtepSchemaConstants.HARDWARE_VTEP, connectionInstance.getConnectionInfo(), e);
413 GenericTableSchema hwvtepSchema = TyperUtils.getTableSchema(dbSchema, Global.class);
414 Select<GenericTableSchema> selectOperation = op.select(hwvtepSchema);
415 selectOperation.setColumns(new ArrayList<>(hwvtepSchema.getColumns()));
417 ArrayList<Operation> operations = new ArrayList<>(2);
418 operations.add(selectOperation);
419 operations.add(op.comment("Fetching hardware_vtep table rows"));
421 final List<OperationResult> results;
423 results = connectionInstance.transact(dbSchema, operations).get();
424 } catch (InterruptedException | ExecutionException e) {
425 LOG.warn("Not able to fetch hardware_vtep table row from device {}", connectionInstance.getConnectionInfo(),
430 final Global globalRow;
431 if (results != null) {
432 OperationResult selectResult = results.get(0);
433 globalRow = TyperUtils.getTypedRowWrapper(dbSchema,Global.class,selectResult.getRows().get(0));
437 LOG.trace("Fetched global {} from hardware_vtep schema", globalRow);
441 private Entity getEntityFromConnectionInstance(@NonNull final HwvtepConnectionInstance hwvtepConnectionInstance) {
442 InstanceIdentifier<Node> iid = hwvtepConnectionInstance.getInstanceIdentifier();
444 //TODO: Is Global the right one?
445 Global hwvtepGlobalRow = getHwvtepGlobalTableEntry(hwvtepConnectionInstance);
446 iid = HwvtepSouthboundMapper.getInstanceIdentifier(hwvtepGlobalRow);
447 /* Let's set the iid now */
448 hwvtepConnectionInstance.setInstanceIdentifier(iid);
449 LOG.info("InstanceIdentifier {} generated for device "
450 + "connection {}",iid, hwvtepConnectionInstance.getConnectionInfo());
451 controllerTxHistory.putIfAbsent(iid,
452 new TransactionHistory(TRANSACTION_HISTORY_CAPACITY, TRANSACTION_HISTORY_WATERMARK));
453 deviceUpdateHistory.putIfAbsent(iid,
454 new TransactionHistory(TRANSACTION_HISTORY_CAPACITY, TRANSACTION_HISTORY_WATERMARK));
455 TransactionHistory controllerLog = controllerTxHistory.get(iid);
456 TransactionHistory deviceLog = deviceUpdateHistory.get(iid);
457 int port = hwvtepConnectionInstance.getOvsdbClient().getConnectionInfo().getRemotePort();
458 deviceLog.addToHistory(TransactionType.ADD, new ClientConnected(port));
459 hwvtepConnectionInstance.setControllerTxHistory(controllerLog);
460 hwvtepConnectionInstance.setDeviceUpdateHistory(deviceLog);
462 Entity deviceEntity = new Entity(ENTITY_TYPE, iid);
463 LOG.debug("Entity {} created for device connection {}",
464 deviceEntity, hwvtepConnectionInstance.getConnectionInfo());
468 private void unregisterEntityForOwnership(final HwvtepConnectionInstance hwvtepConnectionInstance) {
469 hwvtepConnectionInstance.closeDeviceOwnershipCandidateRegistration();
470 entityConnectionMap.remove(hwvtepConnectionInstance.getConnectedEntity());
473 public void reconcileConnection(final InstanceIdentifier<Node> iid, final HwvtepGlobalAugmentation hwvtepNode) {
474 this.retryConnection(iid, hwvtepNode,
475 ConnectionReconciliationTriggers.ON_CONTROLLER_INITIATED_CONNECTION_FAILURE);
478 public void stopConnectionReconciliationIfActive(final InstanceIdentifier<?> iid,
479 final HwvtepGlobalAugmentation hwvtepNode) {
480 final ReconciliationTask task = new ConnectionReconciliationTask(
481 reconciliationManager,
485 reconciliationManager.dequeue(task);
488 private void retryConnection(final InstanceIdentifier<Node> iid, final HwvtepGlobalAugmentation hwvtepNode,
489 final ConnectionReconciliationTriggers trigger) {
490 final ReconciliationTask task = new ConnectionReconciliationTask(
491 reconciliationManager,
496 if (reconciliationManager.isEnqueued(task)) {
501 case ON_CONTROLLER_INITIATED_CONNECTION_FAILURE:
502 reconciliationManager.enqueueForRetry(task);
504 case ON_DISCONNECT: {
505 ReadOnlyTransaction tx = db.newReadOnlyTransaction();
506 CheckedFuture<Optional<Node>, ReadFailedException> readNodeFuture =
507 tx.read(LogicalDatastoreType.CONFIGURATION, iid);
509 Futures.addCallback(readNodeFuture, new FutureCallback<Optional<Node>>() {
511 public void onSuccess(final Optional<Node> node) {
512 if (node.isPresent()) {
513 HwvtepGlobalAugmentation augmentation = node.get()
514 .augmentation(HwvtepGlobalAugmentation.class);
515 if (augmentation == null || augmentation.getConnectionInfo() == null) {
519 "Disconnected/Failed connection {} was controller initiated, attempting reconnection",
520 hwvtepNode.getConnectionInfo());
521 reconciliationManager.enqueue(task);
524 LOG.debug("Connection {} was switch initiated, no reconciliation is required",
525 iid.firstKeyOf(Node.class).getNodeId());
530 public void onFailure(final Throwable ex) {
531 LOG.warn("Read Config/DS for Node failed! {}", iid, ex);
533 }, MoreExecutors.directExecutor());
541 public void handleOwnershipChanged(final EntityOwnershipChange ownershipChange) {
542 HwvtepConnectionInstance hwvtepConnectionInstance =
543 getConnectionInstanceFromEntity(ownershipChange.getEntity());
544 LOG.info("handleOwnershipChanged: {} event received for device {}",
545 ownershipChange, hwvtepConnectionInstance != null ? hwvtepConnectionInstance.getConnectionInfo()
546 : "THAT'S NOT REGISTERED BY THIS SOUTHBOUND PLUGIN INSTANCE");
548 if (hwvtepConnectionInstance == null) {
549 if (ownershipChange.getState().isOwner()) {
550 LOG.warn("handleOwnershipChanged: found no connection instance for {}", ownershipChange.getEntity());
552 // EntityOwnershipService sends notification to all the nodes, irrespective of whether
553 // that instance registered for the device ownership or not. It is to make sure that
554 // If all the controller instance that was connected to the device are down, so the
555 // running instance can clear up the operational data store even though it was not
556 // connected to the device.
557 LOG.debug("handleOwnershipChanged: found no connection instance for {}", ownershipChange.getEntity());
560 // If entity has no owner, clean up the operational data store (it's possible because owner controller
561 // might went down abruptly and didn't get a chance to clean up the operational data store.
562 if (!ownershipChange.getState().hasOwner()) {
563 LOG.debug("{} has no owner, cleaning up the operational data store", ownershipChange.getEntity());
564 // If first cleanEntityOperationalData() was called, this call will be no-op.
565 cleanEntityOperationalData(ownershipChange.getEntity());
569 //Connection detail need to be cached, irrespective of ownership result.
570 putConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo(), hwvtepConnectionInstance);
572 if (ownershipChange.getState().isOwner() == hwvtepConnectionInstance.getHasDeviceOwnership()) {
573 LOG.debug("handleOwnershipChanged: no change in ownership for {}. Ownership status is : {}",
574 hwvtepConnectionInstance.getConnectionInfo(), hwvtepConnectionInstance.getHasDeviceOwnership());
578 hwvtepConnectionInstance.setHasDeviceOwnership(ownershipChange.getState().isOwner());
579 // You were not an owner, but now you are
580 if (ownershipChange.getState().isOwner()) {
581 LOG.info("handleOwnershipChanged: *this* southbound plugin instance is owner of device {}",
582 hwvtepConnectionInstance.getConnectionInfo());
584 //*this* instance of southbound plugin is owner of the device,
585 //so register for monitor callbacks
586 afterTakingOwnership(hwvtepConnectionInstance);
589 //You were owner of the device, but now you are not. With the current ownership
590 //grant mechanism, this scenario should not occur. Because this scenario will occur
591 //when this controller went down or switch flap the connection, but in both the case
592 //it will go through the re-registration process. We need to implement this condition
593 //when clustering service implement a ownership grant strategy which can revoke the
594 //device ownership for load balancing the devices across the instances.
595 //Once this condition occur, we should unregister the callback.
596 LOG.error("handleOwnershipChanged: *this* southbound plugin instance is no longer the owner of device {}",
597 hwvtepConnectionInstance.getNodeId().getValue());
601 private void cleanEntityOperationalData(final Entity entity) {
602 @SuppressWarnings("unchecked")
603 final InstanceIdentifier<Node> nodeIid = (InstanceIdentifier<Node>) entity.getIdentifier();
604 txInvoker.invoke(new HwvtepGlobalRemoveCommand(nodeIid));
607 private HwvtepConnectionInstance getConnectionInstanceFromEntity(final Entity entity) {
608 return entityConnectionMap.get(entity);
611 public Map<InstanceIdentifier<Node>, TransactionHistory> getControllerTxHistory() {
612 return controllerTxHistory;
615 public Map<InstanceIdentifier<Node>, TransactionHistory> getDeviceUpdateHistory() {
616 return deviceUpdateHistory;
619 private static class HwvtepDeviceEntityOwnershipListener implements EntityOwnershipListener {
620 private final HwvtepConnectionManager hcm;
621 private final EntityOwnershipListenerRegistration listenerRegistration;
623 HwvtepDeviceEntityOwnershipListener(final HwvtepConnectionManager hcm,
624 final EntityOwnershipService entityOwnershipService) {
626 listenerRegistration = entityOwnershipService.registerListener(ENTITY_TYPE, this);
629 public void close() {
630 listenerRegistration.close();
634 public void ownershipChanged(final EntityOwnershipChange ownershipChange) {
635 hcm.handleOwnershipChanged(ownershipChange);
639 private enum ConnectionReconciliationTriggers {
641 Reconciliation trigger for scenario where controller's attempt
642 to connect to switch fails on config data store notification
644 ON_CONTROLLER_INITIATED_CONNECTION_FAILURE,
647 Reconciliation trigger for the scenario where controller
648 initiated connection disconnects.
653 public Map<InstanceIdentifier<Node>, HwvtepConnectionInstance> getAllConnectedInstances() {
654 return Collections.unmodifiableMap(nodeIidVsConnectionInstance);