Running the Design Time Pipeline

After you configure config.jsonand profile.json, run the design-time pipeline by using gen.sh. Ensure that the Siebel application is running when you run the design-time pipeline.

The design-time pipeline performs these tasks:

Downloads configurations from Git.
Reads configuration from config.json and profile.json.
Connectsto Siebel and retrieves metadata for the resources configured in config.json.
Generates the OpenAPI specification from the retrieved metadata.
Generates Plain Old Java Objects (POJOs) that bind to the metadata.
Generates the service implementation code that exposes the REST endpoints.
Builds the Helidon service so it is ready to start and process requests.

To run the design-time pipeline script:

Navigate to the openint-deploy directory:
```
cd <INSTALL_DIR>/openint-deploy
```
Run the design-time pipeline script:
```
gen.sh
```
On Windows, run:
```
gen.bat
```

At the end of execution, the pipeline prints a pipeline error summary:

Creates an error-summary.log file in the current folder to capture the execution summary.
Creates an error.log file in the current folder with detailed information if errors occur.

You can use the following options with the design-time pipeline script to control code generation, packaging, startup, OpenAPI logging, and Git-based configuration download:

Option	Description
--codegen	Runs code generation only. Generates and validates artifacts without packaging. This option is useful for the IDE experience.
--package	Runs packaging only. Packages from existing src/main/resources/ outputs.This option expects outputs from a prior --codegen run.
--start	Starts the server (target/openint.jar) after packaging and redirects runtime output to server_output.log.
--openApiSpecLogLevel:<LEVEL>	Sets the OpenAPI retriever log level. Supported values are TRACE, ALL, ERROR, INFO, FATAL, DEBUG, OFF, and WARN.
--download-from-git	Pulls configurations by using git.json before configuration validation.
--git-token=<token>	Exports GIT_TOKEN for Git HTTP or HTTPS authentication.
--git-trsusttore-password=<password>	Exports GIT_TRUSTSTORE_PASSWORD for HTTPS truststore access. This option is strongly recommended for .jks, .p12, and .pfx files.
--clean-configurations	With --download-from-git, replaces local integration-configurations from the Git source.

For example, to download configurations from Git before packaging:

On Windows:

.\gen.bat
            –download-from-git

On Linux:
```
./gen.sh
          --download-from-git
```

Note: Run the design-time pipeline each time you update config.json and profile.json. This ensures the service is rebuilt based on the latest specification.

For details about the script and its supported parameters, see Design Time Workflow and Supporting Artifacts.

End-to-End Design-Time Pipeline Flow

The pipeline validates configuration inputs, initializes the runtime environment, generates code, packages the generated content, and optionally starts target/openint.jar. The pipeline is staged, and multiple stages as follows:

Validation and Initialization Stage

During validation and initialization, the pipeline performs the following tasks:
- Initializes logs:
  - error.log
  - error-summary.log
  - server_output.log
- Performs mandatory prerequisite checks for the following files:
  - jq or jq.exe
  - parent-pom.xml
  - settings.xml
  - openint-dsl.jar
  - openapi-generator-cli.jar
- Performs mandatory prerequisite checks for the following folders:
  - graalvm-jdk
  - apache-maven
  - compile_dependency
  - openapi-generator
- Sets up the environment:
  - JAVA_HOME
  - MAVEN_HOME
  - Local Maven repository
- Checks for configuration location ambiguity between the root location and src/main/resources.
- Validates JSON syntax for configuration files.
- Performs Open Integration specification validation by using openint-spec-validator.jar.
The scripts use the following fail-fast markers:
- BASE_CONFIG_VALIDATION_FAILED
- APIGEN_VALIDATION_FAILED
Code Generation Stage

The code generation stage performs the following tasks:
- Removes previously generated content.
- Runs Maven install for the required local JAR files.
- Retrieves OpenAPI specifications by using openapi-spec-retriever.jar.
- Merges describe/*.json into merged.json as follows: openint-dsl.jar mergedescribe
- Generates the server scaffold by using openapi-generator-cli.jar.
- Generates the external DSL model as follows: openint-dsl.jar externaldsl
- Generates the internal DSL as follows: openint-dsl.jar internaldsl
- Generates the integration workflow as follows:openint-dsl.jar integrations …
If the describe/ directory is empty but event_publish_baseline_openapi.json exists, codegen uses event_publish_baseline_openapi.json as the baseline file.
When the stage is run with the –codegen option, the pipeline moves the following runtime configuration assets to src/main/resources/:
- log4j2.xml
- merged_config.json
- profile.json
- integration-configurations/
- *.jks
Package Stage

The package stage uses configurations from src/main/resources/ and performs the following tasks:
- Runs the Maven package build.
- Copies resources to target/.
- Copies integration configurations to target/.
- Cleans up transient build directories in target/.
The package stage creates the target/openint.jar output artifact.

Optional Start

If --start is set, the pipeline starts the JAR file by running: java $JAVA_OPTS -jar target/openint.jar.

Before you start the JAR file, ensure that all configured spoke systems, including Kafka, are up and running.

Configuration Location Rules

You must keep all configuration inputs in one base location for each run. Use one of the following locations:

openint-deploy/
openint-deploy/src/main/resources/

Note: You must not split files or folders across both locations in the same run. Splitting configuration inputs across both locations causes pipeline failure. If this occurs, clean up the configurations and rerun the pipeline.

Required Inputs

The pipeline requires the following core files and folders:

config.json
profile.json
log4j2.xml
integration-configurations/
JKS files

Artifacts and Logs

The pipeline creates or uses the following artifacts:

target/openint.jar
describe/*.json
merged.json
merged_config.json

The pipeline writes the following logs:

error.log
error-summary.log
server_output.log