3 Creating the UIM Cloud Native Images

UIM cloud native requires container images be made available to create and manage UIM cloud native instances. This chapter describes how to create those UIM cloud native images.

UIM cloud native requires two container images. The UIM DB installer image is used to manage the UIM and Fusion MiddleWare schemas -create,delete,upgrade - as well as purging in the UIM schema. It is also used to generated encrypted weblogic credentials. The other image is the UIM image itself. This image is the basis for all of the long running pods - the WebLogic admin server and all the Managed Servers that comprise a UIM cloud native instance. Each image is built on top of a Linux base image and adds Java, Fusion MiddleWare components and UIM product components on top.

UIM Cloud native images are created using the UIM cloud native builder toolkit and a dependency manifest file. The UIM cloud native Image Builder is intended to be run as part of a Continuous Integration process that generates images. It needs to run on Linux and have access to the local Docker daemon. The versions of these are as per the UIM statement of certification in the UIM documentation. The dependency manifest is a file that describes all the versions and patches required to build out the image.

Downloading the UIM Cloud Native Image Builder

You download the UIM cloud native image builder from My Oracle Support at: https://support.oracle.com

The UIM cloud native image builder is bundled with the following components:

  • UIM cloud native builder kit. The kit contains:
    • The UIM Domain WDT Model.
    • The UIM DB Installer scripts and manifest files.
  • Staging directory structure.

Prerequisites for Creating UIM Images

The pre-requisites for building UIM cloud native images are:

  • Docker client and daemon on the build machine.

  • Installers for WebLogic Server and JDK. Download these from the Oracle Software Delivery Cloud:

    https://edelivery.oracle.com

  • Required patches. Download these from My Oracle Support:

    https://support.oracle.com/

  • Java, installed with JAVA_HOME set in the environment.
  • Bash, to enable the `<tab>` command complete feature.

See "UIM Software Compatibility" in UIM Compatibility Matrix for details about the required and supported versions of these pre-requisite software.

Configuring the UIM Cloud Native Images

The dependency manifest file describes the input that goes into the UIM images. It is consumed by the image build process. The default configuration in the latest manifest file provides all the necessary components and required patches for creating the UIM cloud native images easily.

You can also modify the manifest file to extend it to meet your requirements. This enables you to:

  • Specify any Linux image as the base, as long as its binary is compatible with Oracle Linux.
  • Upgrade the Oracle Enterprise Linux version to a newer version to uptake a quarterly CPU.
  • Upgrade the JDK version to a newer JDK version to uptake a quarterly CPU.
  • Upgrade the Fusion Middleware version to a newer version. For example, you upgrade the Fusion Middleware version to a newer version when you initiate the upgrade to pick up new PSU or when Oracle recommends a new update.
  • Change the set of patches applied on WebLogic Server, Coherence, Fusion Middleware, and OPatch to stay aligned with evolving UIM recommendations.
  • Change the UIM artifacts to newer artifacts to uptake a new UIM patch.
  • Choose a different userid and groupid for oracle:oracle user:group that the image specifies. The default is 1000:1000.

The breakdown of each section in the dependency manifest file is as follows:

Note:

The schemaVersion and date parameters are maintained by Oracle. Do not modify these parameters.

