Oracle Integration Cloud (OIC): Understanding Start vs Resume and Stop vs Pause for Scheduled Integrations

 Introduction

In Oracle Integration Cloud (OIC), we can control scheduled integration executions using four important operations: Start, Stop, Pause, and Resume.

Although these operations may look similar, they behave differently, especially when managing scheduled integration executions.

Let's understand the differences with simple real-time examples.

1. Start vs Resume

Start

• Activates a schedule that is currently stopped.
• Enables the integration to execute according to its configured schedule.
• Once started, OIC begins generating scheduled execution instances.

Example:

Consider an integration that synchronizes employee information from Oracle HCM to an external application every day at 10 AM.

If the schedule is stopped, it will not execute.

When we perform the Start operation, the schedule becomes active again, and the integration will execute according to its configured schedule.

Resume

• Reactivates a schedule that was previously paused.
• Continues the existing schedule from its paused state.
• Allows paused scheduled executions to continue.

Example:

Consider the same employee synchronization integration scheduled to run every day at 10 AM.

Suppose we pause the schedule temporarily due to maintenance. The upcoming scheduled execution is held.

Once maintenance is completed, we perform the Resume operation.

OIC resumes the paused schedule, and the pending scheduled execution can proceed.

Key Difference:

Start is used to activate a stopped schedule, whereas Resume is used to continue a previously paused schedule.

2. Stop vs Pause

Stop

• Completely stops the active schedule.
• Cancels all scheduled runs, including pending future executions.
• To execute the integration again on its configured schedule, we need to Start it.

Example:

Consider an integration that sends daily sales reports to the finance team at 9 AM.

Suppose the integration is no longer required because the business process has been discontinued.

We perform the Stop operation.

The schedule is stopped, and all scheduled runs are cancelled.

If the business requires the integration again in the future, we can Start the schedule.

Pause

• Temporarily suspends scheduled executions.
• Does not permanently stop the schedule.
• Upcoming scheduled executions are held until the schedule is resumed.
• Once resumed, pending executions can proceed.

Example:

Consider an integration scheduled to run every hour:

• 2 PM
• 3 PM
• 4 PM
• 5 PM

Suppose the 3 PM execution completes successfully and we pause the schedule.

The 4 PM execution will be paused.

If we resume the schedule at 4:30 PM, the pending 4 PM execution will be triggered.

This is particularly useful during temporary maintenance, troubleshooting, or planned downtime.

Key Difference:

Stop cancels scheduled runs, whereas Pause temporarily suspends them so they can continue after Resume.

3. Quick Comparison

Start: Activates a stopped schedule.

Resume: Continues a previously paused schedule.

Stop: Stops the schedule and cancels scheduled runs.

Pause: Temporarily suspends scheduled executions without cancelling the pending execution.

4. Real-Time Use Cases

• Start: Enable a newly configured or previously stopped integration schedule.
• Resume: Continue an integration after planned maintenance.
• Stop: Permanently discontinue an integration schedule that is no longer required.
• Pause: Temporarily prevent scheduled executions during troubleshooting or maintenance.

5. OIC Factory API Endpoints

We can automate these operations using Oracle Integration Factory REST APIs.

For an integration in the standard Integrations area, the endpoints are:

Start Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/start

Stop Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/stop

Pause Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/pause

Resume Schedule POST /ic/api/integration/v1/integrations/{id}/schedule/resume

Here, {id} represents the integration composite identifier containing the integration code and version.

Conclusion

Understanding the difference between these four operations is important when managing OIC scheduled integrations.

In simple terms:

• Start = Activate
• Resume = Continue
• Stop = Cancel and deactivate
• Pause = Temporarily hold

Choosing the correct operation helps manage scheduled integrations effectively and avoids unnecessary execution interruptions.

Oracle Documentation

1. Oracle Integration 3 – Start and Pause an Integration Schedule: https://docs.oracle.com/en/cloud/paas/application-integration/integrations-user/start-pause-integration-schedule.html
2. Oracle Integration 3 – Scheduled Integrations REST Endpoints: https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/api-integrations-integrations-scheduled-integrations.html

OIC - Common Service - Streamlining OIC Schedule Management Through REST API Automation

Introduction

In Oracle Integration Cloud (OIC), managing scheduled integrations involves operations such as Stop, Start, Pause, Resume, Add Schedule, and Update Schedule. Performing these operations manually across multiple integrations can be time-consuming.

To simplify this process, we can develop an automated Scheduling Management Service using OIC Factory REST APIs. The solution follows a lookup-driven approach to identify the integrations, execute the required scheduling operations, and generate a consolidated execution report.

Solution Approach

1. Lookup Configuration

Maintain all required details in an OIC lookup, including:

