MainframeMaster

CICS MQSeries Integration

Progress0 of 0 lessons

MQSeries Integration enables CICS applications to participate in enterprise messaging solutions using IBM MQ (formerly WebSphere MQ). This integration provides reliable, asynchronous message processing capabilities that enhance CICS application flexibility and scalability.

What is MQSeries Integration?

MQSeries Integration is a CICS facility that enables applications to send and receive messages through IBM MQ queues. This integration allows CICS programs to participate in distributed messaging architectures, supporting both synchronous and asynchronous communication patterns.

The integration provides a bridge between CICS transaction processing and enterprise messaging systems, enabling applications to communicate with other systems, handle high-volume message processing, and implement event-driven architectures.

Key Concept: MQSeries Integration enables CICS applications to participate in enterprise messaging solutions, providing reliable, asynchronous message processing capabilities that enhance application flexibility and scalability.

MQ Bridge

The MQ Bridge is the core component that connects CICS to IBM MQ systems. It provides the infrastructure and APIs necessary for CICS programs to interact with MQ queues, handle message routing, and manage connection security.

Bridge Components

The MQ Bridge consists of several key components:

  • MQ Connection Manager: Manages connections to MQ queue managers
  • Message Handler: Processes incoming and outgoing messages
  • Security Interface: Handles authentication and authorization
  • Error Handler: Manages connection failures and message errors
  • Performance Monitor: Tracks message throughput and response times

Bridge Configuration

MQ Bridge configuration involves several parameters:

text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
MQ Bridge Configuration Parameters:
 
# System Initialization Table (SIT) Parameters
MQBRIDGE=YES               # Enable MQ Bridge
MQCONN=MQCONN1             # Default connection name
MQTIMEOUT=300              # Connection timeout (seconds)
MQMAXCONN=50               # Maximum connections
MQSECURITY=YES             # Enable security
 
# Connection Definition
DEFINE CONNECTION(MQCONN1) -
       GROUP(MQGROUP) -
       MQCONN(MQMANAGER1) -
       MQUSER(MQUSER1) -
       MQCHANNEL(MQCHL1) -
       SECURITY(USERID) -
       DESCRIPTION('MQ Connection to QM1')

Connection Management

The bridge manages connections to MQ queue managers:

  • Connection Pooling: Reuses connections for efficiency
  • Failover Support: Automatic failover to backup queue managers
  • Load Balancing: Distributes load across multiple connections
  • Health Monitoring: Continuous connection health checks
  • Automatic Recovery: Reconnection after failures

Message-Driven CICS Programs

Message-driven CICS programs are designed to process messages from MQ queues automatically. These programs can be triggered by message arrival, enabling event-driven processing and asynchronous application workflows.

Program Types

Several types of message-driven programs can be implemented:

  • Message Listeners: Continuously monitor queues for new messages
  • Message Processors: Handle specific message types and formats
  • Message Routers: Route messages to appropriate processing programs
  • Message Transformers: Convert message formats between systems
  • Message Validators: Validate message content and structure

Message Processing Flow

The typical message processing flow involves several steps:

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
       IDENTIFICATION DIVISION.
       PROGRAM-ID. MQ-MESSAGE-PROCESSOR.
       
       ENVIRONMENT DIVISION.
       DATA DIVISION.
       
       WORKING-STORAGE SECTION.
       01  MQ-MESSAGE.
           05  MQ-MESSAGE-ID        PIC X(24).
           05  MQ-CORRELATION-ID    PIC X(24).
           05  MQ-MESSAGE-TYPE      PIC X(8).
           05  MQ-MESSAGE-DATA      PIC X(1000).
       
       01  PROCESSING-STATUS        PIC X(8) VALUE 'SUCCESS'.
       
       PROCEDURE DIVISION.
       
       MAIN-LOGIC.
           PERFORM RECEIVE-MQ-MESSAGE
           PERFORM VALIDATE-MESSAGE
           IF VALIDATION-SUCCESSFUL
               PERFORM PROCESS-MESSAGE
               PERFORM SEND-ACKNOWLEDGMENT
           ELSE
               PERFORM SEND-ERROR-RESPONSE
           END-IF
           
           EXEC CICS RETURN END-EXEC
       
       RECEIVE-MQ-MESSAGE.
           EXEC CICS MQ GET
               QUEUE(MQ-INBOUND-QUEUE)
               MESSAGE(MQ-MESSAGE)
               MESSAGEID(MQ-MESSAGE-ID)
               CORRELID(MQ-CORRELATION-ID)
           END-EXEC
       
       VALIDATE-MESSAGE.
           IF MQ-MESSAGE-TYPE = 'CUSTOMER-ORDER'
               MOVE 'VALID' TO PROCESSING-STATUS
           ELSE
               MOVE 'INVALID' TO PROCESSING-STATUS
           END-IF
       
       PROCESS-MESSAGE.
           EXEC CICS LINK
               PROGRAM('CUSTORDER')
               COMMAREA(MQ-MESSAGE-DATA)
           END-EXEC
       
       SEND-ACKNOWLEDGMENT.
           EXEC CICS MQ PUT
               QUEUE(MQ-ACK-QUEUE)
               MESSAGE('MESSAGE PROCESSED SUCCESSFULLY')
               CORRELID(MQ-CORRELATION-ID)
           END-EXEC.

