What is the difference between a process and an activity in CICS BTS?

A process is an instance of a business transaction that contains one or more activities. An activity is a single unit of work within a process that performs a specific business function. Processes provide the overall structure and lifecycle management, while activities perform the actual work and can be organized hierarchically with parent and child activities.

How do you start an activity in CICS BTS?

Activities are started using the START command, which can be issued by a parent activity or by an event handler. The START command specifies the activity name, process context, activity ID, input containers, and other parameters. Once started, the activity executes its associated program and can signal events, access containers, and perform business logic.

What happens when an activity completes?

When an activity completes successfully, it typically signals a completion event that can trigger other activities in the process. The activity's output containers are made available to other activities. If the activity fails, it can signal an error event, and compensation activities may be triggered to reverse the effects of previously completed activities.

How do you monitor activity processing?

Activity processing can be monitored using the CHECK ACTIVITY command to determine activity status, INQUIRE ACTIVITY to get activity attributes, and browsing commands to list activities. CICS Explorer provides visual tools for monitoring BTS processes and activities in real-time, showing activity states, container contents, and event flows.

CICS Activity Processing

Q: What is CICS activity processing?

CICS activity processing involves executing and managing activities within Business Transaction Services (BTS) business processes. Activities are units of work that perform specific business functions, respond to events, manage state through containers, and can be compensated if needed. Activity processing enables long-running, stateful business transactions that span multiple CICS transactions.

Q: How do activities communicate in CICS BTS?

Activities communicate through events and containers. Events signal progress or trigger actions (e.g., activity completion, error conditions). Containers are named storage areas that hold data shared between activities. Activities can signal events to trigger other activities and use containers to pass data and maintain state throughout the business process.

Q: What is activity compensation in CICS BTS?

Activity compensation is the ability to undo or reverse the effects of a completed activity if a business process fails or needs to be rolled back. Each activity that modifies data should have a corresponding compensating activity that can reverse its effects. Compensation enables reliable long-running transactions that can recover from failures.

CICS activity processing is the execution and management of activities within Business Transaction Services (BTS) business processes. Activities are units of work that perform specific business functions, respond to events, manage state through containers, and can be compensated if needed. Understanding activity processing is essential for building reliable, long-running business applications in CICS.

Unlike traditional CICS transactions that are short-lived and stateless, BTS activities enable stateful, long-running business processes that can span multiple transactions, maintain persistent state, and provide automatic recovery and compensation capabilities.

What is Activity Processing?

Activity processing involves:

Activity Execution: Running activity programs that perform business logic
Event Handling: Responding to events and signaling events to coordinate workflow
Container Management: Reading and writing data containers for state management
Compensation: Providing compensating activities to reverse effects if needed
State Management: Maintaining activity state across transaction boundaries

Activity Lifecycle

Activities follow a well-defined lifecycle from creation to completion:

Activity lifecycle stages
Lifecycle Stage	Description	Key Commands
Definition	Activity is defined in resource definitions	DEFINE ACTIVITY (RDO)
Start	Activity is started by parent or event	START, DEFINE ACTIVITY
Execution	Activity program executes business logic	GET CONTAINER, PUT CONTAINER, SIGNAL EVENT
Completion	Activity completes and signals events	SIGNAL EVENT, CHECK ACTIVITY
Compensation	Compensating activity may be triggered if needed	START (compensating activity)

Starting Activities

Activities are started using the START command or by defining child activities. Activities can be started by parent activities, event handlers, or external triggers.

Starting an Activity

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
WORKING-STORAGE SECTION.
01 WS-RESPONSE            PIC S9(8) COMP.
01 WS-RESPONSE2           PIC S9(8) COMP.
01 WS-ACTIVITY-ID         PIC X(16).
01 WS-PROCESS-NAME        PIC X(16) VALUE 'ORDER-PROCESS'.
 
