JMSTriggerFacade (webMethods Java API Reference)

java.lang.Object
- com.wm.app.b2b.server.jms.consumer.JMSTriggerFacade

```
public class JMSTriggerFacade
extends java.lang.Object
```
Provides a simplified interface to JMS trigger functionality. This class includes accessors to retrieve configuration information for the JMS trigger, mutators to set JMS trigger properties, and methods to enable, disable, or quiesce a JMS trigger.
A JMSTriggerFacade object represents an individual JMS trigger on Integration Server.
The JMSTriggerFacade can reference an existing JMS trigger if it is instantiated with the JMSTriggerFacade(String) constructor. When this is done the JMSTriggerFacade can be used to return information about the referenced trigger, update the referenced JMS trigger’s properties, update the referenced trigger’s state (enable/disable/suspend), or it can be used to create a new trigger using the referenced trigger as a starting template.
The JMSTriggerFacade can also be created without any reference to an existing JMS trigger. This is done by instantiating the JMSTriggerFacade with the empty JMSTriggerFacade() constructor. This is only useful when you wish to create a new JMS trigger from scratch.

Constructor Summary

Constructors
Constructor and Description
`JMSTriggerFacade()` Instantiates an empty JMSTriggerFacade.
`JMSTriggerFacade(java.lang.String triggerName)` Instantiates a JMSTriggerFacade object that represents an individual JMS trigger on Integration Server.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`createTrigger(java.lang.String triggerName, java.lang.String triggerPackage)` Creates a JMS trigger in the namespace.
`void`	`disableTrigger()` Disables the JMS trigger.
`void`	`enableTrigger()` Enables the JMS trigger if it is currently suspended or disabled.
`int`	`getAcknowledgeMode()` Returns the acknowledgment mode which indicates how or when the session acknowledges receipt of a message to the JMS provider.
`java.lang.String`	`getAliasName()` Returns the name of the JMS connection alias used by the JMS trigger to receive messages from the JMS provider.
`static IData`	`getAllAsData()` Get metadata and run-time information for all JMS triggers, including destinations, routing rules, configured properties, and global throttling configuration.
`IData`	`getAsData()` Get metadata and run-time information for a single JMS trigger, including destinations, routing rules, configured properties, and global throttling configuration.
`int`	`getBatchSize()` Returns the JMS trigger's batch size, which indicates the maximum number of messages that the associated trigger service can receive at one time.
`int`	`getConsumersCurrentThreadCount()` Returns the number of threads currently receiving and processing messages for the JMS trigger.
`java.util.ArrayList<JMSDestinationFilterPair>`	`getDestinationFilterPairs()` Gets a java.util.ArrayList of JMSDestnationFilterPair objects that specify the destinations from which the JMS trigger receives messages and the message selector the JMS provider uses to filter messages from each destination.
`java.lang.String`	`getExecuteUser()` Returns the name of the user account whose credentials Integration Server uses to execute the trigger service associated with the JMS trigger.
`boolean`	`getInDoubtDetection()` Returns a boolean indicating whether duplicate detection is enabled for persistent messages received by the JMS trigger.
`long`	`getJoinTimeout()` Returns the length of the join time out value (measured in milliseconds) for the JMS trigger
`int`	`getJoinType()` Returns the type of join for the JMS trigger.
`java.lang.Throwable`	`getLastError()` Returns the last error thrown while executing the JMS trigger.
`int`	`getMaxConcurrentThreads()` Returns the maximum number of server threads that can process messages for this JMS trigger at one time.
`int`	`getMaxDeliveryAttempts()` Returns the maximum number of retry attempts Integration Server will make for a trigger service invoked by this JMS trigger.
`int`	`getPrefetchSize()` Deprecated. No replacement. webMethods Broker is deprecated, which results in the deprecation of this method.
`long`	`getRedeliveryDelay()` Returns the number of milliseconds Integration Server waits between attempts to retry a trigger service for this JMS trigger.
`int`	`getRedeliveryFailureAction()` Returns an int that indicates what action Integration Server takes when retry failure occurs for a non-transacted JMS trigger or a transient error occurs for a transacted JMS trigger.
`long`	`getResolutionHistoryTTL()` Returns a long specifying the number of milliseconds the document history database maintains an entry for a message processed by this trigger.
`NSName`	`getResolverServiceName()` Returns the name of the document resolver service for the JMS trigger.
`boolean`	`getResolveWithHistory()` Returns a boolean indicating whether a document history database is used as part of duplicate detection.
`NSName`	`getResourceMonitoringSvcName()` Returns the name of the resource monitoring service for the JMS trigger.
`java.util.ArrayList<JMSRoutingRule>`	`getRoutingRules()` Gets a java.util.ArrayList of JMSRoutingRule objects that specify the routing rules for messages received by a JMS trigger.
`static java.lang.String[]`	`getSortedJMSTriggerNames()` Returns a list of JMS triggers on Integration Server.
`int`	`getState()` Returns an int specifying the state of a JMS trigger.
`boolean`	`getSuspendOnError()` Returns a boolean indicating whether Integration Server suspends a JMS trigger automatically if a fatal error occurs during trigger service execution.
`int`	`getTotalThrottledThreads()` Returns the current number of server threads that can be used to process JMS triggers as determined by the Thread Pool Throttle.
`java.lang.String`	`getTriggerName()` Returns the fully qualified name of the referenced JMS trigger.
`boolean`	`isConcurrent()` Returns a boolean that indicates the message processing mode used by the JMS trigger.
`boolean`	`isEnabled()` Returns a boolean indicating whether or not the JMS trigger is enabled.
`void`	`resumeTrigger()` Enables a JMS trigger that is currently suspended.
`void`	`setAcknowledgmentMode(int acknowledgeMode)` Sets the acknowledgement mode for a JMS trigger, which indicates how Integration Server acknowledges messages received on behalf of a JMS trigger.
`void`	`setAliasName(java.lang.String aliasName)` Sets the name of the JMS connection alias that the JMS trigger uses to connect to the JMS provider.
`void`	`setBatchSize(int batchSize)` Sets the maximum batch size for a JMS trigger.
`void`	`setConcurrent(boolean flag)` Sets the message processing of a JMS trigger to serial or concurrent processing.
`void`	`setDestinationFilterPairs(java.util.ArrayList<JMSDestinationFilterPair> pairs)` Specifies the destinations from which the JMS trigger receives messages and the message selector the JMS provider uses to filter messages from each destination.
`void`	`setEnabled(boolean enabled)` Enables or disables the JMS trigger.
`void`	`setExecuteUser(java.lang.String executeUser)` Sets the execution user for a JMS trigger.
`void`	`setInDoubtDetection(boolean flag)` Enables or disables duplicate detection for the JMS trigger.
`void`	`setJoinTimeout(long timeout)` Sets the length of the join time-out.
`void`	`setJoinType(int joinType)` Sets the join type for a JMS trigger.
`void`	`setMaxConcurrentThreads(int maxConcurrent)` Sets the maximum number of messages that Integration Server can process concurrently for this JMS trigger.
`void`	`setMaxDeliveryAttempts(int maxRedeliveryAttempts)` Sets the maximum number of attempts Integration Server makes to re-execute a trigger service if the trigger service failed because of a transient error.
`void`	`setPrefetchSize(int prefetchSize)` Sets the maximum number of messages that Integration Server retrieves for this JMS trigger at one time from the webMethods Broker.
`void`	`setRedeliveryDelay(long redeliveryDelay)` Sets the time interval Integration Server waits between retry attempts for a trigger service that failed because of a transient error.
`void`	`setRedeliveryFailureAction(int redeliveryFailureAction)` Determines what action Integration Server takes when retry failure occurs for a non-transacted JMS trigger or a transient error occurs for a transacted JMS trigger.
`void`	`setResolutionHistoryTTL(long ttl)` Sets the length of time the document history database maintains an entry for a message processed by this trigger.
`void`	`setResolverServiceName(NSName name)` Sets the name of the document resolver service for the JMS trigger.
`void`	`setResolveWithHistory(boolean flag)` Determines whether a document history database is used as part of duplicate detection.
`void`	`setResourceMonitoringSvcName(NSName resourceMonitoringSvcName)` Sets the resource monitoring service for the JMS trigger.
`void`	`setRoutingRules(java.util.ArrayList<JMSRoutingRule> rules)` Specifies the routing rules for the messages received by the JMS trigger.
`void`	`setSuspendOnError(boolean flag)` Sets a flag indicating whether the JMS trigger suspends automatically when a fatal exception occurs during trigger service execution.
`void`	`suspendTrigger()` Suspends the JMS trigger.
`void`	`updateTrigger()` Updates the JMS trigger you indicated in the constructor with the changes you made by calling the setter methods.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - JMSTriggerFacade
```
public JMSTriggerFacade(java.lang.String triggerName)
                 throws JMSSubsystemException
```
    Instantiates a JMSTriggerFacade object that represents an individual JMS trigger on Integration Server. The JMSTriggerFacade can be used to return information about the referenced trigger, update the referenced JMS trigger’s properties, update the referenced trigger’s state (enable/disable/suspend), or it can be used to create a new trigger using the referenced trigger as a starting template
    
    Parameters:
    
    triggerName - the String representing the fully qualified name of the JMS trigger for which you want to initialize a JMSTriggerFacade object
    
    Throws:
    
    JMSSubsystemException - if the required triggerName parameter is not provided or if triggerName specifies a JMS trigger that does not exist
  - JMSTriggerFacade
