12 Configuring and Managing Bridge Services

Message-Oriented Middleware (MOM) systems use a broad spectrum of technologies and standards to provide messaging services. Often, these technologies and standards are incompatible, leading to MOM systems that cannot communicate with each other in a larger enterprise application context.

To alleviate this inability to communicate, Message Queue incorporates the Bridge Service Manager, which supports individual bridge services of various types. Each type of bridge service provides connectivity at the broker level to a MOM technology or standard that would otherwise be unavailable in Message Queue.

This chapter provides information about the administrative components of the Bridge Service Manager, and shows how to configure and manage the two types of bridge services currently available:

The Bridge Service Manager
Configuring and Managing JMS Bridge Services
Configuring and Managing STOMP Bridge Services

The Bridge Service Manager

The Message Queue Bridge Service Manager is an application that runs in same JVM as a broker to manage the bridges configured for the broker. Two administrative components control operation of the Bridge Service Manager:

Bridge-related broker properties
The Bridge Manager utility (imqbridgermgr)

The following sections introduce these two components.

Bridge-Related Broker Properties

The operation of the Bridge Service Manager is in part controlled by several broker properties. These broker properties, all of which begin with imq.bridge, are listed in tables under Bridge Properties. Some of the properties apply to all bridges configured for the broker, while others apply only to a specific bridge. The properties that apply to a specific bridge all begin with imq.bridge.bridgeName, where bridgeName is:

The same as the type of the bridge for bridge services that support only one bridge instance per broker, such as the STOMP bridge service
A name you specify for a bridge instance for bridge services that support multiple bridge instances per broker, such as the JMS bridge service

Of all the bridge-related broker properties, the two most important are imq.bridge.enabled and imq.bridge.activelist:

The imq.bridge.enabled property controls whether the Bridge Service Manager is enabled on the broker.
The imq.bridge.activelist property contains a comma-separated list bridges (by name) to be loaded when the broker starts.

To Enable the Bridge Service Manager

Set the imq.bridge.enabled broker property to true.
Set the imq.bridge.admin.user broker property to the user name of the admin user.
Set the imq.bridge.admin.password broker property to the password of the admin user.

Alternatively, you can specify the password using the -passfile option when you use the imqbrokerd command to start the broker hosting the bridge service manager.
Set the imq.bridge.activelist broker property to a comma-separated list of bridges to instantiate at broker startup.

Bridge Manager Utility

The Bridge Manager utility (imqbridgemgr) is the interface to the bridge management functions of the Bridge Service Manager. It provides commands to:

Stop and start bridges
Pause and resume bridges
List configured bridges
Manage type-dependent subcomponents of bridges, such as the links within a JMS bridge service

The imqbridgemgr utility uses the same Command Line Syntax as the other Message Queue utilities:

imqbridgemgr subcommand commandArgument [ options ]

For example, the following command lists all bridges of type JMS on the broker localhost:7373:

imqbridgemgr list bridge -t jms -b localhost:7373

For the complete set of subcommands, command arguments, and options supported by the imqbridgemgr utility, see Bridge Manager Utility.

Logging of Bridge Services

Each bridge managed by the Bridge Service Manager for a broker has its own log file stored in the IMQ_VARHOME/instances/broker-name/bridges/bridge-name/ directory.

The JMS and STOMP bridge services use the Java logging facility, which can be configured by the Java logging configuration file. The logging level for a bridge can be controlled by setting the imq.bridge.bridge-name.level property in the Java logging configuration file. Then, the Java system property java.util.logging.config.file can be set to the Java logging configuration file when the broker is started; as in:

imqbrokerd -Djava.util.logging.config.file=config-file

Configuring and Managing JMS Bridge Services

Because the JMS specification does not dictate the communication protocol between brokers and clients, each JMS provider (including Message Queue) has defined and uses its own propriety protocol. This situation has led to non-interoperability across JMS providers.

The JMS bridge service in Message Queue 4.5.2 closes this gap by enabling a Message Queue broker to map its destinations to destinations in external JMS providers. This mapping effectively allows the Message Queue broker to communicate with clients of the external JMS provider.

The JMS bridge service supports mapping destinations to external JMS providers that:

Are JMS 1.1 compliant
Support JNDI administrative objects
Use connection factories of type javax.jms.ConnectionFactory or javax.jms.XAConnectionFactory
Support the XA interfaces as a resource manager for transacted mapping

As an administrative and management convenience, the JMS bridge service supports the creation of any number of JMS bridges in a broker. Each JMS bridge in the broker is identified by a unique name, has its own configuration, and is managed separately from other JMS bridges in the broker.

The following subsections provide information about JMS bridges and how to configure and manage them:

JMS Bridge Components
JMS Bridge Features
Message Processing Sequence Across a Link in a JMS Bridge
Configuring a JMS Bridge
Starting and Stopping JMS Bridges
Starting and Stopping Links in a JMS Bridge

JMS Bridge Components

A JMS bridge consists of two primary components:

One or more links, each of which maps between a destination in the Message Queue broker and a destination in an external JMS provider or in another Message Queue broker
A default Dead Message Queue (DMQ) where undeliverable messages are sent. Additional, special-purpose DMQs can also be specified.

To provide destination mapping, each link consists of:

A source: the destination from which the JMS bridge receives messages. The source consists of a connection factory for creating connections to a JMS provider and a destination in that provider.
A target: the destination to which the JMS bridge forwards messages received from the source. The target consists of a connection factory for creating connections to a JMS provider and a destination in that provider. Additionally, a target can optionally specify a message transformer that alters messages from the source before forwarding them to the target destination.

Links are unidirectional. Links that have an external JMS provider or another Message Queue broker as their source are called inbound links, and links that have the Message Queue broker as their source are called outbound links.