PROCEDURE DIVISION.
    *> Start a child activity
    MOVE 'ACTIVITY-001' TO WS-ACTIVITY-ID
    
    EXEC CICS START
        ACTIVITY('PROCESS-ORDER')
        PROCESS(WS-PROCESS-NAME)
        ACTIVITYID(WS-ACTIVITY-ID)
        RESP(WS-RESPONSE)
        RESP2(WS-RESPONSE2)
    END-EXEC
    
    IF WS-RESPONSE NOT EQUAL DFHRESP(NORMAL)
        EXEC CICS WRITE OPERATOR
            TEXT('Failed to start activity')
        END-EXEC
        EXEC CICS RETURN END-EXEC
    END-IF.
    
    *> Activity started successfully
    *> The activity program will execute and can access containers

Defining and Starting Child Activities

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PROCEDURE DIVISION.
    *> Define a child activity within the current process
    EXEC CICS DEFINE ACTIVITY('VALIDATE-ORDER')
        PROCESS(WS-PROCESS-NAME)
        ACTIVITYID('VALIDATE-001')
        PARENT(WS-CURRENT-ACTIVITY-ID)
        RESP(WS-RESPONSE)
    END-EXEC
    
    IF WS-RESPONSE EQUAL DFHRESP(NORMAL)
        *> Start the child activity
        EXEC CICS START
            ACTIVITY('VALIDATE-ORDER')
            PROCESS(WS-PROCESS-NAME)
            ACTIVITYID('VALIDATE-001')
            RESP(WS-RESPONSE)
        END-EXEC
    END-IF.

Activity Execution

Once started, an activity executes its associated program. The activity program can access containers, signal events, and perform business logic.

Accessing Containers in Activities

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
WORKING-STORAGE SECTION.
01 WS-ORDER-DATA.
   05 WS-ORDER-NUMBER      PIC X(10).
   05 WS-CUSTOMER-ID       PIC X(8).
   05 WS-ORDER-AMOUNT      PIC S9(9)V99 COMP-3.
 
01 WS-CONTAINER-LENGTH     PIC S9(8) COMP.
01 WS-RESPONSE             PIC S9(8) COMP.
 
PROCEDURE DIVISION.
    *> Activity program execution
    *> Get input data from container
    EXEC CICS GET CONTAINER('ORDER-INPUT')
        INTO(WS-ORDER-DATA)
        FLENGTH(WS-CONTAINER-LENGTH)
        BTS
        RESP(WS-RESPONSE)
    END-EXEC
    
    IF WS-RESPONSE NOT EQUAL DFHRESP(NORMAL)
        EXEC CICS SIGNAL EVENT('ORDER-ERROR')
            PROCESS(WS-PROCESS-NAME)
        END-EXEC
        EXEC CICS RETURN END-EXEC
    END-IF
    
    *> Process the order
    PERFORM VALIDATE-ORDER
    PERFORM CALCULATE-TOTALS
    PERFORM UPDATE-INVENTORY
    
    *> Store results in output container
    EXEC CICS PUT CONTAINER('ORDER-RESULT')
        FROM(WS-ORDER-DATA)
        FLENGTH(LENGTH OF WS-ORDER-DATA)
        BTS
        RESP(WS-RESPONSE)
    END-EXEC
    
    *> Signal completion event
    EXEC CICS SIGNAL EVENT('ORDER-PROCESSED')
        PROCESS(WS-PROCESS-NAME)
        RESP(WS-RESPONSE)
    END-EXEC
    
    EXEC CICS RETURN END-EXEC.

Event Handling

Events are the primary mechanism for coordinating activities. Activities can signal events to trigger other activities or indicate completion.

Signaling Events

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
PROCEDURE DIVISION.
    *> Signal a completion event
    EXEC CICS SIGNAL EVENT('VALIDATION-COMPLETE')
        PROCESS(WS-PROCESS-NAME)
        RESP(WS-RESPONSE)
    END-EXEC
    
    *> Signal an error event
    IF WS-ERROR-OCCURRED
        EXEC CICS SIGNAL EVENT('VALIDATION-ERROR')
            PROCESS(WS-PROCESS-NAME)
            RESP(WS-RESPONSE)
        END-EXEC
    END-IF
    
    *> Signal event with data
    EXEC CICS SIGNAL EVENT('ORDER-APPROVED')
        PROCESS(WS-PROCESS-NAME)
        FROM(WS-APPROVAL-DATA)
        FLENGTH(LENGTH OF WS-APPROVAL-DATA)
        RESP(WS-RESPONSE)
    END-EXEC.

