infra/it/benchmark/src/main/java/io/fd/honeycomb/benchmark/util/DataProvider.java

   1 /*
   2  * Copyright (c) 2016 Cisco and/or its affiliates.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package io.fd.honeycomb.benchmark.util;
  18
  19 import static com.google.common.base.Preconditions.checkArgument;
  20
  21 import com.google.common.collect.Lists;
  22 import java.util.HashMap;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.stream.Collectors;
  26 import java.util.stream.IntStream;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.ContainerWithList;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.SimpleContainer;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.SimpleContainerBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.ListInContainer;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.ListInContainerBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.ListInContainerKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.list.in.container.ContainerInListBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.list.in.container.container.in.list.NestedList;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.hc.test.rev150105.container.with.list.list.in.container.container.in.list.NestedListBuilder;
  36 import org.opendaylight.yangtools.yang.binding.DataObject;
  37 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  38
  39 public interface DataProvider {
  40
  41     String SIMPLE_CONTAINER = "simple-container";
  42     String LIST_IN_CONTAINER = "list-in-container";
  43     String COMPLEX_LIST_IN_CONTAINER = "complex-list-in-container";
  44
  45     InstanceIdentifier<?> getId(final long counter);
  46
  47     DataObject getData(final long counter);
  48
  49     static DataProvider from(String data) {
  50         return new MapBackedDataProvider(data);
  51     }
  52
  53     final class MapBackedDataProvider implements DataProvider {
  54
  55         private static final Map<String, DataProvider> map;
  56
  57         static {
  58             map = new HashMap<>();
  59
  60             final InstanceIdentifier<SimpleContainer> simpleContainerId = InstanceIdentifier.create(SimpleContainer.class);
  61             map.put(SIMPLE_CONTAINER, new MultiValueDataProvider(Lists.newArrayList(
  62                     // Multiple values of container to ensure each time the value in DS after commit changes to trigger
  63                     // writers in test
  64                     new SingleValueDataProvider<>(
  65                             new SimpleContainerBuilder().setSimpleContainerName("first").build(), simpleContainerId),
  66                     new SingleValueDataProvider<>(
  67                             new SimpleContainerBuilder().setSimpleContainerName("second").build(), simpleContainerId),
  68                     new SingleValueDataProvider<>(
  69                             new SimpleContainerBuilder().setSimpleContainerName("third").build(), simpleContainerId))
  70             ));
  71             map.put(LIST_IN_CONTAINER, new MultiValueDataProvider(getListInContainerValues(100_000)));
  72             map.put(COMPLEX_LIST_IN_CONTAINER,
  73                     new MultiValueDataProvider(getComplexListInContainerValues(100_000)));
  74         }
  75
  76         private final DataProvider delegate;
  77
  78         MapBackedDataProvider(final String data) {
  79             checkArgument(map.containsKey(data));
  80             this.delegate = map.get(data);
  81         }
  82
  83         @Override
  84         public InstanceIdentifier<?> getId(final long counter) {
  85             return delegate.getId(counter);
  86         }
  87
  88         @Override
  89         public DataObject getData(final long counter) {
  90             return delegate.getData(counter);
  91         }
  92
  93         @Override
  94         public String toString() {
  95             return "MapBackedDataProvider{" +
  96                     "delegate=" + delegate +
  97                     '}';
  98         }
  99     }
 100
 101
 102     static List<DataProvider> getListInContainerValues(final int i) {
 103         return IntStream.range(0, i)
 104                 .mapToObj(idx -> new SingleValueDataProvider<>(
 105                         new ListInContainerBuilder()
 106                                 .setId((long) idx)
 107                                 .build(),
 108                         InstanceIdentifier.create(ContainerWithList.class)
 109                                 .child(ListInContainer.class, new ListInContainerKey((long) idx))
 110                 ))
 111                 .collect(Collectors.toList());
 112     }
 113
 114     static List<DataProvider> getComplexListInContainerValues(final int i) {
 115         return IntStream.range(0, i)
 116                 .mapToObj(idx -> new SingleValueDataProvider<>(
 117                         new ListInContainerBuilder()
 118                                 .setId((long) idx)
 119                                 .setContainerInList(new ContainerInListBuilder()
 120                                         .setName("nested container")
 121                                         .setNestedList(Lists.newArrayList(
 122                                                 getNestedList("1"),
 123                                                 getNestedList("2"),
 124                                                 getNestedList("3")))
 125                                         .build())
 126                                 .build(),
 127                         InstanceIdentifier.create(ContainerWithList.class)
 128                                 .child(ListInContainer.class, new ListInContainerKey((long) idx))
 129                 ))
 130                 .collect(Collectors.toList());
 131     }
 132
 133     static NestedList getNestedList(final String value) {
 134         return new NestedListBuilder()
 135                 .setNestedId(value)
 136                 .setNestedName(value + "N")
 137                 .build();
 138     }
 139
 140     final class SingleValueDataProvider<T extends DataObject> implements DataProvider {
 141
 142         private final DataObject data;
 143         private final InstanceIdentifier<?> id;
 144
 145         SingleValueDataProvider(final T data, final InstanceIdentifier<T> id) {
 146             this.data = data;
 147             this.id = id;
 148         }
 149
 150         @Override
 151         public InstanceIdentifier<?> getId(final long counter) {
 152             return id;
 153         }
 154
 155         @Override
 156         public DataObject getData(final long counter) {
 157             return data;
 158         }
 159
 160         @Override
 161         public String toString() {
 162             return "SingleValueDataProvider{" +
 163                     "data=" + data +
 164                     ", id=" + id +
 165                     '}';
 166         }
 167     }
 168
 169     final class MultiValueDataProvider<T extends DataObject> implements DataProvider {
 170
 171         private final List<DataProvider> values;
 172         private int valueSize;
 173
 174         MultiValueDataProvider(final List<DataProvider> values) {
 175             // Wrap as array list so that index lookup is fast
 176             this.values = Lists.newArrayList(values);
 177             this.valueSize = values.size();
 178         }
 179
 180         @Override
 181         public InstanceIdentifier<?> getId(final long counter) {
 182             return values.get((int) (counter % valueSize)).getId(counter);
 183         }
 184
 185         @Override
 186         public DataObject getData(final long counter) {
 187             return values.get((int) (counter % valueSize)).getData(counter);
 188         }
 189
 190         @Override
 191         public String toString() {
 192             return "MultiValueDataProvider{" +
 193                     "valueSize=" + valueSize +
 194                     '}';
 195         }
 196     }
 197 }