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