Waiting for Events

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PROCEDURE DIVISION.
    *> Wait for a specific event
    EXEC CICS WAIT EVENT('PAYMENT-RECEIVED')
        PROCESS(WS-PROCESS-NAME)
        TIMEOUT(WS-TIMEOUT-VALUE)
        RESP(WS-RESPONSE)
    END-EXEC
    
    IF WS-RESPONSE EQUAL DFHRESP(NORMAL)
        *> Event received, continue processing
        PERFORM PROCESS-PAYMENT
    ELSE IF WS-RESPONSE EQUAL DFHRESP(TIMEOUT)
        *> Timeout occurred
        PERFORM HANDLE-TIMEOUT
    ELSE
        *> Error occurred
        PERFORM HANDLE-ERROR
    END-IF.

Container Management

Containers are named storage areas that hold data shared between activities. They persist across transaction boundaries and enable state management in long-running processes.

Putting Data in Containers

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
PROCEDURE DIVISION.
    *> Store order data in container
    EXEC CICS PUT CONTAINER('ORDER-DATA')
        FROM(WS-ORDER-RECORD)
        FLENGTH(LENGTH OF WS-ORDER-RECORD)
        BTS
        RESP(WS-RESPONSE)
    END-EXEC
    
    *> Store customer information
    EXEC CICS PUT CONTAINER('CUSTOMER-INFO')
        FROM(WS-CUSTOMER-RECORD)
        FLENGTH(LENGTH OF WS-CUSTOMER-RECORD)
        BTS
        RESP(WS-RESPONSE)
    END-EXEC.

Getting Data from Containers

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
WORKING-STORAGE SECTION.
01 WS-ORDER-DATA           PIC X(200).
01 WS-CONTAINER-LENGTH      PIC S9(8) COMP.
 
PROCEDURE DIVISION.
    *> Retrieve order data from container
    EXEC CICS GET CONTAINER('ORDER-DATA')
        INTO(WS-ORDER-DATA)
        FLENGTH(WS-CONTAINER-LENGTH)
        BTS
        RESP(WS-RESPONSE)
    END-EXEC
    
    IF WS-RESPONSE EQUAL DFHRESP(NORMAL)
        *> Process the retrieved data
        PERFORM PROCESS-ORDER-DATA
    ELSE IF WS-RESPONSE EQUAL DFHRESP(NOTFND)
        *> Container not found
        PERFORM HANDLE-MISSING-CONTAINER
    END-IF.

Activity Compensation

Compensation allows activities to be reversed if a business process fails. Each activity that modifies data should have a corresponding compensating activity.

Compensation Pattern

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
PROCEDURE DIVISION.
    *> Main activity: Reserve inventory
    RESERVE-INVENTORY-ACTIVITY.
        EXEC CICS GET CONTAINER('ORDER-DATA')
            INTO(WS-ORDER-DATA)
            BTS
        END-EXEC
        
        *> Reserve inventory items
        PERFORM RESERVE-INVENTORY-ITEMS
        
        *> Store compensation data
        EXEC CICS PUT CONTAINER('RESERVATION-DATA')
            FROM(WS-RESERVATION-RECORD)
            FLENGTH(LENGTH OF WS-RESERVATION-RECORD)
            BTS
        END-EXEC
        
        *> Signal completion
        EXEC CICS SIGNAL EVENT('INVENTORY-RESERVED')
            PROCESS(WS-PROCESS-NAME)
        END-EXEC.
    
    *> Compensating activity: Release inventory
    RELEASE-INVENTORY-ACTIVITY.
        *> Get reservation data
        EXEC CICS GET CONTAINER('RESERVATION-DATA')
            INTO(WS-RESERVATION-RECORD)
            BTS
        END-EXEC
        
        *> Reverse the reservation
        PERFORM RELEASE-INVENTORY-ITEMS
        
        *> Signal compensation complete
        EXEC CICS SIGNAL EVENT('INVENTORY-RELEASED')
            PROCESS(WS-PROCESS-NAME)
        END-EXEC.

