#include <bmqa_session.h>

Inheritance diagram for bmqa::Session:

Public Types
typedef AbstractSession::OpenQueueCallback	OpenQueueCallback
typedef AbstractSession::ConfigureQueueCallback	ConfigureQueueCallback
typedef AbstractSession::CloseQueueCallback	CloseQueueCallback
Public Member Functions
	Session (const bmqt::SessionOptions &options=bmqt::SessionOptions(), bslma::Allocator *allocator=0)
	Session (bslma::ManagedPtr< SessionEventHandler > eventHandler, const bmqt::SessionOptions &options=bmqt::SessionOptions(), bslma::Allocator *allocator=0)
	~Session () BSLS_KEYWORD_OVERRIDE
int	start (const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
int	startAsync (const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
void	stop () BSLS_KEYWORD_OVERRIDE
void	stopAsync () BSLS_KEYWORD_OVERRIDE
void	finalizeStop () BSLS_KEYWORD_OVERRIDE
virtual MessageEventBuilder	createMessageEventBuilder ()
void	loadMessageEventBuilder (MessageEventBuilder *builder) BSLS_KEYWORD_OVERRIDE
void	loadConfirmEventBuilder (ConfirmEventBuilder *builder) BSLS_KEYWORD_OVERRIDE
void	loadMessageProperties (MessageProperties *buffer) BSLS_KEYWORD_OVERRIDE
int	getQueueId (QueueId *queueId, const bmqt::Uri &uri) const BSLS_KEYWORD_OVERRIDE
int	getQueueId (QueueId *queueId, const bmqt::CorrelationId &correlationId) const BSLS_KEYWORD_OVERRIDE
int	openQueue (QueueId *queueId, const bmqt::Uri &uri, bsls::Types::Uint64 flags, const bmqt::QueueOptions &options=bmqt::QueueOptions(), const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
OpenQueueStatus	openQueueSync (QueueId *queueId, const bmqt::Uri &uri, bsls::Types::Uint64 flags, const bmqt::QueueOptions &options=bmqt::QueueOptions(), const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
virtual int	openQueue (const QueueId &queueId, const bmqt::Uri &uri, bsls::Types::Uint64 flags, const bmqt::QueueOptions &options=bmqt::QueueOptions(), const bsls::TimeInterval &timeout=bsls::TimeInterval())
int	openQueueAsync (QueueId *queueId, const bmqt::Uri &uri, bsls::Types::Uint64 flags, const bmqt::QueueOptions &options=bmqt::QueueOptions(), const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
void	openQueueAsync (QueueId *queueId, const bmqt::Uri &uri, bsls::Types::Uint64 flags, const OpenQueueCallback &callback, const bmqt::QueueOptions &options=bmqt::QueueOptions(), const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
int	configureQueue (QueueId *queueId, const bmqt::QueueOptions &options, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
ConfigureQueueStatus	configureQueueSync (const QueueId *queueId, const bmqt::QueueOptions &options, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
int	configureQueueAsync (QueueId *queueId, const bmqt::QueueOptions &options, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
void	configureQueueAsync (const QueueId *queueId, const bmqt::QueueOptions &options, const ConfigureQueueCallback &callback, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
int	closeQueue (QueueId *queueId, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
CloseQueueStatus	closeQueueSync (const QueueId *queueId, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
virtual int	closeQueue (const QueueId &queueId, const bsls::TimeInterval &timeout=bsls::TimeInterval())
int	closeQueueAsync (QueueId *queueId, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
void	closeQueueAsync (const QueueId *queueId, const CloseQueueCallback &callback, const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
virtual int	closeQueueAsync (const QueueId &queueId, const bsls::TimeInterval &timeout=bsls::TimeInterval())
Event	nextEvent (const bsls::TimeInterval &timeout=bsls::TimeInterval()) BSLS_KEYWORD_OVERRIDE
int	post (const MessageEvent &event) BSLS_KEYWORD_OVERRIDE
int	confirmMessage (const Message &message) BSLS_KEYWORD_OVERRIDE
int	confirmMessage (const MessageConfirmationCookie &cookie) BSLS_KEYWORD_OVERRIDE
int	confirmMessages (ConfirmEventBuilder *builder) BSLS_KEYWORD_OVERRIDE
int	configureMessageDumping (const bslstl::StringRef &command) BSLS_KEYWORD_OVERRIDE
void *	impl ()

Detailed Description

A session with a BlazingMQ broker.

See Component bmqa_session

Member Typedef Documentation

typedef AbstractSession::OpenQueueCallback bmqa::Session::OpenQueueCallback

Invoked as a response to an asynchronous open queue operation, OpenQueueCallback is an alias for a callback function object (functor) that takes as an argument the specified result, providing the result and context of the requested operation.

Reimplemented from bmqa::AbstractSession.

typedef AbstractSession::ConfigureQueueCallback bmqa::Session::ConfigureQueueCallback

Invoked as a response to an asynchronous configure queue operation, ConfigureQueueCallback is an alias for a callback function object (functor) that takes as an argument the specified result, providing the result and context of the requested operation.

Reimplemented from bmqa::AbstractSession.

typedef AbstractSession::CloseQueueCallback bmqa::Session::CloseQueueCallback

Invoked as a response to an asynchronous close queue operation, CloseQueueCallback is an alias for a callback function object (functor) that takes as an argument the specified result, providing the result and context of the requested operation.

Reimplemented from bmqa::AbstractSession.

Constructor & Destructor Documentation

bmqa::Session::Session	(	const bmqt::SessionOptions &	options = `bmqt::SessionOptions()`,
		bslma::Allocator *	allocator = `0`
	)			`[explicit]`

Create a new Session in synchronous mode using the optionally specified options. In such mode, events have to be fetched by the application using the nextEvent() method. Optionally specify an allocator used to supply memory. If allocator is 0, the currently installed default allocator is used.

bmqa::Session::Session	(	bslma::ManagedPtr< SessionEventHandler >	eventHandler,
		const bmqt::SessionOptions &	options = `bmqt::SessionOptions()`,
		bslma::Allocator *	allocator = `0`
	)			`[explicit]`

Create a Session in asynchronous mode using the specified eventHandler as callback for event processing and the optionally specified options. Optionally specify an allocator used to supply memory. If the optionally specified allocator is 0, the currently installed default allocator is used.

bmqa::Session::~Session ( )

Stop the Session and destroy this object.

Member Function Documentation

int bmqa::Session::start ( const bsls::TimeInterval & timeout = bsls::TimeInterval() ) [virtual]

Connect to the BlazingMQ broker and start the message processing for this Session. This method blocks until either the Session is connected to the broker, fails to connect, or the operation times out. If the optionally specified timeout is not populated, use the one defined in the session options. Return 0 on success, or a non-zero value corresponding to the bmqt::GenericResult::Enum enum values otherwise. The behavior is undefined if this method is called on an already started Session.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::startAsync ( const bsls::TimeInterval & timeout = bsls::TimeInterval() ) [virtual]

Connect to the BlazingMQ broker and start the message processing for this Session. This method returns without blocking. The result of the operation is communicated with a session event. If the optionally specified timeout is not populated, use the one defined in the session options. Return 0 on success (this doesn't imply the session is connected !), or a non-zero value corresponding to the bmqt::GenericResult::Enum enum values otherwise. The behavior is undefined if this method is called on an already started Session.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::stop ( ) [virtual]

Gracefully disconnect from the BlazingMQ broker and stop the operation of this Session. This method blocks waiting for all already invoked event handlers to exit and all session-related operations to be finished. No other method but start() may be used after this method returns. This method must NOT be called if the session is in synchronous mode (i.e., not using the EventHandler), stopAsync() should be called in this case.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::stopAsync ( ) [virtual]

Disconnect from the BlazingMQ broker and stop the operation of this Session. This method returns without blocking and neither enforce nor waits for any already started session-related operation to be finished. No method may be used after this method returns.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::finalizeStop ( ) [virtual]

**DEPRECATED**

This method is only to be used if the session is in synchronous mode (i.e., not using the EventHandler): it must be called once all threads getting events with nextEvent() have been joined.

Reimplemented from bmqa::AbstractSession.

virtual MessageEventBuilder bmqa::Session::createMessageEventBuilder ( ) [virtual]

Return a MessageEventBuilder that can be used to build message event for posting on this session. The behavior is undefined unless the session has been successfully started. Note that lifetime of the returned object is bound by the lifetime of this session instance (i.e., returned instance cannot outlive this session instance). Also note that the MessageEventBuilder objects are pooled, so this operation is cheap, and MessageEventBuilder can be obtained on demand and kept on the stack.

DEPRECATED: Use the 'loadMessageEventBuilder instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

void bmqa::Session::loadMessageEventBuilder ( MessageEventBuilder * builder ) [virtual]

Load into the specified builder an instance of bmqa::MessageEventBuilder that can be used to build message event for posting on this session. The behavior is undefined unless the session has been successfully started and builder is non-null. Note that lifetime of the loaded object is bound by the lifetime of this session instance (i.e., loaded instance cannot outlive this session instance). Also note that the MessageEventBuilder objects are pooled, so this operation is cheap, and MessageEventBuilder can be obtained on demand and kept on the stack.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::loadConfirmEventBuilder ( ConfirmEventBuilder * builder ) [virtual]

Load into the specified builder an instance of bmqa::ConfirmEventBuilder that can be used to build a batch of CONFIRM messages for sending to the broker. The behavior is undefined unless the session has been successfully started and builder is non-null. Note that the lifetime of the loaded object is bound by the lifetime of this session instance (i.e., loaded instance cannot outlive this session instance).

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::loadMessageProperties ( MessageProperties * buffer ) [virtual]

Load into the specified buffer an instance of MessageProperties that can be used to specify and associate properties while building a bmqa::Message. The behavior is undefined unless the session has been successfully started and buffer is non-null. Note that lifetime of the loaded object is bound by the lifetime of this session instance (i.e., loaded instance cannot outlive this session instance).

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::getQueueId	(	QueueId *	queueId,
		const bmqt::Uri &	uri
	)			const `[virtual]`

Load in the specified queueId the queue corresponding to the specified uri and return 0 if such a queue was found, or leave queueId untouched and return a non-zero value if no queue corresponding to uri is currently open.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::getQueueId	(	QueueId *	queueId,
		const bmqt::CorrelationId &	correlationId
	)			const `[virtual]`

Load in the specified queueId the queue corresponding to the specified correlationId and return 0 if such a queue was found, or leave queueId untouched and return a non-zero value if no queue corresponding to correlationId is currently open.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::openQueue	(	QueueId *	queueId,
		const bmqt::Uri &	uri,
		bsls::Types::Uint64	flags,
		const bmqt::QueueOptions &	options = `bmqt::QueueOptions()`,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the openQueueSync(QueueId *queueId...) instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Reimplemented from bmqa::AbstractSession.

OpenQueueStatus bmqa::Session::openQueueSync	(	QueueId *	queueId,
		const bmqt::Uri &	uri,
		bsls::Types::Uint64	flags,
		const bmqt::QueueOptions &	options = `bmqt::QueueOptions()`,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

Open the queue having the specified uri with the specified flags (a combination of the values defined in bmqt::QueueFlags::Enum), using the specified queueId to correlate events related to that queue. The object queueId referring to is modified, so the queueId represents the actual queue uri, flags and options. Return a result providing the status and context of the operation. Use the optionally specified options to configure some advanced settings. Note that this operation fails if queueId is non-unique. If the optionally specified timeout is not populated, use the one defined in the session options. This operation will block until either success, failure, or timing out happens.

THREAD: Note that calling this method from the event processing thread(s) (i.e., from the EventHandler callback, if provided) WILL lead to a DEADLOCK.

Reimplemented from bmqa::AbstractSession.

virtual int bmqa::Session::openQueue	(	const QueueId &	queueId,
		const bmqt::Uri &	uri,
		bsls::Types::Uint64	flags,
		const bmqt::QueueOptions &	options = `bmqt::QueueOptions()`,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the openQueue(QueueId *queueId...) instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

int bmqa::Session::openQueueAsync	(	QueueId *	queueId,
		const bmqt::Uri &	uri,
		bsls::Types::Uint64	flags,
		const bmqt::QueueOptions &	options = `bmqt::QueueOptions()`,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the openQueueAsync(...) with callback flavor instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::openQueueAsync	(	QueueId *	queueId,
		const bmqt::Uri &	uri,
		bsls::Types::Uint64	flags,
		const OpenQueueCallback &	callback,
		const bmqt::QueueOptions &	options = `bmqt::QueueOptions()`,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

Asynchronously open the queue having the specified uri with the specified flags (a combination of the values defined in bmqt::QueueFlags::Enum), using the specified queueId to correlate events related to that queue and the optionally specified options to configure some advanced settings. The object queueId referring to is modified, so the queueId represents the actual queue uri, flags and options. The result of the operation is communicated to the specified callback via a bmqa::OpenQueueStatus, providing the status and context of the requested operation. Note that this operation fails if queueId is non-unique. If the optionally specified timeout is not populated, use the one defined in the session options.

THREAD: The callback will ALWAYS be invoked from the EventHandler thread(s) (or if a SessionEventHandler was not specified, from the thread invoking nextEvent).

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::configureQueue	(	QueueId *	queueId,
		const bmqt::QueueOptions &	options,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the 'configureQueueSync(QueueId *queueId...) instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Reimplemented from bmqa::AbstractSession.

ConfigureQueueStatus bmqa::Session::configureQueueSync	(	const QueueId *	queueId,
		const bmqt::QueueOptions &	options,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

Configure the queue identified by the specified queueId using the specified options and return a result providing the status and context of the operation. If the optionally specified timeout is not populated, use the one defined in the session options. This operation returns error if there is a pending configure for the same queue. This operation will block until either success, failure, or timing out happens.

Note that the following bmqt::QueueOptions fields cannot be reconfigured after the queue has been opened:

suspendsOnBadHostHealth Attempts to reconfigure these fields will yield an e_NOT_SUPPORTED error code.

THREAD: Note that calling this method from the event processing thread(s) (i.e., from the EventHandler callback, if provided) WILL lead to a DEADLOCK.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::configureQueueAsync	(	QueueId *	queueId,
		const bmqt::QueueOptions &	options,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the configureQueueAsync(...) with callback flavor instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::configureQueueAsync	(	const QueueId *	queueId,
		const bmqt::QueueOptions &	options,
		const ConfigureQueueCallback &	callback,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

Asynchronously configure the queue identified by the specified queueId using the specified options to configure some advanced settings. The result of the operation is communicated to the specified callback via a bmqa::ConfigureQueueStatus, providing the status and context of the requested operation. If the optionally specified timeout is not populated, use the one defined in the session options.

Note that the following bmqt::QueueOptions fields cannot be reconfigured after the queue has been opened:

suspendsOnBadHostHealth Attempts to reconfigure these fields will yield an e_NOT_SUPPORTED error code.

THREAD: The callback will ALWAYS be invoked from the EventHandler thread(s) (or if a SessionEventHandler was not specified, from the thread invoking nextEvent).

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::closeQueue	(	QueueId *	queueId,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the 'closeQueueSync(QueueId *queueId...) instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Reimplemented from bmqa::AbstractSession.

CloseQueueStatus bmqa::Session::closeQueueSync	(	const QueueId *	queueId,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

Close the queue identified by the specified queueId and return a result providing the status and context of the operation. If the optionally specified timeout is not populated, use the one defined in the session options. Any outstanding configureQueue request for this queueId will be canceled. This operation will block until either success, failure, or timing out happens. Once this method returns, there is guarantee that no more messages and events for this queueId will be received. Note that successful processing of this request in the broker closes this session's view of the queue; the underlying queue may not be deleted in the broker. When this method returns, the correlationId associated to the queue is cleared.

THREAD: Note that calling this method from the event processing thread(s) (i.e., from the EventHandler callback, if provided) WILL lead to a DEADLOCK.

Reimplemented from bmqa::AbstractSession.

virtual int bmqa::Session::closeQueue	(	const QueueId &	queueId,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the 'closeQueue(QueueId *queueId...) instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

int bmqa::Session::closeQueueAsync	(	QueueId *	queueId,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the closeQueueAsync(...) with callback flavor instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Reimplemented from bmqa::AbstractSession.

void bmqa::Session::closeQueueAsync	(	const QueueId *	queueId,
		const CloseQueueCallback &	callback,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

Asynchronously close the queue identified by the specified queueId. Any outstanding configureQueue requests will be canceled. The result of the operation is communicated to the specified callback via a bmqa::CloseQueueStatus, providing the status and context of the operation. If the optionally specified timeout is not populated, use the one defined in the session options. Note that successful processing of this request in the broker closes this session's view of the queue; the underlying queue may not be deleted in the broker. The correlationId associated to the queue remains valid until the bmqa::CloseQueueStatus result has been received and processed by the callback, after which it will be cleared and no more messages and events for this queueId will be received.

THREAD: The callback will ALWAYS be invoked from the EventHandler thread(s) (or if a SessionEventHandler was not specified, from the thread invoking nextEvent).

Reimplemented from bmqa::AbstractSession.

virtual int bmqa::Session::closeQueueAsync	(	const QueueId &	queueId,
		const bsls::TimeInterval &	timeout = `bsls::TimeInterval()`
	)			`[virtual]`

DEPRECATED: Use the closeQueueAsync(...) with callback flavor instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED in future release of libbmq.

Event bmqa::Session::nextEvent ( const bsls::TimeInterval & timeout = bsls::TimeInterval() ) [virtual]

Return the next available event received for this session. If there is no event available, this method blocks for up to the optionally specified timeout time interval for an event to arrive. An empty time interval for timeout (the default) indicates that the method should not timeout (the method will not return until the next event is available). Return a bmqa::SessionEvent of type bmqt::SessionEventType::e_TIMEOUT if a timeout was specified and that timeout expired before any event was received. Note that this method can only be used if the session is in synchronous mode (ie not using the EventHandler). The behavior is undefined unless the session was started.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::post ( const MessageEvent & event ) [virtual]

Asynchronously post the specified event that must contain one or more Messages. The return value is one of the values defined in the bmqt::PostResult::Enum enum. Return zero on success and a non-zero value otherwise. Note that success implies that SDK has accepted the event and will eventually deliver it to the broker. The behavior is undefined unless the session was started.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::confirmMessage ( const Message & message ) [virtual]

Asynchronously confirm the receipt of the specified message. This indicates that the application is done processing the message and that the broker can safely discard it from the queue according to the retention policy set up for that queue. Return 0 on success, and a non-zero value otherwise. Note that success implies that SDK has accepted the message and will eventually send confirmation notification to the broker.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::confirmMessage ( const MessageConfirmationCookie & cookie ) [virtual]

Asynchronously confirm the receipt of the message with which the specified cookie is associated. This indicates that the application is done processing the message and that the broker can safely discard it from the queue according to the retention policy set up for that queue. Return 0 on success, and a non-zero value otherwise. Note that success implies that SDK has accepted the message and will eventually send confirmation notification to the broker.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::confirmMessages ( ConfirmEventBuilder * builder ) [virtual]

Asynchronously confirm the receipt of the batch of CONFIRM messages contained in the specified builder. This indicates that the application is done processing all of the messages and that the broker can safely discard them from the queue according to the retention policy set up for that queue. The return value is one of the values defined in the bmqt::GenericResult::Enum enum. Note that in case of success, the instance pointed by the builder will be reset. Also note that success implies that SDK has accepted all of the messages in builder and will eventually send confirmation notification to the broker, whereas failure implies that none of the messages in builder were accepted. Behavior is undefined unless builder is non-null.

Reimplemented from bmqa::AbstractSession.

int bmqa::Session::configureMessageDumping ( const bslstl::StringRef & command ) [virtual]

Configure this session instance to dump messages to the installed logger at ball::Severity::INFO level according to the specified command that should adhere to the following pattern:

           IN|OUT|PUSH|ACK|PUT|CONFIRM ON|OFF|100|10s

where each token has a specific meaning:

IN : incoming (PUSH and ACK) events
OUT : outgoing (PUT and CONFIRM) events
PUSH : incoming PUSH events
ACK : incoming ACK events
PUT : outgoing PUT events
CONFIRM : outgoing CONFIRM events
ON : turn on message dumping until explicitly turned off
OFF : turn off message dumping
100 : turn on message dumping for the next 100 messages
10s : turn on message dumping for the next 10 seconds

Above, the numerical values 100 and 10 are just for illustration purposes, and application can choose an appropriate positive numeric value for them. Also, pattern is case-insensitive. Return zero if command is valid and message dumping has been configured, non-zero value otherwise. The behavior is undefined unless the session has been started.

Reimplemented from bmqa::AbstractSession.

void* bmqa::Session::impl ( )

Do NOT use. Internal function, reserved for BlazingMQ internal usage.

The documentation for this class was generated from the following file:

bmqa_session.h

bmqa::Session Class Reference

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation