X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=benchmark%2Fntfbenchmark%2Fsrc%2Fmain%2Fjava%2Fntfbenchmark%2Fimpl%2FNtfbenchmarkProvider.java;h=acd5af61436a9be62f886e8e1fdfa6372c286c6a;hb=refs%2Fchanges%2F22%2F97722%2F3;hp=4b2a1ebdf3b2fd50d6ed7c93dde1f287b8927a78;hpb=2188a562d80e6eec5dbb5a29779d2521272ccec6;p=controller.git diff --git a/benchmark/ntfbenchmark/src/main/java/ntfbenchmark/impl/NtfbenchmarkProvider.java b/benchmark/ntfbenchmark/src/main/java/ntfbenchmark/impl/NtfbenchmarkProvider.java index 4b2a1ebdf3..acd5af6143 100644 --- a/benchmark/ntfbenchmark/src/main/java/ntfbenchmark/impl/NtfbenchmarkProvider.java +++ b/benchmark/ntfbenchmark/src/main/java/ntfbenchmark/impl/NtfbenchmarkProvider.java @@ -5,55 +5,76 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package ntfbenchmark.impl; +import static com.google.common.base.Verify.verifyNotNull; +import static java.util.Objects.requireNonNull; + +import com.google.common.util.concurrent.ListenableFuture; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; -import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; -import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService; -import org.opendaylight.controller.md.sal.binding.api.NotificationService; +import javax.annotation.PreDestroy; +import javax.inject.Inject; +import javax.inject.Singleton; +import org.opendaylight.mdsal.binding.api.NotificationPublishService; +import org.opendaylight.mdsal.binding.api.NotificationService; +import org.opendaylight.mdsal.binding.api.RpcProviderService; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.NtfbenchmarkService; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.StartTestInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.StartTestInput.ProducerType; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.StartTestOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.StartTestOutputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.TestStatusInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ntfbenchmark.rev150105.TestStatusOutput; import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.concepts.Registration; 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 NtfbenchmarkProvider implements AutoCloseable, NtfbenchmarkService { - +@Singleton +@Component(service = {}) +@RequireServiceComponentRuntime +public final class NtfbenchmarkProvider implements AutoCloseable, NtfbenchmarkService { private static final Logger LOG = LoggerFactory.getLogger(NtfbenchmarkProvider.class); + private static final int TEST_TIMEOUT = 5; + private final NotificationService listenService; private final NotificationPublishService publishService; - private static final int testTimeout = 5; - - public NtfbenchmarkProvider(final NotificationService listenServiceDependency, - final NotificationPublishService publishServiceDependency) { - LOG.debug("NtfbenchmarkProvider Constructor"); - listenService = listenServiceDependency; - publishService = publishServiceDependency; - } - - public void init() { - LOG.info("NtfbenchmarkProvider initiated"); + private final Registration reg; + + @Inject + @Activate + public NtfbenchmarkProvider(@Reference final NotificationService listenService, + @Reference final NotificationPublishService publishService, + @Reference final RpcProviderService rpcService) { + this.listenService = requireNonNull(listenService); + this.publishService = requireNonNull(publishService); + reg = rpcService.registerRpcImplementation(NtfbenchmarkService.class, this); + LOG.debug("NtfbenchmarkProvider initiated"); } @Override - public void close() throws Exception { + @PreDestroy + @Deactivate + public void close() { + reg.close(); LOG.info("NtfbenchmarkProvider closed"); } @Override - public Future> startTest(final StartTestInput input) { + public ListenableFuture> startTest(final StartTestInput input) { final int producerCount = input.getProducers().intValue(); final int listenerCount = input.getListeners().intValue(); final int iterations = input.getIterations().intValue(); @@ -83,16 +104,17 @@ public class NtfbenchmarkProvider implements AutoCloseable, NtfbenchmarkService final long startTime = System.nanoTime(); for (int i = 0; i < input.getProducers().intValue(); i++) { - executor.submit(producers.get(i)); + // FIXME: fools RV_RETURN_VALUE_IGNORED_BAD_PRACTICE for now, but we should check some more + verifyNotNull(executor.submit(producers.get(i))); } executor.shutdown(); try { - executor.awaitTermination(testTimeout, TimeUnit.MINUTES); + executor.awaitTermination(TEST_TIMEOUT, TimeUnit.MINUTES); for (ListenerRegistration listenerRegistration : listeners) { listenerRegistration.getInstance().getAllDone().get(); } } catch (final InterruptedException | ExecutionException e) { - LOG.error("Out of time: test did not finish within the {} min deadline ", testTimeout); + LOG.error("Out of time: test did not finish within the {} min deadline ", TEST_TIMEOUT); } final long producerEndTime = System.nanoTime(); @@ -106,7 +128,6 @@ public class NtfbenchmarkProvider implements AutoCloseable, NtfbenchmarkService allListeners += listenerRegistration.getInstance().getReceived(); } - final long listenerEndTime = System.nanoTime(); final long listenerElapsedTime = producerEndTime - startTime; LOG.info("Test Done"); @@ -116,16 +137,16 @@ public class NtfbenchmarkProvider implements AutoCloseable, NtfbenchmarkService allProducersError += abstractNtfbenchProducer.getNtfError(); } - final StartTestOutput output = - new StartTestOutputBuilder() - .setProducerElapsedTime(producerElapsedTime / 1000000) - .setListenerElapsedTime(listenerElapsedTime / 1000000) - .setListenerOk(allListeners) - .setProducerOk(allProducersOk) - .setProducerError(allProducersError) - .setProducerRate((allProducersOk + allProducersError) * 1000000000 / producerElapsedTime) - .setListenerRate(allListeners * 1000000000 / listenerElapsedTime) - .build(); + final StartTestOutput output = new StartTestOutputBuilder() + .setProducerElapsedTime(Uint32.valueOf(producerElapsedTime / 1000000)) + .setListenerElapsedTime(Uint32.valueOf(listenerElapsedTime / 1000000)) + .setListenerOk(Uint32.valueOf(allListeners)) + .setProducerOk(Uint32.valueOf(allProducersOk)) + .setProducerError(Uint32.valueOf(allProducersError)) + .setProducerRate( + Uint32.valueOf((allProducersOk + allProducersError) * 1000000000 / producerElapsedTime)) + .setListenerRate(Uint32.valueOf(allListeners * 1000000000 / listenerElapsedTime)) + .build(); return RpcResultBuilder.success(output).buildFuture(); } finally { for (final ListenerRegistration listenerRegistration : listeners) { @@ -135,9 +156,7 @@ public class NtfbenchmarkProvider implements AutoCloseable, NtfbenchmarkService } @Override - public Future> testStatus() { - // TODO Auto-generated method stub - return null; + public ListenableFuture> testStatus(final TestStatusInput input) { + throw new UnsupportedOperationException("Not implemented"); } - }