Version numbers provided here are only examples. The manifest file used specifies the actual versions currently recommended.

  • UIM Cloud Native Infrastructure Image

    While not required by UIM cloud native to create or manage UIM instances, this infrastructure image is a necessary building block of the final UIM container image.

    linux:
    vendor: Oracle
    version: 8-slim
    image: container-registry.oracle.com/os/oraclelinux:8-slim

    The Linux parameter specifies the base Linux image to be used as the base docker image. The version is the two-digit version from /etc/redhat-release.

    The vendor and version details are specified and used for:

    • Validation when an image is built.
    • Querying at run-time. To troubleshoot issues, Oracle support requires you to provide these details in the manifest file used to build the image.
    userGroup:
  username: oracle
  userid: 1000
  groupname: oracle
  groupid: 1000

    The userGroup parameter specifies the default userId and groupId for oracle

     jdk:
    vendor: Oracle
    version: 8u391
    path: $CN_BUILDER_STAGING/java/jdk-8u391-linux-x64.tar.gz

    The jdk parameter specifies the JDK vendor, version, and the staging path. 

    fmw:
    version: 12.2.1.4.0
    path: $CN_BUILDER_STAGING/fmw/install/fmw_12.2.1.4.0_infrastructure_Disk1_1of1.zip

    The fmw parameter specifies the Fusion Middleware version and staging path. 

     oPatch:
    description: Weblogic Opatch
    patchNumber: 28186730
    patchId: 28186730_13.9.4.2.6
    path: $CN_BUILDER_STAGING/fmw/patch/p28186730_139426_Generic.zip

    The oPatch parameter specifies the Oracle Patch tool and staging path. 

    fmwPatch:
    - description: PSU for WLS (OCT 2023 CPU)
      patchNumber: 35893811
      patchId: 35893811_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p35893811_122140_Generic.zip
    - description: PSU Coherence 12.2.1.4.19 (OCT 2023 CPU)
      patchNumber: 35778804
      patchId: 35778804_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p35778804_122140_Generic.zip
    - description: FMW PLATFORM 12.2.1.4.0 SPU FOR WLS (APR 2022 CPU)
      patchNumber: 33093748
      patchId: 33093748_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p33093748_122140_Generic.zip
    - description: ADF BUNDLE PATCH 12.2.1.4.230306 (JULY 2023 CPU)
      patchNumber: 35503128
      patchId: 35503128_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p35503128_122140_Generic.zip
    - description: ADR FOR WLS (OCT 2023 CPU)
      patchNumber: 35476067
      patchId: 35476067_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p35476067_122140_Linux-x86-64.zip
    - description: OPSS Bundle Patch 12.2.1.4.220311(APR 2022 CPU)
      patchNumber: 33950717
      patchId: 33950717_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p33950717_122140_Generic.zip
    - description: FMW COMMON THIRD PARTY SPU 12.2.1.4.0 (OCT 2023 CPU)
      patchNumber: 35882299
      patchId: 35882299_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p35882299_122140_Generic.zip
    - description: FMW Control SPU Patch (OCT 2022 CPU)
      patchNumber: 34542329
      patchId: 34542329_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p34542329_122140_Generic.zip
    - description: LOGIN FAILS AFTER APPLYING 1.80.331 JDK (APR 2022 CPU)
      patchNumber: 33903365
      patchId: 33903365_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p33903365_122140_Generic.zip
    - description: DMS Metric table uses UUID for Keys
      patchNumber: 28334768
      patchId: 28334768_12.2.1.4.0
      path: $CN_BUILDER_STAGING/fmw/patch/p28334768_122140_Generic.zip
    - description: STUCK THREAD AT

    The fmwPatch parameter specifies additional patches and their staging paths.

  • UIM Cloud Native Image

    Note:

    Do not modify this section other than for name, tag, and layertag. Rest of the parameters are maintained by Oracle. 
    uimCnImage:
  name: uim-cn-base
  tag: 7.5.1.2.0
  layertag: 7.5.1.2.0.1
  wdt:
    version: 3.2.3
    path: $CN_BUILDER_STAGING/cnsdk/tools/weblogic-deploy.zip
  modelfiles: $CN_BUILDER_STAGING/cnsdk/uim-model/uim-domain-config/uim-base-domain.yaml,$CN_BUILDER_STAGING/cnsdk/uim-model/uim-domain-config/properties/docker-build/domain.properties
  application: $CN_BUILDER_STAGING/cnsdk/uim-model/uim-app-archive.zip
  customApplication: $CN_BUILDER_STAGING/cnsdk/uim-model/uim-custom-archive.zip
  customConfig: $CN_BUILDER_STAGING/cnsdk/uim-model/uim-custom-config
  configfiles: $CN_BUILDER_STAGING/cnsdk/uim-model/UIM
  dockerExtension: $CN_BUILDER_STAGING/cnsdk/uim-model/additionalBuildCommands.txt

    Where name is the name of the UIM image, tag is the tag name of the UIM image, and layertag is the tag name of the customized UIM image.

    The uimCnImage section specifies details about the UIM artifacts required to build the UIM base image and UIM layered image. These include the inventory.ear, sharedLibraries, UIM application configuration files, customizations, WDT and base model files.

  • UIM Cloud Native DB Installer Image

    uimCnDbInstallerImage:
  name: uim-cn-db-installer
  tag: 7.5.1.2.0

  dbtools:
    vendor: Oracle
    version: 7.5.1.2.0    
    path: $CN_BUILDER_STAGING/cnsdk/uim-db/ora_uim_dbtools.jar

    The uimCnDbInstallerImage parameter specifies the DB Installer image name and version. This includes UIM DB Utility jar and Password Encryptor jar.