Monitoring Activity Processing

Activities can be monitored to check their status and retrieve information about their execution.

Checking Activity Status

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
WORKING-STORAGE SECTION.
01 WS-ACTIVITY-STATUS      PIC X(16).
01 WS-RESPONSE             PIC S9(8) COMP.
 
PROCEDURE DIVISION.
    *> Check if activity has completed
    EXEC CICS CHECK ACTIVITY('PROCESS-ORDER')
        PROCESS(WS-PROCESS-NAME)
        ACTIVITYID(WS-ACTIVITY-ID)
        STATUS(WS-ACTIVITY-STATUS)
        RESP(WS-RESPONSE)
    END-EXEC
    
    IF WS-RESPONSE EQUAL DFHRESP(NORMAL)
        EVALUATE WS-ACTIVITY-STATUS
            WHEN 'ACTIVE'
                DISPLAY 'Activity is still running'
            WHEN 'COMPLETE'
                DISPLAY 'Activity completed successfully'
            WHEN 'FAILED'
                DISPLAY 'Activity failed'
                PERFORM TRIGGER-COMPENSATION
            WHEN OTHER
                DISPLAY 'Activity status: ' WS-ACTIVITY-STATUS
        END-EVALUATE
    END-IF.

Complete Activity Processing Example

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
IDENTIFICATION DIVISION.
PROGRAM-ID. ORDER-PROCESSING-ACTIVITY.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PROCESS-NAME         PIC X(16) VALUE 'ORDER-BP'.
01 WS-ACTIVITY-ID          PIC X(16).
01 WS-RESPONSE             PIC S9(8) COMP.
01 WS-RESPONSE2            PIC S9(8) COMP.
 
01 WS-ORDER-DATA.
   05 WS-ORDER-NUMBER      PIC X(10).
   05 WS-CUSTOMER-ID       PIC X(8).
   05 WS-ORDER-AMOUNT      PIC S9(9)V99 COMP-3.
   05 WS-ORDER-STATUS      PIC X(1).
 
PROCEDURE DIVISION.
MAIN-ACTIVITY.
    *> Get order data from input container
    EXEC CICS GET CONTAINER('ORDER-INPUT')
        INTO(WS-ORDER-DATA)
        FLENGTH(LENGTH OF WS-ORDER-DATA)
        BTS
        RESP(WS-RESPONSE)
    END-EXEC
    
    IF WS-RESPONSE NOT EQUAL DFHRESP(NORMAL)
        EXEC CICS SIGNAL EVENT('ORDER-ERROR')
            PROCESS(WS-PROCESS-NAME)
        END-EXEC
        EXEC CICS RETURN END-EXEC
    END-IF
    
    *> Validate order
    PERFORM VALIDATE-ORDER
    
    IF WS-ORDER-STATUS = 'V'
        *> Order valid - process it
        PERFORM PROCESS-ORDER
        
        *> Store results
        EXEC CICS PUT CONTAINER('ORDER-RESULT')
            FROM(WS-ORDER-DATA)
            FLENGTH(LENGTH OF WS-ORDER-DATA)
            BTS
            RESP(WS-RESPONSE)
        END-EXEC
        
        *> Signal success
        EXEC CICS SIGNAL EVENT('ORDER-PROCESSED')
            PROCESS(WS-PROCESS-NAME)
            RESP(WS-RESPONSE)
        END-EXEC
    ELSE
        *> Order invalid
        EXEC CICS SIGNAL EVENT('ORDER-REJECTED')
            PROCESS(WS-PROCESS-NAME)
            RESP(WS-RESPONSE)
        END-EXEC
    END-IF
    
    EXEC CICS RETURN END-EXEC.
 
VALIDATE-ORDER.
    *> Validation logic
    IF WS-ORDER-AMOUNT > 0 AND WS-CUSTOMER-ID NOT = SPACES
        MOVE 'V' TO WS-ORDER-STATUS
    ELSE
        MOVE 'I' TO WS-ORDER-STATUS
    END-IF.
 
PROCESS-ORDER.
    *> Business logic for processing order
    CONTINUE.

Best Practices

1. Design Activities for Single Responsibility

