progress.message.jclient.mp
Interface Connection

All Superinterfaces:

Connection

All Known Subinterfaces:

QueueConnection, TopicConnection

public interface Connection
extends Connection

Title: SonicMQ Adaptive Pacing (Managed Client Connection)

Description: Managed Client Connection. This is a wrapper around the standard SonicMQ Connection implementation. It allows all the same functionality as a standard Connection class in all respects. There are additional capabilities that this Connection supports outlined in the general Managed Client specification. By default all Managed Client features are disabled, which allows the JMS wrapper to function as a standard SonicMQ client with no additional capabilities.

Exception Handling

In general, since the delegate model implements a layered set of classes on top of SonicMQ standard JMS API most of the relevant exceptions are re-thrown as Managed Client JMS Exceptions. This does not typically indicate a problem in the Managed Client layer. It is done for the express purpose of making developers aware of the fact that they are using the delegate client.

Developers should check the Linked Exception and stack trace information in order to access the parent exception. In situations where underlying errors cause Managed Client exceptions the error message text will state the specific problem area. In certain situations, particularly where multi-threaded access issues or race conditions may occur the layered exceptions provide a more detailed set of information then the underlying JMS Exceptions, thus adding a safeguard layer to the JMS client.

Note Managed Client Illegal State Exception is usually thrown in situations where the underlying structures (ie. Connections, Sessions, Producers, Consumers) have become unavailable or null. This does not typically indicate a Managed Client error, but rather supercedes the standard JMS Illegal State Exception that would have been thrown in its place.

Adaptive Pacing

This capability optimizes message producer and consumer performance by adaptivley batching up send and receive operations. Each producer and consumer (message processor) is created with a special Pacer Thread that assists in managing the operation batches. Grouping send operations or receive acknowledgements dramatically reduces the number of outstanding acknowledgements as well as latency associated with synchronous message processing. The basic principles of Adaptive Pacing are the same as those found in the Nagle Algorithm used by TCP/IP. Unlike Nagle's solution, Adapive Pacing facilitates a configurable latency interval. Detailed information about Paced Session implementation may be found at: PacerThread.

General Function Overview

If Adaptive Pacing has been enabled on this connection the createSession() method returns Adaptive Paced sessions. Such Sessions are inherently transactional from the perspective of the JMS client with a few noted exceptions:

• Explicit usage of Commit/Rollback is not supported. The method calls will return without doing anything.
• Explicit creation of Transacted Sessions is not supported. Attempting this will throw a JMSException.
• Mixed mode Sessions, that is sessions that define both Producers and Consumers, are not supported. Attempts to create such sessions will result in a JMSException. A given Paced session may only be defined for a Producer or a Consumer. Sessions may not be reused for Mixed Mode purposes. Once created they remain dedicated.
• getTransacted() returns false.
• Since Adaptive Pacing is a Session level setting it is not possible to mix paced and non-paced producers and consumers on the same Session. Furthermore, if using ConnectionFactory settings obtained from an external Managed JMS Object definition each new Session will automatically inherit these settings from the progress.message.jclient.mp.Connection object. Users that wish to disable Adaptive Pacing for specific Sessions may use the setAdaptivePacing() method prior to session creation to force standard Session creation (ie. conn.setAdaptivePacing(false); ).
• By default, Adaptive Pacing extends to Message Producers and all their derrivatives (ie. Publishers, Senders) as well as Message Consumers (ie. Listeners, Receivers, Durable Subscribers). Batch Size and Timer interval are inherited by each Connection and Session unless overriden prior to object creation.
• Adaptive Pacing does not extend to Connection level methods that utiize Server Session Pools. J2EE Applications wishing to take advantage of Application Server pool are prohibited from participating in Adaptive Pacing. Such applications would have to utilize dedicated sessions in order to take advantage of Adaptive Pacing.

Copyright: Copyright (c) 2006

Company: Progress Software

Version:

2.2

Author:

Dmitry Lelchuk

Method Summary

boolean	getAdaptivePacing()
int	getAdaptivePacingBatchSize()
int	getAdaptivePacingTimer()
java.lang.String	getConnectionName()
void	setAdaptivePacing(boolean enableAdaptivePacing)
void	setAdaptivePacingBatchSize(int adaptivePacingBatchSize)
void	setAdaptivePacingTimer(int adaptivePacingTimer)

Methods inherited from interface progress.message.jclient.Connection

createSession, getBrokerReconnectURLs, getBrokerURL, getChannel, getConnectID, getConnectionState, getConnectionStateChangeListener, getRoutingNodeName, getStandbyBrokerReconnectURLs, getUnfinishedChannelIDs, getUnfinishedChannels, getUsername, hasUnfinishedChannel, hasUnfinishedChannels, isFaultTolerant, isSecure, setConnectionStateChangeListener, setPingInterval, setRejectionListener

Methods inherited from interface javax.jms.Connection

close, createConnectionConsumer, createDurableConnectionConsumer, getClientID, getExceptionListener, getMetaData, setClientID, setExceptionListener, start, stop

Method Detail

getConnectionName

java.lang.String getConnectionName()

setAdaptivePacing

void setAdaptivePacing(boolean enableAdaptivePacing)

getAdaptivePacing

boolean getAdaptivePacing()

setAdaptivePacingBatchSize

void setAdaptivePacingBatchSize(int adaptivePacingBatchSize)

getAdaptivePacingBatchSize

int getAdaptivePacingBatchSize()

setAdaptivePacingTimer

void setAdaptivePacingTimer(int adaptivePacingTimer)

getAdaptivePacingTimer

int getAdaptivePacingTimer()