X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=southbound%2Fsouthbound-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fovsdb%2Fsouthbound%2Fovsdb%2Ftransact%2FTransactUtils.java;h=c5e565a2d53add51b093741c64ca96342dd92ef4;hb=55ce82cbd9fdcb0edf9e629bd2d626b193c6ab26;hp=9af3750a7b2e8dd2057031b5bb420ed6350f9f10;hpb=1fbc1aa3836a2a1596ca91715bc2c087c626f0e2;p=ovsdb.git

diff --git a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
index 9af3750a7..c5e565a2d 100644
--- a/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
+++ b/southbound/southbound-impl/src/main/java/org/opendaylight/ovsdb/southbound/ovsdb/transact/TransactUtils.java
@@ -10,13 +10,21 @@ package org.opendaylight.ovsdb.southbound.ovsdb.transact;
 import static org.opendaylight.ovsdb.lib.operations.Operations.op;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Queue;
 import java.util.Set;
 
+import javax.annotation.Nullable;
+
+import com.google.common.base.Predicate;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+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.Mutation;
 import org.opendaylight.ovsdb.lib.notation.Mutator;
@@ -33,10 +41,13 @@ import org.opendaylight.ovsdb.southbound.SouthboundConstants;
 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
 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.ChildOf;
 import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 
 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableMap;