```
public JMSTriggerFacade()
```
    Instantiates an empty JMSTriggerFacade. This is only useful when you wish to create a new trigger from scratch.
    Note: All getter methods will return null, false, or zero (0) if JMSTriggerFacade is instantiated with this constructor.
- Method Detail
  - getTriggerName
```
public java.lang.String getTriggerName()
```
    Returns the fully qualified name of the referenced JMS trigger.
    
    Returns:
    
    a String specifying the name of the JMS trigger
  - getAcknowledgeMode
```
public int getAcknowledgeMode()
```
    Returns the acknowledgment mode which indicates how or when the session acknowledges receipt of a message to the JMS provider.
    
    Returns:
    
    an int specifying the acknowledgement mode of the trigger. AUTO_ACKNOWLEDGE = 1; CLIENT_ACKNOWLEDGE = 2; DUPS_OK_ACKNOWLEDGE = 3
  - getAliasName
```
public java.lang.String getAliasName()
```
    Returns the name of the JMS connection alias used by the JMS trigger to receive messages from the JMS provider.
    
    Returns:
    
    a String with the JMS connection alias the JMS trigger uses to connect to and receive messages from the JMS provider
  - getBatchSize
```
public int getBatchSize()
```
    Returns the JMS trigger's batch size, which indicates the maximum number of messages that the associated trigger service can receive at one time.
    Batch processing can be an effective way of handling a high volume of small messages for the purposes of persisting them or delivering them to another back-end resource. For example, you might want to take a batch of messages, create a packet of SAP IDocs, and send the packet to SAP with a single call. Alternatively, you might want to insert multiple messages into a database at one time using only one insert. The trigger service processes the messages as a unit as opposed to in a series.
    Integration Server acknowledges all the messages received in a batch from the JMS provider at one time.
    
    Returns:
    
    an int that specifies the maximum number of messages the trigger service can receive as input at one time
  - isConcurrent
