Integrated Development Environment for Integration Developers

This topic describes how to use the integrated development environment (IDE) for Open Integration development, including generating project artifacts for IDE-based development, testing changes, and packaging the completed solution.

The integrated development environment (IDE) helps Integration Developers to open Open Integration in an IDE to make changes, rebuild, and retest with less turnaround time.

You can use:

• --codegen to generate the project artifacts for IDE development.
• --package to package when the changes are ready.

Prerequisites

Before you start, you must complete the following tasks:

1. Rename settings.xml.template in <INSTALLED-DIRECTORY> to settings.xml.
2. Ensure that all configurations are available in one of the following locations:
   • Local workspace or
   • Remote repository
3. Place all JKS file references in config.json and profile.json under <INSTALLED-DIRECTORY>/openit-deploy.

Generating Artifacts for IDE Development

After integration configurations are ready in the local workspace or remote repository, you must run the design-time pipeline with the --codegen option as follows:

• On Windows:
  • If the integration configurations are available locally:

    gen.bat --codegen

  • If the integration configurations (config.json and profile.json) are in a remote Git repository:
    1. Update git.json in <ROOT>/openit-deploy with the required connection and download details.
    2. Run the following command:

       gen.bat
                 --codegen --download-from-git [--git-token=<git password>]
                 [--git-truststore-password=<trusstore passsword>]

• On Linux:
  • If the integration configurations are available locally:

    gen.sh --codegen.

  • If the integration configurations (config.json and profile.json) are in a remote Git repository:
    1. Update git.json in <ROOT>/openit-deploy with the required connection and download details.
    2. Run the following command:

       ./gen.sh --codegen --download-from-git [--git-token=<git password>]
                 [--git-truststore-password=<trusstore passsword>]

Preparing IDE

You can use any one of the following IDEs for Open Integration:

• IntelliJ IDE
• Eclipse IDE
• VS Code
• Apache NetBeans

Setting up IntelliJ IDE

1. Launch IntelliJ IDEA.
2. Open <INSTALLED-DIRECTORY>/openit-deploy. IntelliJ should detect it as a Maven project.
3. If prompted, choose Trust Project > Load Maven Project/ Import Maven Projects.
4. Open the Maven tool window and verify that the project lifecycle goals, such as clean and install, are available.
5. Configure Maven to use your custom settings.xml:
   1. Go to File > Settings > Build > Execution > Deployment > Build Tools > Maven.
   2. In User settings file, select Override, and then browse to <INSTALLED-DIRECTORY>/settings.xml.
   3. Click Apply, and then click OK.
   4. In the Maven tool window, click Reload All Maven Projects. This action ensures that IntelliJ IDEA uses the internal repositories defined in the settings.xml file.
6. Add the GraalVM JDK and set it as Project SDK:
   1. Go to File > Project Structure > Platform Settings > SDKs.
   2. Click Add JDK from disk, and then select <INSTALLED-DIRECTORY>/graalvm-jdk.
   3. Name the SDK GRAAL-JDK-25.
   4. Go to Project Settings > Project.
   5. Set Project SDK to GRAAL-JDK-25.
   6. Click Apply, and then click OK.
7. Ensure that Module SDK is set to Project SDK or GRAAL-JDK-25, in Project Settings > Modules > Dependencies.
8. Restart IntelliJ IDEA. If indexing issues occur, use Invalidate Caches before restarting.
9. Perform a quick verification, from the IntelliJ Maven tool window, run clean, and then run test or install.

Prepare Eclipse IDE

1. Ensure that Maven integration, or m2e, is installed. If it is not installed, use Help, Eclipse Marketplace, search for m2e or Maven Integration for Eclipse, install it, and restart Eclipse.
2. Import the Maven project:
   1. Go to File > Import.
   2. Select Maven > Existing Maven Projects.
   3. Set Root Directory to <INSTALLED-DIRECTORY>/openit-deploy.
   4. Ensure that pom.xml is detected, and then click Finish.
3. Configure Maven to use your custom settings.xml:
   1. Go to Window > Preferences > Maven > User Settings.
   2. Select Override, browse to <INSTALLED-DIRECTORY>/settings.xml.
   3. Click Apply and then Close.
4. Add the GraalVM JDK in Eclipse and set it for the project:
   1. Go to > Window > Preferences > Java > Installed JREs.
   2. Click Add, choose Standard VM, and set JRE home to <INSTALLED-DIRECTORY>/graalvm-jdk.
   3. Name it JRE GRAAL-JDK-25.
   4. Optionally select it as the default.
   5. Click Apply and then Close.
5. Set the project’s JDK level:
   1. Click Project > Properties.
   2. Go to Java Build Path > Libraries.

      Ensure that the project uses the correct JRE.

   3. Go to Java Compiler and set the compliance level required by the build. Ensure you match the pom.xml or toolchain expectations
6. Restart Eclipse.

Prepare VS Code

1. In VS Code, install the following extensions:
   • Extension Pack for Java (Microsoft)
   • Maven for Java
