Sunday, November 15, 2026

OIC - Disaster Recovery (DR) Validation: End-to-End Test Scenarios

 1. Introduction

  • Disaster Recovery (DR) is an important aspect of any enterprise integration platform. Organizations rely on Oracle Integration Cloud (OIC) to exchange business-critical data between Oracle Fusion Applications, on-premise applications, OCI services, and external systems.
  • In the event of a regional outage or infrastructure failure, the DR environment must be capable of taking over integration workloads with minimal business disruption.
  • However, configuring a secondary OIC instance is not sufficient. We must validate connectivity, authentication, integrations, scheduling, messaging, and external application access after failover.

This blog covers nine important test scenarios to validate OIC functionality following a disaster recovery exercise.

2. Business Use Case

Consider an organization running its integrations in a primary OCI region, connecting to:

  • Oracle Fusion ERP.
  • On-premise applications through OIC Connectivity Agent.
  • OCI Functions and Vault.
  • OCI Object Storage.
  • External applications consuming OIC REST services.
  • Kafka messaging platforms.

The organization maintains a secondary OIC environment in another region.

During a disaster recovery exercise, the secondary environment takes over the integration workloads.

The objective is to ensure that all critical integration capabilities continue functioning as expected after failover.

3. DR Validation Architecture

Primary Region:

  • OIC Primary Instance
  • Oracle Fusion ERP
  • OCI Services
  • On-premise Connectivity Agent
  • External Applications
  • Kafka Platform

Secondary Region:

  • OIC Secondary Instance
  • Replicated or configured integration artifacts
  • Required connections and credentials
  • DR connectivity and service configurations

After failover, the secondary OIC instance becomes responsible for processing integration requests.

4. Disaster Recovery Test Scenarios

TEST01: OIC to ERP Connectivity

Objective: Verify connectivity between OIC and Oracle ERP.

Test Steps:

  1. Access the OIC DR instance.
  2. Navigate to Connections.
  3. Validate the ERP connection.
  4. Execute the connection test.
  5. Validate authentication and connectivity using the configured consent user.

Expected Result: OIC should successfully authenticate and establish connectivity with Oracle ERP.

TEST02: OIC to On-Premise Shared Folder Connectivity

Objective: Verify connectivity between OIC and on-premise applications through the Connectivity Agent.

Test Steps:

  1. Verify the Connectivity Agent status.
  2. Execute an integration using the configured agent.
  3. Write a sample file to the on-premise shared folder.
  4. Verify whether the file is successfully created.

Expected Result: OIC should successfully communicate with the on-premise environment and write the file to the shared folder.

TEST03: OIC to On-Premise SOAP/API Connectivity

Objective: Verify SOAP/API connectivity between OIC and on-premise applications through the Connectivity Agent.

Test Steps:

  1. Validate the agent connectivity.
  2. Execute an integration invoking the on-premise SOAP/API service.
  3. Validate the request and response.
  4. Verify that the target application processes the request successfully.

Expected Result: OIC should successfully invoke the on-premise SOAP/API service and receive the expected response.

TEST04: OIC to OCI Function Service Connectivity

Objective: Verify connectivity between OIC and OCI Functions.

Test Steps:

  1. Validate the OCI Function connection configuration.
  2. Execute an OIC integration invoking the configured Function Service.
  3. Validate the request payload.
  4. Verify the response returned by the Function.

Expected Result: OIC should successfully invoke the OCI Function and receive the expected response.

TEST05: OIC to OCI Vault Connectivity

Objective: Verify connectivity between OIC and OCI Vault.

Test Steps:

  1. Validate the Vault connection configuration.
  2. Verify the required authentication and IAM permissions.
  3. Execute an integration that retrieves the required secret from Vault.
  4. Validate the response.

Expected Result: OIC should successfully access the configured Vault resource based on the assigned permissions.

TEST06: OIC to OCI Object Storage Connectivity

Objective: Verify connectivity between OIC and OCI Object Storage.