```
public boolean isConcurrent()
```
    Returns a boolean that indicates the message processing mode used by the JMS trigger.
    
    Returns:
    
    true if concurrent; false if serial
  - getConsumersCurrentThreadCount
```
public int getConsumersCurrentThreadCount()
```
    Returns the number of threads currently receiving and processing messages for the JMS trigger.
    Serial JMS triggers have one consumer and will use one thread from the server thread pool to receive and process a message.
    Concurrent JMS triggers use a pool of consumers to receive and process messages. Each consumer uses one thread from the server thread pool to receive and process a message. For a concurrent JMS trigger, Integration Server also dedicates a thread to managing the pool of consumers. Consequently, the maximum number of threads that can be used by a JMS trigger is equal to the Max execution threads value plus 1. For example, a concurrent JMS trigger configured to process up to 10 messages at a time can use a maximum of 11 server threads.
    
    Returns:
    
    an int specifying the number of threads actively receiving or processing messages for a JMS trigger; disabled triggers will return -1
  - isEnabled
```
public boolean isEnabled()
```
    Returns a boolean indicating whether or not the JMS trigger is enabled. Note that a JMS trigger can be enabled even if retrieval and processing have been suspended. To determine the processing state, call getState().
    
    Returns:
    
    true if the JMS trigger is enabled; false if it is disabled.
    
    See Also:
    
    getState()
  - getExecuteUser
```
public java.lang.String getExecuteUser()
```
    Returns the name of the user account whose credentials Integration Server uses to execute the trigger service associated with the JMS trigger. Integration Server checks the credentials and user group membership of the user account against the Execute ACL assigned to the service.
    
    Returns:
    
    a String containing the user account whose credentials Integration Server should supply when invoking a JMS trigger service
  - getDestinationFilterPairs
```
public java.util.ArrayList<JMSDestinationFilterPair> getDestinationFilterPairs()
```
    Gets a java.util.ArrayList of JMSDestnationFilterPair objects that specify the destinations from which the JMS trigger receives messages and the message selector the JMS provider uses to filter messages from each destination.
    
    Returns:
    
    a java.util.ArrayList of JMSDetinationFilterPair objects that specify each destination from which a JMS trigger receives messages and the message selector the JMS provider uses to filter the messages received from each destination
  - getInDoubtDetection
```
public boolean getInDoubtDetection()
```
    Returns a boolean indicating whether duplicate detection is enabled for persistent messages received by the JMS trigger. Integration Server can only perform duplicate detection for JMS triggers with an acknowledgment mode set to CLIENT_ACKNOWLEDGE.
    
    Returns:
    
    true if duplicate detection is enabled; false if duplicate detection is disabled
  - getJoinTimeout
```
public long getJoinTimeout()
```
    Returns the length of the join time out value (measured in milliseconds) for the JMS trigger
    
    Returns:
    
    a long indicating the number of milliseconds Integration Server waits for messages from the other destinations specified in the join after Integration Server receives the first message from a specified destination. A value of -1 indicates that the join does not expire.
  - getJoinType
```
public int getJoinType()
```
    Returns the type of join for the JMS trigger.
    - AND. Specifies that Integration Server invokes the trigger service when the JMS trigger receives a message from every destination within the join time-out period.
    - XOR. Specifies that Integration Server invokes the trigger service when it receives a message from any of the specified destinations. For the duration of the join time-out period, the Integration Server discards any messages with the same activation that the JMS trigger receives from the specified destinations.
    - OR. Specifies that Integration Server invokes the trigger service when the trigger receives a message from any of the specified destinations. This is the default join type.
    Returns:
    
    an int representing the join type. AND = 1; XOR = 2; OR = 3 The default is 3.
  - getLastError