Creating the UIM Cloud Native Images

To create the UIM image or UIM DB Installer image, the image builder initially generates infrastructure image with the following:

  • Starts with a base-level operating system image (for example, oraclelinux:8-slim).
  • Creates user and group (for example, oracle:oracle).
  • Updates the image with the necessary packages for installing Fusion Middleware.
  • Installs Java, Fusion Middleware and applies patches.

To create the UIM image, the image builder does the following:

  • Infrastructure image is reused if it exists, else it builds infrastructure image.
  • Installs the UIM application base on the WDT model along with customizations.

To create the UIM DB Installer image, the image builder does the following:

  • Infrastructure image is reused if it exists else it builds infrastructure image.
  • Installs the UIM DB Installer with ora_uim_dbtools.jar and password_encryptor.jar.

You can specify any Linux image as the base, as long as its binary is compatible with Oracle Linux and conforms to the compatibility matrix. See "UIM Software Compatibility" in UIM Compatibility Matrix for details about the supported software.

The following packages must be installed onto the given base image, or be already present:

  • gzip
  • tar
  • unzip

Creating the UIM and UIM DB Installer Images

To create the UIM and UIM DB Installer images:

  1. Create the workspace directory:
    mkdir workspace
  2. Obtain and untar the UIM image builder file: uim-image-builder.tar.gz to the workspace directory:
    tar -xf ./uim-image-builder.tar.gz --directory workspace
  3. Download JDK to the workspace/uim-image-builder/staging/javadirectory directory. The JDK version to be downloaded is described in the dependency manifest file.
    cp jdk-8u391-linux-x64.tar.gz ./workspace/uim-image-builder/staging/java/jdk-8u281-linux-x64.tar.gz
  4. From Oracle Software Delivery Cloud, download Fusion Middleware Infrastructure installer and copy it to the workspace/uim-image-builder/staging/fmw/installdirectory directory. The Fusion Middleware Infrastructure installer version to be download is described in the dependency manifest file under the fmw section.
    cp fmw_12.2.1.4.0_infrastructure_Disk1_1of1.zip ./workspace/uim-image-builder/staging/fmw/install/fmw_12.2.1.4.0_infrastructure_Disk1_1of1.zip
  5. From https://github.com/oracle/weblogic-deploy-tooling/releases, download WDT 3.2.3 (weblogic-deploy.zip) and copy it to the workspace/uim-image-builder/staging/cnsdk/tools directory.
  6. From https://github.com/oracle/weblogic-image-tool/releases, download WIT 1.11.11 (imagetool.zip) and copy it to the workspace/uim-image-builder/staging/cnsdk/tools directory.
  7. Download all the listed patches to the workspace/uim-image-builder/staging/fmw/patch directory. The list of required patches is in the dependency manifest file in the oPatch and fmwPatch sections.
    You can download the patches using any of the following options:
    • (Recommended) Manually search for and download each OPatch/FMW patches from Oracle Support to the current working directory and then copy to the staging directory.
      cp pxxxxxx_xxxxx_Generic.zip ./workspace/uim-image-builder/staging/fmw/patch
    • Provide your My Oracle Support account credentials when invoking the build-uim-images.sh script, and let the builder download the patches automatically:

      Note:

      Some patches may not be retrievable in this manner. If the image build process fails with errors about a missing patch, use the recommended option. 
      ./workspace/uim-image-builder/bin/build-uim-images.sh -f $DMANIFEST -s $STAGING -c uim -u MOS_username -p MOS_password
  8. Run customization.sh if you made any customizations. For making customizations, see "Customizing Images". Export the variables as required and then run customization.sh: 
    mkdir workspace/customization
