Search in sources :

Example 36 with StanzaListener

use of org.jivesoftware.smack.StanzaListener in project Smack by igniterealtime.

the class XmppConnectionStressTest method run.

public void run(List<? extends XMPPConnection> connections, final long replyTimeoutMillis) throws InterruptedException, NotAllMessagesReceivedException, ErrorsWhileSendingOrReceivingException {
    final MultiMap<XMPPConnection, Message> messages = new MultiMap<>();
    final Random random = new Random(configuration.seed);
    final Map<XMPPConnection, Exception> sendExceptions = new ConcurrentHashMap<>();
    final Map<XMPPConnection, Exception> receiveExceptions = new ConcurrentHashMap<>();
    waitStart = -1;
    for (XMPPConnection fromConnection : connections) {
        MultiMap<XMPPConnection, Message> toConnectionMessages = new MultiMap<>();
        for (XMPPConnection toConnection : connections) {
            for (int i = 0; i < configuration.messagesPerConnection; i++) {
                MessageBuilder messageBuilder = fromConnection.getStanzaFactory().buildMessageStanza();
                messageBuilder.to(toConnection.getUser());
                final int payloadChunkCount;
                if (configuration.maxPayloadChunks == 0) {
                    payloadChunkCount = 0;
                } else {
                    payloadChunkCount = random.nextInt(configuration.maxPayloadChunks) + 1;
                }
                for (int c = 0; c < payloadChunkCount; c++) {
                    int payloadChunkSize = random.nextInt(configuration.maxPayloadChunkSize) + 1;
                    String payloadCunk = StringUtils.randomString(payloadChunkSize, random);
                    JivePropertiesManager.addProperty(messageBuilder, "payload-chunk-" + c, payloadCunk);
                }
                JivePropertiesManager.addProperty(messageBuilder, MESSAGE_NUMBER_PROPERTY, i);
                Message message = messageBuilder.build();
                toConnectionMessages.put(toConnection, message);
            }
        }
        if (configuration.intermixMessages) {
            while (!toConnectionMessages.isEmpty()) {
                int next = random.nextInt(connections.size());
                Message message = null;
                while (message == null) {
                    XMPPConnection toConnection = connections.get(next);
                    message = toConnectionMessages.getFirst(toConnection);
                    next = (next + 1) % connections.size();
                }
                messages.put(fromConnection, message);
            }
        } else {
            for (XMPPConnection toConnection : connections) {
                for (Message message : toConnectionMessages.getAll(toConnection)) {
                    messages.put(fromConnection, message);
                }
            }
        }
    }
    Semaphore receivedSemaphore = new Semaphore(-connections.size() + 1);
    Map<XMPPConnection, Map<EntityFullJid, boolean[]>> receiveMarkers = new ConcurrentHashMap<>(connections.size());
    for (XMPPConnection connection : connections) {
        final Map<EntityFullJid, boolean[]> myReceiveMarkers = new HashMap<>(connections.size());
        receiveMarkers.put(connection, myReceiveMarkers);
        for (XMPPConnection otherConnection : connections) {
            boolean[] fromMarkers = new boolean[configuration.messagesPerConnection];
            myReceiveMarkers.put(otherConnection.getUser(), fromMarkers);
        }
        connection.addSyncStanzaListener(new StanzaListener() {

            @Override
            public void processStanza(Stanza stanza) {
                waitStart = System.currentTimeMillis();
                EntityFullJid from = stanza.getFrom().asEntityFullJidOrThrow();
                Message message = (Message) stanza;
                JivePropertiesExtension extension = JivePropertiesExtension.from(message);
                Integer messageNumber = (Integer) extension.getProperty(MESSAGE_NUMBER_PROPERTY);
                boolean[] fromMarkers = myReceiveMarkers.get(from);
                // Sanity check: All markers before must be true, all markers including the messageNumber marker must be false.
                for (int i = 0; i < fromMarkers.length; i++) {
                    final String inOrderViolation;
                    if (i < messageNumber && !fromMarkers[i]) {
                        // A previous message was missing.
                        inOrderViolation = "not yet message #";
                    } else if (i >= messageNumber && fromMarkers[i]) {
                        // We already received a new message.
                        // TODO: Can it ever happen that this is taken? Wouldn't we prior run into the "a previous
                        // message is missing" case?
                        inOrderViolation = "we already received a later (or the same) message #";
                    } else {
                        continue;
                    }
                    StringBuilder exceptionMessage = new StringBuilder();
                    exceptionMessage.append("We received message #").append(messageNumber).append(" but ");
                    exceptionMessage.append(inOrderViolation);
                    exceptionMessage.append(i);
                    exceptionMessage.append("\nMessage with id ").append(stanza.getStanzaId()).append(" from ").append(from).append(" to ").append(stanza.getTo()).append('\n');
                    exceptionMessage.append("From Markers: ").append(Arrays.toString(fromMarkers)).append('\n');
                    Exception exception = new Exception(exceptionMessage.toString());
                    receiveExceptions.put(connection, exception);
                    // TODO: Current Smack design does not guarantee that the listener won't be invoked again.
                    // This is because the decission to invoke a sync listeners is done at a different place
                    // then invoking the listener.
                    connection.removeSyncStanzaListener(this);
                    receivedSemaphore.release();
                    // TODO: Do not return here?
                    return;
                }
                fromMarkers[messageNumber] = true;
                for (boolean[] markers : myReceiveMarkers.values()) {
                    if (BooleansUtils.contains(markers, false)) {
                        // receivedSemaphore.
                        return;
                    }
                }
                // All markers set to true, this means we received all messages.
                receivedSemaphore.release();
            }
        }, new AndFilter(MessageTypeFilter.NORMAL, new StanzaExtensionFilter(JivePropertiesExtension.ELEMENT, JivePropertiesExtension.NAMESPACE)));
    }
    Semaphore sendSemaphore = new Semaphore(-connections.size() + 1);
    for (XMPPConnection connection : connections) {
        Async.go(() -> {
            List<Message> messagesToSend;
            synchronized (messages) {
                messagesToSend = messages.getAll(connection);
            }
            try {
                for (Message messageToSend : messagesToSend) {
                    connection.sendStanza(messageToSend);
                }
            } catch (NotConnectedException | InterruptedException e) {
                sendExceptions.put(connection, e);
            } finally {
                sendSemaphore.release();
            }
        });
    }
    sendSemaphore.acquire();
    if (waitStart < 0) {
        waitStart = System.currentTimeMillis();
    }
    boolean acquired;
    do {
        long acquireWait = waitStart + replyTimeoutMillis - System.currentTimeMillis();
        acquired = receivedSemaphore.tryAcquire(acquireWait, TimeUnit.MILLISECONDS);
    } while (!acquired && System.currentTimeMillis() < waitStart + replyTimeoutMillis);
    if (!acquired && receiveExceptions.isEmpty() && sendExceptions.isEmpty()) {
        throw new StressTestFailedException.NotAllMessagesReceivedException(receiveMarkers, connections);
    }
    if (!receiveExceptions.isEmpty() || !sendExceptions.isEmpty()) {
        throw new StressTestFailedException.ErrorsWhileSendingOrReceivingException(sendExceptions, receiveExceptions);
    }
// Test successful.
}
Also used : Message(org.jivesoftware.smack.packet.Message) NotConnectedException(org.jivesoftware.smack.SmackException.NotConnectedException) HashMap(java.util.HashMap) ConcurrentHashMap(java.util.concurrent.ConcurrentHashMap) StanzaExtensionFilter(org.jivesoftware.smack.filter.StanzaExtensionFilter) StanzaListener(org.jivesoftware.smack.StanzaListener) XMPPConnection(org.jivesoftware.smack.XMPPConnection) Semaphore(java.util.concurrent.Semaphore) MultiMap(org.jivesoftware.smack.util.MultiMap) Random(java.util.Random) MessageBuilder(org.jivesoftware.smack.packet.MessageBuilder) NotAllMessagesReceivedException(org.igniterealtime.smack.XmppConnectionStressTest.StressTestFailedException.NotAllMessagesReceivedException) ConcurrentHashMap(java.util.concurrent.ConcurrentHashMap) EntityFullJid(org.jxmpp.jid.EntityFullJid) Stanza(org.jivesoftware.smack.packet.Stanza) NotConnectedException(org.jivesoftware.smack.SmackException.NotConnectedException) NotAllMessagesReceivedException(org.igniterealtime.smack.XmppConnectionStressTest.StressTestFailedException.NotAllMessagesReceivedException) ErrorsWhileSendingOrReceivingException(org.igniterealtime.smack.XmppConnectionStressTest.StressTestFailedException.ErrorsWhileSendingOrReceivingException) JivePropertiesExtension(org.jivesoftware.smackx.jiveproperties.packet.JivePropertiesExtension) AndFilter(org.jivesoftware.smack.filter.AndFilter) HashMap(java.util.HashMap) Map(java.util.Map) ConcurrentHashMap(java.util.concurrent.ConcurrentHashMap) MultiMap(org.jivesoftware.smack.util.MultiMap) ErrorsWhileSendingOrReceivingException(org.igniterealtime.smack.XmppConnectionStressTest.StressTestFailedException.ErrorsWhileSendingOrReceivingException)