```
public java.lang.Throwable getLastError()
```
    Returns the last error thrown while executing the JMS trigger.
    
    Returns:
    
    a java.lang.Throwable for the last error thrown for the JMS trigger
  - getMaxConcurrentThreads
```
public int getMaxConcurrentThreads()
```
    Returns the maximum number of server threads that can process messages for this JMS trigger at one time.
    Serial JMS triggers use one thread at a time pool to receive and process a message.
    Concurrent JMS triggers can use multiple server threads to receive and process messages at one time.
    
    Returns:
    
    an int specifying the maximum number of server threads that can process messages for this JMS trigger concurrently.
  - getMaxDeliveryAttempts
```
public int getMaxDeliveryAttempts()
```
    Returns the maximum number of retry attempts Integration Server will make for a trigger service invoked by this JMS trigger. Integration Service retries a trigger service only when it fails because of a transient exception. That is, if the trigger service fails because an ISRuntimeException caused a transient error, Integration Server re-execute the trigger service after waiting a specified amount of time.
    Transient error handling, including specifying retry attempts, can be configured for non-transacted JMS triggers only.
    
    Returns:
    
    an int specifying the maximum number of attempts that Integration Server makes to retry a trigger service for this JMS trigger; 0 indicates the trigger service does not retry
    
    See Also:
    
    JMSTriggerFacade.setMaxDeliveryAttempts
  - getPrefetchSize
```
public int getPrefetchSize()
```
    Deprecated. No replacement. webMethods Broker is deprecated, which results in the deprecation of this method.
    
    Returns the maximum number of messages that Integration Server retrieves for this trigger at one time from the webMethods Broker. Integration Server uses the value of the watt.server.jms.trigger.maxPrefetchSize parameter as the global value for all JMS triggers. The default value of this parameter is 10.
    Note: This method is only applicable when retrieving messages from the webMethods Broker.
    Use the setPrefetchSize(int) method to change the prefetch value for a specific JMS trigger.
    
    Returns:
    
    an int specifying the maximum number of messages for this JMS trigger that Integration Server receives from the webMethods JMS provider at one time. Returns -1 if the value of the watt.server.jms.trigger.maxPrefetch size is used as the prefetch cache size.
    
    See Also:
    
    setPrefetchSize(int)
  - getRedeliveryDelay
```
public long getRedeliveryDelay()
```
    Returns the number of milliseconds Integration Server waits between attempts to retry a trigger service for this JMS trigger. Integration Server retries a trigger service if the JMS trigger is configured to retry when a transient error occurs.
    
    Returns:
    
    a long for the number of milliseconds between retry attempts; 0 indicates the trigger service does not retry
  - getRedeliveryFailureAction
```
public int getRedeliveryFailureAction()
```
    Returns an int that indicates what action Integration Server takes when retry failure occurs for a non-transacted JMS trigger or a transient error occurs for a transacted JMS trigger.
    For a non-transacted JMS trigger, Integration Server can do one of the following
    - Throw Exception. When Integration Server reaches the maximum number of retry attempts, Integration Server treats the last trigger service failure as a service error. This is the default behavior.
    - Suspend and Retry Later. When Integration Server reaches the maximum number of retry attempts, Integration Server suspends the trigger and then retries the trigger service at a later time.
    For a transacted JMS trigger, Integration Server can do one of the following:
    - Recover Only. After a transaction is rolled back, Integration Server receives the message from the JMS provider almost immediately.
    - Suspend and Recover. After a transaction is rolled back, Integration Server suspends the JMS trigger and receives the message from the JMS provider at a later time.
    Returns:
    
    For a non-transacted JMS trigger, Throw Exception = 0; Suspend and Retry Later = 1. For a transacted JMS trigger, Recover Only = 0; Suspend and Recover = 1.
  - getResolutionHistoryTTL
```
public long getResolutionHistoryTTL()
```
    Returns a long specifying the number of milliseconds the document history database maintains an entry for a message processed by this trigger. This value determines the length of the duplicate detection window.
    
    Returns:
    
    a long indicating the time to live (measured in milliseconds) for a document history entry created for a message processed by this JMS trigger; 0 if document history is not used to perform duplicate detection
  - getResolverServiceName
```
public NSName getResolverServiceName()
```
    Returns the name of the document resolver service for the JMS trigger. Integration Server uses the document resolver service as the final method of duplicate detection.
    
    Returns:
    
    an NSName object specifying the namespace name of the document resolver service; null if no document resolver service is specified
  - getResolveWithHistory
```
public boolean getResolveWithHistory()
```
    Returns a boolean indicating whether a document history database is used as part of duplicate detection.
    The document history database maintains a history of the persistent messages processed by JMS triggers. Integration Server adds an entry to the document history database when a trigger service begins executing and when it executes to completion (whether it ends in success or failure). The document history database contains message processing information only for triggers for which the Use history property is set to true.
    
    Returns:
    
    true if document history database is used; otherwise false
  - getResourceMonitoringSvcName