mkdir workspace/temp

    • Export the work space as follows. WORKSPACEDIR is the mandatory parameter that has the path where uim-image-builder is extracted. 

      
export WORKSPACEDIR=$(pwd)/workspace

    • Export the custom folder as follows. CUSTOMFOLDER is the parameter for the path where the custom folder of uim-app-archive.zip is copied and modified for the customization. 

      
export CUSTOMFOLDER=$(pwd)/workspace/customization 
###extract custom folder of uim-app-archive.zip in this directory

    • Export the temp directory as follows. TEMPDIR is the mandatory parameter to store the temp location where we have the merged folder of uim-app-archive.zip with customizations for any future reference. 

      
export TEMPDIR=$(pwd)/workspace/temp

    • Apply customizations to UIM application as follows:

      ./workspace/uim-image-builder/bin/customization.sh

    Note:

    You can also export the following variables:
    • CARTRIDGESDIR is the parameter that has the path to copy solution cartridges. The default path is $CUSTOMFOLDER/custom/cartridges.
    • PURGELIMIT the optional parameter that sets the number of folders. Not setting any value defaults to having 3 existing folders in it.
  9. Run build-uim-images.sh and pass the dependency manifest file, staging path, and the type of image to be created.
    export DMANIFEST=$(pwd)/workspace/uim-image-builder/bin/uim_cn_ci_manifest.yaml
export STAGING=$(pwd)/workspace/uim-image-builder/staging
    • To create UIM image, use -c uim as shown:
      ./workspace/uim-image-builder/bin/build-uim-images.sh -f $DMANIFEST -s $STAGING -c uim
    • To create UIM DB installer image, use -c dbinstaller as shown:
      ./workspace/uim-image-builder/bin/build-uim-images.sh -f $DMANIFEST -s $STAGING -c dbinstaller
    • To create UIM layered image, use -c layer as shown: 
      ./workspace/uim-image-builder/bin/build-uim-images.sh -f $DMANIFEST -s $STAGING -c layer

      Note:

      Run customization.sh before you create UIM layered image. This can used during solution development phase for creating updated image in case of Java code changes in the cartridges.

These steps can be included into your CI pipeline as long as the required components are already downloaded to the staging area.

Post-build Image Management

The UIM cloud native image builder creates images with names and tags based on the settings in the manifest file. By default, this results in the following images:
  • uim-cn-infrastructure:12.2.1.4.0
  • uim-cn-base:7.5.1.2.0
  • uim-cn-db-installer:7.5.1.2.0
  • uim-cn-base:7.5.1.2.0.1

    Note:

    An optional layered image is created, if Customization is enabled and either Java Ruleset code or configuration files are present in the solution cartridges.

Once images are built in a CI pipeline, the pipeline uniquely tags the images and pushes them to an internal Docker repository. An uptake process can then be triggered for the new images:

  • Sanity Test
  • Development Test (for explicit retesting of scenarios that triggered the rebuild, if any)
  • System Test
  • Integration Test
  • Pre-Production Test
  • Production

Customizing Images

Various customizations such as UI, Localization, Web Services, and so on can be performed during the docker image creation. To apply these customizations, you have to run an additional script uim-image-builder/bin/customization.sh, in the UIM image builder toolkit before creating the UIM docker image. Based on the customization type, an additional layer is generated with the Layer tag, as defined in the uim-image-builder/bin/uim_cn_ci_manifest.yaml file. For example, if solution cartridges contain configuration files, Java ruleset code, and for custom applications, the layered build gets generated.

