benchmark/dsbenchmark/src/main/java/org/opendaylight/dsbenchmark/DsbenchmarkProvider.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems 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.dsbenchmark;
   9
  10 import com.google.common.util.concurrent.Futures;
  11 import java.util.Collections;
  12 import java.util.concurrent.Future;
  13 import java.util.concurrent.atomic.AtomicReference;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  18 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  19 import org.opendaylight.dsbenchmark.listener.DsbenchmarkListenerProvider;
  20 import org.opendaylight.dsbenchmark.simpletx.SimpletxBaDelete;
  21 import org.opendaylight.dsbenchmark.simpletx.SimpletxBaRead;
  22 import org.opendaylight.dsbenchmark.simpletx.SimpletxBaWrite;
  23 import org.opendaylight.dsbenchmark.simpletx.SimpletxDomDelete;
  24 import org.opendaylight.dsbenchmark.simpletx.SimpletxDomRead;
  25 import org.opendaylight.dsbenchmark.simpletx.SimpletxDomWrite;
  26 import org.opendaylight.dsbenchmark.txchain.TxchainBaDelete;
  27 import org.opendaylight.dsbenchmark.txchain.TxchainBaRead;
  28 import org.opendaylight.dsbenchmark.txchain.TxchainBaWrite;
  29 import org.opendaylight.dsbenchmark.txchain.TxchainDomDelete;
  30 import org.opendaylight.dsbenchmark.txchain.TxchainDomRead;
  31 import org.opendaylight.dsbenchmark.txchain.TxchainDomWrite;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.DsbenchmarkService;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestOutput;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestOutputBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExec;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestExecBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestStatus;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestStatus.ExecStatus;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestStatusBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.test.exec.OuterList;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.opendaylight.yangtools.yang.common.RpcResult;
  44 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 public class DsbenchmarkProvider implements DsbenchmarkService, AutoCloseable {
  49
  50     private static final Logger LOG = LoggerFactory.getLogger(DsbenchmarkProvider.class);
  51     private static final InstanceIdentifier<TestExec> TEST_EXEC_IID =
  52             InstanceIdentifier.builder(TestExec.class).build();
  53     private static final InstanceIdentifier<TestStatus> TEST_STATUS_IID =
  54             InstanceIdentifier.builder(TestStatus.class).build();
  55
  56     private final AtomicReference<ExecStatus> execStatus = new AtomicReference<>(ExecStatus.Idle);
  57     private final DsbenchmarkListenerProvider listenerProvider = new DsbenchmarkListenerProvider();
  58     private final DOMDataBroker domDataBroker;  // Async DOM Broker for use with all DOM operations
  59     private final DataBroker txChainDataBroker; // Async Binding-Aware Broker for use in tx chains; initialized to
  60                                                 // ping-pong broker in default config (see default-config.xml and
  61                                                 // dsbenchmark-impl.yang)
  62     private final DataBroker simpleTxDataBroker;      // "Legacy" OSGI Data Broker for use in simple transactions
  63
  64     private long testsCompleted = 0;
  65
  66     public DsbenchmarkProvider(final DOMDataBroker domDataBroker, final DataBroker txChainDataBroker,
  67             final DataBroker simpleTxDataBroker) {
  68         this.domDataBroker = domDataBroker;
  69         this.txChainDataBroker = txChainDataBroker;
  70         this.simpleTxDataBroker = simpleTxDataBroker;
  71     }
  72
  73     public void init() {
  74         listenerProvider.setDataBroker(simpleTxDataBroker);
  75         setTestOperData(this.execStatus.get(), testsCompleted);
  76
  77         LOG.info("DsbenchmarkProvider initiated");
  78     }
  79
  80     @Override
  81     public void close() {
  82         LOG.info("DsbenchmarkProvider closed");
  83     }
  84
  85     @Override
  86     public Future<RpcResult<Void>> cleanupStore() {
  87         cleanupTestStore();
  88         LOG.debug("Data Store cleaned up");
  89         return Futures.immediateFuture( RpcResultBuilder.<Void>success().build());
  90     }
  91
  92     @Override
  93     public Future<RpcResult<StartTestOutput>> startTest(final StartTestInput input) {
  94         LOG.info("Starting the data store benchmark test, input: {}", input);
  95
  96         // Check if there is a test in progress
  97         if ( execStatus.compareAndSet(ExecStatus.Idle, ExecStatus.Executing) == false ) {
  98             LOG.info("Test in progress");
  99             return RpcResultBuilder.success(new StartTestOutputBuilder()
 100                     .setStatus(StartTestOutput.Status.TESTINPROGRESS)
 101                     .build()).buildFuture();
 102         }
 103
 104         // Cleanup data that may be left over from a previous test run
 105         cleanupTestStore();
 106
 107         // Get the appropriate writer based on operation type and data format
 108         DatastoreAbstractWriter dsWriter = getDatastoreWriter(input);
 109
 110         // Create listeners on OPERATIONAL and CONFIG test data subtrees
 111         listenerProvider.createAndRegisterListeners(input.getListeners().intValue());
 112
 113         long startTime, endTime, listCreateTime, execTime;
 114
 115         startTime = System.nanoTime();
 116         dsWriter.createList();
 117         endTime = System.nanoTime();
 118         listCreateTime = (endTime - startTime) / 1000;
 119
 120         // Run the test and measure the execution time
 121         try {
 122             startTime = System.nanoTime();
 123             dsWriter.executeList();
 124             endTime = System.nanoTime();
 125             execTime = (endTime - startTime) / 1000;
 126
 127             this.testsCompleted++;
 128
 129         } catch (final Exception e) {
 130             LOG.error( "Test error: {}", e.toString());
 131             execStatus.set( ExecStatus.Idle );
 132             return RpcResultBuilder.success(new StartTestOutputBuilder()
 133                     .setStatus(StartTestOutput.Status.FAILED)
 134                     .build()).buildFuture();
 135         }
 136
 137         LOG.info("Test finished");
 138         setTestOperData( ExecStatus.Idle, testsCompleted);
 139         execStatus.set(ExecStatus.Idle);
 140
 141         // Get the number of data change events and cleanup the data change listeners
 142         long numDataChanges = listenerProvider.getDataChangeCount();
 143         long numEvents = listenerProvider.getEventCountAndDestroyListeners();
 144
 145         StartTestOutput output = new StartTestOutputBuilder()
 146                 .setStatus(StartTestOutput.Status.OK)
 147                 .setListBuildTime(listCreateTime)
 148                 .setExecTime(execTime)
 149                 .setTxOk((long)dsWriter.getTxOk())
 150                 .setNtfOk(numEvents)
 151                 .setDataChangeEventsOk(numDataChanges)
 152                 .setTxError((long)dsWriter.getTxError())
 153                 .build();
 154
 155         return RpcResultBuilder.success(output).buildFuture();
 156     }
 157
 158     private void setTestOperData( final ExecStatus sts, final long tstCompl ) {
 159         TestStatus status = new TestStatusBuilder()
 160                 .setExecStatus(sts)
 161                 .setTestsCompleted(tstCompl)
 162                 .build();
 163
 164         WriteTransaction tx = simpleTxDataBroker.newWriteOnlyTransaction();
 165         tx.put(LogicalDatastoreType.OPERATIONAL, TEST_STATUS_IID, status);
 166
 167         try {
 168             tx.submit().checkedGet();
 169         } catch (final TransactionCommitFailedException e) {
 170             throw new IllegalStateException(e);
 171         }
 172
 173         LOG.debug("DataStore test oper status populated: {}", status);
 174     }
 175
 176     private void cleanupTestStore() {
 177         TestExec data = new TestExecBuilder()
 178                 .setOuterList(Collections.<OuterList>emptyList())
 179                 .build();
 180
 181         WriteTransaction tx = simpleTxDataBroker.newWriteOnlyTransaction();
 182         tx.put(LogicalDatastoreType.CONFIGURATION, TEST_EXEC_IID, data);
 183         try {
 184             tx.submit().checkedGet();
 185             LOG.debug("DataStore config test data cleaned up");
 186         } catch (final TransactionCommitFailedException e) {
 187             LOG.info("Failed to cleanup DataStore configtest data");
 188             throw new IllegalStateException(e);
 189         }
 190
 191         tx = simpleTxDataBroker.newWriteOnlyTransaction();
 192         tx.put(LogicalDatastoreType.OPERATIONAL, TEST_EXEC_IID, data);
 193         try {
 194             tx.submit().checkedGet();
 195             LOG.debug("DataStore operational test data cleaned up");
 196         } catch (final TransactionCommitFailedException e) {
 197             LOG.info("Failed to cleanup DataStore operational test data");
 198             throw new IllegalStateException(e);
 199         }
 200
 201     }
 202
 203     private DatastoreAbstractWriter getDatastoreWriter(final StartTestInput input) {
 204
 205         final DatastoreAbstractWriter retVal;
 206
 207         StartTestInput.TransactionType txType = input.getTransactionType();
 208         StartTestInput.Operation oper = input.getOperation();
 209         StartTestInput.DataFormat dataFormat = input.getDataFormat();
 210         StartTestInput.DataStore dataStore = input.getDataStore();
 211         int outerListElem = input.getOuterElements().intValue();
 212         int innerListElem = input.getInnerElements().intValue();
 213         int writesPerTx = input.getPutsPerTx().intValue();
 214
 215         try {
 216             if (txType == StartTestInput.TransactionType.SIMPLETX) {
 217                 if (dataFormat == StartTestInput.DataFormat.BINDINGAWARE) {
 218                     if (StartTestInput.Operation.DELETE == oper) {
 219                         retVal = new SimpletxBaDelete(this.simpleTxDataBroker, outerListElem,
 220                                 innerListElem,writesPerTx, dataStore);
 221                     } else if (StartTestInput.Operation.READ == oper) {
 222                         retVal = new SimpletxBaRead(this.simpleTxDataBroker, outerListElem,
 223                                 innerListElem, writesPerTx, dataStore);
 224                     } else {
 225                         retVal = new SimpletxBaWrite(this.simpleTxDataBroker, oper, outerListElem,
 226                                 innerListElem, writesPerTx, dataStore);
 227                     }
 228                 } else {
 229                     if (StartTestInput.Operation.DELETE == oper) {
 230                         retVal = new SimpletxDomDelete(this.domDataBroker, outerListElem,
 231                                 innerListElem, writesPerTx, dataStore);
 232                     } else if (StartTestInput.Operation.READ == oper) {
 233                         retVal = new SimpletxDomRead(this.domDataBroker, outerListElem,
 234                                 innerListElem, writesPerTx, dataStore);
 235                     } else {
 236                         retVal = new SimpletxDomWrite(this.domDataBroker, oper, outerListElem,
 237                                 innerListElem, writesPerTx, dataStore);
 238                     }
 239                 }
 240             } else {
 241                 if (dataFormat == StartTestInput.DataFormat.BINDINGAWARE) {
 242                     if (StartTestInput.Operation.DELETE == oper) {
 243                         retVal = new TxchainBaDelete(this.txChainDataBroker, outerListElem,
 244                                 innerListElem, writesPerTx, dataStore);
 245                     } else if (StartTestInput.Operation.READ == oper) {
 246                         retVal = new TxchainBaRead(this.txChainDataBroker,outerListElem,
 247                                 innerListElem,writesPerTx, dataStore);
 248                     } else {
 249                         retVal = new TxchainBaWrite(this.txChainDataBroker, oper, outerListElem,
 250                                 innerListElem, writesPerTx, dataStore);
 251                     }
 252                 } else {
 253                     if (StartTestInput.Operation.DELETE == oper) {
 254                         retVal = new TxchainDomDelete(this.domDataBroker, outerListElem,
 255                                 innerListElem, writesPerTx, dataStore);
 256                     } else if (StartTestInput.Operation.READ == oper) {
 257                         retVal = new TxchainDomRead(this.domDataBroker, outerListElem,
 258                                 innerListElem, writesPerTx, dataStore);
 259
 260                     } else {
 261                         retVal = new TxchainDomWrite(this.domDataBroker, oper, outerListElem,
 262                                 innerListElem,writesPerTx, dataStore);
 263                     }
 264                 }
 265             }
 266         } finally {
 267             execStatus.set(ExecStatus.Idle);
 268         }
 269         return retVal;
 270     }
 271 }