opendaylight/md-sal/sal-binding-dom-it/src/test/java/org/opendaylight/controller/md/sal/binding/data/WildcardedDataChangeListenerTest.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.controller.md.sal.binding.data;
   9
  10 import static org.junit.Assert.assertFalse;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import java.util.Collections;
  15 import java.util.concurrent.ExecutionException;
  16 import java.util.concurrent.TimeUnit;
  17 import java.util.concurrent.TimeoutException;
  18
  19 import org.junit.Test;
  20 import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
  21 import org.opendaylight.controller.sal.binding.api.data.DataChangeListener;
  22 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
  23 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
  24 import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeaturesBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeaturesKey;
  40 import org.opendaylight.yangtools.yang.binding.DataObject;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  42
  43 import com.google.common.util.concurrent.SettableFuture;
  44
  45 /*
  46  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
  47  *
  48  * This program and the accompanying materials are made available under the
  49  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  50  * and is available at http://www.eclipse.org/legal/epl-v10.html
  51  */
  52 public class WildcardedDataChangeListenerTest extends AbstractDataServiceTest {
  53
  54     private static final NodeKey NODE_0_KEY = new NodeKey(new NodeId("test:0"));
  55     private static final NodeKey NODE_1_KEY = new NodeKey(new NodeId("test:1"));
  56
  57     public static final InstanceIdentifier<Flow> DEEP_WILDCARDED_PATH = InstanceIdentifier.builder(Nodes.class)
  58             .child(Node.class) //
  59             .augmentation(FlowCapableNode.class) //
  60             .child(Table.class) //
  61             .child(Flow.class) //
  62             .build();
  63
  64     private static final TableKey TABLE_0_KEY = new TableKey((short) 0);
  65     private static final TableFeaturesKey TABLE_FEATURES_KEY = new TableFeaturesKey((short) 0);
  66
  67     private static final InstanceIdentifier<Table> NODE_0_TABLE_PATH = InstanceIdentifier.builder(Nodes.class)
  68             .child(Node.class, NODE_0_KEY) //
  69             .augmentation(FlowCapableNode.class) //
  70             .child(Table.class, TABLE_0_KEY) //
  71             .build();
  72
  73     private static final InstanceIdentifier<Table> NODE_1_TABLE_PATH = InstanceIdentifier.builder(Nodes.class)
  74             .child(Node.class, NODE_1_KEY) //
  75             .augmentation(FlowCapableNode.class) //
  76             .child(Table.class, TABLE_0_KEY) //
  77             .build();
  78
  79     private static final FlowKey FLOW_KEY = new FlowKey(new FlowId("test"));
  80
  81     private static final InstanceIdentifier<Flow> NODE_0_FLOW_PATH = InstanceIdentifier.builder(NODE_0_TABLE_PATH)
  82             .child(Flow.class, FLOW_KEY).build();
  83
  84     private static final InstanceIdentifier<Flow> NODE_1_FLOW_PATH = InstanceIdentifier.builder(NODE_1_TABLE_PATH)
  85             .child(Flow.class, FLOW_KEY).build();
  86
  87     private static final InstanceIdentifier<TableFeatures> NODE_0_TABLE_FEATURES_PATH = InstanceIdentifier
  88             .builder(NODE_0_TABLE_PATH).child(TableFeatures.class, TABLE_FEATURES_KEY).build();
  89
  90     private static final TableFeatures TABLE_FEATURES = new TableFeaturesBuilder()//
  91             .setKey(TABLE_FEATURES_KEY) //
  92             .setName("Foo") //
  93             .setMaxEntries(1000L) //
  94             .build();
  95
  96     private static final Flow FLOW = new FlowBuilder() //
  97             .setKey(FLOW_KEY) //
  98             .setBarrier(true) //
  99             .setStrict(true) //
 100             .build();
 101
 102     @Test
 103     public void testSepareteWrites() throws InterruptedException, TimeoutException, ExecutionException {
 104
 105         DataProviderService dataBroker = testContext.getBindingDataBroker();
 106
 107         final SettableFuture<DataChangeEvent<InstanceIdentifier<?>, DataObject>> eventFuture = SettableFuture.create();
 108         dataBroker.registerDataChangeListener(DEEP_WILDCARDED_PATH, new DataChangeListener() {
 109
 110             @Override
 111             public void onDataChanged(final DataChangeEvent<InstanceIdentifier<?>, DataObject> dataChangeEvent) {
 112                 eventFuture.set(dataChangeEvent);
 113             }
 114         });
 115
 116         DataModificationTransaction transaction = dataBroker.beginTransaction();
 117         transaction.putOperationalData(NODE_0_TABLE_FEATURES_PATH, TABLE_FEATURES);
 118         transaction.putOperationalData(NODE_0_FLOW_PATH, FLOW);
 119         transaction.putOperationalData(NODE_1_FLOW_PATH, FLOW);
 120         transaction.commit().get();
 121
 122         DataChangeEvent<InstanceIdentifier<?>, DataObject> event = eventFuture.get(1000, TimeUnit.MILLISECONDS);
 123
 124         validateEvent(event);
 125     }
 126
 127     @Test
 128     public void testWriteByReplace() throws InterruptedException, TimeoutException, ExecutionException {
 129
 130         DataProviderService dataBroker = testContext.getBindingDataBroker();
 131
 132         final SettableFuture<DataChangeEvent<InstanceIdentifier<?>, DataObject>> eventFuture = SettableFuture.create();
 133         dataBroker.registerDataChangeListener(DEEP_WILDCARDED_PATH, new DataChangeListener() {
 134
 135             @Override
 136             public void onDataChanged(final DataChangeEvent<InstanceIdentifier<?>, DataObject> dataChangeEvent) {
 137                 eventFuture.set(dataChangeEvent);
 138             }
 139         });
 140
 141         DataModificationTransaction tableTx = dataBroker.beginTransaction();
 142         tableTx.putOperationalData(NODE_0_TABLE_FEATURES_PATH, TABLE_FEATURES);
 143         tableTx.commit().get();
 144
 145         assertFalse(eventFuture.isDone());
 146
 147         DataModificationTransaction flowTx = dataBroker.beginTransaction();
 148
 149         Table table = new TableBuilder() //
 150                 .setKey(TABLE_0_KEY) //
 151                 .setFlow(Collections.singletonList(FLOW)) //
 152                 .build();
 153
 154         flowTx.putOperationalData(NODE_0_TABLE_PATH, table);
 155         flowTx.putOperationalData(NODE_1_FLOW_PATH, FLOW);
 156         flowTx.commit().get();
 157
 158         validateEvent(eventFuture.get(1000, TimeUnit.MILLISECONDS));
 159     }
 160
 161     @Test
 162     public void testNoChangeOnReplaceWithSameValue() throws InterruptedException, TimeoutException, ExecutionException {
 163
 164         DataProviderService dataBroker = testContext.getBindingDataBroker();
 165
 166         // We wrote initial state NODE_0_FLOW
 167         DataModificationTransaction transaction = dataBroker.beginTransaction();
 168         transaction.putOperationalData(NODE_0_FLOW_PATH, FLOW);
 169         transaction.commit().get();
 170
 171         // We registered DataChangeListener
 172         final SettableFuture<DataChangeEvent<InstanceIdentifier<?>, DataObject>> eventFuture = SettableFuture.create();
 173         dataBroker.registerDataChangeListener(DEEP_WILDCARDED_PATH, new DataChangeListener() {
 174
 175             @Override
 176             public void onDataChanged(final DataChangeEvent<InstanceIdentifier<?>, DataObject> dataChangeEvent) {
 177                 eventFuture.set(dataChangeEvent);
 178             }
 179         });
 180         assertFalse(eventFuture.isDone());
 181
 182         DataModificationTransaction secondTx = dataBroker.beginTransaction();
 183         secondTx.putOperationalData(NODE_0_FLOW_PATH, FLOW);
 184         secondTx.putOperationalData(NODE_1_FLOW_PATH, FLOW);
 185         secondTx.commit().get();
 186
 187         DataChangeEvent<InstanceIdentifier<?>, DataObject> event = (eventFuture.get(1000, TimeUnit.MILLISECONDS));
 188         assertNotNull(event);
 189         // Data change should contains NODE_1 Flow - which was added
 190         assertTrue(event.getCreatedOperationalData().containsKey(NODE_1_FLOW_PATH));
 191         // Data change must not containe NODE_0 Flow which was replaced with same value.
 192         assertFalse(event.getUpdatedOperationalData().containsKey(NODE_0_FLOW_PATH));
 193     }
 194
 195     private static void validateEvent(final DataChangeEvent<InstanceIdentifier<?>, DataObject> event) {
 196         assertNotNull(event);
 197         assertTrue(event.getCreatedOperationalData().containsKey(NODE_1_FLOW_PATH));
 198         assertTrue(event.getCreatedOperationalData().containsKey(NODE_0_FLOW_PATH));
 199         assertFalse(event.getCreatedOperationalData().containsKey(NODE_0_TABLE_FEATURES_PATH));
 200     }
 201
 202 }