Script:
Owner:
Subdir: middlewarenews
Blog ID: 93013848
Group ID: User ID: 92249378

    IBM Websphere MQ - MQRC Reason Codes - Middleware News

    Tuesday, June 19, 2012, 12:40 PM
    Posted By: Karthick

    MQRC_* (Reason Codes)

    <td class="entry" valign="top"
    MQRC_NONE 0 X'00000000'
    MQRC_APPL_FIRST 900 X'00000384'
    MQRC_APPL_LAST 999 X'000003E7'
    MQRC_ALIAS_BASE_Q_TYPE_ERROR 2001 X'000007D1'
    MQRC_ALREADY_CONNECTED 2002 X'000007D2'
    MQRC_BACKED_OUT 2003 X'000007D3'
    MQRC_BUFFER_ERROR 2004 X'000007D4'
    MQRC_BUFFER_LENGTH_ERROR 2005 X'000007D5'
    MQRC_CHAR_ATTR_LENGTH_ERROR 2006 X'000007D6'
    MQRC_CHAR_ATTRS_ERROR 2007 X'000007D7'
    MQRC_CHAR_ATTRS_TOO_SHORT 2008 X'000007D8'
    MQRC_CONNECTION_BROKEN 2009 X'000007D9'
    MQRC_DATA_LENGTH_ERROR 2010 X'000007DA'
    MQRC_DYNAMIC_Q_NAME_ERROR 2011 X'000007DB'
    MQRC_ENVIRONMENT_ERROR 2012 X'000007DC'
    MQRC_EXPIRY_ERROR 2013 X'000007DD'
    MQRC_FEEDBACK_ERROR 2014 X'000007DE'
    MQRC_GET_INHIBITED 2016 X'000007E0'
    MQRC_HANDLE_NOT_AVAILABLE 2017 X'000007E1'
    MQRC_HCONN_ERROR 2018 X'000007E2'
    MQRC_HOBJ_ERROR 2019 X'000007E3'
    MQRC_INHIBIT_VALUE_ERROR 2020 X'000007E4'
    MQRC_INT_ATTR_COUNT_ERROR 2021 X'000007E5'
    MQRC_INT_ATTR_COUNT_TOO_SMALL 2022 X'000007E6'
    MQRC_INT_ATTRS_ARRAY_ERROR 2023 X'000007E7'
    MQRC_SYNCPOINT_LIMIT_REACHED 2024 X'000007E8'
    MQRC_MAX_CONNS_LIMIT_REACHED 2025 X'000007E9'
    MQRC_MD_ERROR 2026 X'000007EA'
    MQRC_MISSING_REPLY_TO_Q 2027 X'000007EB'
    MQRC_MSG_TYPE_ERROR 2029 X'000007ED'
    MQRC_MSG_TOO_BIG_FOR_Q 2030 X'000007EE'
    MQRC_MSG_TOO_BIG_FOR_Q_MGR 2031 X'000007EF'
    MQRC_NO_MSG_AVAILABLE 2033 X'000007F1'
    MQRC_NO_MSG_UNDER_CURSOR 2034 X'000007F2'
    MQRC_NOT_AUTHORIZED 2035 X'000007F3'
    MQRC_NOT_OPEN_FOR_BROWSE 2036 X'000007F4'
    MQRC_NOT_OPEN_FOR_INPUT 2037 X'000007F5'
    MQRC_NOT_OPEN_FOR_INQUIRE 2038 X'000007F6'
    MQRC_NOT_OPEN_FOR_OUTPUT 2039 X'000007F7'
    MQRC_NOT_OPEN_FOR_SET 2040 X'000007F8'
    MQRC_OBJECT_CHANGED 2041 X'000007F9'
    MQRC_OBJECT_IN_USE 2042 X'000007FA'
    MQRC_OBJECT_TYPE_ERROR 2043 X'000007FB'
    MQRC_OD_ERROR 2044 X'000007FC'
    MQRC_OPTION_NOT_VALID_FOR_TYPE 2045 X'000007FD'
    MQRC_OPTIONS_ERROR 2046 X'000007FE'
    MQRC_PERSISTENCE_ERROR 2047 X'000007FF'
    MQRC_PERSISTENT_NOT_ALLOWED 2048 X'00000800'
    MQRC_PRIORITY_EXCEEDS_MAXIMUM 2049 X'00000801'
    MQRC_PRIORITY_ERROR 2050 X'00000802'
    MQRC_PUT_INHIBITED 2051 X'00000803'
    MQRC_Q_DELETED 2052 X'00000804'
    MQRC_Q_FULL 2053 X'00000805'
    MQRC_Q_NOT_EMPTY 2055 X'00000807'
    MQRC_Q_SPACE_NOT_AVAILABLE 2056 X'00000808'
    MQRC_Q_TYPE_ERROR 2057 X'00000809'
    MQRC_Q_MGR_NAME_ERROR 2058 X'0000080A'
    MQRC_Q_MGR_NOT_AVAILABLE 2059 X'0000080B'
    MQRC_REPORT_OPTIONS_ERROR 2061 X'0000080D'
    MQRC_SECOND_MARK_NOT_ALLOWED 2062 X'0000080E'
    MQRC_SECURITY_ERROR 2063 X'0000080F'
    MQRC_SELECTOR_COUNT_ERROR 2065 X'00000811'
    MQRC_SELECTOR_LIMIT_EXCEEDED 2066 X'00000812'
    MQRC_SELECTOR_ERROR 2067 X'00000813'
    MQRC_SELECTOR_NOT_FOR_TYPE 2068 X'00000814'
    MQRC_SIGNAL_OUTSTANDING 2069 X'00000815'
    MQRC_SIGNAL_REQUEST_ACCEPTED 2070 X'00000816'
    MQRC_STORAGE_NOT_AVAILABLE 2071 X'00000817'
    MQRC_SYNCPOINT_NOT_AVAILABLE 2072 X'00000818'
    MQRC_TRIGGER_CONTROL_ERROR 2075 X'0000081B'
    MQRC_TRIGGER_DEPTH_ERROR 2076 X'0000081C'
    MQRC_TRIGGER_MSG_PRIORITY_ERR 2077 X'0000081D'
    MQRC_TRIGGER_TYPE_ERROR 2078 X'0000081E'
    MQRC_TRUNCATED_MSG_ACCEPTED 2079 X'0000081F'
    MQRC_TRUNCATED_MSG_FAILED 2080 X'00000820'
    MQRC_UNKNOWN_ALIAS_BASE_Q 2082 X'00000822'
    MQRC_UNKNOWN_OBJECT_NAME 2085 X'00000825'
    MQRC_UNKNOWN_OBJECT_Q_MGR 2086 X'00000826'
    MQRC_UNKNOWN_REMOTE_Q_MGR 2087 X'00000827'
    MQRC_WAIT_INTERVAL_ERROR 2090 X'0000082A'
    MQRC_XMIT_Q_TYPE_ERROR 2091 X'0000082B'
    MQRC_XMIT_Q_USAGE_ERROR 2092 X'0000082C'
    MQRC_NOT_OPEN_FOR_PASS_ALL 2093 X'0000082D'
    MQRC_NOT_OPEN_FOR_PASS_IDENT 2094 X'0000082E'
    MQRC_NOT_OPEN_FOR_SET_ALL 2095 X'0000082F'
    MQRC_NOT_OPEN_FOR_SET_IDENT 2096 X'00000830'
    MQRC_CONTEXT_HANDLE_ERROR 2097 X'00000831'
    MQRC_CONTEXT_NOT_AVAILABLE 2098 X'00000832'
    MQRC_SIGNAL1_ERROR 2099 X'00000833'
    MQRC_OBJECT_ALREADY_EXISTS 2100 X'00000834'
    MQRC_OBJECT_DAMAGED 2101 X'00000835'
    MQRC_RESOURCE_PROBLEM 2102 X'00000836'
    MQRC_ANOTHER_Q_MGR_CONNECTED 2103 X'00000837'
    MQRC_UNKNOWN_REPORT_OPTION 2104 X'00000838'
    MQRC_STORAGE_CLASS_ERROR 2105 X'00000839'
    MQRC_COD_NOT_VALID_FOR_XCF_Q 2106 X'0000083A'
    MQRC_XWAIT_CANCELED 2107 X'0000083B'
    MQRC_XWAIT_ERROR 2108 X'0000083C'
    MQRC_SUPPRESSED_BY_EXIT 2109 X'0000083D'
    MQRC_FORMAT_ERROR 2110 X'0000083E'
    MQRC_SOURCE_CCSID_ERROR 2111 X'0000083F'
    MQRC_SOURCE_INTEGER_ENC_ERROR 2112 X'00000840'
    MQRC_SOURCE_DECIMAL_ENC_ERROR 2113 X'00000841'
    MQRC_SOURCE_FLOAT_ENC_ERROR 2114 X'00000842'
    MQRC_TARGET_CCSID_ERROR 2115 X'00000843'
    MQRC_TARGET_INTEGER_ENC_ERROR 2116 X'00000844'
    MQRC_TARGET_DECIMAL_ENC_ERROR 2117 X'00000845'
    MQRC_TARGET_FLOAT_ENC_ERROR 2118 X'00000846'
    MQRC_NOT_CONVERTED 2119 X'00000847'
    MQRC_CONVERTED_MSG_TOO_BIG 2120 X'00000848'
    MQRC_TRUNCATED 2120 X'00000848'
    MQRC_NO_EXTERNAL_PARTICIPANTS 2121 X'00000849'
    MQRC_PARTICIPANT_NOT_AVAILABLE 2122 X'0000084A'
    MQRC_OUTCOME_MIXED 2123 X'0000084B'
    MQRC_OUTCOME_PENDING 2124 X'0000084C'
    MQRC_BRIDGE_STARTED 2125 X'0000084D'
    MQRC_BRIDGE_STOPPED 2126 X'0000084E'
    MQRC_ADAPTER_STORAGE_SHORTAGE 2127 X'0000084F'
    MQRC_UOW_IN_PROGRESS 2128 X'00000850'
    MQRC_ADAPTER_CONN_LOAD_ERROR 2129 X'00000851'
    MQRC_ADAPTER_SERV_LOAD_ERROR 2130 X'00000852'
    MQRC_ADAPTER_DEFS_ERROR 2131 X'00000853'
    MQRC_ADAPTER_DEFS_LOAD_ERROR 2132 X'00000854'
    MQRC_ADAPTER_CONV_LOAD_ERROR 2133 X'00000855'
    MQRC_BO_ERROR 2134 X'00000856'
    MQRC_DH_ERROR 2135 X'00000857'
    MQRC_MULTIPLE_REASONS 2136 X'00000858'
    MQRC_OPEN_FAILED 2137 X'00000859'
    MQRC_ADAPTER_DISC_LOAD_ERROR 2138 X'0000085A'
    MQRC_CNO_ERROR 2139 X'0000085B'
    MQRC_CICS_WAIT_FAILED 2140 X'0000085C'
    MQRC_DLH_ERROR 2141 X'0000085D'
    MQRC_HEADER_ERROR 2142 X'0000085E'
    MQRC_SOURCE_LENGTH_ERROR 2143 X'0000085F'
    MQRC_TARGET_LENGTH_ERROR 2144 X'00000860'
    MQRC_SOURCE_BUFFER_ERROR 2145 X'00000861'
    MQRC_TARGET_BUFFER_ERROR 2146 X'00000862'
    MQRC_IIH_ERROR 2148 X'00000864'
    MQRC_PCF_ERROR 2149 X'00000865'
    MQRC_DBCS_ERROR 2150 X'00000866'
    MQRC_OBJECT_NAME_ERROR 2152 X'00000868'
    MQRC_OBJECT_Q_MGR_NAME_ERROR 2153 X'00000869'
    MQRC_RECS_PRESENT_ERROR 2154 X'0000086A'
    MQRC_OBJECT_RECORDS_ERROR 2155 X'0000086B'
    MQRC_RESPONSE_RECORDS_ERROR 2156 X'0000086C'
    MQRC_ASID_MISMATCH 2157 X'0000086D'
    MQRC_PMO_RECORD_FLAGS_ERROR 2158 X'0000086E'
    MQRC_PUT_MSG_RECORDS_ERROR 2159 X'0000086F'
    MQRC_CONN_ID_IN_USE 2160 X'00000870'
    MQRC_Q_MGR_QUIESCING 2161 X'00000871'
    MQRC_Q_MGR_STOPPING 2162 X'00000872'
    MQRC_DUPLICATE_RECOV_COORD 2163 X'00000873'
    MQRC_PMO_ERROR 2173 X'0000087D'
    MQRC_API_EXIT_NOT_FOUND 2182 X'00000886'
    MQRC_API_EXIT_LOAD_ERROR 2183 X'00000887'
    MQRC_REMOTE_Q_NAME_ERROR 2184 X'00000888'
    MQRC_INCONSISTENT_PERSISTENCE 2185 X'00000889'
    MQRC_GMO_ERROR 2186 X'0000088A'
    MQRC_CICS_BRIDGE_RESTRICTION 2187 X'0000088B'
    MQRC_STOPPED_BY_CLUSTER_EXIT 2188 X'0000088C'
    MQRC_CLUSTER_RESOLUTION_ERROR 2189 X'0000088D'
    MQRC_CONVERTED_STRING_TOO_BIG 2190 X'0000088E'
    MQRC_TMC_ERROR 2191 X'0000088F'
    MQRC_PAGESET_FULL 2192 X'00000890'
    MQRC_STORAGE_MEDIUM_FULL 2192 X'00000890'
    MQRC_PAGESET_ERROR 2193 X'00000891'
    MQRC_NAME_NOT_VALID_FOR_TYPE 2194 X'00000892'
    MQRC_UNEXPECTED_ERROR 2195 X'00000893'
    MQRC_UNKNOWN_XMIT_Q 2196 X'00000894'
    MQRC_UNKNOWN_DEF_XMIT_Q 2197 X'00000895'
    MQRC_DEF_XMIT_Q_TYPE_ERROR 2198 X'00000896'
    MQRC_DEF_XMIT_Q_USAGE_ERROR 2199 X'00000897'
    MQRC_MSG_MARKED_BROWSE_CO_OP 2200 X'00000898'
    MQRC_NAME_IN_USE 2201 X'00000899'
    MQRC_CONNECTION_QUIESCING 2202 X'0000089A'
    MQRC_CONNECTION_STOPPING 2203 X'0000089B'
    MQRC_ADAPTER_NOT_AVAILABLE 2204 X'0000089C'
    MQRC_MSG_ID_ERROR 2206 X'0000089E'
    MQRC_CORREL_ID_ERROR 2207 X'0000089F'
    MQRC_FILE_SYSTEM_ERROR 2208 X'000008A0'
    MQRC_NO_MSG_LOCKED 2209 X'000008A1'
    MQRC_SOAP_DOTNET_ERROR 2210 X'000008A2'
    MQRC_SOAP_AXIS_ERROR 2211 X'000008A3'
    MQRC_SOAP_URL_ERROR 2212 X'000008A4'
    MQRC_FILE_NOT_AUDITED 2216 X'000008A8'
    MQRC_CONNECTION_NOT_AUTHORIZED 2217 X'000008A9'
    MQRC_MSG_TOO_BIG_FOR_CHANNEL 2218 X'000008AA'
    MQRC_CALL_IN_PROGRESS 2219 X'000008AB'
    MQRC_RMH_ERROR 2220 X'000008AC'
    MQRC_Q_MGR_ACTIVE 2222 X'000008AE'
    MQRC_Q_MGR_NOT_ACTIVE 2223 X'000008AF'
    MQRC_Q_DEPTH_HIGH 2224 X'000008B0'
    MQRC_Q_DEPTH_LOW 2225 X'000008B1'
    MQRC_Q_SERVICE_INTERVAL_HIGH 2226 X'000008B2'
    MQRC_Q_SERVICE_INTERVAL_OK 2227 X'000008B3'
    MQRC_RFH_HEADER_FIELD_ERROR 2228 X'000008B4'
    MQRC_RAS_PROPERTY_ERROR 2229 X'000008B5'
    MQRC_UNIT_OF_WORK_NOT_STARTED 2232 X'000008B8'
    MQRC_CHANNEL_AUTO_DEF_OK 2233 X'000008B9'
    MQRC_CHANNEL_AUTO_DEF_ERROR 2234 X'000008BA'
    MQRC_CFH_ERROR 2235 X'000008BB'
    MQRC_CFIL_ERROR 2236 X'000008BC'
    MQRC_CFIN_ERROR 2237 X'000008BD'
    MQRC_CFSL_ERROR 2238 X'000008BE'
    MQRC_CFST_ERROR 2239 X'000008BF'
    MQRC_INCOMPLETE_GROUP 2241 X'000008C1'
    MQRC_INCOMPLETE_MSG 2242 X'000008C2'
    MQRC_INCONSISTENT_CCSIDS 2243 X'000008C3'
    MQRC_INCONSISTENT_ENCODINGS 2244 X'000008C4'
    MQRC_INCONSISTENT_UOW 2245 X'000008C5'
    MQRC_INVALID_MSG_UNDER_CURSOR 2246 X'000008C6'
    MQRC_MATCH_OPTIONS_ERROR 2247 X'000008C7'
    MQRC_MDE_ERROR 2248 X'000008C8'
    MQRC_MSG_FLAGS_ERROR 2249 X'000008C9'
    MQRC_MSG_SEQ_NUMBER_ERROR 2250 X'000008CA'
    MQRC_OFFSET_ERROR 2251 X'000008CB'

    [Edited By Moderator]

    0 (0 Ratings)

    IBM Announcement: End of Support for WebSphere MQ V6

    Tuesday, June 19, 2012, 12:11 PM
    Posted By: Karthick

    IBM Announcement: End of Support for WebSphere MQ V6 - Middleware News

    On September 30 2012, IBM will withdraw support for WebSphere MQ v6.0 under the International Program License Agreement (IPLA). The replacement product is WebSphere MQ for Multiplatforms V7.x.

    Content

    Support will be withdrawn for all Websphere MQ components including Server, Client and MQ Explorer of following platforms :

    Product Name Version General
    availability
    End of
    Support
    WebSphere MQ for AIX 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for HP-UX (Itanium) 6.0.x 02 Dec 2005 30 Sep 2012
    WebSphere MQ for HP-UX (PA-RISC) 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for iSeries 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for Linux (POWER) 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for Linux (x86) 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for Linux (x86-64) 6.0.x 02 Dec 2005 30 Sep 2012
    WebSphere MQ for Linux (zSeries) 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for Linux (zSeries s390x) 6.0.x 02 Dec 2005 30 Sep 2012
    WebSphere MQ for Solaris (SPARC) 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for Solaris (x86-64) 6.0.x 02 Dec 2005 30 Sep 2012
    WebSphere MQ for Windows 6.0.x 24 Jun 2005 30 Sep 2012
    WebSphere MQ for z/OS 6.0.x 24 Jun 2005 30 Sep 2012
    0 (0 Ratings)

    Processing messages with the WebSphere Application Server V7 and V8 WebSphere MQ messaging provider activation specifications

    Sunday, May 27, 2012, 10:09 AM
    Posted By: Karthick

    IBM® WebSphere® Application Server V7 and V8 provide support for asynchronous messaging based on the Java Message Service (JMS) specification. Using the WebSphere MQ messaging provider, you can write message-driven beans that listen on a WebSphere MQ destination (either a message queue or a topic). When a message arrives on the destination, the message-driven bean's onMessage() method is invoked to process the message.

    In WebSphere Application Server V7 and V8, the WebSphere MQ messaging provider supports the use of activation specifications to monitor destinations hosted by WebSphere MQ queue managers. This article shows how activation specifications connect to WebSphere MQ on distributed platforms, describes the mechanism used to monitor the destinations looking for messages, and then shows how message-driven beans are invoked after a suitable message has been detected. The article assumes a basic knowledge of JMS and WebSphere MQ.

    Activation specifications

    In general terms, J2C activation specifications are administered objects that contain information about how to connect to a JMS provider, along with details of the destination on that JMS provider that will be monitored for messages. When deploying an application that contains a message-driven bean, you need to specify the activation specification that the message-driven beans will use. When the activation specification starts up, it connects to a JMS provider, opens the JMS destination, and then monitors it looking for messages.

    Figures 1 and 2 below show a sample WebSphere MQ activation specification that has been defined using the activation specification panel in the WebSphere Application Server Integrated Solutions Console. When this activation specification starts up, it makes a BINDINGS mode connection to a local WebSphere MQ queue manager called pault, opens the destination jms/TestQueue, and then starts monitoring this destination for messages.


    Figure 1. Specifying the queue manager name and transport type
    Specifying the queue manager name and transport type

    Figure 2. Specifying the JMS destination that an activation specification will monitor
    Specifying the JMS destination that an activation specification will monitor

    Activation specifications can be configured to use message selectors, which enables them to only pass messages that meet the selection criteria to message-driven beans. In Figure 2 above, no message selector has been specified, and therefore all messages that arrive on the destination are suitable for processing by this activation specification.

    Once an activation specification finds a suitable message, it schedules a piece of work within the application server to process it. Each message requires a JMS server session in order to run, and multiple messages can be processed at the same time.

    Each activation specification has an associated server session pool, and its size controls the number of messages that can be processed concurrently by an activation specification. The default size of the server session pool is 10, which means that up to 10 messages can be processed at the same time by a single activation specification. To change the server session pool size, modify the activation specification advanced property Maximum server sessions, as shown in Figure 3:


    Figure 3. Specifying how many messages can be processed concurrently
    Specifying how many messages can be processed concurrently

    Detecting messages

    The mechanism that an activation specification uses to detect messages on JMS destinations hosted on a WebSphere MQ queue manager varies depending on the WebSphere MQ messaging provider mode that is being used, as described below.

    WebSphere MQ messaging provider normal mode

    Activation specifications use the WebSphere MQ messaging provider normal mode if they are connecting to a WebSphere MQ V7 queue manager and they have the Provider versionproperty set to either unspecified (the default value) or 7. In this mode of operation, the activation specification takes advantage of a number of the features of WebSphere MQ V7 when connecting to a queue manager and getting messages. When it starts up, the activation specification:

    1. Creates a connection to the WebSphere MQ queue manager it has been set up to use.
    2. If the activation specification is configured to use a Queue Destination, it opens the queue using the WebSphere MQ API call MQOPEN.
    3. If the activation specification has been configured to use a Topic Destination, it issues a WebSphere MQ API MQSUB call to subscribe to the appropriate topic.
    4. After the queue has been opened or the topic subscribed to, the activation specification uses the WebSphere MQ API call MQCB to register a callback. The callback is set up with the following WebSphere MQ GetMessageOptions:
      • MQGMO_BROWSE_FIRST
      • MQGMO_UNMARKED_BROWSE_MSG
      • MQGMO_MARK_BROWSE_CO_OP
    5. After the callback has been registered, the activation specification issues a WebSphere MQ MQCTL API call, which tells the queue manager that the activation specification is ready to start receiving messages.

    Now, when a suitable message arrives on the queue that the activation specification is monitoring, or is published on the topic that the activation specification has subscribed to, the queue manager marks the message to prevent any other activation specifications from seeing it, and then passes details of the message to the activation specification via the callback that was set up earlier.

    WebSphere MQ messaging provider migration mode

    The other way that activation specifications can connect to a WebSphere MQ queue manager is by using the WebSphere MQ messaging provider migration mode. This mode is used if one of the following conditions is true:

    • The activation specification is configured to connect to a WebSphere MQ V6 queue manager.
    • The activation specification is configured to connect to a WebSphere MQ V7 queue manager, and has the Provider Versionproperty set to 6.
    • The activation specification has been configured to connect to a WebSphere MQ V7 queue manager using the CLIENT transport, and is using a WebSphere MQ channel that has the Sharing Conversations (SHARECNV) property set to 0.

    When the activation specification starts up in migration mode, it:

    1. Creates a connection to the WebSphere MQ queue manager it has been set up to use.
    2. If the activation specification has been configured to monitor a Queue Destination, it issues an MQOPEN API call to open the queue.
    3. If the activation specification has been configured to use a Topic Destination, it:
      • Opens a subscription for the topic.
      • Checks the values of the activation specification Broker Properties Broker connection consumer subscription queue and Broker durable subscriber connection consumer queue to see which WebSphere MQ queue the Broker will publish messages for this activation specification to.
      • Calls the WebSphere MQ API MQOPEN to open the appropriate subscription queue.
    4. Once the queue has been opened on the queue manager, the activation specification browses the queue looking for messages by issuing a number of MQGET API calls. The activation specification uses a combination of the WebSphere MQ GetMessageOptions MQGMO_BROWSE_FIRST and MQGMO_BROWSE_NEXT to scan the queue from top to bottom.

    Processing messages

    When an activation specification has detected a message on a destination (either because a WebSphere MQ V7 queue manager has passed back information about a message via a callback, or because the activation specification has browsed a suitable message), it:

    1. Constructs a message reference that represents the message.
    2. Gets a server session from the activation specification server session pool.
    3. Loads up the server session with the message reference.
    4. Schedules a piece of work with the application server Work Manager.

    The activation specification then goes back to looking for more messages.

    Getting server sessions

    As mentioned earlier, activation specifications will process up to 10 messages concurrently by default. What happens if an activation specification tries to process a message and all 10 server sessions are already busy processing messages? In this situation, the activation specification will block until a server session becomes free. As soon as a server session is available, the activation specification loads it up with the message reference, and then schedules a new piece of work so the server session can run again.

    Scheduling work

    Once the activation specification loads a server session with a message reference, it schedules some work so that the message can be processed. What happens to the work? The Work Manager:

    1. Gets a thread from the WebSphere Application Server WebSphere MQ messaging provider Resource Adapter thread pool. The name of this thread pool is WMQJCAResourceAdapter.
    2. Runs the piece of work on this thread.

    After the work has been scheduled, the application server Work Manager will run this piece of work at some point in the future. The work, when started:

    1. Starts either a local or global (XA) transaction, depending on whether the message-driven bean requires XA transactions or not (specified in the message-driven bean's deployment descriptor).
    2. If this is the first time the server session has been used, it:
      • Creates a new connection to WebSphere MQ.
      • Issues an MQOPEN API call to open the queue where the message resides.
    3. Gets the message from WebSphere MQ by issuing a destructive MQGET API call.
    4. Runs the message-driven bean's onMessage() method.
    5. Once onMessage() has completed, the server session completes the local or global transaction before exiting.

    To improve performance, the connection to the queue manager that the server session uses is left open after the message has been processed and the work completed. Then, the next time the server session is used to process a message, it need not reconnect to WebSphere MQ and reopen the queue containing the message. By default, unused server sessions associated with activation specifications are left open for 30 minutes before being closed off. You can later this timeout period by modifying the value of the activation specification advanced property Server session pool timeout, as shown in Figure 4 below

    On a lightly loaded system, the time between the piece of work being scheduled and the Work Manager starting the work can be just a few milliseconds. On busy systems, there may be a lengthy delay before the work is actually started. There are two possible reasons for a delay:

    • There were no free threads in the WMQJCAResourceAdapter thread pool to run the work.
    • The Work Manager was able to get a thread from the thread pool, and but then could not start the work because the application server was too busy.

    The Work Manager records when a piece of work was scheduled, and when it starts the work, it checks how much time has elapsed since the activation specification scheduled the work. By default, the activation specification expects the work to be started within 10 seconds of it being scheduled. If more than 10 seconds elapse before the Work Manager starts the work, then a WorkRejected exception is returned back to the activation specification, causing exceptions similar to the one below to appear in the application server SystemErr.log:

    Exception in thread "WMQJCAResourceAdapter : 1" 
    java.lang.RuntimeException: javax.resource.spi.work.WorkRejectedException: Work timed
    out (id=4), error code: 1 : : : : : : : : : : : : : : : Caused by: javax.resource.spi.work.WorkRejectedException:
    Work timed out (id=4), error code: 1

    When an exception like this one occurs, the message in the Message Reference will have been "unmarked" by the queue manager, so that it can be reprocessed. You can change this 10-second time limit on the activation specification Advanced properties panel using Start timeout, as shown in Figure 4:


    Figure 4. Modifying the server session timeout and the amount of time to wait for work to start

    Earlier, it was mentioned that a piece of work might get delayed if there are not enough threads in the WMQJCAResourceAdapter thread pool, which leads to the obvious question, "What should the size of this thread pool be?". One thread pool per application server is used by activation specifications to run server sessions. Each activation specification has an advanced property called Maximum server sessions, which defines the maximum number of concurrent server sessions that can be running at the same time. Since each server session is used to process messages, this property essentially says how many messages can be processed concurrently by message-driven beans using this activation specification. So in order to determine what the size of the WMQJCAResourceAdapter thread pool should be, you need to add up the values of the Maximum server sessions properties for each WebSphere MQ messaging provider activation specification on the application server. For example, suppose you have 25 activation specifications defined, each with the Maximum server sessions property set to 3. In this situation, there can be up to 75 server sessions running concurrently, each of them using a thread from the WMQJCAResourceAdapter thread pool. Therefore you should set the maximum size of this thread pool to 75. Figure 5 shows the WMQJCAResourceAdapter thread pool panel in the WebSphere Integrated Solutions Console, where you can change the size of this thread pool:


    Figure 5. Changing max number of threads available to all activation specifications defined in the application server.

    If you start seeing WorkRejected errors appearing in the application server SystemOut.log file, the first thing to check is that the WMQJCAResourceAdapter thread pool is large enough to handle all of the server sessions needed by your activation specifications. If the thread pool is the right size, then the errors are caused by the Work Manager being unable to start the work request within the specified time period. In this situation, you should either increase the value of the activation specification advanced property Start Timeout, or investigate reducing the load on your application server system.

    Using WebSphere MQ messaging provider normal mode

    As described above, there are three situations in which there might be a delay in between a message being detected and that message being processed by a message-driven bean:

    • If all server sessions associated with an activation specification are being used.
    • If all threads in the WMQJCAResourceAdapter thread pool are being used to process messages.
    • If there is a delay between work being scheduled and the Work Manager actually starting the work.

    If the activation specification is running in WebSphere MQ messaging provider normal mode, the queue manager marks messages before passing their details back to the activation specification. Marking the message means that no other activation specification (or WebSphere Application Server Listener Port), either running in the same application server or on a different application server, can see the message, which prevents another message-driven bean from getting the message before a server session has had time to process it.

    By default, messages are marked for 5 seconds. To change this time period, modify the WebSphere MQ queue manager property Message mark browse interval (MARKINT).

    After WebSphere MQ has passed details of a message to process to an activation specification, the 5 second timer starts. During these five seconds:

    1. The activation specification must get a server session from the server session pool.
    2. The server session must be loaded up with details of the message to process.
    3. The work must be scheduled.
    4. The Work Manager must start the work request.

    If there is a delay in getting a server session or a thread from the WMQJCAResourceAdapter thread pool, or if the system is busy and it takes a long time for the Work Manager to schedule the work, then the time between WebSphere MQ passing details of the message and it actually being consumed might be longer than 5 seconds. What happens in this situation?

    Well, if the message has been on the queue for longer than 5 seconds, the queue manager will unmark it, and another activation specification or listener port is then free to come along and get the message. If this happens, then when the server session that has previously been given details of this message tries to get it, it will find that the message is no longer on the destination, and write the following message to the application server SystemOut.log:

    CWSJY0003W: JMSCC0108: WebSphere classes for JMS attempted to get 
    a message for delivery to an message listener that had previously been 
    marked using browse-with-mark, but the message was not there.
    

    Should you see this message, you have three options:

    • Increase the value of the WebSphere MQ queue manager property Message mark browse interval (MARKINT), to give the activation specification more time to get the message. If you have multiple applications monitoring the same destination and want the messages to be processed quickly, you should think hard about adopting this approach, as increasing the amount of time the message is marked for will prevent any other applications from getting it.
    • Tune the application server so that it does not block either waiting for a server session or waiting for a thread from the WMQJCAResourceAdapter thread pool. To do this, increase the size of both the server session pool and the thread pool. This change will mean that messages can be processed within the default message browse mark interval, although more resources will be used within the application server as it will be able to process more messages concurrently.
    • Do nothing. Not recommended, because it means that the activation specification will waste time and resources trying to get messages that have already been picked up and processed by another application!

    Conclusion

    This article described the mechanisms that activation specifications use to get messages from WebSphere MQ queue managers, including how activation specifications create a connection to a queue manager and the mechanisms they use to monitor JMS destinations looking for suitable messages to process. The article also described how the application server schedules the processing of messages, once a suitable message has been found.

    [Edited By Moderator]

    0 (0 Ratings)

    IBM WebSphere MQ V7.5 delivers new features and integrates managed file transfer - Middleware News

    Thursday, May 17, 2012, 10:21 AM
    Posted By: Karthick

    WebSphere® MQ V7.5 for Multiplatforms provides additional enhancements to IBM® Universal Messaging to deliver a single, integrated offering for all core messaging functions. Customers gain access to previously separately installable capabilities, enabling more complete solutions for data and message movement along with reduced complexity.

    Enhancements include:



    Overview

    WebSphere MQ V7.5 delivers a single Universal Messaging solution. It enables the simple, rapid, reliable, and secure transport of data and messages between applications, systems, and services.

    WebSphere MQ is the market-leading, message-oriented middleware product that delivers a reliable, proven universal messaging backbone for almost 10,000 organizations of different sizes, spanning many industries around the world.

    This new release builds on the added capabilities and new functions that were delivered in WebSphere MQ V7.1, which was announced in October, 2011. It also builds on the previous announcements for WebSphere MQ File Transfer Edition V7.0.4, in April, 2011, and WebSphere MQ Advanced Message Security V7.0.1, in October, 2011.

    Note: WebSphere MQ for z/OS®, V7.1 is not updated in this release of WebSphere MQ V7.5 for Multiplatforms.

    You can obtain the new enhanced functions offered in WebSphere MQ V7.5 by migrating directly to V7.5 from WebSphere MQ V6.0, V7.0.1, or V.7.1 -- without migrating to an interim version or release.

    A key new feature of WebSphere MQ V7.5 is the consolidation of multiple previously separate product capabilities into a single integrated offering. WebSphere MQ File Transfer Edition and WebSphere MQ Advanced Message Security, both previously announced separate products, are now available as integrated capabilities for optional installation as Managed File Transfer and Advanced Message Security components within the WebSphere MQ product. They are subject to appropriate licensing entitlement.

    WebSphere MQ V7.1 introduced a capability to support install of different versions of WebSphere MQ in different locations on your system. WebSphere MQ V7.5 extends this to enable additional capabilities for Advanced Message Security and Managed File Transfer to be optionally installed as part of the WebSphere MQ server install.

    WebSphere MQ V7.5 queue managers gain access to these additional capabilities without requiring additional access to code, or separate product installs. All tooling necessary to use these functions is included in the MQ Explorer tooling or command line tools for scripted configuration as standard for all customers, including those on z/OS.

    Changes made to the licensing of the Extended Transactional Client and the WebSphere MQ Telemetry Client benefit all customers in providing increased entitlement. This applies to customers of WebSphere MQ V7.5 as well as WebSphere MQ V7.0.1 and WebSphere MQ V7.1.

    For ordering, contact Your IBM representative or an IBM Business Partner. For more information contact the Americas Call Centers at 800-IBM-CALL (426-2255). Reference: YE001


    Description
     

    WebSphere MQ delivers a single integrated Universal Messaging solution. This V7.5 release delivers new features and also enhances the total capabilities available through integrating managed file transfer functions and advanced message security capabilities that were previously available and installable as separate offerings.

    Integrated managed file transfer

    WebSphere MQ File Transfer Edition has been available as a separate product offering for a number of years, providing the ability for customers to move their business data stored in files over the WebSphere MQ infrastructure, improving the reliability, security, and management of their file transfers. WebSphere MQ V7.5 extends this capability from being a separate offering, to being an integrated optional feature of the WebSphere MQ server component as the WebSphere MQ Managed File Transfer Service. Now all WebSphere MQ servers can install, subject to entitlement, this server-based capability. Additional separately installable endpoints, WebSphere MQ Managed File Transfer Agents, are included in the package. These are entitled separately to allow customers to extend the managed file transfer infrastructure to any point in their enterprise connection to the WebSphere MQ server deployments.

    Integrated advanced message security

    WebSphere MQ Advanced Message Security, also available for a number of years, allows customers to protect the security of their messages from application to application, without the need to change the application code itself. With WebSphere MQ V7.5, this capability is included as a part of the install, making it simpler for customers to see the function, and to have it installed should they wish to buy license entitlement to use it.

    Improved application isolation

    WebSphere MQ V7.5 includes improved ability to scale for differing workload environments by the ability to configure multiple transmission queues in a WebSphere MQ clustered environment. This enables applications with different workloads and performance requirements to operate at their own rate without impacting other applications.

    Enhancements for the managed file transfer capabilities

    In addition to the tight integration, as a part of WebSphere MQ V7.5, which enhances the runtime control, the managed file transfer capabilities are also enhanced. There are additional choices for storing file transfer audit information with the addition of the file system as an option. There is also greater customization for the content and format, as well as more options for logging.

    Enhancements for WebSphere MQ Security

    The addition of Managed File Transfer capabilities as well as WebSphere MQ Advanced Message Security into WebSphere MQ V7.5 enables some improvements to the security possible within WebSphere MQ.

    With WebSphere MQ V7.5 the Advanced Message Security feature built into all MQ clients, end-to-end encryption is allowed by updates to WebSphere MQ objects for customers who are licensed to use that function. There is also further support for protecting sensitive data such as passwords used in configuring managed file transfers.

    Wider access to the Extended Transactional Client for all customers

    The Extended Transactional Client enables customers to configure their WebSphere MQ client to participate in a transactional unit of work when exchanging messages to an MQ server. Use of this client without charge was previously restricted to customers using WebSphere Application Server, WebSphere Enterprise Service Bus, or WebSphere Process Server as the Transaction Manager. With the announcement of WebSphere MQ V7.5, the Extended Transactional Client is available for use in all client deployments without additional entitlement. This includes all supported versions of WebSphere MQ client connecting to any supported version of WebSphere MQ queue manager.

    With the availability of WebSphere MQ V7.5 the capability previously delivered within the Extended Transactional Client is incorporated into the standard WebSphere MQ client. Customers using WebSphere MQ V7.0.1 and WebSphere MQ V7.1 gain the benefit of use of the Extended Transactional Client without charge from the date of this announcement. IBM is making available refreshed code including updated License Information. Customers can realize this benefit through the download and acceptance of this new License Information.

    Using WebSphere MQ Telemetry Standard Client

    WebSphere MQ Telemetry was included as part of the WebSphere MQ V7.1 offering, providing wider access to this capability for customers who wanted to deploy the WebSphere MQ Telemetry clients on suitable endpoints and connect them to their WebSphere MQ servers.

    Connecting these clients to WebSphere MQ servers required purchasing entitlements based on the number of Telemetry clients connecting to a WebSphere MQ Queue Manager at any one time. With the announcement of WebSphere MQ V7.5, use of the WebSphere MQ Telemetry Client requires purchasing an entitlement for WebSphere MQ Telemetry Clients for each WebSphere MQ Server installed that will have WebSphere MQ Telemetry clients connected to it, with no limit to the number of clients connected. This change in the license entitlement for WebSphere MQ Telemetry Clients applies to not just WebSphere MQ V7.5. It also benefits customers using WebSphere MQ Telemetry Clients with WebSphere MQ V7.0.1 and WebSphere MQ V7.1 from the date of this announcement. IBM is making available refreshed code including updated License Information and customers can realize this benefit through the download and acceptance of this new License Information.

    The WebSphere MQ Telemetry Advanced Client entitlements are still based on the number of clients connected at any one time.

    Enhancements for the use of WebSphere MQ as a trial

    Customers wanting to make a rapid start connecting applications with WebSphere MQ can take advantage of the availability of WebSphere MQ as a free download in a trial version. With WebSphere MQ V7.1 this feature was enhanced to enable trial versions of WebSphere MQ to be upgraded to a full production license. With the integration of additional entitled capabilities in WebSphere MQ V7.5, a trial download is still available. However, where entitlement was not purchased at the end of the trial for capabilities that were installed, then those capabilities without entitlement must be removed from the system.

    Accessibility by people with disabilities

    WebSphere MQ is capable as of June 15, 2012, when used in accordance with associated IBM documentation, of satisfying the applicable requirements of Section 508 of the Rehabilitation Act, provided that any assistive technology used with the product properly interoperates with it.

     
    0 (0 Ratings)

    Performance: Getting the Most Out of IBM WebSphere MQ - Middleware News

    Wednesday, May 16, 2012, 11:11 AM
    Posted By: Karthick

    Getting the most out of WebSphere MQ first requires you to define performance. This should be followed up with a look at several factors that affect WebSphere MQ performance, and techniques that can be used to improve performance.

    What is Performance

    The concept of performance has different aspects. When addressing the issue of performance, your first consideration should be to identify the aspect you plan to address.
    People associate performance with:

    • The measurement of response time. Thus, better performance is defined as the completion of a task in less time (quicker response).


    • Moving the work through the system with less impact on the system and other applications.


    • Providing the most throughput at peak times.


    • Availability. The application has to be available when required.
    Based on your objectives, you may address performance similarly, but the trade-offs you choose may vary.

    WebSphere MQ applications

    Different types of WebSphere MQ applications have different performance characteristics. Several types are provided below.
    Asynchronous send
    The asynchronous send application sends messages based on some external activity. Examples might include a stock ticker or an application that reports scores for a sports event.
    This application is primarily concerned with throughput, in that it needs to keep up with the rate that events occur. Whether the message takes seconds or days to reach its destination, once it is sent, it does not affect the application.
    Synchronous send and receive
    Another common type of WebSphere MQ application is the synchronous application. Technically, this application is not synchronous, but rather it is an asynchronous one that expects a timely response to the sent message. For this application, the key concern is the response time for the reply message(s). If the responding application is remote (on a network), this time includes WebSphere MQ processing on multiple hosts, the processing by the remote application and the network transmission time for both messages.
    It is possible given the design of WebSphere MQ that the response may not be timely and must be dealt with by the application design. For example, if the application does an infinite wait for the message to arrive, this will consume system resources and could affect other applications.
    Server
    The server application is complementary to the previous two examples. It processes WebSphere MQ messages; performs local processing, such as accessing a database; and may send a response. Multiple servers may be used to share a portion of the workload.
    WebSphere MQ client
    The WebSphere MQ client application may be an implementation of any of the previous applications, but introduces a key response-driven component. As there is no local queue manager, all requests must pass over the network to the associated server queue manager. The number of requests, the speed at which the request and response can be transmitted, and the additional processing time on the server are all components of the application's performance.

    Factors that affect WebSphere MQ performance - an overview

    There are many different factors that address performance. Given the diversity of WebSphere MQ environments, some recommendations may or may not be applicable. For each, there is typically a trade-off in providing better performance to the WebSphere MQ application, such as degrading another application. It is important that the cost and benefit are understood before making changes.
    The usual suspects
    The key elements of response time have not changed in more than 20 years.

    • The processor time to service the application plus the overhead of the operating environment (in this case, WebSphere MQ and the operating system)


    • The time spent waiting for I/O operations (all computers wait at the same speed)


    • The time spent transmitting requests over a network


    • Any contention for resources required by the application
    Each of these key components will be addressed in the following sections.
    Adding system resources
    The most common approach to improving performance is simply to add additional resources. To accomplish this, you could try moving the queue manager to a larger server or adding additional memory. With today's price-to-performance ratios, this can provide significant improvements at little cost.

    Performance Factors and Techniques

    CPU factors

    The main component of CPU consumption for a WebSphere MQ application is the type and number of MQI calls issued.
    Calls in order of CPU consumption:

    • MQCONN - connects to the queue manager, creates required task structures and control blocks


    • MQOPEN - opens a specific queue for processing, may lock required resources and acquires control blocks


    • MQCLOSE - closes the queue, commits resources, frees locks and releases control blocks


    • MQPUT - puts a message to a queue (recovery processing may be required)


    • MQGET - gets a message from a queue (recovery processing may be required)
    On S390, most CPU is charged to the calling application. On distributed systems, an agent process is used to communicate with WebSphere MQ, and this process will consume most WebSphere MQ-related CPU.
    Avoid unnecessary calls
    The best and most obvious way to avoid CPU consumption is to avoid unnecessary MQI calls. For example, consider the server application discussed previously. The application could be designed to trigger the server's start when a message arrives, connect to the queue manager, open the queue, retrieve the message and process the response (opening a second queue), close all queues and disconnect from the queue manager. The process would repeat for the next message, and so on. This may be a good solution for a low arrival rate. However, for higher message arrival rates, there are two alternatives.
    First, rather than closing all queues and disconnecting1, the application could try to do an additional get with wait2 from the queue. If another message is already available, it could process this message and avoid additional connect and open calls3. This process could be repeated until no unprocessed messages remain, and only then would the server terminate. If the message arrival rate is high enough, rather than using triggering, the application could be permanently active, simply looping on a get with wait call. Note that if the arrival rate is insufficient, the above solutions could be unnecessary processing.
    Reduce message size and/or compress messages
    Message size is a key component in message processing. While application developers can be coerced into reducing message size, there is no guarantee that they will do so. Traditionally, software solutions to compress messages have had a greater success rate than those that relied on application methodology. As seen in Figure 1, which demonstrates the use of compression software, message size can have a significant impact on CPU time. This is primarily due to data movement within the queue manager. Data must be moved out of the application and into WebSphere MQ buffers. It must be logged if persistent, and may have to be written to and read from physical DASD.
    Figure 1—CPU Consumption
    Directly related to the reduced CPU, but also due to I/O and network transmission time savings achieved, the elapsed time of the compressed data is significantly lower than that of the native messages.
    To achieve these savings however, it should be noted that messages must be compressed prior to their placement on the queue.
    Reduced number of messages
    Is one big message better than several small ones? Opinions vary.
    Larger messages are subject to additional processing overhead, whereas each small message incurs a base amount of processing. WebSphere MQ now supports messages up to 100MB, so it is possible to logically join multiple records (taking care not to go overboard). Define messages that make sense from an application point of view, and don't overanalyze message design. If the number of messages is low, the difference in processing for either method will be small. If a large number of messages are being written, combining the messages may result in a significant reduction in processing overhead.
    Use intermediate commits for large numbers of messages
    There are several reasons to periodically commit messages. First, the processing required is not linear to the number of messages. The impact of the final commit increases as the number of messages in the unit of work increases. Second, periodic commits spread the total time to process over a longer period (less impact on other applications). Third, messages are not visible to other applications until they have been committed, thus the messages will appear all at once to the server application. The processing application may be overwhelmed. Of course, the commits must be reflected in completed units of work.
    Queue use
    Is it better to have a single queue shared by multiple application instances or individual queues? This is an area of debate, but it typically does not make sense to share queues across different applications. However, it may make sense to share queues within an application domain. For example, the Command MQ for S/390 product from BMC Software supports multiple users connected to a single queue manager. It could have been designed with a unique queue per user, but instead it implements a single queue shared by all users based on correlation ID (CorrelId), resulting in fewer queues to manage.
    WebSphere MQ on distributed platforms uses an indexed technique to make this efficient. On S/390 with V1.2 and later, the queue can be defined as indexed. This builds an in-storage index. The index can be based on message ID (MsgId) or CorrelId, but not both. This is not typically a problem, as applications use one or the other. However, if the queue is a priority-based queue, additional processing is required for each message with the same index.
    If you have applications displaying this behavior, it is important that you define the associated queue as indexed. Consider a queue with 1,000 messages for application A, followed by 50 messages for application B. To read the 50 messages, application B would actually read the 1,000 messages for application A before hitting any of its own messages. Depending on application design, this could result in a total reference of 50,050 messages to process all 50 messages.
    Defining a queue as indexed adds a minimal amount of additional processing during put processing, but can be noticeable during queue manager restart for large queues.
    Additionally, if all access to the queue is by MsgId or CorrelId and message expiry is used, it is possible to fill a queue with expired messages. WebSphere MQ does not remove messages until the expired message's get with update is performed.
    Trusted applications
    For distributed queue managers, another CPU consumer is process switching. Process switching prevents the corruption of WebSphere MQ due to application program errors.
    The queue manager is isolated from the application program through the use of an agent process that executes within the queue manager domain. For each WebSphere MQ call, an IPC is used to switch from the application to the agent. When defined as trusted, the application, the agent and the queue manager are within a common domain. This eliminates the overhead, but leaves the queue manager open to corruption by the application. Thus, it is intended only for truly trusted applications.
    Trusted applications are primarily used for the WebSphere MQ channel agents. While from a WebSphere MQ perspective these are application programs, from a customer point of view they are part of WebSphere MQ. These should be configured as trusted, reducing overhead for the channel processing. Channel exits will execute within the trusted environment, should be evaluated, and must conform to trusted application restrictions. Note that an application must be designed to use trusted binding. For example, it must use an MQCONNX call instead of the standard MQCONN call.

    I/O factors

    I/O can be a major component of a WebSphere MQ application, particularly if logging is the primary factor. In order to provide guaranteed once-and-once-only delivery, WebSphere MQ must log every processed message. Additionally, WebSphere MQ must ensure that the log has been committed prior to the work unit's completion.
    Queue I/O is typically performed independent from application response time, but could affect device use. When processed within a resource manager, I/O to the queue is not performed unless buffer space is exhausted. Therefore, it is possible for a message to be sent to a queue and read by the processing application without ever being written to the physical queue storage.
    Use nonpersistent messages when appropriate
    Because logging is only performed for persistent messages, using nonpersistent messages eliminates logging activity. Nonpersistent messages are not guaranteed from a WebSphere MQ perspective. That is, they may never be delivered. Most notably, nonpersistent messages are not maintained across a restart of the queue manager. Some cases of non-persistent messages make sense. For example, consider an application that sends the current temperature. If a single reporting instance is lost, correction will occur with the next temperature report. However, stock trade messages cannot be lost.
    Reduce message size and/or compress messages
    0 (0 Ratings)

    Page 10 of 18  •  Prev 1 ... 8 9 10 11 12 ... 18 Next

Tag Cloud

Connect w/ Others

    No blog posts have been added.