Package org.cometd.bayeux.client

Examples of org.cometd.bayeux.client.ClientSessionChannel


                else if (wasConnected && !connected.get())
                    System.err.println("BayeuxClient unconnected");
            }
        });
        String channelName = "/test";
        ClientSessionChannel channel = client.getChannel(channelName);
        channel.addListener(new ClientSessionChannel.MessageListener()
        {
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                if (!message.isSuccessful())
                    publishLatch.get().countDown();
            }
        });
        client.handshake();
        assertTrue(connectLatch.await(5, TimeUnit.SECONDS));

        // Wait for a second connect to be issued
        Thread.sleep(1000);

        // Add some margin since the session is swept every 'sweepIntervalMs'
        long networkDown = maxInterval + 3 * sweepInterval;
        client.setNetworkDown(networkDown);

        // Publish, it must succeed
        publishLatch.set(new CountDownLatch(1));
        channel.publish(new HashMap());
        assertTrue(publishLatch.get().await(5, TimeUnit.SECONDS));

        // Wait for the connect to return
        // We already slept a bit before, so we are sure that the connect returned
        Thread.sleep(timeout);

        // Now we are simulating the network is down
        // Be sure we are disconnected
        assertFalse(connected.get());

        // Another publish, it must fail
        publishLatch.set(new CountDownLatch(1));
        channel.publish(new HashMap());
        assertTrue(publishLatch.get().await(5, TimeUnit.SECONDS));

        // Sleep to allow the next connect to be issued
        Thread.sleep(networkDown);

        // Now another connect has been sent (delayed by 'networkDown' ms)
        // but the server expired the client, so we handshake again
        assertTrue(handshakeLatch.await(5, TimeUnit.SECONDS));

        // We should be able to publish now
        publishLatch.set(new CountDownLatch(1));
        channel.publish(new HashMap());
        assertFalse(publishLatch.get().await(1, TimeUnit.SECONDS));

        disconnectBayeuxClient(client);
    }
View Full Code Here


            if (oortComet != null)
            {
                Set<String> associatedUserIds = getAssociatedUserIds();
                if (_logger.isDebugEnabled())
                    _logger.debug("Pushing associated users {} to comet {}", associatedUserIds, oortURL);
                ClientSessionChannel channel = oortComet.getChannel(generateSetiChannel(generateSetiId(oortURL)));
                channel.publish(new SetiPresence(true, associatedUserIds));
            }
        }
    }
View Full Code Here

        boolean processed = processor.process(service);
        assertTrue(processed);

        LocalSession remote = bayeuxServer.newLocalSession("remoteCall");
        remote.handshake();
        ClientSessionChannel channel = remote.getChannel(Channel.SERVICE + RemoteCallWithResultService.CHANNEL);
        final CountDownLatch latch = new CountDownLatch(1);
        channel.addListener(new ClientSessionChannel.MessageListener()
        {
            @Override
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                if (message.isPublishReply())
                    return;
                assertTrue(message.isSuccessful());
                assertEquals(calleeData, message.getData());
                latch.countDown();
            }
        });
        channel.publish(callerData);

        assertTrue(latch.await(5, TimeUnit.SECONDS));
    }
View Full Code Here

        assertTrue(handshakeLatch.await(5, TimeUnit.SECONDS));
        assertTrue(connectLatch.await(5, TimeUnit.SECONDS));
        assertTrue(client.waitFor(5000, BayeuxClient.State.CONNECTED));

        ClientSessionChannel channel = client.getChannel(channelName);
        channel.subscribe(new ClientSessionChannel.MessageListener()
        {
            public void onMessage(ClientSessionChannel channel, Message message)
            {
            }
        });
        assertTrue(subscribeLatch.await(5, TimeUnit.SECONDS));

        channel.publish(new HashMap<>());
        assertTrue(publishLatch.await(5, TimeUnit.SECONDS));

        channel.unsubscribe();
        assertTrue(unsubscribeLatch.await(5, TimeUnit.SECONDS));

        disconnectBayeuxClient(client);
    }
View Full Code Here

        bayeux.addExtension(new TimestampExtension());

        final String channelName = "/service/test";
        BayeuxClient client = newBayeuxClient();
        final CountDownLatch messageLatch = new CountDownLatch(1);
        ClientSessionChannel channel = client.getChannel(channelName);
        channel.addListener(new ClientSessionChannel.MessageListener()
        {
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                messageLatch.countDown();
            }
        });

        new DeliverService(bayeux, channelName);

        client.handshake();
        Assert.assertTrue(client.waitFor(5000, BayeuxClient.State.CONNECTED));

        // Wait for the long poll
        Thread.sleep(1000);

        channel.publish(new HashMap<>());

        Assert.assertTrue(messageLatch.await(5, TimeUnit.SECONDS));

        disconnectBayeuxClient(client);
    }