Example 37 with StanzaListener

use of org.jivesoftware.smack.StanzaListener in project Smack by igniterealtime.

the class SimpleXmppConnectionIntegrationTest method createConnectionTest.

@SmackIntegrationTest(connectionCount = 2)
public void createConnectionTest(List<AbstractXMPPConnection> connections) throws TimeoutException, Exception {
    final AbstractXMPPConnection conOne = connections.get(0), conTwo = connections.get(1);
    EntityFullJid userTwo = conTwo.getUser();
    final String messageBody = testRunId + ": Hello from the other side!";
    Message message = conTwo.getStanzaFactory().buildMessageStanza().to(userTwo).setBody(messageBody).build();
    final SimpleResultSyncPoint messageReceived = new SimpleResultSyncPoint();
    final StanzaListener stanzaListener = (Stanza stanza) -> {
        if (((Message) stanza).getBody().equals(messageBody)) {
            messageReceived.signal();
        }
    };
    conTwo.addAsyncStanzaListener(stanzaListener, MessageWithBodiesFilter.INSTANCE);
    try {
        conOne.sendStanza(message);
        messageReceived.waitForResult(timeout);
    } finally {
        conTwo.removeAsyncStanzaListener(stanzaListener);
    }
}
Also used : Message(org.jivesoftware.smack.packet.Message) EntityFullJid(org.jxmpp.jid.EntityFullJid) Stanza(org.jivesoftware.smack.packet.Stanza) StanzaListener(org.jivesoftware.smack.StanzaListener) SimpleResultSyncPoint(org.igniterealtime.smack.inttest.util.SimpleResultSyncPoint) AbstractXMPPConnection(org.jivesoftware.smack.AbstractXMPPConnection) SmackIntegrationTest(org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest)

