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