Examples with ErrorCondition org.apache.qpid.proton.amqp.transport.ErrorCondition used on opensource projects

Example 46 with ErrorCondition

use of org.apache.qpid.proton.amqp.transport.ErrorCondition in project activemq-artemis by apache.

the class AMQPSessionContext method addSender.

public void addSender(Sender sender) throws Exception {
    // TODO: Remove this check when we have support for global link names
    boolean outgoing = (sender.getContext() != null && sender.getContext().equals(true));
    ProtonServerSenderContext protonSender = outgoing ? new ProtonClientSenderContext(connection, sender, this, sessionSPI) : new ProtonServerSenderContext(connection, sender, this, sessionSPI);
    try {
        protonSender.initialise();
        senders.put(sender, protonSender);
        serverSenders.put(protonSender.getBrokerConsumer(), protonSender);
        sender.setContext(protonSender);
        connection.lock();
        try {
            sender.open();
        } finally {
            connection.unlock();
        }
        protonSender.start();
    } catch (ActiveMQAMQPException e) {
        senders.remove(sender);
        sender.setSource(null);
        sender.setCondition(new ErrorCondition(e.getAmqpError(), e.getMessage()));
        connection.lock();
        try {
            sender.close();
        } finally {
            connection.unlock();
        }
    }
}

Example 47 with ErrorCondition

use of org.apache.qpid.proton.amqp.transport.ErrorCondition in project activemq-artemis by apache.

the class ProtonTransactionHandler method createRejected.

private Rejected createRejected(Symbol amqpError, String message) {
    Rejected rejected = new Rejected();
    ErrorCondition condition = new ErrorCondition();
    condition.setCondition(amqpError);
    condition.setDescription(message);
    rejected.setError(condition);
    return rejected;
}

Example 48 with ErrorCondition

use of org.apache.qpid.proton.amqp.transport.ErrorCondition in project azure-service-bus-java by Azure.

the class CoreMessageSender method onSendComplete.

@Override
public void onSendComplete(final Delivery delivery) {
    final DeliveryState outcome = delivery.getRemoteState();
    final String deliveryTag = new String(delivery.getTag());
    TRACE_LOGGER.debug("Received ack for delivery. path:{}, linkName:{}, deliveryTag:{}, outcome:{}", CoreMessageSender.this.sendPath, this.sendLink.getName(), deliveryTag, outcome);
    final SendWorkItem<Void> pendingSendWorkItem = this.pendingSendsData.remove(deliveryTag);
    if (pendingSendWorkItem != null) {
        if (outcome instanceof Accepted) {
            this.lastKnownLinkError = null;
            this.retryPolicy.resetRetryCount(this.getClientId());
            pendingSendWorkItem.cancelTimeoutTask(false);
            AsyncUtil.completeFuture(pendingSendWorkItem.getWork(), null);
        } else if (outcome instanceof Rejected) {
            Rejected rejected = (Rejected) outcome;
            ErrorCondition error = rejected.getError();
            Exception exception = ExceptionUtil.toException(error);
            if (ExceptionUtil.isGeneralError(error.getCondition())) {
                this.lastKnownLinkError = exception;
                this.lastKnownErrorReportedAt = Instant.now();
            }
            Duration retryInterval = this.retryPolicy.getNextRetryInterval(this.getClientId(), exception, pendingSendWorkItem.getTimeoutTracker().remaining());
            if (retryInterval == null) {
                this.cleanupFailedSend(pendingSendWorkItem, exception);
            } else {
                TRACE_LOGGER.warn("Send failed for delivery '{}'. Will retry after '{}'", deliveryTag, retryInterval);
                pendingSendWorkItem.setLastKnownException(exception);
                Timer.schedule(() -> {
                    CoreMessageSender.this.reSendAsync(deliveryTag, pendingSendWorkItem, false);
                }, retryInterval, TimerType.OneTimeRun);
            }
        } else if (outcome instanceof Released) {
            this.cleanupFailedSend(pendingSendWorkItem, new OperationCancelledException(outcome.toString()));
        } else {
            this.cleanupFailedSend(pendingSendWorkItem, new ServiceBusException(false, outcome.toString()));
        }
    } else {
        TRACE_LOGGER.warn("Delivery mismatch. path:{}, linkName:{}, delivery:{}", this.sendPath, this.sendLink.getName(), deliveryTag);
    }
}

Example 49 with ErrorCondition

use of org.apache.qpid.proton.amqp.transport.ErrorCondition in project azure-service-bus-java by Azure.

the class ConnectionHandler method onConnectionRemoteClose.

@Override
public void onConnectionRemoteClose(Event event) {
    final Connection connection = event.getConnection();
    final ErrorCondition error = connection.getRemoteCondition();
    TRACE_LOGGER.debug("onConnectionRemoteClose: hostname:{},errorCondition:{}", connection.getHostname(), error != null ? error.getCondition() + "," + error.getDescription() : null);
    boolean shouldFreeConnection = connection.getLocalState() == EndpointState.CLOSED;
    this.messagingFactory.onConnectionError(error);
    if (shouldFreeConnection) {
        connection.free();
    }
}