Example 38 with StanzaListener

use of org.jivesoftware.smack.StanzaListener in project Smack by igniterealtime.

the class InBandBytestreamSessionTest method shouldNotCloseBothStreamsIfOutputStreamIsClosed.

/**
 * If the input stream is closed the output stream should not be closed as well.
 *
 * @throws Exception should not happen
 */
@Test
public void shouldNotCloseBothStreamsIfOutputStreamIsClosed() throws Exception {
    InBandBytestreamSession session = new InBandBytestreamSession(connection, initBytestream, initiatorJID);
    OutputStream outputStream = session.getOutputStream();
    outputStream.close();
    // verify data packet confirmation is of type RESULT
    protocol.addResponse(null, Verification.requestTypeRESULT);
    // insert data to read
    InputStream inputStream = session.getInputStream();
    StanzaListener listener = Whitebox.getInternalState(inputStream, "dataPacketListener", StanzaListener.class);
    String base64Data = Base64.encode("Data");
    DataPacketExtension dpe = new DataPacketExtension(sessionID, 0, base64Data);
    Data data = new Data(dpe);
    listener.processStanza(data);
    // verify no packet send
    protocol.verifyAll();
    try {
        outputStream.flush();
        fail("should throw an exception");
    } catch (IOException e) {
        assertTrue(e.getMessage().contains("closed"));
    }
    assertTrue(inputStream.read() != 0);
}
Also used : DataPacketExtension(org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension) InputStream(java.io.InputStream) OutputStream(java.io.OutputStream) StanzaListener(org.jivesoftware.smack.StanzaListener) Data(org.jivesoftware.smackx.bytestreams.ibb.packet.Data) IOException(java.io.IOException) Test(org.junit.jupiter.api.Test)

Example 39 with StanzaListener

use of org.jivesoftware.smack.StanzaListener in project Smack by igniterealtime.