Message Triggering

Messages can trigger CICS programs in several ways:

  • Immediate Triggering: Programs start immediately when messages arrive
  • Batch Processing: Multiple messages processed in batches
  • Scheduled Processing: Messages processed at specific intervals
  • Priority-Based: High-priority messages processed first
  • Conditional Triggering: Programs triggered based on message content

Asynchronous Processing

Asynchronous processing is a key benefit of MQSeries Integration, allowing CICS applications to handle high-volume message processing without blocking user interactions or other system operations.

Asynchronous Patterns

Several asynchronous processing patterns can be implemented:

  • Fire-and-Forget: Send messages without expecting responses
  • Request-Response: Send requests and handle responses asynchronously
  • Publish-Subscribe: Publish messages to multiple subscribers
  • Message Queuing: Queue messages for later processing
  • Event-Driven: Trigger processing based on message events

Implementation Example

Here's an example of asynchronous message processing:

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
       IDENTIFICATION DIVISION.
       PROGRAM-ID. ASYNC-MESSAGE-HANDLER.
       
       ENVIRONMENT DIVISION.
       DATA DIVISION.
       
       WORKING-STORAGE SECTION.
       01  MQ-REQUEST.
           05  REQUEST-TYPE         PIC X(20).
           05  REQUEST-DATA         PIC X(500).
           05  REQUEST-TIMESTAMP    PIC X(26).
       
       01  MQ-RESPONSE.
           05  RESPONSE-STATUS      PIC X(8).
           05  RESPONSE-DATA        PIC X(500).
           05  RESPONSE-TIMESTAMP   PIC X(26).
       
       01  PROCESSING-TASK         PIC X(8).
       
       PROCEDURE DIVISION.
       
       MAIN-LOGIC.
           PERFORM RECEIVE-REQUEST
           PERFORM START-ASYNC-PROCESSING
           PERFORM SEND-ACKNOWLEDGMENT
           
           EXEC CICS RETURN END-EXEC
       
       RECEIVE-REQUEST.
           EXEC CICS MQ GET
               QUEUE(MQ-REQUEST-QUEUE)
               MESSAGE(MQ-REQUEST)
           END-EXEC
       
       START-ASYNC-PROCESSING.
           EXEC CICS START
               TRANSID('PROCESS')
               FROM(MQ-REQUEST)
               TERMID('MQTERM')
               TASKID(PROCESSING-TASK)
           END-EXEC
       
       SEND-ACKNOWLEDGMENT.
           MOVE 'ACCEPTED' TO RESPONSE-STATUS
           MOVE FUNCTION CURRENT-DATE TO RESPONSE-TIMESTAMP
           
           EXEC CICS MQ PUT
               QUEUE(MQ-RESPONSE-QUEUE)
               MESSAGE(MQ-RESPONSE)
               CORRELID(MQ-REQUEST-TYPE)
           END-EXEC.

Benefits of Asynchronous Processing

Asynchronous processing provides several advantages:

  • Improved Responsiveness: User interactions are not blocked by message processing
  • Better Scalability: Handle high message volumes without performance degradation
  • Fault Tolerance: Message processing continues even if individual programs fail
  • Load Balancing: Distribute processing across multiple CICS regions
  • System Stability: Prevent message processing from overwhelming the system

Message Types and Formats

Understanding different message types and formats is essential for effective MQSeries Integration. CICS applications can handle various message structures and content types.

Message Types

Several message types are commonly used:

  • Data Messages: Contain application data for processing
  • Control Messages: Control application behavior and flow
  • Event Messages: Notify applications of system events
  • Response Messages: Provide responses to previous requests
  • Error Messages: Report processing errors and failures

Message Formats

Messages can be formatted in various ways:

text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Message Format Examples:
 
# XML Format


    ORD12345
    CUST001
    2024-01-15
    
        
            PROD001
            2
            29.99
        
    

 
# JSON Format
{
    "orderId": "ORD12345",
    "customerId": "CUST001",
    "orderDate": "2024-01-15",
    "items": [
        {
            "productId": "PROD001",
            "quantity": 2,
            "unitPrice": 29.99
        }
    ]
}
 
# Fixed-Length Format
ORD12345CUST0012024-01-15PROD001000200002999
 
# Variable-Length Format
ORD12345|CUST001|2024-01-15|PROD001|2|29.99

Message Handling

Effective message handling involves several considerations:

  • Message Validation: Verify message structure and content
  • Error Handling: Handle malformed or invalid messages
  • Message Transformation: Convert between different formats
  • Message Routing: Route messages to appropriate handlers
  • Message Persistence: Ensure messages are not lost during processing

Error Handling and Recovery

Robust error handling and recovery mechanisms are essential for production MQSeries Integration. CICS provides several facilities for managing message processing errors and system failures.

