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