This code does an initial write of a bridge.
It also introduces a simplifying framework for
handling writes to ovsdb in the southbound plugin.
Change-Id: I7aa370b7ce9b976febd87478e1e6ff96c17ba8a4
Signed-off-by: Ed Warnicke <eaw@cisco.com>
*/
package org.opendaylight.ovsdb.southbound;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
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.GenericTableSchema;
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;
private OvsdbClient client;
private OvsdbClientKey key;
private TransactionInvoker txInvoker;
+ private Map<DatabaseSchema,TransactInvoker> transactInvokers = new HashMap<DatabaseSchema,TransactInvoker>();
private MonitorCallBack callback;
OvsdbConnectionInstance(OvsdbClientKey key,OvsdbClient client,TransactionInvoker txInvoker) {
registerCallBack();
}
+ public void transact(TransactCommand command) {
+ for(TransactInvoker transactInvoker: transactInvokers.values()) {
+ transactInvoker.invoke(command);
+ }
+ }
+
private void registerCallBack() {
this.callback = new OvsdbMonitorCallback(key,txInvoker);
try {
for (String database : databases) {
DatabaseSchema dbSchema = getSchema(database).get();
if(dbSchema != null) {
+ transactInvokers.put(dbSchema, new TransactInvokerImpl(this,dbSchema));
monitorAllTables(database, dbSchema);
} else {
LOG.warn("No schema reported for database {} for key {}",database,key);
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.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;
+import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.CheckedFuture;
}
public OvsdbConnectionInstance getConnectionInstance(OvsdbBridgeAttributes mn) {
- Preconditions.checkNotNull(mn);
- try {
- OvsdbNodeRef ref = mn.getManagedBy();
- if(ref != null) {
- ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- CheckedFuture<?, ReadFailedException> nf = transaction.read(LogicalDatastoreType.OPERATIONAL, ref.getValue());
- transaction.close();
- Object obj = nf.get();
- if(obj instanceof Node) {
- OvsdbNodeAugmentation ovsdbNode = ((Node)obj).getAugmentation(OvsdbNodeAugmentation.class);
- if(ovsdbNode !=null) {
- return getConnectionInstance(ovsdbNode);
- } else {
- LOG.warn("OvsdbManagedNode {} claims to be managed by {} but that OvsdbNode does not exist",mn,ref.getValue());
- return null;
- }
- } else {
- LOG.warn("Mysteriously got back a thing which is *not* a topology Node: {}",obj);
- return null;
- }
- } else {
- LOG.warn("Cannot find client for OvsdbManagedNode without a specified ManagedBy {}",mn);
- return null;
- }
- } catch (Exception e) {
- LOG.warn("Failed to get OvsdbNode that manages OvsdbManagedNode {}",mn, e);
- return null;
- }
+ Optional<OvsdbNodeAugmentation> optional = SouthboundUtil.getManagingNode(db, mn);
+ if(optional.isPresent()) {
+ return getConnectionInstance(optional.get());
+ } else {
+ return null;
+ }
}
public OvsdbConnectionInstance getConnectionInstance(Node node) {
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.lib.OvsdbClient;
+import org.opendaylight.ovsdb.southbound.ovsdb.transact.DataChangesManagedByOvsdbNodeEvent;
+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.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;
// TODO validate we have the correct kind of InstanceIdentifier
if(created.getValue() instanceof OvsdbBridgeAugmentation) {
LOG.debug("Received request to create {}",created.getValue());
- OvsdbClient client = cm.getClient((OvsdbBridgeAugmentation)created.getValue());
+ OvsdbConnectionInstance client = cm.getConnectionInstance((OvsdbBridgeAugmentation)created.getValue());
if(client != null) {
LOG.debug("Found client for {}", created.getValue());
+ client.transact(new TransactCommandAggregator(
+ new DataChangesManagedByOvsdbNodeEvent(
+ SouthboundMapper.createInstanceIdentifier(client.getKey()),
+ changes)));
} else {
LOG.debug("Did not find client for {}",created.getValue());
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound;
+
+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.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAttributes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
+import 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;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.CheckedFuture;
+
+public class SouthboundUtil {
+
+ private static final Logger LOG = LoggerFactory.getLogger(SouthboundUtil.class);
+
+
+ public static Optional<OvsdbNodeAugmentation> getManagingNode(DataBroker db,OvsdbBridgeAttributes mn) {
+ Preconditions.checkNotNull(mn);
+ try {
+ OvsdbNodeRef ref = mn.getManagedBy();
+ 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);
+ transaction.close();
+ Optional<Node> optional = nf.get();
+ if(optional != null && optional.isPresent() && optional.get() instanceof Node) {
+ OvsdbNodeAugmentation ovsdbNode = optional.get().getAugmentation(OvsdbNodeAugmentation.class);
+ 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());
+ return Optional.absent();
+ }
+ } else {
+ LOG.warn("Mysteriously got back a thing which is *not* a topology Node: {}",optional);
+ 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();
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+
+import java.util.Map;
+
+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.operations.TransactionBuilder;
+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.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.Sets;
+
+public class BridgeCreateCommand implements TransactCommand {
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes;
+ private static final Logger LOG = LoggerFactory.getLogger(BridgeCreateCommand.class);
+
+
+ public BridgeCreateCommand(AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ this.changes = changes;
+ }
+
+ @Override
+ public void execute(TransactionBuilder transaction) {
+ 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());
+ String namedUuid = "Bridge_" + ovsdbManagedNode.getBridgeName().getValue();
+ transaction.add(op.insert(bridge).withId(namedUuid));
+
+ // OpenVSwitchPart
+ OpenVSwitch ovs = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), OpenVSwitch.class);
+ ovs.setBridges(Sets.newHashSet(new UUID(namedUuid)));
+ transaction.add(op.mutate(ovs).addMutation(ovs.getBridgesColumn().getSchema(),
+ Mutator.INSERT,
+ ovs.getBridgesColumn().getData())
+ );
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class DataChangesManagedByOvsdbNodeEvent implements
+ AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> {
+ //primary fields
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> event;
+ private InstanceIdentifier<?> iid;
+
+ // local caches of computed data
+ private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> createdData = null;
+ private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> updatedData = null;
+ private Set<InstanceIdentifier<?>> removedPaths = null;
+ private Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> originalData;
+
+ 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
+ && created.getValue() instanceof OvsdbBridgeAugmentation
+ && ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy() != null
+ && ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy().getValue() != null
+ && ((OvsdbBridgeAugmentation)created.getValue()).getManagedBy().getValue().equals(iid)) {
+ result.put(created.getKey(),((OvsdbBridgeAugmentation)created.getValue()));
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getCreatedData() {
+ if(this.createdData == null) {
+ this.createdData = filter(event.getCreatedData());
+ }
+ return this.createdData;
+ }
+
+ @Override
+ public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getUpdatedData() {
+ if(this.updatedData == null) {
+ this.updatedData = filter(event.getUpdatedData());
+ }
+ return this.updatedData;
+ }
+
+ @Override
+ public Set<InstanceIdentifier<?>> getRemovedPaths() {
+ if(this.removedPaths != null) {
+ this.removedPaths = new HashSet<InstanceIdentifier<?>>();
+ for(InstanceIdentifier<?> path: event.getRemovedPaths()) {
+ DataObject original = this.event.getOriginalData().get(path);
+ if(original != null
+ && original instanceof OvsdbBridgeAugmentation
+ && ((OvsdbBridgeAugmentation)original).getManagedBy().equals(this.iid)) {
+ this.removedPaths.add(path);
+ }
+ }
+ }
+ return this.removedPaths;
+ }
+
+ @Override
+ public Map<InstanceIdentifier<?>, OvsdbBridgeAugmentation> getOriginalData() {
+ if(this.originalData == null) {
+ this.originalData = filter(event.getOriginalData());
+ }
+ return this.originalData;
+ }
+
+ @Override
+ public OvsdbBridgeAugmentation getOriginalSubtree() {
+ if(this.event.getOriginalSubtree() instanceof OvsdbBridgeAugmentation) {
+ return (OvsdbBridgeAugmentation)this.event.getOriginalSubtree();
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public OvsdbBridgeAugmentation getUpdatedSubtree() {
+ if(this.event.getUpdatedSubtree() instanceof OvsdbBridgeAugmentation) {
+ return (OvsdbBridgeAugmentation)this.event.getUpdatedSubtree();
+ } else {
+ return null;
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
+
+public interface TransactCommand {
+
+ public void execute(TransactionBuilder transaction);
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class TransactCommandAggregator implements TransactCommand {
+
+ private List<TransactCommand> commands = new ArrayList<TransactCommand>();
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes;
+
+ public TransactCommandAggregator(AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ this.changes=changes;
+ commands.add(new BridgeCreateCommand(changes));
+ }
+
+ @Override
+ public void execute(TransactionBuilder transaction) {
+ for(TransactCommand command:commands) {
+ command.execute(transaction);
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+public interface TransactInvoker {
+ public void invoke(TransactCommand command);
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import java.util.List;
+
+import org.opendaylight.ovsdb.lib.operations.OperationResult;
+import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
+import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
+import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+public class TransactInvokerImpl implements TransactInvoker {
+ private static final Logger LOG = LoggerFactory.getLogger(BridgeCreateCommand.class);
+ private OvsdbConnectionInstance connectionInstance;
+ private DatabaseSchema dbSchema;
+
+ public TransactInvokerImpl(OvsdbConnectionInstance connectionInstance, DatabaseSchema dbSchema) {
+ this.connectionInstance =connectionInstance;
+ this.dbSchema = dbSchema;
+ }
+
+ @Override
+ public void invoke(TransactCommand command) {
+ TransactionBuilder tb = new TransactionBuilder(connectionInstance, dbSchema);
+ command.execute(tb);
+ ListenableFuture<List<OperationResult>> result = tb.execute();
+ try {
+ List<OperationResult> got = result.get();
+ LOG.debug("Results of create bridge request",got);
+ } catch (Exception e){
+ LOG.warn("Transact execution exception: ",e);
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+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.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TransactUtils {
+ private static final Logger LOG = LoggerFactory.getLogger(TransactUtils.class);
+
+ public static Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> extractOvsdbManagedNodeCreate(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ return extractOvsdbManagedNode(changes.getCreatedData());
+ }
+
+ public static Map<InstanceIdentifier<Node>,OvsdbBridgeAugmentation> extractOvsdbManagedNode(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, OvsdbBridgeAugmentation> changes) {
+ return extractOvsdbManagedNode(changes.getUpdatedData());
+ }
+
+ 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)) {
+ @SuppressWarnings("unchecked") // Actually checked above
+ InstanceIdentifier<Node> iidn = (InstanceIdentifier<Node>)iid;
+ result.add(iidn);
+ }
+ }
+ return result;
+ }
+
+
+ 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()) {
+ OvsdbBridgeAugmentation value = created.getValue();
+ Class<?> type = created.getKey().getTargetType();
+ if(type.equals(OvsdbBridgeAugmentation.class)) {
+ @SuppressWarnings("unchecked") // Actually checked above
+ InstanceIdentifier<Node> iid = (InstanceIdentifier<Node>) created.getKey();
+ OvsdbBridgeAugmentation ovsdbManagedNode = (OvsdbBridgeAugmentation) value;
+ result.put(iid, ovsdbManagedNode);
+ }
+ }
+ return result;
+ }
+
+}
Code Review / ovsdb.git / commitdiff