Error Types

Several types of errors can occur:

  • Message Format Errors: Invalid message structure or content
  • Processing Errors: Business logic failures during message processing
  • System Errors: CICS or MQ system failures
  • Connection Errors: MQ connection failures or timeouts
  • Resource Errors: Insufficient system resources

Error Handling Strategies

Several error handling strategies can be implemented:

cobol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
       IDENTIFICATION DIVISION.
       PROGRAM-ID. ERROR-HANDLER.
       
       ENVIRONMENT DIVISION.
       DATA DIVISION.
       
       WORKING-STORAGE SECTION.
       01  ERROR-INFO.
           05  ERROR-CODE           PIC S9(8) COMP.
           05  ERROR-MESSAGE        PIC X(100).
           05  ERROR-SEVERITY       PIC X(8).
       
       01  RECOVERY-ACTION          PIC X(20).
       
       PROCEDURE DIVISION.
       
       MAIN-LOGIC.
           PERFORM HANDLE-ERROR
           PERFORM EXECUTE-RECOVERY
           
           EXEC CICS RETURN END-EXEC
       
       HANDLE-ERROR.
           EXEC CICS HANDLE CONDITION
               ERROR(ERROR-ROUTINE)
           END-EXEC
       
       ERROR-ROUTINE.
           MOVE DFHEIBLK TO ERROR-INFO
           
           EVALUATE ERROR-CODE
               WHEN 1001
                   MOVE 'RETRY' TO RECOVERY-ACTION
               WHEN 1002
                   MOVE 'DEAD-LETTER' TO RECOVERY-ACTION
               WHEN 1003
                   MOVE 'ROLLBACK' TO RECOVERY-ACTION
               WHEN OTHER
                   MOVE 'ABEND' TO RECOVERY-ACTION
           END-EVALUATE
       
       EXECUTE-RECOVERY.
           EVALUATE RECOVERY-ACTION
               WHEN 'RETRY'
                   PERFORM RETRY-MESSAGE
               WHEN 'DEAD-LETTER'
                   PERFORM SEND-TO-DEAD-LETTER-QUEUE
               WHEN 'ROLLBACK'
                   EXEC CICS SYNCPOINT ROLLBACK END-EXEC
               WHEN 'ABEND'
                   EXEC CICS ABEND ABCODE('MQER') END-EXEC
           END-EVALUATE.

Recovery Mechanisms

Several recovery mechanisms are available:

  • Message Retry: Automatically retry failed message processing
  • Dead Letter Queues: Route failed messages to special queues
  • Transaction Rollback: Rollback failed transactions
  • Message Replay: Replay messages from backup sources
  • System Restart: Restart failed processing programs

Performance and Tuning

Performance optimization is crucial for MQSeries Integration in production environments. Understanding performance factors and tuning techniques ensures optimal message processing throughput.

Performance Factors

Several factors affect MQSeries Integration performance:

  • Message Size: Larger messages require more processing time
  • Message Volume: High message volumes impact system resources
  • Processing Complexity: Complex business logic increases processing time
  • Queue Depth: Deep queues can cause processing delays
  • System Resources: CPU, memory, and I/O capacity limitations

Tuning Techniques

Several tuning techniques can improve performance:

text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Performance Tuning Parameters:
 
# CICS System Parameters
MAXTASKS=1000              # Maximum concurrent tasks
MAXOPENFILES=500           # Maximum open files
MAXTS=1000                 # Maximum temporary storage entries
MAXTD=1000                 # Maximum transient data entries
 
# MQ Bridge Parameters
MQMAXCONN=100              # Maximum MQ connections
MQTIMEOUT=60               # Connection timeout
MQMAXMSGLEN=1048576        # Maximum message length
MQPERSISTENCE=YES          # Message persistence
 
# Queue Manager Parameters
MAXMSGL=1048576            # Maximum message length
MAXDEPTH=10000             # Maximum queue depth
MAXHANDS=1000              # Maximum handles
MAXCHANNELS=100            # Maximum channels

Monitoring and Metrics

Key performance metrics should be monitored:

  • Message Throughput: Messages processed per second
  • Response Time: Time to process individual messages
  • Queue Depth: Number of messages waiting in queues
  • Error Rates: Percentage of failed message processing
  • Resource Utilization: CPU, memory, and I/O usage

Knowledge Check: CICS MQSeries Integration

Question 1: What is the primary purpose of the MQ Bridge in CICS MQSeries Integration?

Question 2: What is a key benefit of asynchronous processing in MQSeries Integration?

Question 3: What is the purpose of dead letter queues in MQSeries Integration?

Answers:

Question 1: B) Connect CICS to IBM MQ systems and manage message routing
Question 2: B) Improves application responsiveness and scalability
Question 3: B) Route failed messages for manual review and recovery

Related Concepts

CICS Web & API Integration

Web-based integration capabilities in CICS

CICS Programming Models

Different programming approaches and languages in CICS

CICS EXEC CICS Commands

Core CICS commands for program control and resource management

CICS Performance Tuning

Performance optimization and monitoring in CICS