To configure these components, you specify several imq.bridge.bridgeName broker properties, and you create an XML configuration file that specifies the links, sources, targets, connection factories, destinations, and DMQs in the bridge. This XML configuration file must conform to the JMS bridge DTD.

JMS Bridge Features

To provide flexible, high-performing message transfer between mapped destinations, a JMS bridge offers these features:

Pooled, Shared, and Dedicated Connections
Transactional Message Transfer
JMS Bridges in High Availability (HA) Broker Clusters
Message Transformation During Message Delivery
JMSReplyTo Header Processing
Dead Message Queue (DMQ) Processing

Pooled, Shared, and Dedicated Connections

A JMS bridge uses the connection factories configured for link sources, link targets, and DMQs to create connections to the Message Queue broker and the external JMS provider. When making connections, the JMS bridge follows these rules to determine whether to use a pooled connection, a shared connection, or a dedicated connection:

For link source connections, the JMS bridge always uses a dedicated connection.
For link target and DMQ connections, the JMS bridge uses:
- A pooled connection if the link target's or DMQ's stay-connected attribute is false and the connection factory has no JMS client identifier configured.
- A dedicated connection if the link target's or DMQ's stay-connected attribute is true or if the link target's or DMQ's clientid attribute is set
- A shared connection in all other cases

Transactional Message Transfer

Each JMS bridge includes a built-in XA transaction coordinator that enables its links to be configured as "transacted" such that message transfer from the source to the target is done in a XA distributed transaction.

For a link to be configured as transacted, both the link source and link target must specify connection factories of type javax.jms.XAConnectionFactory.

The built-in XA transaction coordinator logs transaction records using the same type of store as the Message Queue broker in which the JMS bridge resides. For file-based transaction logging, the transaction log for a JMS bridge is located at:

IMQ_VARHOME/instances/brokerInstance/bridges/bridgeName/txlog.bridgeNane

For JDBC-based transaction logging, the built-in XA transaction coordinator uses the same JDBC store as the Message Queue broker in which the JMS bridge resides.

Resource Manager Registration and The Built-In XA Transaction Coordinator

When a JMS bridge is started, it registers all its Resource Managers (RMs) with the built-in XA transaction coordinator so that the coordinator can identify specific RMs during recovery.

For connection factories, the JMS bridge only registers the factory as an RM if the factory's multi-rm attribute value is false. A connection factory with a multi-rm attribute value of true should have each of its RMs identified by a connection factory whose multi-rmattribute value of false in order to participate in transactional message transfer. Additionally, the JMS bridge uses a connection factory's ref-name attribute value as part of its RM name when registering RMs with the built-in XA transaction coordinator, so this attribute should not be changed between restarts of the bridge if transaction recovery is desired between restarts.

JMS Bridges in High Availability (HA) Broker Clusters

Message Queue supports JMS bridges in HA broker clusters, but some special constraints apply due to the inherent nature of HA broker clusters:

Each JMS bridge must have a name that is unique across all the JMS bridges in all the brokers in the cluster.
Each JMS bridge must have the same bridge configuration across all the brokers in the cluster.
The imq.bridge.enabled broker property must have the same value across all brokers in the cluster.
Before broker startup, the imq.bridge.activelist broker property for each broker lists only those JMS bridges that are to be owned by that broker.

To ensure that bridges in the cluster have the same configuration across all brokers in the cluster, all bridge-related broker properties except for imq.bridge.activelist should be specified in the centralized cluster properties file defined by the imq.cluster.url broker property.

A table in the cluster's HA store is used to maintain a consistent record of JMS bridge ownership by the brokers in the cluster.

During broker startup, the JMS bridge service compares the broker's imq.bridge.activelist property value to this table's entries before starting any JMS bridges, with the following consequences:

If a JMS bridge named in imq.bridge.activelist does not appear in the table, it is added to the table and associated with the broker.
If a JMS bridge name in imq.bridge.activelist does appear in the table, and the table entry already associates the bridge with a different broker, the bridge name is removed from imq.bridge.activelist.
If an entry in the table associates a JMS bridge with the broker, and that bridge's name is not in imq.bridge.activelist, the bridge name is added to imq.bridge.activelist.

Message Transformation During Message Delivery

A link target or a DMQ can specify a message transformer to process the message before it is delivered to the target destination or DMQ destination. This message transformer must be a Java class that extends the Message Queue bridge com.sun.messaging.bridge.service.MessageTransformer abstract class and has javax.jms.Message as its formal type parameters. To specify a message transformer, set the message-transformer-class attribute of a link target or a DMQ to the fully qualified class name of the Java class.

During message transfer processing, the JMS message to be transferred to a target, plus any property subelements of the link's target element or the dmq element, are passed to the message transformer's MessageTransformer.transform() method, and the returned JMS message is sent to the target destination.

JMSReplyTo Header Processing

In a JMS message, the JMSReplyTo header value is provider dependent. Therefore, unless both the source provider and target provider are Message Queue, the JMS bridge sets an existing JMSReplyTo header to a null value before passing the message to a link target or, if specified, the message transformer for the link target.

This default behavior can be overridden by setting the retain-replyto attribute of the link's target element to true. Overriding the default behavior is useful when:

The message transformer for a link target handles processing of the JMSReplyTo header.
Both the link source and link target have the same JMS provider, and clients of the target provider instance need to send reply messages back across the JMS bridge to the JMSReplyTo destination in the source provider instance. To successfully implement this case:
- The JMSReplyTo destination must exist (or be able to be auto-created) in the target provider instance.
- A JMS bridge link must be defined with its source set to the JMSReplyTo destination in the target provider instance and its target set to the JMSReplyTo destination in the source provider instance.

Dead Message Queue (DMQ) Processing

