public void testGetInstance() { Context context1 = new MockContext(mMockApplication); Client c = Proton.getInjector(context1).getInstance(Client.class); assertNotNull(c); assertEquals( c.contextScopedClass1, Proton.getInjector(context1).getInstance(ContextScopedClass.class)); assertNotSame( c.contextScopedClass1, Proton.getInjector(new MockContext(mMockApplication)) .getInstance(ContextScopedClass.class)); }
public void testInject() { Context context1 = new MockContext(mMockApplication); Client obj1 = Proton.getInjector(context1).inject(new Client()); assertNotNull(obj1.contextScopedClass1); assertEquals(obj1.contextScopedClass1, obj1.contextScopedClass2); assertNotNull(obj1.contextScopedClassProvider1); assertEquals(obj1.contextScopedClassProvider1, obj1.contextScopedClassProvider2); Client obj2 = Proton.getInjector(context1).inject(new Client()); assertEquals(obj1.contextScopedClass1, obj2.contextScopedClass2); assertEquals(obj1.contextScopedClassProvider1, obj2.contextScopedClassProvider2); Client obj3 = Proton.getInjector(new MockContext(mMockApplication)).inject(new Client()); assertNotSame(obj1.contextScopedClass1, obj3.contextScopedClass1); assertNotSame(obj1.contextScopedClassProvider1, obj3.contextScopedClassProvider1); }
@Override public void onLinkFlow(Event event) { Sender snd = (Sender) event.getLink(); if (snd.getCredit() > 0 && snd.getLocalState() != EndpointState.CLOSED) { Message message = Proton.message(); ++count; message.setBody(new AmqpValue("message-" + count)); byte[] msgData = new byte[1024]; int length; while (true) { try { length = message.encode(msgData, 0, msgData.length); break; } catch (BufferOverflowException e) { msgData = new byte[msgData.length * 2]; } } byte[] tag = String.valueOf(count).getBytes(); Delivery dlv = snd.delivery(tag); snd.send(msgData, 0, length); dlv.settle(); snd.advance(); if (count == numMsgs) { snd.close(); snd.getSession().close(); snd.getSession().getConnection().close(); result = true; } } }
@Override public void onDelivery(Event event) { Receiver recv = (Receiver) event.getLink(); Delivery delivery = recv.current(); if (delivery.isReadable() && !delivery.isPartial()) { int size = delivery.pending(); byte[] buffer = new byte[size]; int read = recv.recv(buffer, 0, buffer.length); recv.advance(); Message msg = Proton.message(); msg.decode(buffer, 0, read); ++count; String msgBody = ((AmqpValue) msg.getBody()).getValue().toString(); String expected = "message-" + count; if (!expected.equals(msgBody)) { throw new RuntimeException( "Received message body '" + msgBody + "', expected: '" + expected + "'"); } if (count == numMsgs) { recv.close(); recv.getSession().close(); recv.getSession().getConnection().close(); acceptor.close(); } } }
/** * Asynchronously runs the Proton {@link Reactor} accepting and sending messages. Any other call * to this method on this {@link AmqpsIotHubConnection} will block until the {@link Reactor} * terminates and this {@link AmqpsIotHubConnection} closes. Normally, this method should only be * called once by the {@link #open()} method until the {@link AmqpsIotHubConnection} has been * closed. * * @throws IOException if the {@link AmqpsIotHubConnectionBaseHandler} has not been initialized. * @throws InterruptedException if there is a problem acquiring the semaphore. */ private synchronized void startReactorAsync() throws IOException, InterruptedException { // Acquire permit to continue execution of this method and spawn a new thread. reactorSemaphore.acquire(); if (this.amqpsHandler != null) { this.reactor = Proton.reactor(this); new Thread( () -> { try { reactor.run(); // Closing here should be okay. The reactor will only stop running if the // connection is remotely // or locally closed. The transport will attempt to receive/send a message and // will get an exception // causing it to create a new AmqpsIoTHubConnection. close(); // Release the semaphore and make permit available allowing for the next reactor // thread to spawn. reactorSemaphore.release(); } catch (Exception e) { close(); reactorSemaphore.release(); } }) .start(); } else { throw new IOException( "The Handler has not been initialized. Ensure that the AmqpsIotHubConnection is in an OPEN state by calling open()."); } }
public static void main(String[] args) throws IOException { try { int port = Integer.valueOf(args[1]); int numMsgs = Integer.valueOf(args[2]); boolean result = false; if ("send".equalsIgnoreCase(args[0])) { Send send = new Send("localhost", port, numMsgs); Reactor r = Proton.reactor(send); r.run(); result = send.getResult(); } else { Reactor r = Proton.reactor(new Recv(port, numMsgs)); r.run(); result = true; } System.exit(result ? 0 : 1); } catch (Throwable t) { t.printStackTrace(); System.exit(1); } }
@Override protected void setUp() throws Exception { super.setUp(); mMockApplication = new MockApplication(); Proton.initialize( mMockApplication, new DefaultModule() { @Override protected void configure() { super.configure(); bind(Client.class); bind(ContextScopedClass.class); } }); }
@Override protected void tearDown() throws Exception { Proton.destroy(); super.tearDown(); }