Configuring Connection Details

SolacePubSub+ Connection Details

The Spring Cloud Stream Binder for PubSub+ uses Spring Boot Auto-Configuration for the Solace Java API to configure its session. In the application.yml, this typically is configured as follows:

solace:
  java:
    host: tcp://localhost:55555
    msg-vpn: default
    client-username: default
    client-password: default

For more information and options to configure the PubSub+ session, see Spring Boot Auto-Configuration for the Solace Java API.

Preventing Message Loss when Publishing to Topic-to-Queue Mappings

If the connector is publishing to a topic that is subscribed to by a queue, messages may be lost if they are rejected. For example, if the queue ingress is shutdown.

To prevent message loss, configure the reject-msg-to-sender-on-discard with the including-when-shutdown flag.

TIBCO EMS Connection Details

Manual Configuration

To manually configure TIBCO EMS connection details, set the following in application.yml:

solace: 
  tibco-ems:
    server-url: tcp://localhost:7222 
    username: username
    password: password 
    properties: 
      <key>:<value>

Properties are key/value pairs where key starts with the com.tibco.tibjms.* prefix. These properties are passed without validation as a Mapto the TIBCO EMS JMS Connection Factory. Accepted properties can be found in Tibjms and in TibjmsSSL.

JNDI

The JMS binder provides a generic way of configuring and using JNDI.

JNDI Context

The first step in using JNDI is to configure the JNDI context. The JMS binder expects standard JNDI properties to be specified under jms-binder.jndi.context in a key/value pair format. The key is the name of the property (e.g. "java.naming.provider.url") and the value is a string in the format defined for that property.

For instance, using the TIBCO EMS server as the JNDI provider could look like:

jms-binder: 
  jndi: 
    context:
      java.naming.factory.initial: com.tibco.tibjms.naming.TibjmsInitialContextFactory 
      java.naming.provider.url: tibjmsnaming://localhost:7222

Note that classes required by the chosen JNDI service provider need to be added to the classpath.

Once a JNDI context is successfully configured, connection factories and/or destinations can be looked up.

Connection Factory Lookup

To look up a connection factory, configure jms-binder.jndi.connection-factory.

jms-binder: 
  jndi:
    connection-factory:
      name: <jndiConnectionFactoryName>
      user: <someUser>
      password: <somePassword>

Where:

<jndiConnectionFactoryName> is the JNDI object name of the connection factory.
<someUser> is the user to authenticate with the JMS broker.
<somePassword> is the password to authenticate with the JMS broker.

The JNDI connection factories must not specify a clientID as this prevents producer bindings from connecting.

Connecting to Multiple Systems

To connect to multiple systems of a same type, use the multiple binder syntax.

For example:

spring: 
  cloud:
    stream: 
      binders:
        
        # 1st solace binder in this example 
	 solace1:
          type: solace 
	   environment: 
	     solace: 
	       java:
        	 host: tcp://localhost:55555
         
	 # 2nd solace binder in this example 
	 solace2:
          type: solace 
          environment: 
            solace: 
	       java:
        	 host: tcp://other-host:55555
        
	 # The only jms binder 
	 jms1:
          type: jms
	   # Add `environment` property map here if you need to customize this binder. 
	   # But for this example, we'll assume that defaults are used.
          
	 # Required for internal use 
	 undefined:
          type: undefined 
	 bindings:
          input-0:
            destination: <input-destination> 
	     binder: jms1
          output-0:
            destination: <output-destination>
            binder: solace1 # Reference 1st solace binder 
	   input-1:
            destination: <input-destination> 
	     binder: jms1
          output-1:
            destination: <output-destination>
            binder: solace2 # Reference 2nd solace binder

The configuration above defines two binders of type solace and one binder of type jms, which are then referenced within the bindings.

Each binder above is configured independently under spring.cloud.stream.binders.<bindername>.environment..

When connecting to multiple systems, all binder configuration must be specified using the multiple binder syntax for all binders. For example, under the spring.cloud.stream.binders.<binder-name>.environment.

Do not use single-binder configuration (for example, solace.java.* at the root of your application.yml) while using the multiple binder syntax.

Provide feedback