Each JMS bridge includes a built-in Dead Message Queue (DMQ) named built-in-dmq. This DMQ is a designated Queue destination named imq.bridge.jms.dmq in the broker hosting the JMS bridge. You can also configure additional DMQs for the JMS bridge, in which case the DMQ can use any JMS destination in any configured JMS provider.

Note:

In a production environment, the built-in DMQ, imq.bridge.jms.dmq, should be administratively created and have its access controls set appropriately before starting a broker that uses JMS bridge services.

When a DMQ uses Message Queue as the JMS provider, it can be configured such that messages sent to it will automatically be transferred to the Message Queue broker's DMQ. To do so, set physical destination properties of the JMS bridge's DMQ as follows:

useDMQ=true
limitBehavior=REMOVE_OLDEST
maxNumMsgs=0

When a message is sent to the DMQ, the JMS bridge follows this sequence with the built-in DMQ first:

The bridge creates a new DMQ javax.jms.ObjectMessage object and sets the properties listed in Table 12-1 to the ObjectMessage.
If the DMQ has defined a message transformer, the original message is passed to the transformer's MessageTransformer.transform() method.
The body of the javax.jms.ObjectMessage is set to the transformed message (or original message if no message transformer is defined). If this action fails (usually because the message is not serializable), the body of the ObjectMessage is instead set to the toString() value of the original message.
The javax.jms.ObjectMessage is sent (up to send-attempts times) to the DMQ's destination with a timeToLive value based on the DMQ's time-to-live-in-millis attribute and with the same JMSDeliveryMode and JMSPriority as the original message.
If sending the message fails, the bridge repeats Steps 2 through 4 for each DMQ defined in the bridge's XML configuration file in the order they appear in the file, stopping when a send attempt succeeds, unless it is the built-in DMQ.
If the message can't be sent to any DMQ, a log message is generated, containing the properties and headers of the original message and the properties set in Step 1.

Table 12-1 DMQ Message Propeties

Property	Type	Description
`JMS_SUN_JMSBRIDGE_DMQ_BODY_TRUNCATED`	String	If unable to set the original message or the transformed message (if the DMQ has a message transformer) to the body of the DMQ `ObjectMessage`. In that case the message's `toString()` is set to the body of the DMQ `ObjectMessage`.
`JMS_SUN_JMSBRIDGE_DMQ_EXCEPTION`	String	The `Exception.getMessage()` if exception occurred or detailed comments on the failure; null if none.
`JMS_SUN_JMSBRIDGE_DMQ_REASON`	String	One of: `MESSAGE_EXPIRED`, `SEND_FAILURE`, `ACK_FAILURE`, `TRANSFORM_FAILURE`, `COMMIT_FAILURE`.
`JMS_SUN_JMSBRIDGE_DMQ_TIMESTAMP`	String	The timestamp when the JMS bridge sends the message to the DMQ.
`JMS_SUN_JMSBRIDGE_SOURCE_CORRELATIONID`	String	The original message's `getJMSCorrelationID()`.
`JMS_SUN_JMSBRIDGE_SOURCE_DESTINATION`	String	The original message's source destination name.
`JMS_SUN_JMSBRIDGE_SOURCE_JMSTYPE`	String	The original message's `getJMSType()`.
`JMS_SUN_JMSBRIDGE_SOURCE_MESSAGEID`	String	The orginal message's `getJMSMessageID()`, or null if not available.
`JMS_SUN_JMSBRIDGE_SOURCE_PROVIDER`	String	The `ConnectionMetaData.getJMSProviderName` of the connection the original message was received on; if not available, the source connection factory's `getClass().getName()`.
`JMS_SUN_JMSBRIDGE_SOURCE_TIMESTAMP`	Long	The original message's `getJMSTimestamp()`.
`JMS_SUN_JMSBRIDGE_TARGET_DESTINATION`	String	The name of the target destination where the original message was intended to send to.
`JMS_SUN_JMSBRIDGE_TARGET_PROVIDER`	String	The `ConnectionMetaData.getJMSProviderName` of the connection the original message was intended to send on; if not available, the target connection factory's `getClass().getName()`.

Message Processing Sequence Across a Link in a JMS Bridge

A JMS bridge link receives messages in the order sent by the link's source JMS provider and transfer them in the same order to the link's target JMS provider. A link follows this sequence to transfer each message:

The link receives a JMS message from its source.
The link checks the JMSExpiration header to determine whether the message has expired. If it has, a log message is generated, the JMS message is sent to the DMQ, and no further action is taken.
If the message has a JMSReplyTo header and the link target's retain-replyto attribute is false, the JMSReplyTo header value is set to null.
If the link target has defined a message transformer, the transformer's MessageTransformer.transform() method is called. If the call fails or if the message transformer returns a null value, a log message is generated and then processing continues as follows:
- If the target's consume-no-transfer-on-transform-error XML attribute is true, the untransformed message is sent to the DMQ, consumed from the source, but not sent to the target.
- If the target's consume-no-transfer-on-transform-error XML attribute is false, the link is stopped and the message is neither consumed from the source nor sent to the target.
If the message-transfer-tag-bridge-name attribute of the jmsbridge element is true, the JMS_SUN_JMSBRIDGE_NAME property is added to the message and set to the name of the bridge.
The message is sent to the link target's destination with a timeToLive value based on the JMSExpiration header and current GMT time and with the same JMSDeliveryMode and JMSPriority values as the original message. If sending to the link target's destination fails and the link is not transacted, a log message is generated, the JMS message is sent to the DMQ, and processing continues.
The source message is acknowledged using JMS CLIENT_ACKNOWLEDGE if the link is not transacted. If the acknowledgement fails, a log message is generated and the JMS message is sent to the DMQ.
If the message processing was successful, an INFO log message is generated. This log message can be suppressed by setting to false the log-message-transfer attribute of the jmsbridge element in the bridge's XML configuration file.