```
public NSName getResourceMonitoringSvcName()
```
    Returns the name of the resource monitoring service for the JMS trigger. A resource monitoring service is a service that you create to check the availability of resources used by a trigger. Integration Server schedules a system task to execute a resource monitoring service after it suspends a trigger.
    
    Returns:
    
    an NSName object specifying the namespace name of resource monitoring service; null if a resource monitoring service is not specified
  - getRoutingRules
```
public java.util.ArrayList<JMSRoutingRule> getRoutingRules()
```
    Gets a java.util.ArrayList of JMSRoutingRule objects that specify the routing rules for messages received by a JMS trigger. When a JMS trigger receives a message from the JMS provider, it executes the trigger service specified in a routing rule. If the JMS trigger lists multiple routing rules, Integration Server applies the local filter to the message to determine which trigger service to execute. If the message does not meet the filter criteria in any of the routing rules, Integration Server discards the message and acknowledges the message to the JMS provider.
    
    Returns:
    
    an array list of JMSRoutingRule objects
  - getSuspendOnError
```
public boolean getSuspendOnError()
```
    Returns a boolean indicating whether Integration Server suspends a JMS trigger automatically if a fatal error occurs during trigger service execution. A fatal error occurs when the trigger service ends because of an exception.
    
    Returns:
    
    true if Integration Server suspends a JMS trigger when a fatal error occurs; otherwise false
  - getState
```
public int getState()
```
    Returns an int specifying the state of a JMS trigger. A JMS trigger can have one of the following states:
    - Enabled. The JMS trigger is running and connected to the JMS provider. Integration Server retrieves and processes messages for the JMS trigger.
    - Disabled. The JMS trigger is stopped. Integration Server neither retrieves nor processes messages for the JMS trigger.
    - Suspended. The JMS trigger is running and connected to the JMS provider. Integration Server has stopped message retrieval, but continues processing any messages it has already retrieved.
    Returns:
    
    Enabled = 0; Disabled = 1; Suspended = 2
  - getTotalThrottledThreads
```
public int getTotalThrottledThreads()
```
    Returns the current number of server threads that can be used to process JMS triggers as determined by the Thread Pool Throttle.
    
    Returns:
    
    an int specifying the maximum number of server threads that can be devoted to trigger processing at one time
  - setAcknowledgmentMode
```
public void setAcknowledgmentMode(int acknowledgeMode)
```
    Sets the acknowledgement mode for a JMS trigger, which indicates how Integration Server acknowledges messages received on behalf of a JMS trigger. A message is not considered to be successfully consumed until it is acknowledged. Acknowledgement mode can be one of the following:
    AUTO_ACKNOWLEDGE Automatically acknowledges the message when it is received by the JMS trigger. Integration Server will acknowledge the message before the trigger completes processing. The JMS provider cannot redeliver the message if Integration Server becomes unavailable before message processing completes.
    CLIENT_ACKNOWLEDGE Acknowledges or recovers the message only after the JMS trigger processes the message completely.
    DUPS_OK_ACKNOWLEDGE Lazily acknowledges the delivery of messages. This may result in the delivery of duplicate messages.
    
    Parameters:
    
    acknowledgeMode - an int representing the acknowledgement mode; AUTO_ACKNOWLEDGE = 1; CLIENT_ACKNOWLEDGE = 2; DUPS_OK_ACKNOWLEDGE = 3
  - setAliasName
```
public void setAliasName(java.lang.String aliasName)
```
    Sets the name of the JMS connection alias that the JMS trigger uses to connect to the JMS provider.
    
    Parameters:
    
    aliasName - a String for the JMS connection alias
  - setBatchSize
```
public void setBatchSize(int batchSize)
```
    Sets the maximum batch size for a JMS trigger. The batch size indicates the maximum number of messages that the trigger service can receive at one time. For example, if the batch size is set to 5, Integration Server passes the trigger service up to 5 messages received by the JMS trigger to process during a single execution.
    When setting batch processing, keep the following in mind:
    The trigger service must be coded to handle multiple messages as input. That is, the trigger service must use the pub.jms.batchTriggerSpec as the service signature.
    When receiving a batch of messages, Integration Server evaluates the local filter in the routing rule against the first message in the batch only.
    The JMS trigger must not be part of a transaction. The JMS connection alias specified by the trigger must have a transaction type of NO TRANSACTION.
    A JMS trigger that contains an All (AND) or Only one (XOR) join cannot use batch processing.
    
    Parameters:
    
    batchSize - an int for the batch size for the JMS trigger. If you do not want Integration Server to perform batch processing for this JMS trigger, specify 1. If this JMS trigger uses a transacted JMS connection alias, the batchSize must be set to 1.
  - setConcurrent
```
public void setConcurrent(boolean flag)
```
    Sets the message processing of a JMS trigger to serial or concurrent processing. In serial processing, Integration Server processes messages received by the trigger one after the other. In concurrent processing, Integration Server processes multiple messages for this trigger at one time
    
    Parameters:
    
    flag - a boolean indicating whether the JMS trigger processes messages concurrently or serially. Specify true for concurrent processing; false for serial processing.
  - setDestinationFilterPairs