Test Steps:

  1. Validate the Object Storage connection.
  2. Execute an integration that uploads a sample file to the configured bucket.
  3. Verify that the file is available in the target bucket.
  4. Validate download/access functionality if applicable.

Expected Result: OIC should successfully upload and access files in the configured Object Storage bucket.

TEST07: External Application to OIC Connectivity

Objective: Verify that external systems can continue invoking OIC services after DR failover.

Test Steps:

  1. Identify the production OIC REST service URL.
  2. Perform the DR failover.
  3. Verify the production endpoint and DNS/routing configuration.
  4. Invoke the OIC REST service from the external application.
  5. Validate the response.

Expected Result: External applications should successfully invoke OIC services using the unchanged production URL.

Important: This validation assumes a common custom endpoint or equivalent routing strategy is configured. The endpoint and DNS handling depend on the DR approach being used.

TEST08: Next/Queue Execution and Scheduling

Objective: Verify that asynchronous processing and scheduled integrations function correctly after DR failover.

Test Steps:

  1. Execute a sample integration using the configured Next/Queue processing mechanism.
  2. Verify that the message is successfully processed.
  3. Validate the scheduled integration configuration.
  4. Verify schedule activation and execution.
  5. Check the integration monitoring logs for successful execution.

Expected Result: Queue-based processing and scheduled integrations should operate as expected in the DR environment.

Note: Validate pending and in-flight transactions separately. Some asynchronous transactions may require manual retry after failover.

TEST09: OIC to Kafka Connectivity

Objective: Verify Kafka connectivity through the Connectivity Agent.

Test Steps:

  1. Validate the Kafka connection configuration.
  2. Verify agent connectivity.
  3. Execute a Publish operation from OIC.
  4. Verify that the message is available in the target Kafka topic.
  5. Execute a Subscribe operation.
  6. Validate that OIC successfully consumes the published message.

Expected Result: OIC should successfully publish and subscribe to Kafka events after DR failover.

5. Overall DR Validation Checklist

After executing all nine test cases, validate the following:

  • ERP connectivity is working.
  • On-premise shared folder connectivity is working.
  • SOAP/API connectivity is working.
  • OCI Function invocation is successful.
  • OCI Vault access is successful.
  • Object Storage operations are successful.
  • External applications can invoke OIC services.
  • Queue processing and schedules are functioning.
  • Kafka Publish/Subscribe operations are successful.

Capture the execution status, test evidence, and any issues identified during validation.

6. Conclusion

Disaster Recovery validation is not just about making the secondary OIC instance available. It is about ensuring that the complete integration ecosystem continues to operate successfully after failover.

Executing these nine test scenarios provides a practical approach to validating connectivity, authentication, OCI services, scheduling, messaging, and external application access.

Regular DR simulations and end-to-end testing help organizations improve recovery readiness, minimize business disruption, and maintain integration service continuity.

The ultimate goal is simple: When the primary region becomes unavailable, the business integrations should continue operating through the secondary region with minimum disruption.

7. Oracle Documentation References

  1. Configuring Oracle-Managed DR for OIC 3: https://docs.oracle.com/en/cloud/paas/application-integration/oracle-disaster-recovery/introduction-oracle-managed-disaster-recovery.html

  2. Configuring Customer-Managed DR for OIC 3: https://docs.oracle.com/en/cloud/paas/application-integration/disaster-recovery/disaster-recovery-integrations.html

  3. OIC Connectivity Agent Responsibilities During Failover: https://docs.oracle.com/en/cloud/paas/application-integration/oracle-disaster-recovery/understand-connectivity-agent-responsibilities-failover.html

  4. OIC Failover Process: https://docs.oracle.com/en/cloud/paas/application-integration/oracle-disaster-recovery/fail-secondary-instance.html

Tuesday, November 10, 2026

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




Monday, November 2, 2026

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



Friday, October 30, 2026

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.

Featured Post

OIC - Disaster Recovery (DR) Validation: End-to-End Test Scenarios

 1. Introduction Disaster Recovery (DR) is an important aspect of any enterprise integration platform. Organizations rely on Oracle Integra...