• Project name
• Integration identifier
• Schedule name
• Operation type (Stop/Start/Pause/Resume/Add/Update)
• Required schedule configuration for Add or Update operations.

2. Main Integration – Scheduling Service

• Fetch all configuration records from the lookup.
• Read the project, integration, schedule, and operation details.
• Pass the required configuration details to the Child Integration.
• Invoke the Child Integration to process the scheduling operations.

3. Child Integration – Schedule Operations

• Receive configuration details from the Main Integration.
• For each record, call the OIC Factory API to retrieve the existing schedule details.
• Append the retrieved schedule information to a file for processing.
• Iterate through each schedule entry.
• Use a Switch action to identify the requested operation.
• Based on the operation type, invoke the corresponding OIC Factory REST API.

Supported Operations:

• Stop: Stop an active schedule.
• Start: Start a stopped schedule.
• Pause: Temporarily pause schedule execution.
• Resume: Resume a paused schedule.
• Add Schedule: Create a new schedule.
• Update Schedule: Modify an existing schedule.

Stop Schedule:

Resume Schedule:

Pause Schedule:

Start Schedule:

Get schedule info:

ADD Schedule:

Update Schedule:

4. Consolidated Execution Report

After processing all records:

• Capture the API response for each operation.
• Maintain success and failure status for every record.
• Capture error details wherever an operation fails.
• Generate a consolidated execution report.
• Send the report through email to the configured recipients.

Benefits

• Automates bulk scheduling operations across multiple OIC integrations.
• Eliminates repetitive manual schedule management.
• Lookup-driven configuration makes the solution reusable and easy to maintain.
• Supports multiple scheduling operations through a single service.
• Provides centralized execution tracking and failure details.
• Improves operational efficiency and reduces manual errors.

Conclusion

By leveraging OIC Factory REST APIs and lookup-driven configurations, we can build a reusable Scheduling Management Service that automates multiple scheduling operations from a single integration. This approach simplifies OIC operational management and provides a consolidated view of all scheduling activities through email reporting.

Reference:

https://docs.oracle.com/en/cloud/paas/integration-cloud/rest-api/op-ic-api-integration-v1-integrations-id-schedule-stop-post.html

OIC - Automated OIC Project Export and Backup Using Factory APIs

1. Introduction

To simplify OIC project backup, we developed a reusable integration solution using OIC Factory APIs to export projects as CAR files and save them to the OIC embedded SFTP server. The exported files can then be manually downloaded and uploaded to SharePoint or any other backup location.

2. Solution Overview

The solution consists of two integrations: Main and Child.

Lookup Configuration

An OIC lookup maintains the following project details:

• Project Code
• Project Type (Developed / XBA)
• Version (for Accelerator projects)

3. Integration Flow

Main Integration:

1. Fetch all project details from the configured lookup.
2. Iterate through the lookup records.
3. Pass project code, project type, and version one by one to the child integration.
4. Invoke the child integration for each project.

Get Export lookup data:

GET /ic/api/integration/v1/projects/{projectId}/lookups/{name}

Trigger:

Run from Lookup for all projects:

Adhoc projects run:

Child Integration:

1. Receive project details from the main integration.
2. Prepare the export request based on the project type and version.
3. Invoke the OIC Factory API to export the respective project.
4. Retrieve the generated CAR file.
5. Save the CAR file to the configured OIC SFTP directory.
6. Return the export status to the main integration.

API used: https://<OIC-HOST>/ic/api/integration/v1/projects/{id}/archive?integrationInstance=<service-instance-name>

Request payload:

{

  "code": "TEST_PROJECT",

  "type": "DEVELOPED",

  "label": "01.00.0000"

}

4. Backup Process

Once all projects are exported successfully, the CAR files are available in the OIC SFTP directory. These files can be manually downloaded and uploaded to SharePoint, OCI Object Storage, or any other enterprise backup location.

Oracle Documentation:

https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/op-ic-api-integration-v1-projects-id-archive-post.html?utm_source=chatgpt.com

https://docs.oracle.com/en/cloud/paas/application-integration/rest-api/op-ic-api-integration-v1-lookups-name-get.html?source=%3Aow%3Alp%3Acpo%3A%3A%3A%3ARC_CORP250721P00028%3ADMO400412486

5. Benefits

• Automates project export using OIC Factory APIs.
• Centralizes project configuration through lookups.
• Supports multiple project types.
• Reuses a common child integration for all projects.
• Reduces manual effort in project backup.
• Provides a centralized location for exported CAR files.

6. Conclusion

This solution provides a reusable and configurable approach to exporting multiple OIC projects and consolidating their CAR files in SFTP. It simplifies project backup activities and makes the exported archives available for storage in external backup locations.