test-common/src/main/java/org/opendaylight/transportpce/test/DeviceWrapper.java

   1 /*
   2  * Copyright © 2016 AT&T 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.transportpce.test;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.base.Strings;
  14 import com.google.common.collect.Lists;
  15 import java.io.InputStream;
  16 import java.util.AbstractMap;
  17 import java.util.List;
  18 import java.util.Map.Entry;
  19 import java.util.Optional;
  20 import java.util.concurrent.ExecutionException;
  21 import javax.annotation.Nonnull;
  22 import org.opendaylight.mdsal.binding.api.DataBroker;
  23 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  24 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  25 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
  26 import org.opendaylight.transportpce.test.converter.XMLDataObjectConverter;
  27 import org.opendaylight.yangtools.yang.common.QName;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  29 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  30 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  31 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 /**
  36  * Wrapper class around {@link DataBroker} and {@link DOMDataBroker}.
  37  *
  38  */
  39 public final class DeviceWrapper {
  40     private static final Logger LOG = LoggerFactory.getLogger(DeviceWrapper.class);
  41
  42     private final String identifier;
  43     private final DataBroker dataBroker;
  44     private final DOMDataBroker domDataBroker;
  45
  46     /**
  47      * May be created only inside of {@link AbstractDeviceTest}.
  48      *
  49      * @param identifier id of this simulator
  50      * @param dataBroker data broker used in this simulator
  51      * @param domDataBroker dom data broker used in this simulator
  52      */
  53     private DeviceWrapper(String identifier, DataBroker dataBroker, DOMDataBroker domDataBroker) {
  54         this.identifier = identifier;
  55         this.dataBroker = dataBroker;
  56         this.domDataBroker = domDataBroker;
  57     }
  58
  59     /**
  60      * Gets the data broker.
  61      *
  62      * @return the dataBroker
  63      */
  64     public DataBroker getDataBroker() {
  65         return dataBroker;
  66     }
  67
  68     /**
  69      * Gets the DOM data broker.
  70      *
  71      * @return the domDataBroker
  72      */
  73     public DOMDataBroker getDeviceDomDataBroker() {
  74         return domDataBroker;
  75     }
  76
  77     /**
  78      * Gets the identifier.
  79      *
  80      * @return the identifier
  81      */
  82     public String getIdentifier() {
  83         return identifier;
  84     }
  85
  86     /**
  87      * Creates a device wrapper.
  88      *
  89      * @see #createDeviceWrapper(String, List) with a single list element
  90      * @param key identifier of creating simulator
  91      * @param initialDataXmlInputStream {@link InputStream} of xml with initial data for simulator
  92      * @param intialDataQName {@link QName} of initial data
  93      * @return device simulator
  94      */
  95     public static DeviceWrapper createDeviceWrapper(@Nonnull String key, @Nonnull InputStream initialDataXmlInputStream,
  96             @Nonnull QName intialDataQName) {
  97         requireNonNull(initialDataXmlInputStream, "Input stream cannot be null");
  98         requireNonNull(intialDataQName, "QName cannot be null");
  99         return createDeviceWrapper(key, Lists.newArrayList(
 100                 new AbstractMap.SimpleEntry<QName, InputStream>(intialDataQName, initialDataXmlInputStream)));
 101     }
 102
 103     /**
 104      * Creates an instance of {@link DeviceWrapper} with initial data provided via xml
 105      * input streams and theirs {@link QName}s the xml data <b>must</b> be wrapped
 106      * inside a <b>data</b> tag provided by
 107      * <b>urn:ietf:params:xml:ns:netconf:base:1.0</b>.
 108      *
 109      * @param key string identifier for the device
 110      * @param initialData {@link List} of {@link Entry} values
 111      * @return created {@link DeviceWrapper} with all initial data provided by initial data
 112      */
 113     public static DeviceWrapper createDeviceWrapper(@Nonnull String key,
 114             @Nonnull List<Entry<QName, InputStream>> initialData) {
 115         Preconditions.checkArgument(!Strings.isNullOrEmpty(key), "The provided key cannot be null or empty");
 116         Preconditions.checkArgument(initialData != null && !initialData.isEmpty(),
 117                 "Initial data cannot be null or empty");
 118         DataStoreContext dsContext = new DataStoreContextImpl();
 119         XMLDataObjectConverter xmlConverter = XMLDataObjectConverter.createWithDataStoreUtil(dsContext);
 120         for (Entry<QName, InputStream> entryData : initialData) {
 121             insertDataIntoDS(xmlConverter, entryData.getValue(), entryData.getKey(), dsContext.getDOMDataBroker());
 122         }
 123         return new DeviceWrapper(key, dsContext.getDataBroker(), dsContext.getDOMDataBroker());
 124     }
 125
 126     private static void insertDataIntoDS(XMLDataObjectConverter xmlConverter, InputStream xmlDataInputStream,
 127             QName dataQName, DOMDataBroker domDataBroker) {
 128         Optional<NormalizedNode<? extends PathArgument, ?>> initialDataNormalizedNodes =
 129                 xmlConverter.transformIntoNormalizedNode(xmlDataInputStream);
 130         Preconditions.checkArgument(initialDataNormalizedNodes.isPresent(),
 131                 "Initial data could not be converted to normalized nodes");
 132         LOG.debug("Input data converted into normalizedNodes");
 133
 134         YangInstanceIdentifier initialDataIi = YangInstanceIdentifier.of(dataQName);
 135         LOG.debug("Searching for {} inside {}", initialDataIi, initialDataNormalizedNodes.get());
 136         Optional<NormalizedNode<?, ?>> dataNormalizedNodes =
 137                 NormalizedNodes.findNode(initialDataNormalizedNodes.get(), initialDataIi);
 138         Preconditions.checkArgument(dataNormalizedNodes.isPresent());
 139         LOG.info("Initial data was successfully stored into ds");
 140         DOMDataTreeWriteTransaction writeOnlyTransaction = domDataBroker.newWriteOnlyTransaction();
 141         writeOnlyTransaction.put(LogicalDatastoreType.OPERATIONAL, initialDataIi, dataNormalizedNodes.get());
 142         try {
 143             writeOnlyTransaction.commit().get();
 144         } catch (InterruptedException | ExecutionException e) {
 145             LOG.error("This should be not reached ", e);
 146             throw new IllegalStateException(e);
 147         }
 148     }
 149
 150     @Override
 151     public String toString() {
 152         StringBuilder builder = new StringBuilder();
 153         builder.append("DeviceWrapper [identifier=");
 154         builder.append(identifier);
 155         builder.append(", dataBroker=");
 156         builder.append(dataBroker);
 157         builder.append(", domDataBroker=");
 158         builder.append(domDataBroker);
 159         builder.append("]");
 160         return builder.toString();
 161     }
 162 }