```
public void setDestinationFilterPairs(java.util.ArrayList<JMSDestinationFilterPair> pairs)
```
    Specifies the destinations from which the JMS trigger receives messages and the message selector the JMS provider uses to filter messages from each destination.
    The message selector must use the message selector syntax specified in the Java Message Service, Version 1.1. The message selector can reference header and property fields in the JMS message only.
    
    Parameters:
    
    pairs - a java.util.ArrayList of JMSDetinationFilterPair objects that specify the destinations from which the JMS trigger receives messages and the message selector that the JMS provider uses to limit the messages received by the JMS trigger.
  - setEnabled
```
public void setEnabled(boolean enabled)
```
    Enables or disables the JMS trigger. An enabled JMS trigger is running and connected to the JMS provider. Integration Server retrieves and processes messages for the JMS trigger. A disabled JMS trigger is stopped. Integration Server neither retrieves nor processes messages for the JMS trigger.
    
    Parameters:
    
    enabled - a boolean for enabling or disabling the JMS trigger. Specify true to enable; false to disable
  - setExecuteUser
```
public void setExecuteUser(java.lang.String executeUser)
```
    Sets the execution user for a JMS trigger. Integration Server uses the credentials associated with the specified execution user when invoking services associated with the JMS trigger. Make sure that the user account you select includes the credentials required by the execute ACL assigned to the services associated with the JMS triggers.
    
    Parameters:
    
    executeUser - a String for the name of the user account whose credentials Integration Server uses to execute a service associated with the JMS trigger. You can specify a locally defined user account or a user account defined in a central or external directory.
  - setInDoubtDetection
```
public void setInDoubtDetection(boolean flag)
```
    Enables or disables duplicate detection for the JMS trigger. Duplicate detection determines whether the current message is a copy of one previously processed by the trigger. Integration Server performs duplicate detection as part of providing exactly-once processing.
    
    Parameters:
    
    flag - a boolean to enable or disable duplicate detection. Set to true to enable; false to disable.
  - setJoinTimeout
```
public void setJoinTimeout(long timeout)
```
    Sets the length of the join time-out. The join time-out indicates whether a join times out and if it does, what the time-out period should be. The time-out period indicates how long Integration Server waits for messages from the other destinations specified in the join after Integration Server receives the first message.
    A join time-out only applies when the JMS trigger receives messages from multiple destinations and specifies an And (ALL) or Only one (XOR) join type. A join time-out for an All (AND) join specifies how long Integration Server waits for messages from all of the destinations specified in the join. A join time-out for an Only one (XOR) join specifies how long Integration Server discards instances of the other messages received from the specified destinations.
    
    Parameters:
    
    timeout - a long indicating the length of the join time-out measured in seconds. Set to -1 if you do not want the join to expire.
  - setJoinType
```
public void setJoinType(int joinType)
```
    Sets the join type for a JMS trigger. A JMS trigger has a join when it receives messages from multiple destinations.
    - AND. Specifies that Integration Server invokes the trigger service when the JMS trigger receives a message from every destination within the join time-out period.
    - OR. Specifies that Integration Server invokes the trigger service when the trigger receives a message from any of the specified destinations. This is the default join type.
    - XOR. Specifies that Integration Server invokes the trigger service when it receives a message from any of the specified destinations. For the duration of the join time-out period, the Integration Server discards any messages with the same activation that the JMS trigger receives from the specified destinations.
    Parameters:
    
    joinType - an int to specify the join type for a JMS trigger that receives messages from multiple destinations; AND = 1; XOR = 2; OR = 3. The default is 3.
  - setMaxConcurrentThreads
```
public void setMaxConcurrentThreads(int maxConcurrent)
```
    Sets the maximum number of messages that Integration Server can process concurrently for this JMS trigger.
    
    Parameters:
    
    maxConcurrent - an int for the maximum number of messages that Integration Server can process at one time for this concurrent JMS trigger
  - setMaxDeliveryAttempts
```
public void setMaxDeliveryAttempts(int maxRedeliveryAttempts)
```
    Sets the maximum number of attempts Integration Server makes to re-execute a trigger service if the trigger service failed because of a transient error.
    
    Parameters:
    
    maxRedeliveryAttempts - an int indicating the maximum number of times Integration Server should attempt to re-execute the trigger service. Set to 0 if you do not want Integration Server to retry the trigger service.
  - setPrefetchSize
```
public void setPrefetchSize(int prefetchSize)
```
    Sets the maximum number of messages that Integration Server retrieves for this JMS trigger at one time from the webMethods Broker.
    Note: This method is only applicable when retrieving messages from the webMethods Broker.
    
    Parameters:
    
    prefetchSize - an int for the maximum number of messages Integration Server fetches for this JMS trigger from the JMS provider at one time. The prefetchSize must be greater than 0. Set to -1 to use the value of watt.server.jms.trigger.maxPrefetchSize as the prefetch size.
  - setRedeliveryDelay
```
public void setRedeliveryDelay(long redeliveryDelay)
```
    Sets the time interval Integration Server waits between retry attempts for a trigger service that failed because of a transient error.
    
    Parameters:
    
    redeliveryDelay - a long specifying the number of milliseconds Integration Server waits before retrying a trigger service that failed because of a transient error (ISRuntimException).
  - setRedeliveryFailureAction
