*/
package org.opendaylight.dsbenchmark;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.PreDestroy;
+import javax.inject.Inject;
+import javax.inject.Singleton;
import org.opendaylight.dsbenchmark.listener.DsbenchmarkListenerProvider;
import org.opendaylight.dsbenchmark.simpletx.SimpletxBaDelete;
import org.opendaylight.dsbenchmark.simpletx.SimpletxBaRead;
import org.opendaylight.dsbenchmark.txchain.TxchainDomRead;
import org.opendaylight.dsbenchmark.txchain.TxchainDomWrite;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.RpcProviderService;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.CleanupStore;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.CleanupStoreInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.CleanupStoreOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.CleanupStoreOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.DsbenchmarkService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.StartTestOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestStatus.ExecStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.TestStatusBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.dsbenchmark.rev150105.test.exec.OuterList;
+import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.osgi.service.component.annotations.Activate;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Deactivate;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.RequireServiceComponentRuntime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class DsbenchmarkProvider implements DsbenchmarkService, AutoCloseable {
-
+@Singleton
+@Component(service = { })
+@RequireServiceComponentRuntime
+public final class DsbenchmarkProvider implements AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(DsbenchmarkProvider.class);
- private static final InstanceIdentifier<TestExec> TEST_EXEC_IID =
- InstanceIdentifier.builder(TestExec.class).build();
- private static final InstanceIdentifier<TestStatus> TEST_STATUS_IID =
- InstanceIdentifier.builder(TestStatus.class).build();
+ private static final InstanceIdentifier<TestExec> TEST_EXEC_IID = InstanceIdentifier.create(TestExec.class);
+ private static final InstanceIdentifier<TestStatus> TEST_STATUS_IID = InstanceIdentifier.create(TestStatus.class);
private final AtomicReference<ExecStatus> execStatus = new AtomicReference<>(ExecStatus.Idle);
- private final DsbenchmarkListenerProvider listenerProvider = new DsbenchmarkListenerProvider();
- private final DOMDataBroker domDataBroker; // Async DOM Broker for use with all DOM operations
- private final DataBroker dataBroker; // Async Binding-Aware Broker for use in tx chains
+ private final DsbenchmarkListenerProvider listenerProvider;
+ // Async DOM Broker for use with all DOM operations
+ private final DOMDataBroker domDataBroker;
+ // Async Binding-Aware Broker for use in tx chains;
+ private final DataBroker dataBroker;
+ private final Registration rpcReg;
private long testsCompleted = 0;
- public DsbenchmarkProvider(final DOMDataBroker domDataBroker, final DataBroker dataBroker) {
- this.domDataBroker = domDataBroker;
- this.dataBroker = dataBroker;
- }
-
+ @Inject
+ @Activate
@SuppressWarnings("checkstyle:illegalCatch")
- public void init() {
- listenerProvider.setDataBroker(dataBroker);
+ public DsbenchmarkProvider(@Reference final DOMDataBroker domDataBroker, @Reference final DataBroker dataBroker,
+ @Reference final RpcProviderService rpcService) {
+ this.domDataBroker = requireNonNull(domDataBroker);
+ this.dataBroker = requireNonNull(dataBroker);
+ listenerProvider = new DsbenchmarkListenerProvider(dataBroker);
try {
// We want to set the initial operation status so users can detect we are ready to start test.
- setTestOperData(this.execStatus.get(), testsCompleted);
+ setTestOperData(execStatus.get(), testsCompleted);
} catch (final Exception e) {
// TODO: Use a singleton service to make sure the initial write is performed only once.
- LOG.warn("Working around Bugs 8829 and 6793 by ignoring exception from setTestOperData: {}", e);
+ LOG.warn("Working around Bugs 8829 and 6793 by ignoring exception from setTestOperData", e);
}
+ rpcReg = rpcService.registerRpcImplementations((StartTest) this::startTest, (CleanupStore) this::cleanupStore);
LOG.info("DsbenchmarkProvider initiated");
}
@Override
+ @PreDestroy
+ @Deactivate
public void close() {
+ rpcReg.close();
LOG.info("DsbenchmarkProvider closed");
}
- @Override
- public ListenableFuture<RpcResult<CleanupStoreOutput>> cleanupStore(final CleanupStoreInput input) {
+ private ListenableFuture<RpcResult<CleanupStoreOutput>> cleanupStore(final CleanupStoreInput input) {
cleanupTestStore();
LOG.debug("Data Store cleaned up");
return Futures.immediateFuture(RpcResultBuilder.success(new CleanupStoreOutputBuilder().build()).build());
}
- @Override
@SuppressWarnings("checkstyle:illegalCatch")
- public ListenableFuture<RpcResult<StartTestOutput>> startTest(final StartTestInput input) {
+ private ListenableFuture<RpcResult<StartTestOutput>> startTest(final StartTestInput input) {
LOG.info("Starting the data store benchmark test, input: {}", input);
// Check if there is a test in progress
- if (execStatus.compareAndSet(ExecStatus.Idle, ExecStatus.Executing) == false) {
+ if (!execStatus.compareAndSet(ExecStatus.Idle, ExecStatus.Executing)) {
LOG.info("Test in progress");
return RpcResultBuilder.success(new StartTestOutputBuilder()
- .setStatus(StartTestOutput.Status.TESTINPROGRESS)
- .build()).buildFuture();
+ .setStatus(StartTestOutput.Status.TESTINPROGRESS)
+ .build()).buildFuture();
}
// Cleanup data that may be left over from a previous test run
endTime = System.nanoTime();
execTime = (endTime - startTime) / 1000;
- this.testsCompleted++;
+ testsCompleted++;
} catch (final Exception e) {
- LOG.error("Test error: {}", e.toString());
+ LOG.error("Test error", e);
execStatus.set(ExecStatus.Idle);
return RpcResultBuilder.success(new StartTestOutputBuilder()
- .setStatus(StartTestOutput.Status.FAILED)
- .build()).buildFuture();
+ .setStatus(StartTestOutput.Status.FAILED)
+ .build()).buildFuture();
}
LOG.info("Test finished");
.setStatus(StartTestOutput.Status.OK)
.setListBuildTime(listCreateTime)
.setExecTime(execTime)
- .setTxOk((long)dsWriter.getTxOk())
- .setNtfOk(numEvents)
- .setDataChangeEventsOk(numDataChanges)
- .setTxError((long)dsWriter.getTxError())
+ .setTxOk(Uint32.valueOf(dsWriter.getTxOk()))
+ .setNtfOk(Uint32.valueOf(numEvents))
+ .setDataChangeEventsOk(Uint32.valueOf(numDataChanges))
+ .setTxError(Uint32.valueOf(dsWriter.getTxError()))
.build();
return RpcResultBuilder.success(output).buildFuture();
private void setTestOperData(final ExecStatus sts, final long tstCompl) {
TestStatus status = new TestStatusBuilder()
.setExecStatus(sts)
- .setTestsCompleted(tstCompl)
+ .setTestsCompleted(Uint32.valueOf(tstCompl))
.build();
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
}
private void cleanupTestStore() {
- TestExec data = new TestExecBuilder()
- .setOuterList(Collections.<OuterList>emptyList())
- .build();
+ TestExec data = new TestExecBuilder().setOuterList(Collections.emptyMap()).build();
WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
tx.put(LogicalDatastoreType.CONFIGURATION, TEST_EXEC_IID, data);
if (txType == StartTestInput.TransactionType.SIMPLETX) {
if (dataFormat == StartTestInput.DataFormat.BINDINGAWARE) {
if (StartTestInput.Operation.DELETE == oper) {
- retVal = new SimpletxBaDelete(this.dataBroker, outerListElem,
+ retVal = new SimpletxBaDelete(dataBroker, outerListElem,
innerListElem,writesPerTx, dataStore);
} else if (StartTestInput.Operation.READ == oper) {
- retVal = new SimpletxBaRead(this.dataBroker, outerListElem,
+ retVal = new SimpletxBaRead(dataBroker, outerListElem,
innerListElem, writesPerTx, dataStore);
} else {
- retVal = new SimpletxBaWrite(this.dataBroker, oper, outerListElem,
+ retVal = new SimpletxBaWrite(dataBroker, oper, outerListElem,
innerListElem, writesPerTx, dataStore);
}
+ } else if (StartTestInput.Operation.DELETE == oper) {
+ retVal = new SimpletxDomDelete(domDataBroker, outerListElem,
+ innerListElem, writesPerTx, dataStore);
+ } else if (StartTestInput.Operation.READ == oper) {
+ retVal = new SimpletxDomRead(domDataBroker, outerListElem,
+ innerListElem, writesPerTx, dataStore);
} else {
- if (StartTestInput.Operation.DELETE == oper) {
- retVal = new SimpletxDomDelete(this.domDataBroker, outerListElem,
- innerListElem, writesPerTx, dataStore);
- } else if (StartTestInput.Operation.READ == oper) {
- retVal = new SimpletxDomRead(this.domDataBroker, outerListElem,
- innerListElem, writesPerTx, dataStore);
- } else {
- retVal = new SimpletxDomWrite(this.domDataBroker, oper, outerListElem,
- innerListElem, writesPerTx, dataStore);
- }
+ retVal = new SimpletxDomWrite(domDataBroker, oper, outerListElem,
+ innerListElem, writesPerTx, dataStore);
}
- } else {
- if (dataFormat == StartTestInput.DataFormat.BINDINGAWARE) {
- if (StartTestInput.Operation.DELETE == oper) {
- retVal = new TxchainBaDelete(this.dataBroker, outerListElem,
- innerListElem, writesPerTx, dataStore);
- } else if (StartTestInput.Operation.READ == oper) {
- retVal = new TxchainBaRead(this.dataBroker, outerListElem,
- innerListElem,writesPerTx, dataStore);
- } else {
- retVal = new TxchainBaWrite(this.dataBroker, oper, outerListElem,
- innerListElem, writesPerTx, dataStore);
- }
+ } else if (dataFormat == StartTestInput.DataFormat.BINDINGAWARE) {
+ if (StartTestInput.Operation.DELETE == oper) {
+ retVal = new TxchainBaDelete(dataBroker, outerListElem,
+ innerListElem, writesPerTx, dataStore);
+ } else if (StartTestInput.Operation.READ == oper) {
+ retVal = new TxchainBaRead(dataBroker, outerListElem,
+ innerListElem,writesPerTx, dataStore);
} else {
- if (StartTestInput.Operation.DELETE == oper) {
- retVal = new TxchainDomDelete(this.domDataBroker, outerListElem,
- innerListElem, writesPerTx, dataStore);
- } else if (StartTestInput.Operation.READ == oper) {
- retVal = new TxchainDomRead(this.domDataBroker, outerListElem,
- innerListElem, writesPerTx, dataStore);
-
- } else {
- retVal = new TxchainDomWrite(this.domDataBroker, oper, outerListElem,
- innerListElem,writesPerTx, dataStore);
- }
+ retVal = new TxchainBaWrite(dataBroker, oper, outerListElem,
+ innerListElem, writesPerTx, dataStore);
}
+ } else if (StartTestInput.Operation.DELETE == oper) {
+ retVal = new TxchainDomDelete(domDataBroker, outerListElem,
+ innerListElem, writesPerTx, dataStore);
+ } else if (StartTestInput.Operation.READ == oper) {
+ retVal = new TxchainDomRead(domDataBroker, outerListElem,
+ innerListElem, writesPerTx, dataStore);
+
+ } else {
+ retVal = new TxchainDomWrite(domDataBroker, oper, outerListElem,
+ innerListElem,writesPerTx, dataStore);
}
} finally {
execStatus.set(ExecStatus.Idle);
Code Review / controller.git / blobdiff