All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.microsoft.azure.servicebus.ClientFactory Maven / Gradle / Ivy

The newest version!
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

package com.microsoft.azure.servicebus;

import java.net.URI;
import java.util.concurrent.CompletableFuture;

import com.microsoft.azure.servicebus.primitives.ConnectionStringBuilder;
import com.microsoft.azure.servicebus.primitives.MessagingEntityType;
import com.microsoft.azure.servicebus.primitives.MessagingFactory;
import com.microsoft.azure.servicebus.primitives.ServiceBusException;
import com.microsoft.azure.servicebus.primitives.Util;

/**
 * Utility class for creating message senders and receivers.
 */
public final class ClientFactory {

    private static final ReceiveMode DEFAULTRECEIVEMODE = ReceiveMode.PEEKLOCK;

    private ClientFactory() {
    }

    /**
     * Create message sender from service bus connection string with Shared Access Signatures
     *
     * @param amqpConnectionString the connection string
     * @return {@link IMessageSender} instance
     * @throws InterruptedException if the current thread was interrupted while waiting
     * @throws ServiceBusException  if the sender cannot be created
     */
    public static IMessageSender createMessageSenderFromConnectionString(String amqpConnectionString) throws InterruptedException, ServiceBusException {
        return Utils.completeFuture(createMessageSenderFromConnectionStringAsync(amqpConnectionString));
    }