2. Open <INSTALLED-DIRECTORY>/opening-deploy as the project folder.
3. Configure the GraalVM JDK by using one of the following settings.
   1. Option A: Open Settings (JSON) and add the following:

      {
      "java.jdt.ls.java.home": "<INSTALLED-DIRECTORY>/graalvm-jdk"
      }
      

   2. Option B: Configure multiple runtimes:

      {
      "java.configuration.runtimes": [
      {
      "name": "JavaSE-25",
      "path": "<INSTALLED-DIRECTORY>/graalvm-jdk",
      "default": true
      }
      ]
      }
      

   3. Restart VS Code.
4. Configure Maven to use your custom settings.xml through one of the following options:
   1. Run Maven with the explicit settings option to use the project-specific Maven settings file:

      mvn -s <INSTALLED-DIRECTORY>/settings.xml clean
                  install

   2. Configure the Visual Studio Code Maven extension to use the required Maven settings file. Set the Maven User settings path to your <INSTALLED-DIRECTORY>/settings.xml.
5. Verify the setup as follows:

   mvn -s <INSTALLED-DIRECTORY>/settings.xml -version
   mvn -s <INSTALLED-DIRECTORY>/settings.xml clean install
   

Prepare Apache NetBeans

1. Go to File, and then Open Project. Select <INSTALLED-DIRECTORY>/openit-deploy.
2. Configure Maven settings:
   1. Depending on the NetBeans version, go to Tools > Options > Java/Miscellaneous > Maven.
   2. Set User settings to <INSTALLED-DIRECTORY>/settings.xml.
      Note: If NetBeans does not provide a direct setting, add -s <INSTALLED-DIRECTORY>/settings.xml for builds, or use command-line builds.
3. Configure GraalVM JDK:
   1. Go to Tools > Java Platforms.
   2. Add <INSTALLED-DIRECTORY>/graalvm-jdk as a platform.
   3. Name the platform GRAAL-JDK-25.
   4. Click Project > Properties.
   5. Set Java Platform to GRAAL-JDK-25.
4. Restart NetBeans. Close and reopen to ensure that the platform and Maven settings are applied.

Understanding the Project Structure

The main class is available at src/main/java/com/siebel/openint/resources/Main.java.

The following files and folders are copied to src/main/java/resources:

• integration-configurations
• merged_config.json
• profile.json
• log4j2.xml
• JKS files

Starting the Open Integration Server in an IDE

Use the main class com.siebel.openint.resource.Main and set the environment variable SIEBEL_EVENT_PUBSUB to 1.

For IntelliJ IDEA:

1. Go to Run > Edit Configurations.
2. Create or select an Application configuration for com.siebel.openint.resource.Main.
3. Set main class to com.siebel.openint.resource.Main.
4. Select the module that contains the main class.
5. Add the environment variable SIEBEL_EVENT_PUBSUB=1.
6. Apply the changes and run the configuration.

For Eclipse IDE:

1. In Package Explorer, locate com.siebel.openint.resource.Main.
2. Select Run As, and then Run Configurations.
3. Under Java Application, select or create a Java Application configuration.
4. On the Environment tab, add SIEBEL_EVENT_PUBSUB with the value 1.
5. Apply the changes and run the configuration.

For VS Code:

• Option A: Using launch.json

  1. Add or update launch.json as follows:

     {
     "type": "java",
     "name": "Run Main (Kafka)",
     "request": "launch",
     "mainClass": "com.siebel.openint.resource.Main",
     "env": {
     "SIEBEL_EVENT_PUBSUB": "1"
     }
     }
     

  2. Locate the run configuration named Run Main (Kafka).
  3. Click Run to start the application or click Debug to start the application in debug mode.

• Option B: Run from the terminal

  • On Linux:

    SIEBEL_EVENT_PUBSUB=1 mvn exec:java

  • On Windows Command Prompt or PowerShell:

    $env:SIEBEL_EVENT_PUBSUB="1"; mvn exec:java

    Note: Exact Maven goal may differ based on your project setup.

For NetBeans:

1. Click the Project > Properties.
2. Go to Run.
3. Set Main Class to com.siebel.openint.resource.Main, if it is not already set.
4. Add SIEBEL_EVENT_PUBSUB=1 in Environment Variables or VM Options, depending on the NetBeans version.
5. Run the project.

Note: If the NetBeans version does not expose environment variables for a run configuration, start NetBeans from a terminal where the environment variable is already set, or run from the terminal as shown in the VS Code section.

Continuous Testing and Packaging

If you change any configuration files:

1. During IDE testing, you must re-run code generation:
   • On Linux, from <INSTALLED-DIRECTORY>/openit-deploy, run:

     ./gen.sh --codegen

   • On Windows Command Prompt or PowerShell, from <INSTALLED-DIRECTORY>\openit-deploy, run:

     .\gen.bat –codegen

   This regenerates the configurations and keeps the project up to date.

2. When the changes are ready to be shipped, run packaging:
   • On Linux, from <INSTALLED-DIRECTORY>/openit-deploy, run: ./gen.sh --package
   • On Windows Command Prompt or PowerShell, from <INSTALLED-DIRECTORY>\openit-deploy, run, .\gen.bat –package.

Packaging creates <INSTALLED-DIRECTORY>/openit-deploy/target/opeint.jar that includes all auto generated artifacts.

Packaging also copies all configurations into <INSTALLED-DIRECTORY>/openit-deploy/target.