Example 50 with ErrorCondition

use of org.apache.qpid.proton.amqp.transport.ErrorCondition in project vertx-proton by vert-x3.

the class ProtonClientTest method doMaxMessageSizeTestImpl.

private void doMaxMessageSizeTestImpl(TestContext context, final int maxFrameSize, final int maxMessageSize, final int dataPayloadSize) throws Exception {
    server.close();
    Async serverSenderOpenAsync = context.async();
    Async serverSenderCreditCheck = context.async();
    Async clientReceiverOpenAsync = context.async();
    Async serverSenderDetachCheck = context.async();
    Async maxMessageSizeExceededHandlerFired = context.async();
    AtomicInteger messageCount = new AtomicInteger();
    AtomicInteger handlerCount = new AtomicInteger();
    final UnsignedLong receiverMaxMsgSize = UnsignedLong.valueOf(maxMessageSize);
    final UnsignedLong serverMaxMsgSize = UnsignedLong.valueOf(5 * receiverMaxMsgSize.longValue());
    ProtonServer protonServer = null;
    try {
        protonServer = createServer((serverConnection) -> {
            serverConnection.openHandler(result -> {
                serverConnection.open();
            });
            serverConnection.sessionOpenHandler(session -> {
                session.open();
            });
            serverConnection.senderOpenHandler(serverSender -> {
                context.assertEquals(receiverMaxMsgSize, serverSender.getRemoteMaxMessageSize(), "unexpected remote max message size at server");
                context.assertNull(serverSender.getMaxMessageSize(), "Expected no value to be set");
                serverSender.setMaxMessageSize(serverMaxMsgSize);
                context.assertEquals(serverMaxMsgSize, serverSender.getMaxMessageSize(), "Expected value to now be set");
                serverSender.sendQueueDrainHandler(ss -> {
                    if (!serverSenderCreditCheck.isCompleted()) {
                        context.assertTrue(serverSender.getCredit() > 3, "Unexpectedly low credit: " + serverSender.getCredit());
                        serverSenderCreditCheck.complete();
                        sendMessagesForMaxMessageSizeTest(dataPayloadSize, serverSender);
                    }
                });
                serverSender.detachHandler(res -> {
                    ErrorCondition remoteCondition = serverSender.getRemoteCondition();
                    context.assertNotNull(remoteCondition);
                    context.assertEquals(remoteCondition.getCondition(), LinkError.MESSAGE_SIZE_EXCEEDED);
                    context.assertTrue(res.failed());
                    serverSender.detach();
                    serverSenderDetachCheck.complete();
                });
                LOG.trace("Server sender opened");
                serverSender.open();
                serverSenderOpenAsync.complete();
            });
        });
        // ===== Client Handling =====
        ProtonClient client = ProtonClient.create(vertx);
        ProtonClientOptions options = new ProtonClientOptions();
        options.setMaxFrameSize(maxFrameSize);
        client.connect(options, "localhost", protonServer.actualPort(), res -> {
            context.assertTrue(res.succeeded());
            ProtonConnection connection = res.result();
            connection.openHandler(x -> {
                LOG.trace("Client connection opened");
                final ProtonReceiver receiver = connection.createReceiver("some-address");
                context.assertNull(receiver.getMaxMessageSize(), "Expected no value to be set");
                receiver.setMaxMessageSize(receiverMaxMsgSize);
                context.assertEquals(receiverMaxMsgSize, receiver.getMaxMessageSize(), "Expected value to now be set");
                receiver.openHandler(y -> {
                    LOG.trace("Client link opened");
                    context.assertEquals(serverMaxMsgSize, receiver.getRemoteMaxMessageSize(), "unexpected remote max message size at client");
                    clientReceiverOpenAsync.complete();
                    receiver.handler((delivery, message) -> {
                        validateMessage(context, messageCount.incrementAndGet(), "small-first-message", message);
                    });
                    receiver.maxMessageSizeExceededHandler(recv -> {
                        handlerCount.incrementAndGet();
                        maxMessageSizeExceededHandlerFired.complete();
                    });
                });
                receiver.open();
            }).open();
        });
        serverSenderOpenAsync.awaitSuccess();
        clientReceiverOpenAsync.awaitSuccess();
        serverSenderCreditCheck.awaitSuccess();
        maxMessageSizeExceededHandlerFired.awaitSuccess();
        serverSenderDetachCheck.awaitSuccess();
        context.assertEquals(1, handlerCount.get(), "Unexpected number of handler executions");
        context.assertEquals(1, messageCount.get(), "Unexpected number of deliveries");
    } finally {
        if (protonServer != null) {
            protonServer.close();
        }
    }
}