    /**
     * Create message sender from ConnectionStringBuilder
     * 
     *     IMessageSender messageSender = ClientFactory.createMessageSenderFromConnectionStringBuilder(new ConnectionStringBuilder(connectionString, queueName));
     * 
* * @param amqpConnectionStringBuilder the connection string builder * @return {@link IMessageSender} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the sender cannot be created */ public static IMessageSender createMessageSenderFromConnectionStringBuilder(ConnectionStringBuilder amqpConnectionStringBuilder) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromConnectionStringBuilderAsync(amqpConnectionStringBuilder)); } static IMessageSender createMessageSenderFromConnectionStringBuilder(ConnectionStringBuilder amqpConnectionStringBuilder, MessagingEntityType entityType) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromConnectionStringBuilderAsync(amqpConnectionStringBuilder, entityType)); } /** * Creates a message sender to the entity using the client settings. * @param namespaceName namespace of entity * @param entityPath path of entity * @param clientSettings client settings * @return IMessageSender instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the sender cannot be created */ public static IMessageSender createMessageSenderFromEntityPath(String namespaceName, String entityPath, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromEntityPathAsync(namespaceName, entityPath, clientSettings)); } /** * Creates a message sender to the entity using the client settings. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param clientSettings client settings * @return IMessageSender instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the sender cannot be created */ public static IMessageSender createMessageSenderFromEntityPath(URI namespaceEndpointURI, String entityPath, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromEntityPathAsync(namespaceEndpointURI, entityPath, clientSettings)); } static IMessageSender createMessageSenderFromEntityPath(URI namespaceEndpointURI, String entityPath, MessagingEntityType entityType, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromEntityPathAsync(namespaceEndpointURI, entityPath, entityType, clientSettings)); } /** * Creates a message sender to the entity. * @param messagingFactory messaging factory (which represents a connection) on which sender needs to be created * @param entityPath path of entity * @return IMessageSender instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the sender cannot be created */ public static IMessageSender createMessageSenderFromEntityPath(MessagingFactory messagingFactory, String entityPath) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromEntityPathAsync(messagingFactory, entityPath)); } static IMessageSender createMessageSenderFromEntityPath(MessagingFactory messagingFactory, String entityPath, MessagingEntityType entityType) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageSenderFromEntityPathAsync(messagingFactory, entityPath, entityType)); } /** * Creates a transfer message sender. This sender sends message to destination entity via another entity. * * This is mainly to be used when sending messages in a transaction. * When messages need to be sent across entities in a single transaction, this can be used to ensure * all the messages land initially in the same entity/partition for local transactions, and then * let service bus handle transferring the message to the actual destination. * @param messagingFactory messaging factory (which represents a connection) on which sender needs to be created. * @param entityPath path of the final destination of the message. * @param viaEntityPath The initial destination of the message. * @return IMessageSender instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the sender cannot be created */ public static IMessageSender createTransferMessageSenderFromEntityPath(MessagingFactory messagingFactory, String entityPath, String viaEntityPath) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createTransferMessageSenderFromEntityPathAsync(messagingFactory, entityPath, viaEntityPath)); } /** * Create message sender asynchronously from connection string with Shared Access Signatures * * @param amqpConnectionString the connection string * @return a CompletableFuture representing the pending creating of {@link IMessageSender} instance */ public static CompletableFuture createMessageSenderFromConnectionStringAsync(String amqpConnectionString) { Utils.assertNonNull("amqpConnectionString", amqpConnectionString); return createMessageSenderFromConnectionStringBuilderAsync(new ConnectionStringBuilder(amqpConnectionString)); } /** * Create message sender asynchronously from ConnectionStringBuilder * * @param amqpConnectionStringBuilder the connection string builder * @return a CompletableFuture representing the pending creating of {@link IMessageSender} instance */ public static CompletableFuture createMessageSenderFromConnectionStringBuilderAsync(ConnectionStringBuilder amqpConnectionStringBuilder) { Utils.assertNonNull("amqpConnectionStringBuilder", amqpConnectionStringBuilder); return createMessageSenderFromEntityPathAsync(amqpConnectionStringBuilder.getEndpoint(), amqpConnectionStringBuilder.getEntityPath(), Util.getClientSettingsFromConnectionStringBuilder(amqpConnectionStringBuilder)); } static CompletableFuture createMessageSenderFromConnectionStringBuilderAsync(ConnectionStringBuilder amqpConnectionStringBuilder, MessagingEntityType entityType) { Utils.assertNonNull("amqpConnectionStringBuilder", amqpConnectionStringBuilder); return createMessageSenderFromEntityPathAsync(amqpConnectionStringBuilder.getEndpoint(), amqpConnectionStringBuilder.getEntityPath(), entityType, Util.getClientSettingsFromConnectionStringBuilder(amqpConnectionStringBuilder)); } /** * Creates a message sender asynchronously to the entity using the client settings. * @param namespaceName namespace name of entity * @param entityPath path of entity * @param clientSettings client settings * @return a CompletableFuture representing the pending creating of IMessageSender instance */ public static CompletableFuture createMessageSenderFromEntityPathAsync(String namespaceName, String entityPath, ClientSettings clientSettings) { Utils.assertNonNull("namespaceName", namespaceName); Utils.assertNonNull("entityPath", entityPath); return createMessageSenderFromEntityPathAsync(Util.convertNamespaceToEndPointURI(namespaceName), entityPath, clientSettings); } /** * Creates a message sender asynchronously to the entity using the client settings. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param clientSettings client settings * @return a CompletableFuture representing the pending creating of IMessageSender instance */ public static CompletableFuture createMessageSenderFromEntityPathAsync(URI namespaceEndpointURI, String entityPath, ClientSettings clientSettings) { return createMessageSenderFromEntityPathAsync(namespaceEndpointURI, entityPath, null, clientSettings); } static CompletableFuture createMessageSenderFromEntityPathAsync(URI namespaceEndpointURI, String entityPath, MessagingEntityType entityType, ClientSettings clientSettings) { Utils.assertNonNull("namespaceEndpointURI", namespaceEndpointURI); MessageSender sender = new MessageSender(namespaceEndpointURI, entityPath, null, entityType, clientSettings); return sender.initializeAsync().thenApply((v) -> sender); } /** * Creates a message sender asynchronously to the entity using the {@link MessagingFactory} * @param messagingFactory messaging factory (which represents a connection) on which sender needs to be created * @param entityPath path of entity * @return a CompletableFuture representing the pending creating of IMessageSender instance */ public static CompletableFuture createMessageSenderFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath) { return createMessageSenderFromEntityPathAsync(messagingFactory, entityPath, null); } static CompletableFuture createMessageSenderFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, MessagingEntityType entityType) { Utils.assertNonNull("messagingFactory", messagingFactory); MessageSender sender = new MessageSender(messagingFactory, entityPath, entityType); return sender.initializeAsync().thenApply((v) -> sender); } /** * Creates a transfer message sender asynchronously. This sender sends message to destination entity via another entity. * * This is mainly to be used when sending messages in a transaction. * When messages need to be sent across entities in a single transaction, this can be used to ensure * all the messages land initially in the same entity/partition for local transactions, and then * let service bus handle transferring the message to the actual destination. * @param messagingFactory messaging factory (which represents a connection) on which sender needs to be created. * @param entityPath path of the final destination of the message. * @param viaEntityPath The initial destination of the message. * @return a CompletableFuture representing the pending creating of IMessageSender instance. */ public static CompletableFuture createTransferMessageSenderFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, String viaEntityPath) { Utils.assertNonNull("messagingFactory", messagingFactory); MessageSender sender = new MessageSender(messagingFactory, viaEntityPath, entityPath, null); return sender.initializeAsync().thenApply((v) -> sender); } /** * Create {@link IMessageReceiver} in default {@link ReceiveMode#PEEKLOCK} mode from service bus connection string with Shared Access Signatures * * @param amqpConnectionString the connection string * @return {@link IMessageReceiver} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromConnectionString(String amqpConnectionString) throws InterruptedException, ServiceBusException { return createMessageReceiverFromConnectionString(amqpConnectionString, DEFAULTRECEIVEMODE); } /** * Create {@link IMessageReceiver} in default {@link ReceiveMode#PEEKLOCK} mode from service bus connection string with Shared Access Signatures * * @param amqpConnectionString the connection string * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return {@link IMessageReceiver} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromConnectionString(String amqpConnectionString, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromConnectionStringAsync(amqpConnectionString, receiveMode)); } /** * Create {@link IMessageReceiver} in default {@link ReceiveMode#PEEKLOCK} mode from ConnectionStringBuilder *
     *     IMessageReceiver messageReceiver = ClientFactory.createMessageReceiverFromConnectionStringBuilder(new ConnectionStringBuilder(connectionString, queueName));
     * 
* * @param amqpConnectionStringBuilder {@link ConnectionStringBuilder} * @return The {@link IMessageReceiver} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromConnectionStringBuilder(ConnectionStringBuilder amqpConnectionStringBuilder) throws InterruptedException, ServiceBusException { return createMessageReceiverFromConnectionStringBuilder(amqpConnectionStringBuilder, DEFAULTRECEIVEMODE); } /** * Create {@link IMessageReceiver} from ConnectionStringBuilder *
     *     IMessageReceiver messageReceiver = ClientFactory.createMessageReceiverFromConnectionStringBuilder(new ConnectionStringBuilder(connectionString, queueName), ReceiveMode.PEEKLOCK);
     * 
* * @param amqpConnectionStringBuilder {@link ConnectionStringBuilder} * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return The {@link IMessageReceiver} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromConnectionStringBuilder(ConnectionStringBuilder amqpConnectionStringBuilder, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromConnectionStringBuilderAsync(amqpConnectionStringBuilder, receiveMode)); } /** * Creates a message receiver to the entity using the client settings in PeekLock mode * @param namespaceName namespace of entity * @param entityPath path of the entity * @param clientSettings client settings * @return IMessageReceiver instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromEntityPath(String namespaceName, String entityPath, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromEntityPathAsync(namespaceName, entityPath, clientSettings)); } /** * Creates a message receiver to the entity using the client settings. * @param namespaceName namespace of entity * @param entityPath path of the entity * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return IMessageReceiver instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromEntityPath(String namespaceName, String entityPath, ClientSettings clientSettings, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromEntityPathAsync(namespaceName, entityPath, clientSettings, receiveMode)); } /** * Creates a message receiver to the entity using the client settings in PeekLock mode * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of the entity * @param clientSettings client settings * @return IMessageReceiver instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromEntityPath(URI namespaceEndpointURI, String entityPath, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromEntityPathAsync(namespaceEndpointURI, entityPath, clientSettings)); } /** * Creates a message receiver to the entity using the client settings. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of the entity * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return IMessageReceiver instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromEntityPath(URI namespaceEndpointURI, String entityPath, ClientSettings clientSettings, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromEntityPathAsync(namespaceEndpointURI, entityPath, clientSettings, receiveMode)); } /** * Creates a message receiver to the entity. * @param messagingFactory messaging factory (which represents a connection) on which receiver needs to be created * @param entityPath path of the entity * @return IMessageReceiver instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromEntityPath(MessagingFactory messagingFactory, String entityPath) throws InterruptedException, ServiceBusException { return createMessageReceiverFromEntityPath(messagingFactory, entityPath, DEFAULTRECEIVEMODE); } /** * Creates a message receiver to the entity. * @param messagingFactory messaging factory (which represents a connection) on which receiver needs to be created * @param entityPath path of the entity * @param receiveMode PeekLock or ReceiveAndDelete * @return IMessageReceiver instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the receiver cannot be created */ public static IMessageReceiver createMessageReceiverFromEntityPath(MessagingFactory messagingFactory, String entityPath, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromEntityPathAsync(messagingFactory, entityPath, receiveMode)); } static IMessageReceiver createMessageReceiverFromEntityPath(MessagingFactory messagingFactory, String entityPath, MessagingEntityType entityType, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(createMessageReceiverFromEntityPathAsync(messagingFactory, entityPath, entityType, receiveMode)); } /** * Create {@link IMessageReceiver} in default {@link ReceiveMode#PEEKLOCK} mode asynchronously from connection string with Shared Access Signatures * * @param amqpConnectionString the connection string * @return a CompletableFuture representing the pending creating */ public static CompletableFuture createMessageReceiverFromConnectionStringAsync(String amqpConnectionString) { return createMessageReceiverFromConnectionStringAsync(amqpConnectionString, DEFAULTRECEIVEMODE); } /** * Create {@link IMessageReceiver} in default {@link ReceiveMode#PEEKLOCK} mode asynchronously from connection string with Shared Access Signatures * * @param amqpConnectionString the connection string * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending creating */ public static CompletableFuture createMessageReceiverFromConnectionStringAsync(String amqpConnectionString, ReceiveMode receiveMode) { Utils.assertNonNull("amqpConnectionString", amqpConnectionString); return createMessageReceiverFromConnectionStringBuilderAsync(new ConnectionStringBuilder(amqpConnectionString), receiveMode); } /** * Create {@link IMessageReceiver} in default {@link ReceiveMode#PEEKLOCK} mode asynchronously from ConnectionStringBuilder * * @param amqpConnectionStringBuilder the connection string builder * @return a CompletableFuture representing the pending creating */ public static CompletableFuture createMessageReceiverFromConnectionStringBuilderAsync(ConnectionStringBuilder amqpConnectionStringBuilder) { return createMessageReceiverFromConnectionStringBuilderAsync(amqpConnectionStringBuilder, DEFAULTRECEIVEMODE); } /** * Create {@link IMessageReceiver} asynchronously from ConnectionStringBuilder * * @param amqpConnectionStringBuilder the connection string builder * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending creating */ public static CompletableFuture createMessageReceiverFromConnectionStringBuilderAsync(ConnectionStringBuilder amqpConnectionStringBuilder, ReceiveMode receiveMode) { Utils.assertNonNull("amqpConnectionStringBuilder", amqpConnectionStringBuilder); return createMessageReceiverFromEntityPathAsync(amqpConnectionStringBuilder.getEndpoint(), amqpConnectionStringBuilder.getEntityPath(), Util.getClientSettingsFromConnectionStringBuilder(amqpConnectionStringBuilder), receiveMode); } /** * Asynchronously creates a message receiver to the entity using the client settings in PeekLock mode * @param namespaceName namespace of entity * @param entityPath path of entity * @param clientSettings client settings * @return a CompletableFuture representing the pending creation of message receiver */ public static CompletableFuture createMessageReceiverFromEntityPathAsync(String namespaceName, String entityPath, ClientSettings clientSettings) { return createMessageReceiverFromEntityPathAsync(namespaceName, entityPath, clientSettings, DEFAULTRECEIVEMODE); } /** * Asynchronously creates a message receiver to the entity using the client settings * @param namespaceName namespace of entity * @param entityPath path of entity * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending creation of message receiver */ public static CompletableFuture createMessageReceiverFromEntityPathAsync(String namespaceName, String entityPath, ClientSettings clientSettings, ReceiveMode receiveMode) { Utils.assertNonNull("namespaceName", namespaceName); return createMessageReceiverFromEntityPathAsync(Util.convertNamespaceToEndPointURI(namespaceName), entityPath, clientSettings, receiveMode); } /** * Asynchronously creates a message receiver to the entity using the client settings in PeekLock mode * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param clientSettings client settings * @return a CompletableFuture representing the pending creation of message receiver */ public static CompletableFuture createMessageReceiverFromEntityPathAsync(URI namespaceEndpointURI, String entityPath, ClientSettings clientSettings) { return createMessageReceiverFromEntityPathAsync(namespaceEndpointURI, entityPath, clientSettings, DEFAULTRECEIVEMODE); } /** * Asynchronously creates a message receiver to the entity using the client settings * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending creation of message receiver */ public static CompletableFuture createMessageReceiverFromEntityPathAsync(URI namespaceEndpointURI, String entityPath, ClientSettings clientSettings, ReceiveMode receiveMode) { Utils.assertNonNull("namespaceEndpointURI", namespaceEndpointURI); Utils.assertNonNull("entityPath", entityPath); MessageReceiver receiver = new MessageReceiver(namespaceEndpointURI, entityPath, null, clientSettings, receiveMode); return receiver.initializeAsync().thenApply((v) -> receiver); } /** * Asynchronously creates a new message receiver to the entity on the messagingFactory. * @param messagingFactory messaging factory (which represents a connection) on which receiver needs to be created. * @param entityPath path of entity * @return a CompletableFuture representing the pending creation of message receiver */ public static CompletableFuture createMessageReceiverFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath) { return createMessageReceiverFromEntityPathAsync(messagingFactory, entityPath, DEFAULTRECEIVEMODE); } /** * Asynchronously creates a new message receiver to the entity on the messagingFactory. * @param messagingFactory messaging factory (which represents a connection) on which receiver needs to be created. * @param entityPath path of entity * @param receiveMode PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending creation of message receiver */ public static CompletableFuture createMessageReceiverFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, ReceiveMode receiveMode) { return createMessageReceiverFromEntityPathAsync(messagingFactory, entityPath, null, receiveMode); } static CompletableFuture createMessageReceiverFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, MessagingEntityType entityType, ReceiveMode receiveMode) { Utils.assertNonNull("messagingFactory", messagingFactory); MessageReceiver receiver = new MessageReceiver(messagingFactory, entityPath, entityType, receiveMode); return receiver.initializeAsync().thenApply((v) -> receiver); } /** * Accept a {@link IMessageSession} in default {@link ReceiveMode#PEEKLOCK} mode from service bus connection string with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionString connection string * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @return {@link IMessageSession} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromConnectionString(String amqpConnectionString, String sessionId) throws InterruptedException, ServiceBusException { return acceptSessionFromConnectionString(amqpConnectionString, sessionId, DEFAULTRECEIVEMODE); } /** * Accept a {@link IMessageSession} from service bus connection string with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionString connection string * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return {@link IMessageSession} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromConnectionString(String amqpConnectionString, String sessionId, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromConnectionStringAsync(amqpConnectionString, sessionId, receiveMode)); } /** * Accept a {@link IMessageSession} in default {@link ReceiveMode#PEEKLOCK} mode from service bus connection string builder with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionStringBuilder the connection string builder * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @return {@link IMessageSession} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromConnectionStringBuilder(ConnectionStringBuilder amqpConnectionStringBuilder, String sessionId) throws InterruptedException, ServiceBusException { return acceptSessionFromConnectionStringBuilder(amqpConnectionStringBuilder, sessionId, DEFAULTRECEIVEMODE); } /** * Accept a {@link IMessageSession} from service bus connection string builder with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionStringBuilder the connection string builder * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return {@link IMessageSession} instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromConnectionStringBuilder(ConnectionStringBuilder amqpConnectionStringBuilder, String sessionId, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromConnectionStringBuilderAsync(amqpConnectionStringBuilder, sessionId, receiveMode)); } /** * Accept a {@link IMessageSession} from service bus using the client settings with specified session id in PeekLock mode. Session Id can be null, if null, service will return the first available session. * @param namespaceName namespace of entity * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @return IMessageSession instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromEntityPath(String namespaceName, String entityPath, String sessionId, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromEntityPathAsync(namespaceName, entityPath, sessionId, clientSettings)); } /** * Accept a {@link IMessageSession} from service bus using the client settings with specified session id. Session Id can be null, if null, service will return the first available session. * @param namespaceName namespace of entity * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return IMessageSession instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromEntityPath(String namespaceName, String entityPath, String sessionId, ClientSettings clientSettings, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromEntityPathAsync(namespaceName, entityPath, sessionId, clientSettings, receiveMode)); } /** * Accept a {@link IMessageSession} from service bus using the client settings with specified session id in PeekLock mode. Session Id can be null, if null, service will return the first available session. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @return IMessageSession instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromEntityPath(URI namespaceEndpointURI, String entityPath, String sessionId, ClientSettings clientSettings) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromEntityPathAsync(namespaceEndpointURI, entityPath, sessionId, clientSettings)); } /** * Accept a {@link IMessageSession} from service bus using the client settings with specified session id. Session Id can be null, if null, service will return the first available session. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return IMessageSession instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromEntityPath(URI namespaceEndpointURI, String entityPath, String sessionId, ClientSettings clientSettings, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromEntityPathAsync(namespaceEndpointURI, entityPath, sessionId, clientSettings, receiveMode)); } /** * Accept a {@link IMessageSession} from service bus using the client settings with specified session id. Session Id can be null, if null, service will return the first available session. * @param messagingFactory messaging factory (which represents a connection) on which the session receiver needs to be created. * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @return IMessageSession instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromEntityPath(MessagingFactory messagingFactory, String entityPath, String sessionId) throws InterruptedException, ServiceBusException { return acceptSessionFromEntityPath(messagingFactory, entityPath, sessionId, DEFAULTRECEIVEMODE); } /** * Accept a {@link IMessageSession} from service bus using the client settings with specified session id. Session Id can be null, if null, service will return the first available session. * @param messagingFactory messaging factory (which represents a connection) on which the session receiver needs to be created. * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param receiveMode PeekLock or ReceiveAndDelete * @return IMessageSession instance * @throws InterruptedException if the current thread was interrupted while waiting * @throws ServiceBusException if the session cannot be accepted */ public static IMessageSession acceptSessionFromEntityPath(MessagingFactory messagingFactory, String entityPath, String sessionId, ReceiveMode receiveMode) throws InterruptedException, ServiceBusException { return Utils.completeFuture(acceptSessionFromEntityPathAsync(messagingFactory, entityPath, sessionId, receiveMode)); } /** * Accept a {@link IMessageSession} in default {@link ReceiveMode#PEEKLOCK} mode asynchronously from service bus connection string with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionString the connection string * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromConnectionStringAsync(String amqpConnectionString, String sessionId) { return acceptSessionFromConnectionStringAsync(amqpConnectionString, sessionId, DEFAULTRECEIVEMODE); } /** * Accept a {@link IMessageSession} asynchronously from service bus connection string with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionString the connection string * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromConnectionStringAsync(String amqpConnectionString, String sessionId, ReceiveMode receiveMode) { Utils.assertNonNull("amqpConnectionString", amqpConnectionString); return acceptSessionFromConnectionStringBuilderAsync(new ConnectionStringBuilder(amqpConnectionString), sessionId, receiveMode); } /** * Accept a {@link IMessageSession} in default {@link ReceiveMode#PEEKLOCK} mode asynchronously from service bus connection string builder with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionStringBuilder the connection string builder * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromConnectionStringBuilderAsync(ConnectionStringBuilder amqpConnectionStringBuilder, String sessionId) { return acceptSessionFromConnectionStringBuilderAsync(amqpConnectionStringBuilder, sessionId, DEFAULTRECEIVEMODE); } /** * Accept a {@link IMessageSession} asynchronously from service bus connection string builder with specified session id. Session Id can be null, if null, service will return the first available session. * * @param amqpConnectionStringBuilder connection string builder * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param receiveMode {@link ReceiveMode} PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromConnectionStringBuilderAsync(ConnectionStringBuilder amqpConnectionStringBuilder, String sessionId, ReceiveMode receiveMode) { Utils.assertNonNull("amqpConnectionStringBuilder", amqpConnectionStringBuilder); return acceptSessionFromEntityPathAsync(amqpConnectionStringBuilder.getEndpoint(), amqpConnectionStringBuilder.getEntityPath(), sessionId, Util.getClientSettingsFromConnectionStringBuilder(amqpConnectionStringBuilder), receiveMode); } /** * Asynchronously accepts a session in PeekLock mode from service bus using the client settings. Session Id can be null, if null, service will return the first available session. * @param namespaceName namespace of entity * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromEntityPathAsync(String namespaceName, String entityPath, String sessionId, ClientSettings clientSettings) { return acceptSessionFromEntityPathAsync(namespaceName, entityPath, sessionId, clientSettings, DEFAULTRECEIVEMODE); } /** * Asynchronously accepts a session from service bus using the client settings. Session Id can be null, if null, service will return the first available session. * @param namespaceName namespace of entity * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromEntityPathAsync(String namespaceName, String entityPath, String sessionId, ClientSettings clientSettings, ReceiveMode receiveMode) { Utils.assertNonNull("namespaceName", namespaceName); return acceptSessionFromEntityPathAsync(Util.convertNamespaceToEndPointURI(namespaceName), entityPath, sessionId, clientSettings, receiveMode); } /** * Asynchronously accepts a session in PeekLock mode from service bus using the client settings. Session Id can be null, if null, service will return the first available session. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromEntityPathAsync(URI namespaceEndpointURI, String entityPath, String sessionId, ClientSettings clientSettings) { return acceptSessionFromEntityPathAsync(namespaceEndpointURI, entityPath, sessionId, clientSettings, DEFAULTRECEIVEMODE); } /** * Asynchronously accepts a session from service bus using the client settings. Session Id can be null, if null, service will return the first available session. * @param namespaceEndpointURI endpoint uri of entity namespace * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param clientSettings client settings * @param receiveMode PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromEntityPathAsync(URI namespaceEndpointURI, String entityPath, String sessionId, ClientSettings clientSettings, ReceiveMode receiveMode) { Utils.assertNonNull("namespaceEndpointURI", namespaceEndpointURI); Utils.assertNonNull("entityPath", entityPath); MessageSession session = new MessageSession(namespaceEndpointURI, entityPath, null, sessionId, clientSettings, receiveMode); return session.initializeAsync().thenApply((v) -> session); } /** * Asynchronously accepts a session from service bus using the client settings. Session Id can be null, if null, service will return the first available session. * @param messagingFactory messaging factory (which represents a connection) on which the session receiver needs to be created. * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, String sessionId) { return acceptSessionFromEntityPathAsync(messagingFactory, entityPath, sessionId, DEFAULTRECEIVEMODE); } /** * Asynchronously accepts a session from service bus using the client settings. Session Id can be null, if null, service will return the first available session. * @param messagingFactory messaging factory (which represents a connection) on which the session receiver needs to be created. * @param entityPath path of entity * @param sessionId session id, if null, service will return the first available session, otherwise, service will return specified session * @param receiveMode PeekLock or ReceiveAndDelete * @return a CompletableFuture representing the pending session accepting */ public static CompletableFuture acceptSessionFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, String sessionId, ReceiveMode receiveMode) { return acceptSessionFromEntityPathAsync(messagingFactory, entityPath, null, sessionId, receiveMode); } static CompletableFuture acceptSessionFromEntityPathAsync(MessagingFactory messagingFactory, String entityPath, MessagingEntityType entityType, String sessionId, ReceiveMode receiveMode) { Utils.assertNonNull("messagingFactory", messagingFactory); MessageSession session = new MessageSession(messagingFactory, entityPath, entityType, sessionId, receiveMode); return session.initializeAsync().thenApply((v) -> session); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy