Merge pull request #6 from DecisionsDev/dynamicdomain-review-lolo

fredmerci · web-flow · commit 5f24d3b59257 · 2024-10-31T14:05:19.000+01:00
Dynamicdomain review lolo - Docker part
diff --git a/decisioncenter/docker-compose.yaml b/decisioncenter/docker-compose.yaml
diff --git a/decisioncenter/dynamicdomain/README-DOCKER.md b/decisioncenter/dynamicdomain/README-DOCKER.md
@@ -7,33 +7,61 @@ Doing so, you do not need to have ODM installed. Instead we are relying on the [
 
 Before following the steps below, make sure you have built the customization JAR as explained in [README.md](README.md).
 
-#  Configuring the sample for Docker
+# Configuring the Sample for Docker
 
-## 1. Start the ODM container
+## 1. Build the Sample Code
 
-- Run
-    ```bash
-    docker-compose up odm-dynamic-domain &
-    ```
+The following steps show how to compile the sample code into a JAR file using a Docker container with Maven and JDK 17.
 
-- Then, run
-    ```bash
-    docker-compose exec odm-dynamic-domain sh -c "cp /config/resources/h2*.jar /config/apps/decisioncenter.war/WEB-INF/lib/h2.jar"
-    docker-compose restart odm-dynamic-domain
-    ```
+1. Navigate to the project directory:
+   ```bash
+   cd decisioncenter/dynamicdomain/src/ilog.rules.studio.samples.bomdomainpopulate
+   ```
 
-## 2. Initializing the dynamic domains database
+2. Run the command below to build the JAR file:
+   ```bash
+   docker run --rm \
+        -v "$(pwd)":/usr/src/sample \
+        -w /usr/src/sample \
+        maven:3.8.5-openjdk-17 \
+        mvn clean install -Dtarget.docker
+   ```
+   > **Result**: The generated JAR file will be located in the `target` directory with the name `bomdomainpopulate-1.0.jar`.
 
-- Run
-    ```bash
-    docker-compose exec odm-dynamic-domain sh -c "java \
-        -cp /config/resources/h2*.jar \
-        org.h2.tools.RunScript \
-        -url jdbc:h2:/config/dbdata/bomdomain \
-        -user sa \
-        -script /script/sql/createAndPopulate.sql \
-        -showResults"
-    ```
+
+## 2. Start the ODM Container
+
+To set up the ODM container with dynamic domain support:
+
+1. Start the ODM container:
+   ```bash
+   docker-compose up odm-dynamic-domain &
+   ```
+   > **Explanation**: This command initializes the ODM environment required for the sample.
+
+2. Copy and configure the H2 database library for Decision Center:
+   ```bash
+   docker-compose exec odm-dynamic-domain sh -c "cp /config/resources/h2*.jar /config/apps/decisioncenter.war/WEB-INF/lib/h2.jar"
+   docker-compose restart odm-dynamic-domain
+   ```
+   > **Explanation**: The H2 database library is needed to support the dynamic domains sample. Restarting ensures all configurations take effect.
+
+
+## 3. Initialize the Dynamic Domains Database
+
+To set up and populate the dynamic domains database:
+
+1. Run the initialization script:
+   ```bash
+   docker-compose exec odm-dynamic-domain sh -c "java \
+       -cp /config/resources/h2*.jar \
+       org.h2.tools.RunScript \
+       -url jdbc:h2:/config/dbdata/bomdomain \
+       -user sa \
+       -script /script/sql/createAndPopulate.sql \
+       -showResults"
+   ```
+   > **Explanation**: This command initializes the H2 database schema for the sample and populates it with the necessary data, enabling ODM to recognize and use the dynamic domain setup.
 
 # Using the sample
 
@@ -49,6 +77,7 @@ Before following the steps below, make sure you have built the customization JAR
 1. Navigate to the **Library** tab.
 1. Import the rule project archive `projects/bomdomainpopulate-rules.zip`.
     > Note: this rule project `bomdomainpopulate-rules` is only aimed at editing rules to demonstrate loading domains from a database. It is missing a deployment configuration and cannot be executed.
+1. **Navigate to the Library** tab. Select the **bomdomainpopulate-rules** box (click anywhere except the name) and choose the **main branch**. 
 1. Display the rule `CheckOrder > OrderType`. Notice the error **Value (string) 'CompanyX' is incorrect**. Edit the rule and either remove **"CompanyX"** and press SPACE or double-click **"CompanyX"**. A list of suitable companies gets displayed in a drop-down. Close down the rule without saving.
 1. Display the rule `CheckCurrency > CurrencyRestriction`. No warning is displayed.
 1. Let's now make some changes in the dynamic domains in the database. Run:
diff --git a/decisioncenter/dynamicdomain/README-KUBERNETES.md b/decisioncenter/dynamicdomain/README-KUBERNETES.md
@@ -3,8 +3,22 @@
 This README explains how to run the BOM dynamic domain sample in Kubernetes.
 
 #  Configuring the sample in Kubernetes
+## 1. Build the sample code 
 
-## 1. Uploading JARs on a file server
+The instructions below enable to build the JAR using a Docker container featuring Maven and a JDK version 17. 
+
+Run  command below in the `decisioncenter/dynamicdomain/src/ilog.rules.studio.samples.bomdomainpopulate` directory:
+
+This will compile the source code 
+```bash
+docker run --rm \
+      -v "$(pwd)":/usr/src/sample \
+      -w /usr/src/sample \
+      maven:3.8.5-openjdk-17 \
+      mvn clean install
+``` 
+
+## 2. Uploading JARs on a file server
 
 The customization JARs can be made available to Decision Center in two ways:
 1. the **legacy way**: by copying the JARs to a PVC and referencing this PVC using the parameter `decisionCenter.customlibPvc`
@@ -29,7 +43,7 @@ curl -T target/bomdomainpopulate-1.0.jar $FILESERVER_URL
 curl -T jdbc-driver.jar $FILESERVER_URL
 ```
 
-## 2. Deploying ODM
+## 3. Deploying ODM
 
 Add the public IBM Helm charts repository:
 ```bash
@@ -73,13 +87,13 @@ Install an ODM release named `myodmsample` (if you choose a different release na
 helm install myodmsample ibmcharts/ibm-odm-prod -f values.yaml
 ```
 
-## 3. Configuring Decision Center
+## 4. Configuring Decision Center
 
 The class that implements the customization must be declared:
 - either using a custom setting
 - or using a JVM parameter 
 
-### 3.1 Using a custom setting
+### 4.1 Using a custom setting
 1. Log in into the Business Console as an admin
 1. Navigate to **Administration > Settings > Custom Settings**
 1. Click the *Add custom setting* **icon** and set:
@@ -89,14 +103,14 @@ The class that implements the customization must be declared:
     - leave `default value` empty
 1. Set the value to `ilog.rules.studio.samples.bomdomainpopulate.DataBaseDomainValueProvider`
 
-### 3.2 Using a JVM parameter
+### 4.2 Using a JVM parameter
 
 Follow instructions similar to [here](https://www.ibm.com/docs/en/odm/9.0.0?topic=kubernetes-persisting-decision-center-ruleset-cache) to add the JVM parameter below: (using in a Config Map referenced by the Helm parameter **decisionCenter.jvmOptionsRef**)
 ```
 -Dilog.rules.teamserver.derbyDataBaseDomainProvider=ilog.rules.studio.samples.bomdomainpopulate.DataBaseDomainValueProvider
 ```
 
-## 4. Initializing the database
+## 5. Initializing the database
 
 1. If the data of the dynamic domains are stored in the internal PostgreSQL database, you can find the name of that pod by running:
     ```bash
@@ -115,7 +129,7 @@ Follow instructions similar to [here](https://www.ibm.com/docs/en/odm/9.0.0?topi
     kubectl exec $DBSERVER -- psql -U odmusr -d odmdb -f /tmp/createAndPopulate.sql
     ```
 
-## 5. Using the Sample
+## 6. Using the Sample
 
 1. Log in into the Business Console.
 1. Navigate to the **Library** tab.
diff --git a/decisioncenter/dynamicdomain/README.md b/decisioncenter/dynamicdomain/README.md
@@ -62,63 +62,46 @@ Edit that file otherwise.
 
 > Note: The data of the dynamic domains are stored in a separate schema named `BOMDOMAINSAMPLE`
 
-### 3) Building the Decision Center extension JAR
-
-To use the sample in Decision Center, you need to build a JAR. 
-
-   1. Retrieve ODM libraries:
-
-      ODM libraries are required to compile the JAR.
-
-      - Navigate to the source directory of the BOM dynamic domain sample:
-        ```bash
-        cd decisioncenter/dynamicdomain/src/ilog.rules.studio.samples.bomdomainpopulate
-        ```
-
-      - Deploy ODM for Developer public docker image (to quickly download the ODM libraries):
-        ```
-        docker-compose up odm &
-        ```
-
-      - Download the decision-center-client-api.zip file :
-        ```bash
-        wget http://localhost:9060/decisioncenter/assets/decision-center-client-api.zip
-        ```
-
-      - Then, run:
-        ```bash
-        unzip decision-center-client-api.zip -d "lib"
-        ```
-
-      - Undeploy ODM for developer (especially if you continue this tutorial on [Docker](README-DOCKER.md) to avoid a TCP/IP port usage conflict) :
-        ```
-        docker-compose down
-        ```
-
-   1. Build the JAR
-
-      The instructions below enable to build the JAR using a Docker container featuring Maven and a JDK version 17. For ODM 8.12, you must use `maven:3.8.1-openjdk-11` instead and `maven:3.8-adoptopenjdk-8` for earlier releases.
-
-      Run one of the command below in the `decisioncenter/dynamicdomain/src/ilog.rules.studio.samples.bomdomainpopulate` directory:
-      - to use the sample on **Kubernetes** :
-        ```bash
-        docker run --rm \
-              -v "$(pwd)":/usr/src/sample \
-              -w /usr/src/sample \
-              maven:3.8.5-openjdk-17 \
-              mvn clean install
-        ```
-
-      - to use the sample on **Docker** :
-        ```bash
-        docker run --rm \
-              -v "$(pwd)":/usr/src/sample \
-              -w /usr/src/sample \
-              maven:3.8.5-openjdk-17 \
-              mvn clean install -Dtarget.docker
-        ```
-
-The JAR is generated in the `target` directory and is named `bomdomainpopulate-1.0.jar`.
+### 3) Retrieve ODM Libraries
+
+To use the sample in Decision Center, you need to build a JAR file that depends on IBM ODM libraries for compilation.
+
+#### Steps:
+
+1. **Navigate to the Sample Source Directory**
+
+   Move to the source directory for the BOM dynamic domain sample:
+   ```bash
+   cd decisioncenter/dynamicdomain/src/ilog.rules.studio.samples.bomdomainpopulate
+   ```
+
+2. **Deploy ODM for Developer Using Docker**
+
+   Start the ODM for Developer Docker image to quickly access the necessary libraries:
+   ```bash
+   docker-compose up odm &
+   ```
+
+3. **Download the Decision Center Client API**
+
+   Retrieve the required libraries by downloading `decision-center-client-api.zip` from the local ODM instance:
+   ```bash
+   wget http://localhost:9060/decisioncenter/assets/decision-center-client-api.zip
+   ```
+
+4. **Extract Libraries**
+
+   Unzip the downloaded archive into a directory called `lib` to make the libraries available for compilation:
+   ```bash
+   unzip decision-center-client-api.zip -d "lib"
+   ```
+
+5. **Stop the ODM for Developer Container**
+   Undeploy ODM for developer (especially if you continue this tutorial on [Docker](README-DOCKER.md) to avoid a TCP/IP port usage conflict) :
+   ```bash
+   docker-compose down
+   ```
+
 
 ### 4) Instructions to use the sample in Decision Center
 