```
public void setRedeliveryFailureAction(int redeliveryFailureAction)
```
    Determines what action Integration Server takes when retry failure occurs for a non-transacted JMS trigger or a transient error occurs for a transacted JMS trigger.
    For a non-transacted JMS trigger, Integration Server can do one of the following:
    - Throw Exception. When Integration Server reaches the maximum number of retry attempts, Integration Server treats the last trigger service failure as a service error. This is the default behavior.
    - Suspend and Retry Later. When Integration Server reaches the maximum number of retry attempts, Integration Server suspends the trigger and then retries the trigger service at a later time.
    For a transacted JMS trigger, Integration Server can do one of the following:
    - Recover Only. After a transaction is rolled back, Integration Server receives the message from the JMS provider almost immediately.
    - Suspend and Recover. After a transaction is rolled back, Integration Server suspends the JMS trigger and receives the message from the JMS provider at a later time.
    Parameters:
    
    redeliveryFailureAction - an int indicating how Integration Server responds when retry failure occurs for a trigger service executed by this JMS trigger. For a non-transacted JMS trigger, Throw Exception = 0; Suspend and Retry Later = 1. For a transacted JMS trigger, Recover Only = 0; Suspend and Recover = 1.
  - setResolutionHistoryTTL
```
public void setResolutionHistoryTTL(long ttl)
```
    Sets the length of time the document history database maintains an entry for a message processed by this trigger. This value determines the length of the duplicate detection window.
    
    Parameters:
    
    ttl - a long specifying the number of milliseconds for which the document history database maintains an entry for a message processed by this JMS trigger
    
    See Also:
    
    setResolveWithHistory(boolean)
  - setResolverServiceName
```
public void setResolverServiceName(NSName name)
```
    Sets the name of the document resolver service for the JMS trigger. Integration Server uses the document resolver service as the final method of duplicate detection.
    
    Parameters:
    
    name - an NSName object specifying the namespace name of the document resolver service
  - setResolveWithHistory
```
public void setResolveWithHistory(boolean flag)
```
    Determines whether a document history database is used as part of duplicate detection.
    The document history database maintains a history of the persistent messages processed by JMS triggers. Integration Server adds an entry to the document history database when a trigger service begins executing and when it executes to completion (whether it ends in success or failure). The document history database contains message processing information only for triggers for which the Use history property is set to true.
    
    Parameters:
    
    flag - A boolean indicating whether a document history database is used. True if one is used; otherwise false.
  - setResourceMonitoringSvcName
```
public void setResourceMonitoringSvcName(NSName resourceMonitoringSvcName)
```
    Sets the resource monitoring service for the JMS trigger. A resource monitoring service is a service that you create to check the availability of resources used by a trigger. Integration Server schedules a system task to execute a resource monitoring service after it suspends a trigger.
    
    Parameters:
    
    resourceMonitoringSvcName - an NSName object specifying the namespace name of resource monitoring service
  - setRoutingRules
```
public void setRoutingRules(java.util.ArrayList<JMSRoutingRule> rules)
```
    Specifies the routing rules for the messages received by the JMS trigger. A routing rule consists of a trigger service and optionally, a local filter. A local filter specifies criteria for the contents of the message body. When a JMS trigger receives a message from the JMS provider, it executes the trigger service specified in a routing rule. If the JMS trigger lists multiple routing rules, Integration Server applies the local filter to the message to determine which trigger service to execute. If the message does not meet the filter criteria in any of the routing rules, Integration Server discards the message and acknowledges the message to the JMS provider.
    If a JMS trigger contains multiple routing rules to support ordered service execution, you can use local filters to process a series of messages in a particular order.
    When creating a local filter, you can exclude the JMSMessage document from the filter even though it is part of the pipeline provided to the JMS trigger service.
    
    Parameters:
    
    rules - a java.util.ArrayList of JMSRoutingRule objects that specify trigger service and local filter for each routing rule.
  - setSuspendOnError
```
public void setSuspendOnError(boolean flag)
```
    Sets a flag indicating whether the JMS trigger suspends automatically when a fatal exception occurs during trigger service execution. A fatal error occurs when the trigger service ends because of an exception.
    
    Parameters:
    
    flag - a boolean that specifies whether Integration Server suspends the JMS trigger when the trigger service ends because of a fatal exception. Set to true to suspend; otherwise false.
  - updateTrigger
```
public void updateTrigger()
                   throws JMSSubsystemException
```
    Updates the JMS trigger you indicated in the constructor with the changes you made by calling the setter methods. If the empty JMSTriggerFacade() constructor was used to create the JMSTriggerFacade object, there is no trigger to update. Call the createTrigger(String, String) method to create the JMS trigger with the properties specified in the setter methods. Note: Calling a setter method will have no impact on a JMS trigger until the updateTrigger() method is called.
    
    Throws:
    
    JMSSubsystemException - if the empty JMSTriggerFacade() constructor was used to create the JMSTriggerFacade object.
    
    See Also:
    
    createTrigger(String, String)
  - createTrigger