the class InBandBytestreamSessionTest method shouldConfirmReceivedDataPacket.

/**
 * Valid data packets should be confirmed.
 *
 * @throws Exception should not happen
 */
@Test
public void shouldConfirmReceivedDataPacket() throws Exception {
    // verify data packet confirmation is of type RESULT
    protocol.addResponse(null, Verification.requestTypeRESULT);
    InBandBytestreamSession session = new InBandBytestreamSession(connection, initBytestream, initiatorJID);
    InputStream inputStream = session.getInputStream();
    StanzaListener listener = Whitebox.getInternalState(inputStream, "dataPacketListener", StanzaListener.class);
    String base64Data = Base64.encode("Data");
    DataPacketExtension dpe = new DataPacketExtension(sessionID, 0, base64Data);
    Data data = new Data(dpe);
    listener.processStanza(data);
    protocol.verifyAll();
}
Also used : DataPacketExtension(org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension) InputStream(java.io.InputStream) StanzaListener(org.jivesoftware.smack.StanzaListener) Data(org.jivesoftware.smackx.bytestreams.ibb.packet.Data) Test(org.junit.jupiter.api.Test)

Example 40 with StanzaListener

use of org.jivesoftware.smack.StanzaListener in project Smack by igniterealtime.

the class InBandBytestreamSessionTest method shouldNotCloseBothStreamsIfInputStreamIsClosed.

/**
 * If the output stream is closed the input stream should not be closed as well.
 *
 * @throws Exception should not happen
 */
@Test
public void shouldNotCloseBothStreamsIfInputStreamIsClosed() throws Exception {
    // acknowledgment for data packet
    IQ resultIQ = IBBPacketUtils.createResultIQ(initiatorJID, targetJID);
    protocol.addResponse(resultIQ);
    // get IBB sessions data packet listener
    InBandBytestreamSession session = new InBandBytestreamSession(connection, initBytestream, initiatorJID);
    InputStream inputStream = session.getInputStream();
    StanzaListener listener = Whitebox.getInternalState(inputStream, "dataPacketListener", StanzaListener.class);
    // build data packet
    String base64Data = Base64.encode("Data");
    DataPacketExtension dpe = new DataPacketExtension(sessionID, 0, base64Data);
    Data data = new Data(dpe);
    // add data packets
    listener.processStanza(data);
    inputStream.close();
    protocol.verifyAll();
    try {
        while (inputStream.read() != -1) {
        }
        inputStream.read();
        fail("should throw an exception");
    } catch (IOException e) {
        assertTrue(e.getMessage().contains("closed"));
    }
    session.getOutputStream().flush();
}
Also used : DataPacketExtension(org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension) InputStream(java.io.InputStream) IQ(org.jivesoftware.smack.packet.IQ) StanzaListener(org.jivesoftware.smack.StanzaListener) Data(org.jivesoftware.smackx.bytestreams.ibb.packet.Data) IOException(java.io.IOException) Test(org.junit.jupiter.api.Test)

Aggregations

StanzaListener (org.jivesoftware.smack.StanzaListener)46 Stanza (org.jivesoftware.smack.packet.Stanza)24 InputStream (java.io.InputStream)12 Message (org.jivesoftware.smack.packet.Message)12 DataPacketExtension (org.jivesoftware.smackx.bytestreams.ibb.packet.DataPacketExtension)12 Test (org.junit.jupiter.api.Test)12 IQ (org.jivesoftware.smack.packet.IQ)10 SmackException (org.jivesoftware.smack.SmackException)9 Data (org.jivesoftware.smackx.bytestreams.ibb.packet.Data)9 StanzaTypeFilter (org.jivesoftware.smack.filter.StanzaTypeFilter)8 IOException (java.io.IOException)7 XMPPConnection (org.jivesoftware.smack.XMPPConnection)6 XMPPException (org.jivesoftware.smack.XMPPException)6 ArrayList (java.util.ArrayList)5 Random (java.util.Random)5 ActionEvent (java.awt.event.ActionEvent)4 List (java.util.List)4 SmackIntegrationTest (org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest)4 SimpleResultSyncPoint (org.igniterealtime.smack.inttest.util.SimpleResultSyncPoint)4 StanzaFilter (org.jivesoftware.smack.filter.StanzaFilter)4