View Full Code Here

        BayeuxClient client = newBayeuxClient();
        client.handshake();
        Assert.assertTrue(client.waitFor(5000, BayeuxClient.State.CONNECTED));

        final AtomicReference<CountDownLatch> messageLatch = new AtomicReference<>(new CountDownLatch(1));
        ClientSessionChannel testChannel = client.getChannel(testChannelName);
        client.startBatch();
        testChannel.subscribe(new ClientSessionChannel.MessageListener()
        {
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                messageLatch.get().countDown();
            }
        });
        testChannel.publish(new HashMap<String, Object>());
        client.endBatch();
        Assert.assertTrue(messageLatch.get().await(5, TimeUnit.SECONDS));

        // Tell the server to unsubscribe the session
        Map<String, Object> unsubscribe = new HashMap<>();
        unsubscribe.put(actionField, unsubscribeAction);
        ClientSessionChannel systemChannel = client.getChannel(systemChannelName);
        systemChannel.publish(unsubscribe);
        Assert.assertTrue(unsubscribeLatch.await(5, TimeUnit.SECONDS));

        // Publish, must not receive it
        messageLatch.set(new CountDownLatch(1));
        testChannel.publish(new HashMap<String, Object>());
        Assert.assertFalse(messageLatch.get().await(1, TimeUnit.SECONDS));

        // Tell the server to resubscribe the session
        Map<String, Object> resubscribe = new HashMap<>();
        resubscribe.put(actionField, subscribeAction);
        systemChannel.publish(resubscribe);
        Assert.assertTrue(resubscribeLatch.await(5, TimeUnit.SECONDS));

        // Publish, must receive it
        messageLatch.set(new CountDownLatch(1));
        testChannel.publish(new HashMap<String, Object>());
View Full Code Here

                if (message.isSuccessful())
                    subscribeLatch.countDown();
            }
        });
        final AtomicReference<CountDownLatch> messageLatch = new AtomicReference<>(new CountDownLatch(1));
        ClientSessionChannel testChannel = client.getChannel(testChannelName);
        testChannel.subscribe(new ClientSessionChannel.MessageListener()
        {
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                messageLatch.get().countDown();
            }
        });
        Assert.assertTrue(subscribeLatch.await(5, TimeUnit.SECONDS));

        // Publish, must receive it
        testChannel.publish(new HashMap<String, Object>());
        Assert.assertTrue(messageLatch.get().await(5, TimeUnit.SECONDS));

        // Tell the server to unsubscribe the session
        Assert.assertTrue(bayeux.getChannel(testChannelName).unsubscribe(bayeux.getSession(client.getId())));

        // Publish, must receive it (service channels are always invoked)
        messageLatch.set(new CountDownLatch(1));
        testChannel.publish(new HashMap<String, Object>());
        Assert.assertTrue(messageLatch.get().await(5, TimeUnit.SECONDS));

        // Tell the server to resubscribe the session
        Assert.assertTrue(bayeux.getChannel(testChannelName).subscribe(bayeux.getSession(client.getId())));

        // Publish, must receive it
        messageLatch.set(new CountDownLatch(1));
        testChannel.publish(new HashMap<String, Object>());
        Assert.assertTrue(messageLatch.get().await(5, TimeUnit.SECONDS));

        disconnectBayeuxClient(client);
    }
View Full Code Here

        BayeuxClient client = newBayeuxClient();
        client.handshake();
        Assert.assertTrue(client.waitFor(5000, BayeuxClient.State.CONNECTED));

        final AtomicReference<CountDownLatch> messageLatch = new AtomicReference<>(new CountDownLatch(1));
        ClientSessionChannel testChannel = client.getChannel(testChannelName);
        client.startBatch();
        testChannel.subscribe(new ClientSessionChannel.MessageListener()
        {
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                messageLatch.get().countDown();
            }
        });
        testChannel.publish(new HashMap<String, Object>());
        client.endBatch();
        Assert.assertTrue(messageLatch.get().await(5, TimeUnit.SECONDS));

        // Tell the server to unsubscribe the session
        Map<String, Object> unsubscribe = new HashMap<>();
        unsubscribe.put(actionField, unsubscribeAction);
        ClientSessionChannel systemChannel = client.getChannel(systemChannelName);
        systemChannel.publish(unsubscribe);
        Assert.assertTrue(unsubscribeLatch.await(5, TimeUnit.SECONDS));

        // Publish, must not receive it
        messageLatch.set(new CountDownLatch(1));
        testChannel.publish(new HashMap<String, Object>());
View Full Code Here

        LocalSession remote = bayeuxServer.newLocalSession("remoteCall");
        remote.handshake();

        final String parameter = "param1";
        ClientSessionChannel channel = remote.getChannel(Channel.SERVICE + "/test/" + parameter);
        final CountDownLatch latch = new CountDownLatch(1);
        channel.addListener(new ClientSessionChannel.MessageListener()
        {
            @Override
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                if (message.isPublishReply())
                    return;
                assertEquals(parameter, message.getData());
                latch.countDown();
            }
        });
        channel.publish(new HashMap());

        assertTrue(latch.await(5, TimeUnit.SECONDS));
    }
View Full Code Here

        remote2.handshake();

        final CountDownLatch latch = new CountDownLatch(2);
        final List<Message> responses = new ArrayList<>();

        ClientSessionChannel channel1 = remote1.getChannel(Channel.SERVICE + TwoRemoteCallsWithResultService.CHANNEL);
        channel1.addListener(new ClientSessionChannel.MessageListener()
        {
            @Override
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                if (message.isPublishReply())
                    return;
                responses.add(message);
                latch.countDown();
            }
        });

        ClientSessionChannel channel2 = remote2.getChannel(Channel.SERVICE + TwoRemoteCallsWithResultService.CHANNEL);
        channel2.addListener(new ClientSessionChannel.MessageListener()
        {
            @Override
            public void onMessage(ClientSessionChannel channel, Message message)
            {
                if (message.isPublishReply())
                    return;
                responses.add(message);
                latch.countDown();
            }
        });

        channel1.publish("1");
        channel2.publish("2");

        assertTrue(latch.await(5, TimeUnit.SECONDS));

        assertEquals(2, responses.size());
        Message response1 = responses.get(0);
View Full Code Here

TOP

Related Classes of org.cometd.bayeux.client.ClientSessionChannel

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.