Note:

For certain customization types, additional layer is built on the top of the base image. This approach makes a quick turnaround time for validating solution cartridge changes during the development phase. In case of any changes to the Javaruleset code or configuration files in the cartridges, you do not need to build the UIM Image but you can build only the layer after running uim-image-builder/bin/customization.sh as follows:
./workspace/uim-image-builder/bin/build-uim-images.sh -f $DMANIFEST -s $STAGING -c layer

Including User Interface Customizations and Localizing UIM Help in UIM Cloud Native Images

To include the user interface customizations in UIM cloud native images:

  1. Customize the user interface and generate inv.war file after including the UI customizations. See "Overview" in UIM Developer's Guide for customizing the user interface and deploying the customizations.
  2. Include Localizing UIM Help customizations in the same inv.war file. See "Localizing UIM" for localizing UIM Help and "Localizing the Network Plan and Design Process Page" for localizing Network Pland and Design in UIM Developer's Guide.
  3. Place the inv.war file in the $CUSTOMFOLDER\custom\ui_customization folder.

    Note:

    The CUSTOMFOLDER is the parameter for the path where the custom folder of uim-app-archive.zip is copied and modified for the customization.
  4. If there are any logo customizations, place the comms-platform-ui.jar file in the custom\ui_customization folder.

Including Custom Web Services

To include the custom web services in UIM Cloud Native images:

  1. Develop custom web services and create the WAR file. See "Web Services Overview" in UIM Web Services Developer's Guide for developing custom web services.
  2. Place the web service's WAR file in the CUSTOMFOLDER at custom\customWS.

    Note:

    The CUSTOMFOLDER is the parameter for the path where the custom folder of uim-app-archive.zip is copied and modified for the customization.
  3. Update application.xml and inventory-clusterPlan.xml files with the new custom web service details.

    During the image creation, these custom web services are packaged in inventory.ear.

  4. After a new instance is created with the new image, verify the updated custom web services from the WebLogic console under oracle.communications.inventory.

Updating application.xml

Add the following information to the <module> element to identify the following for the custom web service:

  • The WAR file name, such as ReferenceUim.war
  • The WSDL file prefix, such as ReferenceUim

Note:

Add the <web-uri> element for the WAR file name and the <context-root> element for the WSDL name, as shown in Example.

The sample is as follows:

<!-- Custom Web Service WAR -->
<module>
<web>
<web-uri>ReferenceUim.war</web-uri>
<context-root>ReferenceUim</context-root>
</web>
</module>

Updating inventory-clusterPlan.xml

You can find the inventory-clusterPlan.xml from the CUSTOMFOLDER\custom\plans directory.

To secure the custom webservice, update the deployment plan with required policies. You can use the security policy that comes with the UIM instance Auth.xml, the security policy that comes in the Reference Web Service ZIP file SampleAuth.xml, or create your own security policy file. Custom policies are available in the <custom webservice war>/WEB-INF/policies folder. The following example shows an update to inventory-clusterPlan.xml with default Auth.xml policy: 

<module-override>
  <module-name>ReferenceUim.war</module-name>
  <module-type>war</module-type>
  <module-descriptor external="false">
    <root-element>weblogic-web-app</root-element>
    <uri>WEB-INF/weblogic.xml</uri>
  </module-descriptor>
  <module-descriptor external="false">
    <root-element>web-app</root-element>
    <uri>WEB-INF/web.xml</uri>
  </module-descriptor>
  <module-descriptor external="false">
    <root-element>weblogic-webservices</root-element>
    <uri>WEB-INF/weblogic-webservices.xml</uri>
  </module-descriptor>
  <module-descriptor external="false">
    <root-element>webservices</root-element>
   <uri>WEB-INF/webservices.xml</uri>
  </module-descriptor>
  <module-descriptor external="false">
    <root-element>webservice-policy-ref</root-element>
    <uri>WEB-INF/weblogic-webservices-policy.xml</uri>
    <variable-assignment>
      <name>WsPolicy_policy:Auth.xml_Direction_13075993400140</name>
      <xpath>/webservice-policy-ref/port-policy/[port-name="UIMReferenceUimHTTPPort"]/ws-policy/[uri="policy:Auth.xml"]/direction</xpath>
    </variable-assignment>
    <variable-assignment>
      <name>WsPolicy_policy:Auth.xml_Direction_13075993400140</name>
      <xpath>/webservice-policy-ref/port-policy/[port-name="UIMReferenceUimJMSPort"]/ws-policy/[uri="policy:Auth.xml"]/direction</xpath>
    </variable-assignment>
  </module-descriptor>
</module-override>

Adding Third-party Libraries

To add third-party libraries:

  1. Copy third-party libraries to CUSTOMFOLDER\custom\libraries folder.

    Note:

    The CUSTOMFOLDER is the parameter for the path where the custom folder of uim-app-archive.zip is copied and modified for the customization.
  2. After a new instance is created with the new image, verify that the third-party libraries are available in the pod in the path /UIM/lib, by running the following command:
    kubectl exec <project>-<instance>-ms1 -n <project> -- ls /UIM/lib

Adding WebLogic Deployable Applications

To add WebLogic deployable applications, you can copy WebLogic deployable applications to CUSTOMFOLDER\custom\applications folder.

Note:

The CUSTOMFOLDER is the parameter for the path where the custom folder of uim-app-archive.zip is copied and modified for the customization.

You can also add WebLogic deployable applications using extensions. This mechanism keeps the ear file together with the domain configuration in one location. This is best suited to applications that can be considered standard or fixed for all variants of a domain that are required (test, development, and production). This is best suited in configuring MapViewer in the UIM cloud native instance.

The default WDT model for these applications is constructed while running the customization script as follows:

appDeployments:
  Application:
    '<application-name>':
      SourcePath: 'wlsdeploy/applications/custom/<application-name>.ear'
      ModuleType: ear
      StagingMode: nostage
      PlanStagingMode: nostage
      Target: '@@PROP:CLUSTER_NAME@@'

See "Deploying Entities to a UIM WebLogic Domain" for more information deploying the custom applications using extensions.

Adding Solution Cartridge Customizations

To add solution cartridge customizations, copy all cartridges to CARTRIDGEDIR or $CUSTOMFOLDER/custom/cartridges. You need to run the customization script that scans and packages the configuration files, images, and java ruleset codes into the container image and scans the cartridge jar files and extracts them to $CARTRIDGES_PATH/unpack.

Configuration Files

The configuration files are packaged into a layered image. After a new instance is created with the new image, verify the configuration files in the pod, by running the following command:

kubectl exec <project>-<instance>-ms1 -n <project> -- ls /UIM/config

Images

The image files are packaged into the base image. After a new instance is created with the new image, verify the images files in the pod, by running the following command:

kubectl exec <project>-<instance>-ms1 -n <project> -- ls /UIM/images

Localization

The localization changes are packaged into the base image. Verify the localization in UIM cloud native instance with newly generated image by changing the browser settings. See "Overview" in UIM Developer's Guide to build cartridges with localization files.

Custom Library or Java Ruleset Code

The Java ruleset code is packaged into a layered image. If *Lib.jar or *aop.jar exists in the extracted folder of $CARTRIDGES_PATH/unpack, then uim_custom_lib.ear is updated in uim-custom-archive.zip file.

The Java ruleset code is packaged into layered image as follows:

Table 3-1 Custom Library in Layered Images

Customization Type CUSTOMFOLDER CARTRIDGESDIR Layered Image
User interface The customized inv.war is placed in $CUSTOMFOLDER\custom\ui_customization. NA No layered image generated.
Custom Webservice The customized war files are placed in $CUSTOMFOLDER\custom\customWS. NA No layered image generated.
Libraries Third-party libraries are placed in $CUSTOMFOLDER\custom\libraries. NA Layered image is generated.
Applications Place Weblogic Deployable applications in $CUSTOMFOLDER\custom\applications. NA Layered image is generated.
Solution cartridges