Each activity should perform a single, well-defined business function. This makes activities easier to understand, test, and maintain.

2. Use Containers for State Management

Store all state data in containers rather than program variables. Containers persist across transaction boundaries and enable long-running processes.

3. Always Provide Compensation

For activities that modify data, always provide a compensating activity that can reverse the effects. This enables reliable error recovery.

4. Signal Events Appropriately

Signal events to indicate activity completion, errors, and significant milestones. This enables proper workflow coordination.

5. Handle Errors Gracefully

Check response codes after all BTS commands and signal appropriate error events. Implement proper error handling and recovery mechanisms.

Explain It Like I'm 5 Years Old

Imagine you're building a toy with many steps:

Activity processing is like doing each step of building your toy. First you put on the wheels (one activity), then you attach the body (another activity), then you add the decorations (another activity). Each step is an activity that does one specific thing.

If something goes wrong, you can undo a step (compensation) - like taking off the wheels if you put them on wrong. The activities talk to each other through messages (events) - like "wheels are done, now you can attach the body!"

Just like building a toy step by step, CICS activities do business work step by step, and if something goes wrong, they can undo their work!

Exercises

Exercise 1: Start an Activity

Write code to start a child activity named 'VALIDATE-CUSTOMER' in process 'ORDER-BP' with activity ID 'VALID-001'.

cobol

1
2
3
4
5
6
EXEC CICS START
    ACTIVITY('VALIDATE-CUSTOMER')
    PROCESS('ORDER-BP')
    ACTIVITYID('VALID-001')
    RESP(WS-RESPONSE)
END-EXEC.

Exercise 2: Activity with Container Access

Write an activity that gets data from container 'INPUT-DATA', processes it, stores results in container 'OUTPUT-DATA', and signals event 'PROCESSING-COMPLETE'.

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
*> Get input
EXEC CICS GET CONTAINER('INPUT-DATA')
    INTO(WS-INPUT-DATA)
    FLENGTH(LENGTH OF WS-INPUT-DATA)
    BTS
    RESP(WS-RESPONSE)
END-EXEC
 
*> Process data
PERFORM PROCESS-DATA
 
*> Store output
EXEC CICS PUT CONTAINER('OUTPUT-DATA')
    FROM(WS-OUTPUT-DATA)
    FLENGTH(LENGTH OF WS-OUTPUT-DATA)
    BTS
    RESP(WS-RESPONSE)
END-EXEC
 
*> Signal completion
EXEC CICS SIGNAL EVENT('PROCESSING-COMPLETE')
    PROCESS(WS-PROCESS-NAME)
    RESP(WS-RESPONSE)
END-EXEC.

Test Your Knowledge

1. What is an activity in CICS BTS?

A CICS transaction
A single unit of work within a business process
A file operation
A terminal session

2. How do activities share data in CICS BTS?

Through COMMAREA
Through events and containers
Through file operations
Through terminal I/O

3. What is activity compensation?

Paying for activity execution
The ability to undo or reverse the effects of a completed activity
Scheduling activities
Monitoring activities

4. How are activities started in CICS BTS?

Automatically when a process starts
Using the START command by parent activities or event handlers
By reading from a file
By user input

5. What happens when an activity signals an event?

The activity terminates
Other activities waiting for that event can be triggered
The process ends
Nothing happens

CICS Activity Processing

What is Activity Processing?

Activity Lifecycle

Starting Activities

Starting an Activity

Defining and Starting Child Activities

Activity Execution

Accessing Containers in Activities

Event Handling

Signaling Events

Waiting for Events

Container Management

Putting Data in Containers

Getting Data from Containers

Activity Compensation

Compensation Pattern

Monitoring Activity Processing

Checking Activity Status

Complete Activity Processing Example

Best Practices

1. Design Activities for Single Responsibility

2. Use Containers for State Management

3. Always Provide Compensation

4. Signal Events Appropriately

5. Handle Errors Gracefully

Explain It Like I'm 5 Years Old

Exercises

Exercise 1: Start an Activity

Exercise 2: Activity with Container Access

Test Your Knowledge

Related Concepts

CICS BTS Management

CICS Activity Management

CICS Process Management

Related Pages