@@ -45,13 +56,78 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 
 public class TransactUtils {
-    private static final Logger LOG = LoggerFactory.getLogger(TransactUtils.class);
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataBefore() {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return input != null && input.getDataBefore() != null;
+            }
+        };
+    }
+
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataBeforeAndDataAfter() {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return input != null && input.getDataBefore() != null && input.getDataAfter() != null;
+            }
+        };
+    }
+
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> hasNoDataBefore() {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return input != null && input.getDataBefore() == null;
+            }
+        };
+    }
+
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> hasDataAfterAndMatchesFilter(
+            final Predicate<DataObjectModification<T>> filter) {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return input != null && input.getDataAfter() != null && filter.apply(input);
+            }
+        };
+    }
+
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> matchesEverything() {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return true;
+            }
+        };
+    }
+
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> modificationIsDeletion() {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return input != null && input.getModificationType() == DataObjectModification
+                        .ModificationType.DELETE;
+            }
+        };
+    }
+
+    private static <T extends DataObject> Predicate<DataObjectModification<T>> modificationIsDeletionAndHasDataBefore
+            () {
+        return new Predicate<DataObjectModification<T>>() {
+            @Override
+            public boolean apply(@Nullable DataObjectModification<T> input) {
+                return input != null && input.getModificationType() == DataObjectModification
+                        .ModificationType.DELETE && input.getDataBefore() != null;
+            }
+        };
+    }
 
     public static Map<InstanceIdentifier<Node>,Node> extractNode(
             Map<InstanceIdentifier<?>, DataObject> changes) {
         Map<InstanceIdentifier<Node>,Node> result
             = new HashMap<>();
-        if (changes != null && changes.entrySet() != null) {
+        if (changes != null) {
             for (Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
                 if (created.getValue() instanceof Node) {
                     Node value = (Node) created.getValue();
@@ -72,11 +148,61 @@ public class TransactUtils {
         return extract(changes.getCreatedData(),klazz);
     }
 
+    /**
+     * Extract all the instances of {@code clazz} which were created in the given set of modifications.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The created instances, mapped by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractCreated(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        return extractCreatedOrUpdated(changes, clazz, hasNoDataBefore());
+    }
+
+    /**
+     * Extract all the instance of {@code clazz} which were created or updated in the given set of modifications, and
+     * which satisfy the given filter.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param filter The filter the changes must satisfy.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The created or updated instances which satisfy the filter, mapped by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdated(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz,
+            Predicate<DataObjectModification<T>> filter) {
+        Map<InstanceIdentifier<T>, T> result = new HashMap<>();
+        for (Map.Entry<InstanceIdentifier<T>, DataObjectModification<T>> entry : extractDataObjectModifications(changes,
+                clazz, hasDataAfterAndMatchesFilter(filter)).entrySet()) {
+            result.put(entry.getKey(), entry.getValue().getDataAfter());
+        }
+        return result;
+    }
+
     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractUpdated(
             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
         return extract(changes.getUpdatedData(),klazz);
     }
 
+    /**
+     * Extract all the instances of {@code clazz} which were updated in the given set of modifications.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The updated instances, mapped by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractUpdated(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        return extractCreatedOrUpdated(changes, clazz, hasDataBeforeAndDataAfter());
+    }
+
     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractCreatedOrUpdated(
             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
         Map<InstanceIdentifier<T>,T> result = extractUpdated(changes,klazz);
@@ -84,6 +210,20 @@ public class TransactUtils {
         return result;
     }
 
+    /**
+     * Extract all the instances of {@code clazz} which were created or updated in the given set of modifications.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The created or updated instances, mapped by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdated(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        return extractCreatedOrUpdated(changes, clazz, matchesEverything());
+    }
+
     public static <T extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdatedOrRemoved(
             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
             Class<T> klazz) {
@@ -92,11 +232,49 @@ public class TransactUtils {
         return result;
     }
 
+    /**
+     * Extract all the instances of {@code clazz} which were created, updated, or removed in the given set of
+     * modifications. For instances which were created or updated, the new instances are returned; for instances
+     * which were removed, the old instances are returned.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The created, updated or removed instances, mapped by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T>
+    extractCreatedOrUpdatedOrRemoved(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        Map<InstanceIdentifier<T>, T> result = extractCreatedOrUpdated(changes, clazz);
+        result.putAll(extractRemovedObjects(changes, clazz));
+        return result;
+    }
+
     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
         return extract(changes.getOriginalData(),klazz);
     }
 
+    /**
+     * Extract the original instances of class {@code clazz} in the given set of modifications.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The original instances, mapped by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractOriginal(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        Map<InstanceIdentifier<T>, T> result = new HashMap<>();
+        for (Map.Entry<InstanceIdentifier<T>, DataObjectModification<T>> entry :
+                extractDataObjectModifications(changes, clazz, hasDataBefore()).entrySet()) {
+            result.put(entry.getKey(), entry.getValue().getDataBefore());
+        }
+        return result;
+    }
+
     public static <T extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
             AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
         Set<InstanceIdentifier<T>> result = new HashSet<>();
@@ -112,6 +290,104 @@ public class TransactUtils {
         return result;
     }
 
+    /**
+     * Extract the instance identifier of removed instances of {@code clazz} from the given set of modifications.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The instance identifiers of removed instances.
+     */
+    public static <T extends DataObject, U extends DataObject> Set<InstanceIdentifier<T>> extractRemoved(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        return extractDataObjectModifications(changes, clazz, modificationIsDeletion()).keySet();
+    }
+
+    /**
+     * Extract all the modifications affecting instances of {@code clazz} which are present in the given set of
+     * modifications and satisfy the given filter.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param filter The filter the changes must satisfy.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The modifications, mapped by instance identifier.
+     */
+    private static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, DataObjectModification<T>>
+    extractDataObjectModifications(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz,
+            Predicate<DataObjectModification<T>> filter) {
+        List<DataObjectModification<? extends DataObject>> dataObjectModifications = new ArrayList<>();
+        List<InstanceIdentifier<? extends DataObject>> paths = new ArrayList<>();
+        if (changes != null) {
+            for (DataTreeModification<? extends DataObject> change : changes) {
+                dataObjectModifications.add(change.getRootNode());
+                paths.add(change.getRootPath().getRootIdentifier());
+            }
+        }
+        return extractDataObjectModifications(dataObjectModifications, paths, clazz, filter);
+    }
+
+    /**
+     * Extract all the modifications affecting instances of {@code clazz} which are present in the given set of
+     * modifications and satisfy the given filter.
+     *
+     * @param changes The changes to process.
+     * @param paths The paths of the changes.
+     * @param clazz The class we're interested in.
+     * @param filter The filter the changes must satisfy.
+     * @param <T> The type of changes we're interested in.
+     * @return The modifications, mapped by instance identifier.
+     */
+    private static <T extends DataObject> Map<InstanceIdentifier<T>, DataObjectModification<T>>
+    extractDataObjectModifications(
+            Collection<DataObjectModification<? extends DataObject>> changes,
+            Collection<InstanceIdentifier<? extends DataObject>> paths, Class<T> clazz,
+            Predicate<DataObjectModification<T>> filter) {
+        Map<InstanceIdentifier<T>, DataObjectModification<T>> result = new HashMap<>();
+        Queue<DataObjectModification<? extends DataObject>> remainingChanges = new LinkedList<>(changes);
+        Queue<InstanceIdentifier<? extends DataObject>> remainingPaths = new LinkedList<>(paths);
+        while (!remainingChanges.isEmpty()) {
+            DataObjectModification<? extends DataObject> change = remainingChanges.remove();
+            InstanceIdentifier<? extends DataObject> path = remainingPaths.remove();
+            // Is the change relevant?
+            if (clazz.isAssignableFrom(change.getDataType()) && filter.apply((DataObjectModification<T>) change)) {
+                result.put((InstanceIdentifier<T>) path, (DataObjectModification<T>) change);
+            }
+            // Add any children to the queue
+            for (DataObjectModification<? extends DataObject> child : change.getModifiedChildren()) {
+                remainingChanges.add(child);
+                remainingPaths.add(extendPath(path, child));
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Extends the given instance identifier path to include the given child. Augmentations are treated in the same way
+     * as children; keyed children are handled correctly.
+     *
+     * @param path The current path.
+     * @param child The child modification to include.
+     * @return The extended path.
+     */
+    private static <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>, T extends DataObject>
+    InstanceIdentifier<? extends DataObject> extendPath(
+            InstanceIdentifier path,
+            DataObjectModification child) {
+        Class<N> item = (Class<N>) child.getDataType();
+        if (child.getIdentifier() instanceof InstanceIdentifier.IdentifiableItem) {
+            K key = (K) ((InstanceIdentifier.IdentifiableItem) child.getIdentifier()).getKey();
+            KeyedInstanceIdentifier<N, K> extendedPath = path.child(item, key);
+            return extendedPath;
+        } else {
+            InstanceIdentifier<N> extendedPath = path.child(item);
+            return extendedPath;
+        }
+    }
+
     public static <T extends DataObject> Map<InstanceIdentifier<T>, T> extractRemovedObjects(
             AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
             Class<T> klazz) {
@@ -119,10 +395,29 @@ public class TransactUtils {
         return Maps.filterKeys(extractOriginal(changes, klazz),Predicates.in(iids));
     }
 
+    /**
+     * Extract the removed instances of {@code clazz} from the given set of modifications.
+     *
+     * @param changes The changes to process.
+     * @param clazz The class we're interested in.
+     * @param <T> The type of changes we're interested in.
+     * @param <U> The type of changes to process.
+     * @return The removed instances, keyed by instance identifier.
+     */
+    public static <T extends DataObject, U extends DataObject> Map<InstanceIdentifier<T>, T> extractRemovedObjects(
+            Collection<DataTreeModification<U>> changes, Class<T> clazz) {
+        Map<InstanceIdentifier<T>, T> result = new HashMap<>();
+        for (Map.Entry<InstanceIdentifier<T>, DataObjectModification<T>> entry :
+                extractDataObjectModifications(changes, clazz, modificationIsDeletionAndHasDataBefore()).entrySet()) {
+            result.put(entry.getKey(), entry.getValue().getDataBefore());
+        }
+        return result;
+    }
+
     public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
             Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
         Map<InstanceIdentifier<T>,T> result = new HashMap<>();
-        if (changes != null && changes.entrySet() != null) {
+        if (changes != null) {
             for (Entry<InstanceIdentifier<?>, DataObject> created : changes.entrySet()) {
                 if (klazz.isInstance(created.getValue())) {
                     @SuppressWarnings("unchecked")
@@ -142,11 +437,9 @@ public class TransactUtils {
     public static List<Insert> extractInsert(TransactionBuilder transaction, GenericTableSchema schema) {
         List<Operation> operations = transaction.getOperations();
         List<Insert> inserts = new ArrayList<>();
-        for (int count = 0;count < operations.size();count++) {
-            Operation operation = operations.get(count);
+        for (Operation operation : operations) {
             if (operation instanceof Insert && operation.getTableSchema().equals(schema)) {
-                Insert insert = (Insert)operation;
-                inserts.add(insert);
+                inserts.add((Insert) operation);
             }
         }
         return inserts;
@@ -164,8 +457,7 @@ public class TransactUtils {
         String uuidString = insert.getUuidName() != null
                 ? insert.getUuidName() : SouthboundMapper.getRandomUUID();
         insert.setUuidName(uuidString);
-        UUID uuid = new UUID(uuidString);
-        return uuid;
+        return new UUID(uuidString);
     }
 
     public static <T  extends TableSchema<T>> void stampInstanceIdentifier(TransactionBuilder transaction,
@@ -192,4 +484,41 @@ public class TransactUtils {
         mutate.setMutations(mutations);
         return mutate;
     }
+
+    /**
+     * This method builds a string by concatenating the 2 character
+     * hexadecimal representation of each byte from the input byte array.
+     *
+     * For example: an input byte array containing:
+     *   bytes[0] = 'a'
+     *   bytes[1] = 'b'
+     *   bytes[2] = 'c'
+     *   bytes[3] = '-'
+     *   bytes[4] = '1'
+     *   bytes[5] = '2'
+     *   bytes[6] = '3'
+     * returns the string "6162632d313233"
+     *
+     * @param bytes
+     *            The byte array to convert to string
+     * @return The hexadecimal representation of the byte array. If bytes is
+     *         null, the string "" is returned
+     */
+    public static String bytesToHexString(byte[] bytes) {
+
+        if (bytes == null) {
+            return "";
+        }
+
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < bytes.length; i++) {
+            short u8byte = (short) (bytes[i] & 0xff);
+            String tmp = Integer.toHexString(u8byte);
+            if (tmp.length() == 1) {
+                buf.append("0");
+            }
+            buf.append(tmp);
+        }
+        return buf.toString();
+    }
 }