Optional if CARTRIDGEDIR is exported.

Solution Cartridge jars are placed in $CUSTOMFOLDER/custom/cartridges.

Optional if CUSTOMFOLDER is exported.

Solution Cartridge jar files are placed in $CARTRIDGESDIR.

 Layered image generated for configuration files and Java Ruleset Code.

Layered image not generated for images and localization.

Extending Entity Life Cycles

You can extend entity life cycles in UIM cloud native environment. See "Extending Life Cycles" in UIM Developer's Guide for more information on extending life cycles. The image builder tool kit includes the latest customizations.sh file that enables life cycle extensions support.

To set up your cloud native deployment for extending entity life cycles:

  1. From uim-app-archive.zip, copy the inventory-adapter.ear and core_lib.ear files to a temporary location. For example: D:/workspace/tmp.

  2. In Design Studio:

    1. Rename COMPUTERNAME.properties to match with the name of your computer and update its content to match with your environment.

    2. Update the EAR_PATH and CORE_LIB_DIR path values with the paths of the temporary location where you copied the inventory-adapter.ear and core_lib.ear files. The following text shows changes to the computer properties: 

      APP_NAME=inventory
 
JDK_HOME=C:/Program Files/Java/jdk1.8.0_241
JAVA_HOME=${JDK_HOME}
ANT_HOME=C:/software/apache-ant-1.9.2
 
EAR_BUILD_DIR=generated
 
#location of the UIM home from the installer setup.
UIM_HOME=/weblogicDomainHome/UIM
 
DB_HOME=C:/app/orcluser/product/12.2.0/dbhome_1
DB_DRIVER=${DB_HOME}/jdbc/lib/ojdbc8.jar
DATABASE=oracle
 
#project home location this has to change based on the project location.
PROJECT_HOME=D:/Eclipse_Photon/UIM742/ora_uim_entity_sdk/src
 
#POMS location
POMS_SRCHOME=${PROJECT_HOME}/platformFiles/extract/objmgmt/poms
# POMS extract location.
POMS_ROOT=platformFiles/extract
  
APP_LIB=D:/tmp/UIM_SDK/lib  ### Path to UIM_SDK lib
 
#inventory-adapter.ear
EAR_PATH=D:/workspace/tmp
 
CLASSPATH=${JDK_HOME}/lib/tools.jar;${JDK_HOME}/jre/lib/rt.jar;${DB_DRIVER}
 
#This is required for finding the path for uim_core_lib.ear
CORE_LIB_DIR=D:/workspace/tmp

      Note:

      Both EAR_PATH and CORE_LIB_DIR can have the same path values.

    3. (Optional) Follow the steps described in the Customizing Service Lifecycle to Introduce a New State. (Doc ID 1918850.1) knowledge article on My Oracle Support to customize entity life cycles.

    4. (Optional) Save the build.xml file.

    5. Add any new custom metadata files to define the new custom state and build the project.

    The build updates the .ear files that you copied to your local folder.

    Note:

    During the build process, uim-entities.jar is modified. This .jar file contains the entity Java classes for all UIM entities and all custom entities. After the build, the inventory-adapter.ear and uim_core_lib.ear files in the tmp folder are updated along with the uim_entities.jar file.

  3. Copy the updated inventory-adapter.ear and uim_core_lib.ear files from the tmp folder to $CUSTOMFOLDER\custom\staticExtensions folder.

    Note:

    CUSTOMFOLDER is the parameter for the path where uim-app-archive.zip is copied and modified for customization.

  4. Under the model/content/product_home/config/resources/logging directory of the ora_uim_localization_reference project, modify the status.properties file to display the new state on the UI.

    Note:

    The UI-specific properties files are located in the ora_uim_localization_reference project, under the model/content/product_home/config/resources/logging directory. See "Overview" in UIM Developer's Guide for localizing the UI-specific files.

  5. Add solution cartridge customizations to package the cartridge.

    See "Adding Solution Cartridge Customizations" for more information.