```
public void createTrigger(java.lang.String triggerName,
                          java.lang.String triggerPackage)
                   throws JMSSubsystemException
```
    Creates a JMS trigger in the namespace. The new JMS trigger will be created with the values of the JMS trigger you indicated in the constructor, plus any changes you made by calling the setter methods. If no trigger name was passed into the constructor then the JMS trigger will be created with the default values, plus any changes you made be calling the setter methods.
    
    Parameters:
    
    triggerName - a String specifying the folder and name of the JMS trigger. Separate folder names using a period; separate the node name using a colon. For example, folder.subfolder:JMSTriggerName
    
    triggerPackage - a String for the name of the package in which you want to place the new JMS Trigger
    
    Throws:
    
    JMSSubsystemException - if the triggerName and/or triggerPackage values are not provided; if the specified triggerPackage does not exist; if a trigger with the specified triggerName already exists; if the triggerName contains a restricted character; if the user creating the JMS trigger does not have sufficient permissions to create namespace elements;
  - suspendTrigger
```
public void suspendTrigger()
                    throws java.lang.Exception
```
    Suspends the JMS trigger. When a JMS trigger is suspended, the JMS trigger is running and connected to the JMS provider. Integration Server has stopped message retrieval, but continues processing any messages it has already retrieved. Suspends the JMS trigger until the trigger is manually resumed, the package containing the JMS trigger is reloaded, or the Integration Server restarts.
    
    Throws:
    
    java.lang.Exception - if an exception occurs
  - resumeTrigger
```
public void resumeTrigger()
                   throws java.lang.Exception
```
    Enables a JMS trigger that is currently suspended. This method will not enable a trigger that is currently disabled. To enable a disabled JMS trigger, use the enableTrigger() method.
    When a JMS trigger is enabled, it is running and connected to the JMS provider. Integration Server retrieves and processes messages for the JMS trigger.
    
    Throws:
    
    java.lang.Exception - if an exception occurs
    
    See Also:
    
    enableTrigger()
  - disableTrigger
```
public void disableTrigger()
                    throws java.lang.Exception
```
    Disables the JMS trigger. When a JMS trigger is disabled, it is stopped. Integration Server neither retrieves nor processes messages for the JMS trigger.
    
    Throws:
    
    java.lang.Exception - if an exception occurs
    
    See Also:
    
    enableTrigger()
  - enableTrigger
```
public void enableTrigger()
                   throws java.lang.Exception
```
    Enables the JMS trigger if it is currently suspended or disabled. When a JMS trigger is enabled, it is running and connected to the JMS provider. Integration Server retrieves and processes messages for the JMS trigger.
    
    Throws:
    
    java.lang.Exception - if an exception occurs
  - getSortedJMSTriggerNames
```
public static java.lang.String[] getSortedJMSTriggerNames()
```
    Returns a list of JMS triggers on Integration Server.
    
    Returns:
    
    a String[] of JMS trigger names
  - getAllAsData
```
public static IData getAllAsData()
                          throws JMSSubsystemException
```
    Get metadata and run-time information for all JMS triggers, including destinations, routing rules, configured properties, and global throttling configuration.
    
    Returns:
    
    an IData containing the JMS trigger names, property information, and adjusted concurrent thread values as set by the global JMS trigger throttle controls
    
    Throws:
    
    JMSSubsystemException
  - getAsData
```
public IData getAsData()
```
    Get metadata and run-time information for a single JMS trigger, including destinations, routing rules, configured properties, and global throttling configuration.
    
    Returns:
    
    an IData containing information about the trigger including destinations, routing rules, property values, and adjusted concurrent thread values as set by the global JMS trigger throttle controls

Class JMSTriggerFacade

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JMSTriggerFacade

JMSTriggerFacade

Method Detail

getTriggerName

getAcknowledgeMode

getAliasName

getBatchSize

isConcurrent

getConsumersCurrentThreadCount

isEnabled

getExecuteUser

getDestinationFilterPairs

getInDoubtDetection

getJoinTimeout

getJoinType

getLastError

getMaxConcurrentThreads

getMaxDeliveryAttempts

getPrefetchSize

getRedeliveryDelay

getRedeliveryFailureAction

getResolutionHistoryTTL

getResolverServiceName

getResolveWithHistory

getResourceMonitoringSvcName

getRoutingRules

getSuspendOnError

getState

getTotalThrottledThreads

setAcknowledgmentMode

setAliasName

setBatchSize

setConcurrent

setDestinationFilterPairs

setEnabled

setExecuteUser

setInDoubtDetection

setJoinTimeout

setJoinType

setMaxConcurrentThreads

setMaxDeliveryAttempts

setPrefetchSize

setRedeliveryDelay

setRedeliveryFailureAction

setResolutionHistoryTTL

setResolverServiceName

setResolveWithHistory

setResourceMonitoringSvcName

setRoutingRules

setSuspendOnError

updateTrigger

createTrigger

suspendTrigger

resumeTrigger

disableTrigger

enableTrigger

getSortedJMSTriggerNames

getAllAsData

getAsData