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

My Profile

  • Jennifer

  • Suneel

  • sudheer

  • kotaru

    How to configure UNIX and Linux systems for IBM WebSphere MQ - Middleware News

    Tuesday, June 19, 2012, 1:03 PM
    Categories: WebSphere MQ
    Posted By: Karthick

    How to configure UNIX and Linux systems for WebSphere MQ


    You are planning to install or upgrade a WebSphere MQ server on a UNIX or Linux system and need to know how to tune the operating system parameters, including kernel parameters related to inter-process communication (IPC) resources like shared memory and semaphores.


    If you do not configure your operating system parameters properly, the WebSphere MQ server may exhaust system resources when you process your production workload. Depending on the resource which was exhausted, WebSphere MQ could return an error to the application like MQRC_RESOURCE_PROBLEM (2012), write a message to its error logs, create FDC files in the /var/mqm/errors directory, or even terminate.

    Resolving the problem

    IBM Recommendations
    Using the mqconfig Script
    Operating System Notes
    IPC Tuning Parameters
    Older Version for WebSphere MQ 6.0 and 5.3

    IBM Recommendations

    IBM recommends default values in the WebSphere MQ documentation for several operating system kernel parameters and other tuning values:
    WebSphere MQ 7.5 Additional settings for AIX, HP-UX, Linux and Solaris
    WebSphere MQ 7.1 Additional settings for AIX, HP-UX, Linux and Solaris
    WebSphere MQ 7.0 System resource limits for AIX
    WebSphere MQ 7.0 Kernel configuration for HP-UX
    WebSphere MQ 7.0 Kernel configuration for Linux
    WebSphere MQ 7.0 Resource limit configuration for Solaris
    These default limits should enable you to run WebSphere MQ without exhausting any system resources. However, if your system is extremely busy, you may need to increase certain values beyond the IBM recommended defaults. A busy system may be running a large number of queue managers, or just a single queue manager with thousands of connected applications and millions of messages, or it may be running another product with high resource demands such as IBM DB2.

    If you need to increase parameters beyond the IBM WebSphere MQ defaults, bear in mind that modern systems are capable of supporting large amounts of resources. For example, the UNIX IPC interface was designed in the late 1970s on a 16-bit DEC PDP-11 minicomputer, similar to this one used by UNIX designers Dennis Ritchie and Ken Thompson. Modern systems run with a hundred thousand to more than a million times more memory, so doubling and quadrupling IPC parameters to handle your workload will not stress your system. Be generous with these values and refer to the section on IPC parameters below for more information about specific settings.

    Using the mqconfig Script

    The mqconfig script analyzes your system and compares its settings to the IBM recommended values for WebSphere MQ 7.5, 7.1 or 7.0. It displays the results of this comparison in an easy to read format, along with a PASS, WARN, or FAIL grade for each setting. The mqconfig script does not make any modifications to your systems. A version called mqconfig-old is still provided for older versions of WebSphere MQ.

    To use mqconfig, you must first download the script to your system and make it executable (e.g. 'chmod a+x mqconfig'), then run it using the syntax given below. On Solaris 10 you should use the '-p' parameter to identify the projects in which you run WebSphere MQ queue managers. If you omit this parameter, mqconfig will try to determine which projects it should analyze, perhaps incorrectly.


    syntax: mqconfig -?

            mqconfig -v Version

            mqconfig -v Version [-p Project]...   (Solaris 10 only)

            Version: 7.5, 7.1 or 7.0

    mqconfig -v 7.5
    mqconfig -v 7.1 -p group.mqm -p mqdev
    mqconfig -?

    Here is a sample of the mqconfig output showing a Linux system which has four potential tuning issues. The semmni value is half the IBM recommended value, and the nofile soft limit is way too low, which is why both parameters failed. The tcp_keepalive_time limit is unusual in that lower values are better, so here it failed for being too high. Finally, the shmmni value gave only a warning because it is reasonably close to the IBM limit:

    Please note that any values listed in the "Current User Limits" section are resource limits which apply to the user running mqconfig. If you normally start queue managers as the mqm user (or via sudo to mqm) then you should run mqconfig as mqm to verify its user limits. Other members of the mqm group (and perhaps root as well) can also run mqconfig to make sure their user limits are acceptable for starting WebSphere MQ queue managers.

    The mqconfig script may also recommend a change to your shell options in order to avoid a performance problem caused when shells run WebSphere MQ background jobs with reduced priority. If your shell is not susceptible then mqconfig will print nothing. If mqconfig suggests a change you can simply modify your profile; For example, Korn shell users can add the line 'set +o bgnice' to their profile.

    If you note a discrepancy between mqconfig and the WebSphere MQ Information Center, or if you encounter a problem with the mqconfig script, please submit a comment using the link at the bottom of the page.

    Operating System Notes

    The AIX kernel is self-tuning with regard to IPC parameters, so WebSphere MQ will not run into a limit on shared memory or semaphores. The mqconfig script can check other basic settings to ensure they are suitable for WebSphere MQ.

    HP-UX 11i
    You can view or change kernel parameters with the System Management Homepage tool (smh) or by using the kctune command. The kctune command can show whether a parameter change takes effect immediately or whether you must restart the system. On HP-UX 11.23 and older, you may use the System Administration Manager tool (sam) instead of smh.

    You can view or change kernel parameters dynamically using the sysctl command or using the files under the /proc filesystem. In order to change the parameters permanently you can add your values to the /etc/sysctl.conf file or use a system startup script to modify the parameters on each startup.

    One oddity is that all semaphore tuning parameters are held in a single parameter called sem, rather than individually. The fields in sem correspond to semmsl, semmns, semopm and semmni. All four fields must be set at the same time, even if you wish to change only one value.

    Solaris 9
    Solaris 9 is supported only by WebSphere MQ 7.0 and older versions. You can view kernel parameters by examining the output of the 'sysdef -i' command. To change parameters you must edit the /etc/system file and then reboot the system.

    Solaris 10
    Solaris 10 uses projects to replace the system-wide tuning parameters used in previous versions. The WebSphere MQ Information Center describes how to use the projects, projadd and projmod commands to list, create and modify projects. The previous kernel parameters have received more descriptive names, but note that some begin with 'project' and others with 'process' as shown below:

    Old Name

    New Name











    In order to use the resource limits recommended by IBM, you should configure a project (for example 'group.mqm') and ensure that you start queue managers in that project. You can check your current project using the id command and use the newtask command to run a single command or start a shell in a different project. The following example demonstrates both methods, with the commands on the dark gray background running in the group.mqm project rather than the default project:

     sun10> id -p
     uid=500(justinf) gid=501(dev) projid=3(default)

     sun10> newtask -p group.mqm strmqm SOHO
     WebSphere MQ queue manager 'SOHO' starting.
     The queue manager is associated with installation 'Manhattan'.
     5 log records accessed on queue manager 'SOHO' during the
       log replay phase.
     Log replay for queue manager 'SOHO' complete.
     Transaction manager state recovered for queue manager 'SOHO'.
     WebSphere MQ queue manager 'SOHO' started using V7.1.0.0.

     sun10> id -p
     uid=500(justinf) gid=501(dev) projid=3(default)

     sun10> newtask -p group.mqm

     sun10> id -p
     uid=500(justinf) gid=501(dev) projid=100(group.mqm)

     sun10> strmqm CHELSEA
     WebSphere MQ queue manager 'CHELSEA' starting.
     The queue manager is associated with installation 'Manhattan'.
     5 log records accessed on queue manager 'CHELSEA' during the
       log replay phase.
     Log replay for queue manager 'CHELSEA' complete.
     Transaction manager state recovered for queue manager 'CHELSEA'.
     WebSphere MQ queue manager 'CHELSEA' started using V7.1.0.0.

     sun10> exit

     sun10> id -p
     uid=500(justinf) gid=501(dev) projid=3(default)

    It is easy for WebSphere MQ queue managers to end up running in the default project, for example because an administrator forgot to use the newtask command. You should either configure the default project to satisfy the IBM WebSphere MQ default tuning values, or put processes in place to ensure that WebSphere MQ commands run in the right project.

    IPC Tuning Parameters

    The following parameters control Inter-Process Communication (IPC) semaphore and shared memory resources used by WebSphere MQ. Not all parameters exist on every system; AIX, for example, does not use any of these parameters. Parameters relating the IPC message queues are not listed since WebSphere MQ no longer uses them.

    If you are installing WebSphere MQ on a system with other products that recommend certain IPC parameter settings. In some cases (marked with an asterisk in the table below) you should add up the recommendations of all the products and use the total. For example, if WebSphere MQ recommends 1024 and DB2 recommends 1024, choose a value of 2048 or higher. Otherwise you should use the highest requested value. For example, if WebSphere MQ wants a value of 256 and DB2 asks for 512, you should use the higher value of 512.



     semmni   *

    The maximum number of semaphore sets on the system. WebSphere MQ queue managers add sets based on workload, so you should check this parameter at runtime to ensure the resource usage is safely within your limit.


    The maximum number of semaphores in a single set.

     semmns   *

    The total number of semaphores in the system. You can calculate the theoretical maximum by multiplying semmni * semmsl, but in practice some sets will have fewer than the maximum number of semaphores.

     semmnu   *

    The maximum number of semaphore undo requests in the system. When a program ends or crashes, the operating system will automatically release semaphores for which "undo" support was requested. WebSphere MQ uses the undo option with some semaphores to ensure they will not get stuck in a locked state.

     semume   *

    The maximum number of semaphore undo requests a single process can make.


    The maximum adjustment value the operating system can apply to a semaphore when processing an undo requests. Since WebSphere MQ uses binary rather than counting semaphores, this parameter does not affect it.

     shmmni   *

    The maximum number of shared memory sets on the system. WebSphere MQ queue managers add sets based on workload, so you should check this parameter at runtime to ensure the resource usage is safely within your limit.

     shmseg   *

    The maximum number of shared memory sets a single process can attach. This value should match shmmni so that WebSphere MQ processes can attach all sets, if necessary.


    The maximum size of a shared memory set. Setting a large value will not waste memory on your system since WebSphere MQ starts by allocating small set, and allocates large ones only when it is processing a heavy workload.


    The minimum size of a shared memory set. There is no compelling reason to use any value other than 1.

     shmall   *

    The maximum number of pages available for shared memory on Linux systems.


    The maximum value of a semaphore. WebSphere MQ does not use counting semaphores, so this parameter does not affect it.

    Older Version for WebSphere MQ 6.0 and 5.3

    The mqconfig-old script is an older version for WebSphere MQ 6.0 and 5.3 which will be withdrawn after WebSphere MQ 6.0 ends support on September 30, 2012. To use mqconfig-old, you must first download the script to your system and make it executable (for example 'chmod a+x mqconfig-old'), then run it using the syntax given below. On Solaris 10 you should use the '-p' parameter to identify the projects in which you run WebSphere MQ queue managers. If you omit this parameter, mqconfig-old will try to guess which projects it should analyze.


    syntax: mqconfig-old -?

            mqconfig-old [-v 6.0|5.3]

            mqconfig-old [-v 6.0|5.3] [-p Project]...   (Solaris 10 only)



    [Edited By Moderator]

    0 (0 Ratings)
    [ 2094 views ] Leave a Comment

    Requirements for Remote Administration using the WebSphere MQ Explorer - Middleware News

    Tuesday, June 19, 2012, 12:59 PM
    Categories: WebSphere MQ
    Posted By: Karthick

    Ensure that you have satisfied the following requirements before trying to use the WebSphere MQ Explorer to do remote administration. Verify that:
    1. The WebSphere MQ server and client is installed on the local and the remote machine.
    2. A command server is running for every queue manager.
    3. A TCP/IP listener exists for every queue manager. This can be the WebSphere MQ listener or the inetd daemon as appropriate for your operating system environment.
    4. The server-connection channel, called SYSTEM.ADMIN.SVRCONN, exists on every remote queue manager. This channel is mandatory for every remote queue manager being administered.

    Using the WebSphere MQ Explorer for Remote Administration

    Satisfy all of the requirements for Remote Administration and then you can use the WebSphere MQ to do administration tasks on your local and remote queue managers.

    To show a remote queue manager, right click the WebSphere MQ Explorer Queue Manager folder, select Show/Hide, then select the Add button on the Add Queue Manager screen(see Figure 1then type: Figure 1

    Figure 2

    Reasons for Remote Administration failures:

    1. The Command server is not running on remote queue manager. Message AMQ4042 will be issued.
    2. The Listener is not running on remote queue manager. Message AMQ4043 will be issued.
    3. The SYSTEM.ADMIN.SVRCONN is not defined on remote queue manager. Message AMQ4043 will be issued.
    4. The security check failed on remote queue manager. Message AMQ4043 will be issued.
    5. Prior releases of WebSphere MQ for z/OS (v5.3 and v5.3.1) do not provide this function and any attempt to remotely administer a queue manager will fail. The WebSphere MQ V6.0 product has been enhanced to support the remote administration of a z/OS queue manager using the WebSphere MQ Explorer on Windows and Linux Intel.
    6. Code page conversion failures can cause problems. Message AMQ4043 will be issued. For more information, see technote: Remote Administration through WebSphere MQ Explorer "Show Queue Manager" Fails AMQ4043
    7. The SYSTEM.MQEXPLORER.REPLY.MODEL is not defined on remote queue manager and you are using the V6.0 WebSphere MQ Explorer. Message AMQ4400 will be issued.
    8. The Client attachment feature is not installed on WebSphere MQ for z/OS. The CHIN joblog will contain message CSQX260E. To connect to the z/OS queue manager using the SYSTEM.ADMIN.SVRCONN channel, you need to have the Client Attachment feature installed, which is FMID JMS6007 for WebSphere MQ for z/OS 6.0.0.

      In WebSphere MQ V7 for z/OS you can create five “free” client attachments for use with MQ Explorer. These attachments must use the channel name SYSTEM.ADMIN.SVRCONN, which is the default channel name used by the MQ Explorer.

      To use the free client attachments, you must first alter the SYSTEM.ADMIN.SVRCONN channel definition and set the maximum instances (MAXINST) attribute to 5 or less. You should also ensure that your server-connection channel is secured by the usual means.
    3.7 (1 Ratings)
    [ 4398 views ] Leave a Comment

    IBM Websphere MQ - Constants - Middleware News

    Tuesday, June 19, 2012, 12:49 PM
    Categories: WebSphere MQ
    Posted By: Karthick


    List of all the constants

    [ 677 views ] Leave a Comment

    IBM Websphere MQ (String Lengths) - Middleware News

    Tuesday, June 19, 2012, 12:44 PM
    Categories: WebSphere MQ
    Posted By: Karthick

    MQ (String Lengths)

    MQ_ABEND_CODE_LENGTH 4 X'00000004'
    MQ_APPL_NAME_LENGTH 28 X'0000001C'
    MQ_APPL_TAG_LENGTH 28 X'0000001C'
    MQ_ARM_SUFFIX_LENGTH 2 X'00000002'
    MQ_ATTENTION_ID_LENGTH 4 X'00000004'
    MQ_AUTH_INFO_DESC_LENGTH 64 X'00000040'
    Start of changeMQ_AUTH_INFO_NAME_LENGTHEnd of change Start of change48End of change Start of changeX'00000030'End of change
    MQ_AUTH_INFO_OCSP_URL_LENGTH 256 X'00000100'
    MQ_BRIDGE_NAME_LENGTH 24 X'00000018'
    MQ_CANCEL_CODE_LENGTH 4 X'00000004'
    MQ_CF_STRUC_DESC_LENGTH 64 X'00000040'
    MQ_CF_STRUC_NAME_LENGTH 12 X'0000000C'
    MQ_CHANNEL_DESC_LENGTH 64 X'00000040'
    MQ_CHANNEL_NAME_LENGTH 20 X'00000014'
    MQ_CHANNEL_TIME_LENGTH 8 X'00000008'
    MQ_CICS_FILE_NAME_LENGTH 8 X'00000008'
    MQ_CLUSTER_NAME_LENGTH 48 X'00000030'
    MQ_CONN_NAME_LENGTH 264 X'00000108'
    MQ_CONN_TAG_LENGTH 128 X'00000080'
    MQ_CONNECTION_ID_LENGTH 24 X'00000018'
    MQ_CORREL_ID_LENGTH 24 X'00000018'
    MQ_DATE_LENGTH 12 X'0000000C'
    MQ_DNS_GROUP_NAME_LENGTH 18 X'00000012'
    MQ_EXIT_DATA_LENGTH 32 X'00000020'
    MQ_EXIT_INFO_NAME_LENGTH 48 X'00000030'
    MQ_EXIT_NAME_LENGTH (value differs by platform or version)
    MQ_EXIT_PD_AREA_LENGTH 48 X'00000030'
    MQ_EXIT_USER_AREA_LENGTH 16 X'00000010'
    MQ_FACILITY_LENGTH 8 X'00000008'
    MQ_FORMAT_LENGTH 8 X'00000008'
    MQ_FUNCTION_LENGTH 4 X'00000004'
    MQ_GROUP_ID_LENGTH 24 X'00000018'
    MQ_LDAP_PASSWORD_LENGTH 32 X'00000020'
    MQ_LISTENER_NAME_LENGTH 48 X'00000030'
    MQ_LISTENER_DESC_LENGTH 64 X'00000040'
    MQ_LOCAL_ADDRESS_LENGTH 48 X'00000030'
    MQ_LU_NAME_LENGTH 8 X'00000008'
    MQ_LUWID_LENGTH 16 X'00000010'
    MQ_MAX_EXIT_NAME_LENGTH 128 X'00000080'
    MQ_MAX_MCA_USER_ID_LENGTH 64 X'00000040'
    MQ_MAX_USER_ID_LENGTH 64 X'00000040'
    MQ_MCA_JOB_NAME_LENGTH 28 X'0000001C'
    MQ_MCA_NAME_LENGTH 20 X'00000014'
    MQ_MCA_USER_DATA_LENGTH 32 X'00000020'
    MQ_MCA_USER_ID_LENGTH (value differs by platform or version)
    MQ_MFS_MAP_NAME_LENGTH 8 X'00000008'
    MQ_MODE_NAME_LENGTH 8 X'00000008'
    MQ_MSG_HEADER_LENGTH 4000 X'00000FA0'
    MQ_MSG_ID_LENGTH 24 X'00000018'
    MQ_MSG_TOKEN_LENGTH 16 X'00000010'
    MQ_NAMELIST_DESC_LENGTH 64 X'00000040'
    MQ_NAMELIST_NAME_LENGTH 48 X'00000030'
    MQ_OBJECT_NAME_LENGTH 48 X'00000030'
    MQ_PASSWORD_LENGTH 12 X'0000000C'
    MQ_PROCESS_APPL_ID_LENGTH 256 X'00000100'
    MQ_PROCESS_DESC_LENGTH 64 X'00000040'
    MQ_PROCESS_ENV_DATA_LENGTH 128 X'00000080'
    MQ_PROCESS_NAME_LENGTH 48 X'00000030'
    MQ_PROGRAM_NAME_LENGTH 20 X'00000014'
    MQ_PUT_APPL_NAME_LENGTH 28 X'0000001C'
    MQ_PUT_DATE_LENGTH 8 X'00000008'
    MQ_PUT_TIME_LENGTH 8 X'00000008'
    MQ_Q_DESC_LENGTH 64 X'00000040'
    MQ_Q_MGR_DESC_LENGTH 64 X'00000040'
    MQ_Q_MGR_NAME_LENGTH 48 X'00000030'
    MQ_Q_NAME_LENGTH 48 X'00000030'
    MQ_QSG_NAME_LENGTH 4 X'00000004'
    MQ_REMOTE_SYS_ID_LENGTH 4 X'00000004'
    MQ_SECURITY_ID_LENGTH 40 X'00000028'
    MQ_SELECTOR_LENGTH 10240 X'00002800'
    MQ_SERVICE_DESC_LENGTH 64 X'00000040'
    MQ_SERVICE_NAME_LENGTH 32 X'00000020'
    MQ_SERVICE_STEP_LENGTH 8 X'00000008'
    MQ_SHORT_CONN_NAME_LENGTH 20 X'00000014'
    MQ_SHORT_DNAME_LENGTH 256 X'00000100'
    MQ_SSL_CIPHER_SPEC_LENGTH 32 X'00000020'
    MQ_SSL_KEY_MEMBER_LENGTH 8 X'00000008'
    MQ_SSL_PEER_NAME_LENGTH 1024 X'00000400'
    MQ_START_CODE_LENGTH 4 X'00000004'
    MQ_SUB_IDENTITY_LENGTH 128 X'00000080'
    MQ_SUB_POINT_LENGTH 128 X'00000080'
    MQ_TCP_NAME_LENGTH 8 X'00000008'
    MQ_TIME_LENGTH 8 X'00000008'
    MQ_TOPIC_DESC_LENGTH 64 X'00000040'
    MQ_TOPIC_NAME_LENGTH 48 X'00000030'
    MQ_TOPIC_STR_LENGTH 10240 X'00002800'
    MQ_TP_NAME_LENGTH 64 X'00000040'
    MQ_TPIPE_NAME_LENGTH 8 X'00000008'
    MQ_TRIGGER_DATA_LENGTH 64 X'00000040'
    MQ_USER_ID_LENGTH 12 X'0000000C'
    MQ_XCF_GROUP_NAME_LENGTH 8 X'00000008'
    MQ_XCF_MEMBER_NAME_LENGTH 16 X'00000010'

    MQ (Command format String Lengths)

    MQ_ARCHIVE_PFX_LENGTH 36 X'00000024'
    MQ_ARCHIVE_UNIT_LENGTH 8 X'00000008'
    MQ_ASID_LENGTH 4 X'00000004'
    MQ_CF_LEID_LENGTH 12 X'0000000C'
    MQ_COMMAND_MQSC_LENGTH 32768 X'00008000'
    MQ_DATA_SET_NAME_LENGTH 44 X'0000002C'
    MQ_DB2_NAME_LENGTH 4 X'00000004'
    MQ_DSG_NAME_LENGTH 8 X'00000008'
    MQ_ENTITY_NAME_LENGTH 64 X'00000040'
    MQ_ENV_INFO_LENGTH 96 X'00000060'
    MQ_IP_ADDRESS_LENGTH 48 X'00000030'
    MQ_LOG_CORREL_ID_LENGTH 8 X'00000008'
    MQ_LOG_EXTENT_NAME_LENGTH 24 X'00000018'
    MQ_LOG_PATH_LENGTH 1024 X'00000400'
    MQ_LRSN_LENGTH 12 X'0000000C'
    MQ_ORIGIN_NAME_LENGTH 8 X'00000008'
    MQ_PSB_NAME_LENGTH 8 X'00000008'
    MQ_PST_ID_LENGTH 8 X'00000008'
    MQ_Q_MGR_CPF_LENGTH 4 X'00000004'
    MQ_RESPONSE_ID_LENGTH 24 X'00000018'
    MQ_RBA_LENGTH 12 X'0000000C'
    MQ_SUB_NAME_LENGTH 10240 X'00002800'
    MQ_SYSP_SERVICE_LENGTH 32 X'00000020'
    MQ_SYSTEM_NAME_LENGTH 8 X'00000008'
    MQ_TASK_NUMBER_LENGTH 8 X'00000008'
    MQ_TPIPE_PFX_LENGTH 4 X'00000004'
    MQ_UOW_ID_LENGTH 256 X'00000100'
    MQ_USER_DATA_LENGTH 10240 X'00002800'
    MQ_VOLSER_LENGTH 6 X'00000006'
    0 (0 Ratings)
    [ 547 views ] Leave a Comment

    IBM Websphere MQ - MQRC Reason Codes - Middleware News

    Tuesday, June 19, 2012, 12:40 PM
    Categories: WebSphere MQ
    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_BACKED_OUT 2003 X'000007D3'
    MQRC_BUFFER_ERROR 2004 X'000007D4'
    MQRC_CHAR_ATTRS_ERROR 2007 X'000007D7'
    MQRC_CHAR_ATTRS_TOO_SHORT 2008 X'000007D8'
    MQRC_EXPIRY_ERROR 2013 X'000007DD'
    MQRC_FEEDBACK_ERROR 2014 X'000007DE'
    MQRC_GET_INHIBITED 2016 X'000007E0'
    MQRC_HCONN_ERROR 2018 X'000007E2'
    MQRC_HOBJ_ERROR 2019 X'000007E3'
    MQRC_INT_ATTR_COUNT_ERROR 2021 X'000007E5'
    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_OD_ERROR 2044 X'000007FC'
    MQRC_OPTIONS_ERROR 2046 X'000007FE'
    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_SECURITY_ERROR 2063 X'0000080F'
    MQRC_SELECTOR_COUNT_ERROR 2065 X'00000811'
    MQRC_SELECTOR_ERROR 2067 X'00000813'
    MQRC_SELECTOR_NOT_FOR_TYPE 2068 X'00000814'
    MQRC_SIGNAL_OUTSTANDING 2069 X'00000815'
    MQRC_TRIGGER_TYPE_ERROR 2078 X'0000081E'
    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_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_SET_ALL 2095 X'0000082F'
    MQRC_NOT_OPEN_FOR_SET_IDENT 2096 X'00000830'
    MQRC_CONTEXT_HANDLE_ERROR 2097 X'00000831'
    MQRC_SIGNAL1_ERROR 2099 X'00000833'
    MQRC_OBJECT_DAMAGED 2101 X'00000835'
    MQRC_RESOURCE_PROBLEM 2102 X'00000836'
    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_FLOAT_ENC_ERROR 2114 X'00000842'
    MQRC_TARGET_CCSID_ERROR 2115 X'00000843'
    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_OUTCOME_MIXED 2123 X'0000084B'
    MQRC_OUTCOME_PENDING 2124 X'0000084C'
    MQRC_BRIDGE_STARTED 2125 X'0000084D'
    MQRC_BRIDGE_STOPPED 2126 X'0000084E'
    MQRC_UOW_IN_PROGRESS 2128 X'00000850'
    MQRC_ADAPTER_DEFS_ERROR 2131 X'00000853'
    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_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_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_ASID_MISMATCH 2157 X'0000086D'
    MQRC_CONN_ID_IN_USE 2160 X'00000870'
    MQRC_Q_MGR_QUIESCING 2161 X'00000871'
    MQRC_Q_MGR_STOPPING 2162 X'00000872'
    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_GMO_ERROR 2186 X'0000088A'
    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_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_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_RAS_PROPERTY_ERROR 2229 X'000008B5'
    MQRC_CHANNEL_AUTO_DEF_OK 2233 X'000008B9'
    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_UOW 2245 X'000008C5'
    MQRC_MDE_ERROR 2248 X'000008C8'
    MQRC_MSG_FLAGS_ERROR 2249 X'000008C9'
    MQRC_OFFSET_ERROR 2251 X'000008CB'

    [Edited By Moderator]

    0 (0 Ratings)
    [ 6918 views ] Leave a Comment

    IBM Announcement: End of Support for WebSphere MQ V6

    Tuesday, June 19, 2012, 12:11 PM
    Categories: WebSphere MQ
    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.


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

    Product Name Version General
    End of
    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)
    [ 657 views ] Leave a Comment

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

    Sunday, May 27, 2012, 10:09 AM
    Categories: WebSphere MQ
    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:
    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: Work timed
    out (id=4), error code: 1 : : : : : : : : : : : : : : : Caused by:
    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!


    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)
    [ 2012 views ] Leave a Comment

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

    Thursday, May 17, 2012, 10:21 AM
    Categories: WebSphere MQ
    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:


    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


    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)
    [ 1250 views ] Leave a Comment

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

    Wednesday, May 16, 2012, 11:11 AM
    Categories: WebSphere MQ
    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.
    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)
    [ 921 views ] Leave a Comment

    How SSL works tutorial - with HTTPS example - Middleware News

    Sunday, May 6, 2012, 10:44 AM
    Categories: Security
    Posted By: Karthick

    How SSL works tutorial - with HTTPS example - Middleware News

    3.2 (1 Ratings)
    [ 1535 views ] Leave a Comment

    Page 6 of 11  •  Prev 1 ... 4 5 6 7 8 ... 11 Next

Connect w/ Others

Member of the Month

    • WebSphere z/OS System Administrator