Message processing for messages across transacted links follows the same processing sequence, except JTA interfaces are used to coordinate the source and target resource managers to transfer the message in an XA distributed transaction. For transacted links, failure to send the message to the link target's destination does not cause the JMS message to be sent to the DMQ; instead, the transaction is rolled back. However, if the attempt to commit the transaction fails, a log message is generated and the JMS message is sent to the DMQ.

The quality of message transfer under failures depends on whether the link transferring the message is transacted:

Transacted links: once-only-once
Non-transacted links: at-least-once

Configuring a JMS Bridge

To configure a JMS bridge, you specify several imq.bridge.bridgeName broker properties, where bridgeName is a name you choose for the JMS bridge. Additionally, you create an XML configuration file that specifies the links, sources, targets, connection factories, destinations, and DMQs in the bridge. The url of this configuration file is provided as the value of the imq.bridge.bridgeName.xml property

Specifying the Broker Properties for a JMS Bridge

Table 12-2 lists the broker properties you can specify for a JMS bridge. In this table, name is the name of the JMS bridge, which must be unique across all bridges in the broker.

Table 12-2 Broker Properties for a JMS Bridge

Property	Type	Default Value	Description
`imq.bridge.`name`.type`	String	None	The bridge type of the bridge named name. For JMS bridges, specify a value of `JMS` or `jms`.
`imq.bridge.`name`.xmlurl`	String	None	The URL where the XML configuration file for the JMS bridge name is stored. Examples: `http://webserver/imq/jmsbridge1.config.xml` (for a file on a Web server) `file:/net/fileserver/imq/jmsbridge1.config.xml` (for a file on a shared drive)
`imq.bridge.`name`.autostart`	Boolean	`true`	Should the JMS bridge name be automatically started when the broker is started?
`imq.bridge.`name`.logfile.limit`	Integer	`0`	The approximate maximum number of bytes the JMS bridge name writes to any one log file. A value of `0` (zero) indicates that there is no maximum limit.
`imq.bridge.`name`.logfile.count`	Integer	`1`	The number of log files the JMS bridge name cycles through.
`imq.bridge.tm.props` `imq.bridge.`name`.tm.props`	String	None	Each of these properties specifies a list of key-value pairs for the built-in transaction coordinator for the JMS bridge name. The list consists of one or more key`=`value pairs separated by commas. When the `imq.persist.store` is `file`, the built-in transaction coordinator supports these keys: `txlogSize`, `txlogSync`, and `txlogMmap`. If the same key appears in both properties, the value specified in `imq.bridge.`name`.tm.props` takes precedence.

Creating the XML Configuration File for a JMS Bridge

As mentioned earlier, the XML configuration file for a JMS bridge specifies the following components of the bridge:

Links
Sources
Targets
Connection factories
Destinations
DMQs

The configuration file must conform to the JMS bridge DTD, which is stored at:

IMQ_HOME/lib/dtd/sun_jmsbridge_Version.dtd

The basic structure of configuration file is:

<jmsbridge name=bridgeName otherAttributes>
    <link name=linkName otherAttributes>
        [ <description>linkDescription</description> ]
        <source connection-factory-ref=connFactoryRef destination-ref=destRef otherAttributes>
            [ <description>sourceDescription</description>
        </source>
        <target connection-factory-ref=connFactoryRef destination-ref=destRef otherAttributes>
            [ <description>targetDescription</description> ]
            [ <property name=propName value=propValue /> ] ...
        </target>
    </link> 
    <dmq name=dmqName otherAttributes> /* use name="built-in-dmq" for the built-in DMQ */
        [ <description>dmqDescription</description> ]
        [ <property name=propName value=propValue /> ] ...
    </dmq> 
    <connection-factory ref-name=connFactoryRef otherAttributes>
        [ <description>connFactoryDescription</description> ]
        [ <property name=propName value=propValue /> ] ...
    </connection-factory> 
    <destination ref-name=destRef otherAttributes>
        [ <description>destDescription</description> ]
        [ <property name=propName value=propValue /> ] ...
    </destination> ...
</jmsbridge>

From this abbreviated structure for the bridge XML configuration file, note that source and target are subelements of link, while connection-factory and destination are peer elements to link, not subelements of source and target. Connection factories and destinations are associated with sources and targets by matching connection-factory ref-name and destination ref-name attributes values to source and target connection-factory-ref and destination-ref attribute values, respectively.

As a result of this association by name-matching instead of by subelement inclusion, you can use the same connection factories and destinations across sources and targets in multiple links, thus streamlining the configuration file and making it more manageable.

The following subsections describe the attributes you can specify for the elements in the JMS bridge XML configuration file.

`jmsbridge` Attributes

Table 12-3 lists the attributes for the jmsbridge element in the JMS Bridge XML configuration file.

Table 12-3 jmsbridge Attributes

Attribute Type Description

Attribute	Type	Description
`name`	String	Unique name for this JMS bridge. Default value: no default
`log-message-transfer`^Foot 1	Boolean	Should each successful message transfer generate an INFO level log message? Default value: `true`
`message-transfer-tag-bridge-name`	Boolean	Should the `JMS_SUN_JMSBRIDGE_NAME` property be defined and set to the name of the bridge for each message before transferring to the link target? Default value: `false`

name

String

Unique name for this JMS bridge.

Default value: no default

log-message-transfer^Foot 1

Boolean

Should each successful message transfer generate an INFO level log message?

Default value: true

message-transfer-tag-bridge-name

Boolean

Should the JMS_SUN_JMSBRIDGE_NAME property be defined and set to the name of the bridge for each message before transferring to the link target?

Default value: false

^Footnote 1First available in Message Queue 4.4.2

`link` Attributes

Table 12-4 lists the attributes for the link element in the JMS Bridge XML configuration file.

Table 12-4 link Attributes

Attribute Type Description

Attribute	Type	Description
`enabled`	Boolean	If `false`, the link will not be started Default value: `true`
`name`	String	Unique identifier for this link Default value: no default
`transacted`	Boolean	If `true`, each message transfer from source to target will be done in a XA distributed transaction. The connection factories specified by the source and target must be `javax.jms.XAConnectionFactory` objects. If `false`, `CLIENT_ACKNOWLEDGE` mode will be used on the source The connection factories specified by the source and target must be `javax.jms.ConnectionFactory` objects. Default value: `true`

enabled

Boolean

If false, the link will not be started

Default value: true

name

String

Unique identifier for this link

Default value: no default

transacted

Boolean

If true, each message transfer from source to target will be done in a XA distributed transaction. The connection factories specified by the source and target must be javax.jms.XAConnectionFactory objects.

If false, CLIENT_ACKNOWLEDGE mode will be used on the source The connection factories specified by the source and target must be javax.jms.ConnectionFactory objects.

Default value: true

`source` Attributes

Table 12-5 lists the attributes for the source element in the JMS Bridge XML configuration file.

Table 12-5 source Attributes

Attribute	Type	Description
`clientid`	String	A JMS client identifier for the message consumer connection Default value: not set
`connection-factory-ref`	String	The `ref-name` attribute value of the `connection-factory` element to associate with this source. Default value: no default
`destination-ref`	String	The `ref-name` attribute value of the `destination` element to associate with this source. Default value: no default
`durable-sub`	String	A JMS durable subscription name. This attribute is ignored if the source's destination is not a `javax.jms.Topic` object. Default value: not set
`selector`	String	A JMS selector for the message consumer Default value: not set

`target` Attributes

Table 12-6 lists the attributes for the target element in the JMS Bridge XML configuration file.

Table 12-6 target Attributes

Attribute	Type	Description
`clientid`	String	A JMS client identifier for the message producer connection; if set, use a dedicated connection. Default value: not set
`connection-factory-ref`	String	The `ref-name` attribute value of the `connection-factory` element to associate with this target. Default value: no default
`consume-no-transfer-on-transform-error`	Boolean	Controls processing when the message transformer's `MessageTransformer.transform()` method returns a null value or throws `java.lang.Throwable`: If `true`, the message is sent to the DMQ and consumed from the source but not sent to the target. If `false`, the link is stopped, and the message is neither consumed from the source nor transferred to the target. Default value: `false`
`destination-ref`	String	The `ref-name` attribute value of the `destination` element to associate with this target. The value `AS_SOURCE` is also supported. This value causes the target destination name and type to be set to the source message's `javax.jms.Message.getJMSDestination()`, unless overridden by the message transformer's `MessageTransformer.branchTo()`. Default value: no default
`message-transformer-class`	String	A fully qualified class name that extends the Message Queue bridge `MessageTransformer` class. For more information, see Message Transformation During Message Delivery. Place this class under the `IMQ_HOME/lib/ext` directory. Default value: not set
`retain-replyto`	Boolean	Should the value of the source message's `JMSReplyTo` header (if specified) be retained? For more information, see JMSReplyTo Header Processing. Default value: `false`
`stay-connected`	Boolean	If `true`, the message producer connection will stay connected, and be dedicated. Default value: `true`

`dmq` Attributes

Table 12-7 lists the attributes for the dmq element in the JMS Bridge XML configuration file.

Table 12-7 dmq Attributes

Attribute	Type	Description
`client-id`	String	JMS client identifier for the DMQ producer connection. If set, the connection will be dedicated. Default value: not set
`connection-factory-ref`^Foot 1	String	The `ref-name` attribute value of the `connection-factory` element to associate with this DMQ. This connection factory must be a `javax.jms.ConnectionFactory` object. Default value: no default
`destination-ref`^Footref 1	String	The `ref-name` attribute value of the `destination` element to associate with this DMQ. Default value: no default
`enabled`^Footref 1	Boolean	Is this DMQ is enabled? Default value: `true`
`message-transformer-class`	String	A fully qualified class name that extends the Message Queue bridge `MessageTransformer` class. For more information, see Message Transformation During Message Delivery. Default value: not set
`name`	String	The unique identifier of this DMQ. Default value: no default
`send-attempt-interval-in-seconds`	Integer	How long to wait before attempting to resend an undeliverable message to this DMQ. Default value: `5`
`send-attempts`	Integer	The number of attempts to send (or resend) an undeliverable message to this DMQ. Default value: `3`
`stay-connected`^Footref 1	Boolean	If true, the DMQ producer connection will stay connected and be dedicated. Default value: `true`
`time-to-live-in-millis`	Integer	Time-to-live in milliseconds for messages going to this DMQ. The value `0` means forever. Default value: `0`

^Footnote 1This attribute is ignored for the built-in DMQ, built-in-dmq

`connection-factory` Attributes

Table 12-8 lists the attributes for the connection-factory element in the JMS Bridge XML configuration file.

Table 12-8 connection-factory Attributes

Attribute	Type	Description
`connect-attempt-interval-in-seconds`	Integer	How long to wait before each connect attempt. Default value: `5`
`connect-attempts`	Integer	The number of attempts for connecting. The value `-1` means retry forever Default value: `-1`
`idle-timeout-in-seconds`	Integer	Close a connection if it is idle for more than this long. The value `0` indicates no idle timeout. This attribute is ignored for sources and for targets and DMQs that have their `stay-connected` attribute set to `true`. Default value: `1800`
`lookup-name`	String	JNDI lookup name. If specified, the JNDI environment properties must specified as `property` subelements of this `connection-factory` element. The object returned by the lookup must be either `javax.jms.ConnectionFactory` or `javax.jms.XAConnectionFactory` type If not specified, a default connection factory to the Message Queue broker hosting the bridge is created with the properties in the `property` subelements. Default value: not set
`multi-rm`	Boolean	Set to `true` if this connection factory will potentially create XA connections to more than one XA resource manager (that is, `XAResource.isSame()` is `false` among them). Also, add separate `connection-factory` for each such resource manager so that they will be registered separately to the built-in XA transaction coordinator. Default value: `false`
`password`	String	The password for the user specified in `username`. Default value: not set
`ref-name`	String	Unique name for this connection factory. Default value: no default
`username`	String	The user name to be used to create connections from this connection factory. If this attribute is set, the `password` attribute must also be set. If not set, connections are created using the no-argument `createConnection()` method of the connection factory. Default value: not set

`destination` Attributes

Table 12-9 lists the attributes for the destination element in the JMS Bridge XML configuration file.

Table 12-9 destination Attributes

Attribute	Type	Description
`lookup-name`	String	JNDI lookup name for the destination. If specified, the JNDI environment properties must specified as `property` subelements of this `destination` element. Default value: not set
`name`	String	The JMS destination name of this destination. This attribute is ignored if `lookup-name` is specified. Default value: not set
`ref-name`	String	Unique name for this destination. Default value: no default
`type`	`queue` or `topic`	The JMS destination type of this destination. This attribute is ignored if `lookup-name` is specified Default value: `queue`

Starting and Stopping JMS Bridges

JMS bridges can be started automatically when the broker hosting the bridge starts, or manually using the imqbridgemgr utility. Similarly, JMS bridges are stopped automatically when the broker hosting the bridge is shut down, or manually using the imqbridgemgr utility.

When a JMS bridge is started, the JMS bridge manager performs these tasks:

Parse and validate the bridge's XML configuration file.
Initialize all links and DMQs that have their enabled attribute set to true.
If any enabled links have their transacted attribute set to true:
1. Initialize the built-in XA transaction coordinator.
2. Register resource managers (RMs) for all potential XA connection factories.
3. Perform XA recovery for available RMs.
Create connection pools and shared connections as needed.
Ensure that all DMQs are ready.
Start all enabled links.

When a JMS bridge is stopped, the JMS bridge manager performs these tasks:

Stop all started and paused links.
Wait until all pooled connections are returned to their respective pools and until all references to shared connections are returned.
Close all connection pools and shared connections. This effectively causes all physical connections to JMS providers to close.

To Configure a JMS Bridge to Start at Broker Startup

Follow these steps to configure a JMS bridge so that it starts automatically when the broker hosting it is started.

Confirm that the bridge service manager is enabled.

See To Enable the Bridge Service Manager for instructions.
Add the name of the bridge to the imq.bridge.activelist broker property.
Confirm that the imq.bridge.bridgeName.autostart broker property is set to true.

To Start a JMS Bridge Manually

Enter the imqbridgemgr start bridge command, specifying the bridge name and the broker.

For example, to start the bridge mq2external hosted by the broker running on myhost:8886, enter this command:
```
imqbridgemgr start bridge -bn mq2external -b myhost:8886
```

To Stop a JMS Bridge Manually

Enter the imqbridgemgr stop bridge command, specifying the bridge name and the broker.

For example, to stop the bridge mq2external hosted by the broker running on myhost:8886, enter this command:
```
imqbridgemgr stop bridge -bn mq2external -b myhost:8886
```

Starting and Stopping Links in a JMS Bridge

Links in a JMS bridge are started automatically when the bridge starts. Similarly, links are stopped automatically when the bridge is stopped. Additionally, once a JMS bridge is started, any of its links can be paused, resumed, stopped or restarted manually using the imqbridgemgr utility.

To Stop a Link Manually

Enter the imqbridgemgr stop link command, specifying the link name, the bridge name, and the broker.

For example, to stop the link link1 in the bridge mq2external hosted by the broker running on myhost:8886, enter this command:
```
imqbridgemgr stop link  -ln link1 -bn mq2external -b myhost:8886
```

To Start a Link Manually

A link cannot be started manually unless it is enabled; that is, the enabled attribute of its link element in the bridge's XML configuration file is set to true.

Enter the imqbridgemgr start link command, specifying the link name, the bridge name, and the broker.

For example, to start the link link1 in the bridge mq2external hosted by the broker running on myhost:8886, enter this command:
```
imqbridgemgr start link  -ln link1 -bn mq2external -b myhost:8886
```

Configuring and Managing STOMP Bridge Services

The STOMP (Streaming Text Oriented Messaging Protocol) open source project at http://docs.codehaus.org/display/STOMP/Home defines a simple wire protocol that clients written in any language can use to communicate with any messaging provider that supports the STOMP protocol.

Message Queue 4.5.2 provides support for the STOMP protocol through the STOMP bridge service. This service enables a Message Queue broker to communicate with STOMP clients.

The STOMP bridge service provides the features needed to fully integrate STOMP messaging into the JMS messaging environment of Message Queue:

Registration with the Message Queue Port Mapper service so that STOMP clients can discover the service dynamically
Support for TCP and SSL/TLS connections, including SSL/TLS connections requiring client authentication
Automatic conversion of STOMP frame messages to and from JMS BytesMessage and TextMessage types
Extensible message handling and transformation (by defining a custom message transformer)
Support for the full STOMP protocol, including the STOMP JMS bindings

The following subsections provide information about the STOMP bridge and how to configure and manage it:

Configuring the STOMP Bridge
Starting and Stopping the STOMP Bridge
Message Processing Sequence Across the STOMP Bridge
STOMP Protocol Features and the STOMP Bridge

Configuring the STOMP Bridge

To configure the STOMP bridge, you specify several imq.bridge.stomp broker properties in the broker hosting the bridge. These properties, which control the various features of the STOMP bridge, are listed in Table 12-10.

Table 12-10 Broker Properties for the STOMP Bridge Service

Property	Type	Default Value	Description
`imq.bridge.stomp.hostname`	String	None	Host name or IP address for the STOMP bridge service If specified, overrides `imq.hostname` (see Table 17-1) for the STOMP bridge service.
`imq.bridge.stomp.tcp.enabled`	Boolean	`true`	Does the STOMP bridge accept TCP connections?
`imq.bridge.stomp.tcp.port`	Integer	`7672`	The port on which the STOMP bridge listens for TCP connections, provided that `imq.bridge.stomp.tcp.enabled` is `true`.
`imq.bridge.stomp.tls.enabled`	Boolean	`false`	Does the STOMP bridge accept SSL/TLS connections? If `true`, a keystore must be created using the `imqkeytool` utility before starting the broker.
`imq.bridge.stomp.tls.port`	Integer	`7673`	The port on which the STOMP bridge listens for SSL/TLS connections, provided that `imq.bridge.stomp.tls.enabled` is `true`.
`imq.bridge.stomp.tls.requireClientAuth`	Boolean	`false`	Do SSL/TLS connections require client authentication?
`imq.bridge.stomp.consumerFlowLimit`	Integer	`1000`	The maximum number of unacknowledged messages that the STOMP bridge will deliver on a transacted STOMP subscription. The STOMP client must then acknowledge the messages and commit the transaction.
`imq.bridge.stomp.messageTransformer`	String	None	The fully qualified class name of a class that extends the Message Queue bridge `MessageTransformer` abstract class (with formal type parameters as `javax.jms.Message`). Place this class under the `IMQ_HOME/lib/ext` directory.
`imq.bridge.stomp.logfile.limit`	Integer	`0`	The approximate maximum number of bytes the STOMP bridge writes to any one log file. A value of `0` (zero) indicates that there is no maximum limit.
`imq.bridge.stomp.logfile.count`	Integer	`1`	The number of log files the STOMP bridge cycles through.

Starting and Stopping the STOMP Bridge

The STOMP bridge is started automatically when the broker hosting the bridge starts. Similarly, the STOMP bridge is stopped automatically when the broker hosting it is stopped. The STOMP bridge can be stopped and restarted manually using the imqbridgemgr utility.

To Activate the STOMP Bridge

Confirm that the bridge service manager is enabled.

See To Enable the Bridge Service Manager for instructions.
Add the name stomp to the list of bridge names in the imq.bridge.activelist broker property.

To Stop the STOMP Bridge Manually

Enter the imqbridgemgr stop bridge command, specifying the bridge type and the broker.

For example, to stop the STOMP bridge hosted by the broker running on myhost:8886, enter this command:
```
imqbridgemgr stop bridge -t STOMP -b myhost:8886
```

To Start the STOMP Bridge Manually

Enter the imqbridgemgr start bridge command, specifying the bridge type and the broker.

For example, to start the STOMP bridge hosted by the broker running on myhost:8886, enter this command:
```
imqbridgemgr start bridge -t STOMP -b myhost:8886
```

Message Processing Sequence Across the STOMP Bridge

The STOMP bridge processes messages differently depending on whether the message is a STOMP frame message being received from a STOMP client or a JMS message being sent to a STOMP client.

For STOMP frame messages received from a STOMP client, the STOMP bridge performs these tasks:

Convert the STOMP frame message to a JMS BytesMessage if the content-length header is present; otherwise, convert it to a JMS TextMessage using UTF-8 as the message encoding.
If a custom message transformer is defined for the bridge, pass the JMS message to the transformer's MessageTransformer.transform() method.
Send the message to its destination.

For JMS messages sent to a STOMP client, the STOMP bridge performs these tasks:

If a custom message transformer is defined for the bridge, pass the JMS message to the transformer's MessageTransformer.transform() method.
If the transformed message (or original message when no custom transformer is defined) is not a JMS TextMessage or JMS BytesMessage message, close the STOMP connection and stop processing the message.
Convert the JMS message to a STOMP frame message, using UTF-8 encoding for all headers and for the message body of a JMS TextMessage message.
Send the message to the STOMP client.

Message Transformation During Message Processing

The message transformation between STOMP frame messages and JMS messages that the STOMP bridge automatically provides is sufficient in most applications. However, if you need to perform special processing or to send JMS message types other than BytesMessage or TextMessage to STOMP clients, you can define a custom message transformer for the STOMP bridge.

This custom message transformer is a Java class that extends the Message Queue Bridge MessageTransformer abstract class by implementing the class's transform() method. Then, place the class file in the IMQ_HOME/lib/ext directory and set the imq.bridge.stomp.messageTransformer broker property of the broker hosting the STOMP bridge to the fully qualified class name of the class.

When implementing the transform() method, keep these points in mind:

The formal parameters T and S must be of type javax.jms.Message.
"The source and target arguments will be either "STOMP" and "SUN_MQ" or "SUN_MQ" and "STOMP", respectively.
A source argument value of "STOMP" indicates that the message argument is from a STOMP client SEND frame received by the STOMP bridge.
A source argument value of "SUN_MQ" indicates that the message argument is from a Message Queue destination.
The readOnly argument will be false if the source argument is "STOMP" and true if the source argument is "SUN_MQ".
If the source argument is "STOMP", the properties argument contains, as key/value pairs, any arbitrary user headers that the STOMP bridge was unable to convert to JMS message properties in the message argument. Otherwise, the properties argument is null.
The charsetName argument should be ignored unless the source argument is "STOMP" and the message argument is a JMS BytesMessage message. This combination of argument values indicates that the message is from a STOMP client and has already been converted to a BytesMessage message.
The returned message must be in write-only mode if the source argument is "STOMP" and in read-only mode if the source argument is "SUN_MQ".

STOMP Protocol Features and the STOMP Bridge

The STOMP bridge supports the full STOMP protocol, including all additional STOMP headers for the STOMP JMS bindings, as listed at http://docs.codehaus.org/display/STOMP/Stomp+JMS.

The following table clarifies how the STOMP bridge handles certain command and header combinations that might be otherwise be subject to multiple interpretations.

Table 12-11 STOMP Bridge Handling of Selected Command/Header Combinations

STOMP Frame Command	STOMP Frame Header	Handling by the STOMP Bridge
`CONNECT`	`login` `passcode`	The STOMP bridge requires these headers to be specified; otherwise, it returns an `ERROR` frame.
`SEND` `SUBSCRIBE` `UNSUBSCRIBE` `MESSAGE`	`destination`	MQ STOMP bridge interprets prefixes in `destination` header values as follows: `/queue/`: the prefix is followed by the name of a Queue `/topic/`: the prefix is followed by the name of a Topic `/temp-queue/`: the prefix is followed by the name of a TemporaryQueue `/temp-topic/`: the prefix is followed by the name of a TemporaryTopic Note that the following two prefixes are reserved to be used only for send reply messages to a `MESSAGE` frame's `replyto` destination, and should only be used in the same `CONNECT` session in which the `MESSAGE` is received. `/temp-queue/temporary_destination://queue/` `/temp-topic/temporary_destination://topic/`
`SEND`	`expires` `priority` `persistent`	When these headers are not specified for `SEND`, the message will be sent with the same default values as for a Message Queue Java client.
`SEND`	user specific headers	On `SEND`, a user can specify additional headers beyond the ones specified in the STOMP protocol and STOMP JMS Bindings. These headers are transformed to String properties of the converted JMS message. Therefore, the keys for these headers must be valid JMS property names. If any are not, and a custom message transformer is specified for STOMP bridge, the invalid ones are passed in the properties argument to the transformer's `transform()` method.
`SUBSCRIBE`	`selector`	Supported as described in the STOMP JMS Bindings on `SUBSCRIBE`.
`SUBSCRIBE`	`id`	A STOMP client should always specify an `id` header for `SUBSCRIBE`. If no "id" header is specified, the STOMP bridge assigns it a default value of `/subscription-to/`STOMP-destination-name. All `SUBSCRIBE` `id` values must be unique in the scope of the STOMP client connection to the STOMP bridge; otherwise, an `ERROR` frame will be returned.
`SUBSCRIBE`	`transaction`	For a STOMP subscription to receive messages in a transaction, the `SUBSCRIBE` frame must specify a `transaction` header with a transaction identifier whose transaction state is started. If the transaction does not exist, an `ERROR` frame is returned. After the transaction completes (using either `COMMIT` or `ABORT`), message delivery to the transacted subscription is paused until the next transaction `BEGIN`.
`ABORT`	`transaction`	For transacted subscriptions, aborting a transaction will cause the STOMP bridge to stop message delivery to all transacted subscriptions in the `CONNECT` session. Then, upon the next `BEGIN`, the STOMP bridge restarts the message delivery sequence to all the transacted subscriptions in the `CONNECT` session, including all unconsumed messages that had been previously delivered.
`SUBSCRIBE`	`ack`	For STOMP `ack:auto` (the default), a subscribed message is considered acknowledged as soon as it is sent to the STOMP client.
`UNSUBSCRIBE`	`durable-subscriber-name`	Unsubscribes a durable subscription, with these provisions: `destination` and `id` headers, if specfied, are ignored. An `ERROR` frame is returned if the connection (`CONNECT`) has no `client-id`. If an active subscriber with the durable name exists on the connection, it is first closed, and then the durable subscriber is unsubscribed.
`BEGIN`	`transaction`	Transactions are at STOMP `CONNECT` session level. Nested transactions are not supported. On attempts to start a nested transaction, an `ERROR` frame is returned. The transaction identifier will also be used for `SUBSCRIBE` frame to create a transacted subscription.
`ACK`	`subscription`	`ACK` should always specify a `subscription` header specifying the subscription id that the message to be acked was delivered to. If a subcriber id is not specified, the STOMP bridge default subscription id prefix is used to find the first matching subscription id with the prefix to ack the message. If the subscription for the specified subscription id was not created as transacted, and a `transaction` header is specified for the `ACK`, an `ERROR` frame is returned; `ACK` on a message ID, if found, will `ACK` all earlier messages delivered to the subscription in addition to the message with the given message ID.
`ACK`	`transaction`	For transacted subscription, an `ACK` for a message ID automatically `ACK`s all ealier messages sent to the transacted subscription in addition to the message with the given message ID. For transacted subscription, a message is considered consumed only when it is explicitly or implicitly `ACK`ed in a transaction and there is a subsequent successful `COMMIT` on that transaction. If the `transaction` header is not specified but the `subscription` header is specified and the subscription is a transacted subscription, the message is `ACK`ed in the current transaction if there is a current transaction. If there is no current transaction, an `ERROR` frame is returned.
`MESSAGE` `ERROR`	`content-length`	The STOMP bridge always sets the `content-length` header for `MESSAGE` and `ERROR` frames sent to STOMP clients.
`SEND` `MESSAGE`	`reply-to`	The STOMP bridge permits `SEND` from different STOMP `CONNECT` sessions as well as from the same `CONNECT` session to send reply messages to a STOMP `reply-to` header of temporary destination: In the same `CONNECT` session, when `SUBSCRIBE` and `SEND` reply, use the same temporary destination string that is used in the `SEND`'s `reply-to` header. In a different `CONNECT` session, upon receiving a `MESSAGE` with a `reply-to` header of a temporary destination, use the same temporary destination string in the `MESSAGE`'s `reply-to` header to `SEND` a reply to the `reply-to` temporary destination. This technique can also be used for sending the reply message when in the same `CONNECT` session.