OpenCCM: A Complete Introduction for Developers

Step-by-Step Guide: Building a Microservice with OpenCCM

Overview

This guide walks through building, packaging, and deploying a simple microservice using OpenCCM (an implementation of the CORBA Component Model). It assumes a UNIX-like environment, Java 8+ JDK installed, and basic familiarity with CORBA concepts. The example microservice will expose a simple greeting component accessed via CORBA.

1. Project setup

• Create directory structure
  • src/main/java
  • src/main/resources
  • build.gradle (or Maven POM)
• Dependencies
  • Use OpenCCM runtime jars and a CORBA ORB implementation (e.g., JacORB or OpenJDK’s builtin ORB).
• Example Gradle dependencies

groovy
Copy CodeCopied
dependencies {
implementation files(‘lib/openccm-runtime.jar’)
  implementation files(‘lib/jacorb.jar’)
}

2. Define the component interface (IDL)

• greeting.idl

idl
Copy CodeCopied
module greeting {   interface Greeter {

 
string say_hello(in string name); 
}; }; 


Compile the IDL with the IDL-to-Java compiler provided by your CORBA ORB (e.g., idlj for OpenJDK or JacORB idl compiler).
Generated stubs/skeletons go into src/main/java (or include the generated sources in compilation).

3. Create the component implementation

Implement the CORBA servant and the CCM component facet. Minimal example in Java:

java
Copy CodeCopied
package greeting;

import org.omg.PortableServer.;
import org.omg.CORBA.;
import greeting.GreeterPOA;

public class GreeterImpl extends GreeterPOA {
  private ORB orb;
  public GreeterImpl(ORB orb) { this.orb = orb; }
  @Override
  public String sayhello(String name) {
    return “Hello, “ + name + ”!”;
  }
}


Wrap this in an OpenCCM component class per OpenCCM component model. A simple component class:

java
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
package greeting;

import org.objectweb.util.monolog.api.;
import org.objectweb.CORBA.;
import org.omg.Components.;
import org.omg.PortableServer.;

public class GreeterComponent extends org.omg.CORBA.LocalObject {
  private GreeterImpl greeterServant;

  public void start(ORB orb, POA poa) throws Exception {
    greeterServant = new GreeterImpl(orb);
    poa.activate_object(greeterServant);
    // register component facets with OpenCCM naming or container as needed
  }

  public void stop(POA poa) throws Exception {
    // deactivate servant
    poa.deactivate_object(poa.servant_toid(greeterServant));
  }
}

4. Component assembly descriptor

Create an assembly XML (OpenCCM assembly descriptor) defining the component, its facets, receptacles, and connections.

Example assembly snippet:
xml
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
<assembly name=“GreetingAssembly”>
  <component name=“GreeterComponent” implementation=“greeting.GreeterComponent”>
    <facet name=“Greeter” interface=“IDL:greeting/Greeter:1.0”/>
  </component>
</assembly>

5. Build the project

Compile generated IDL classes and your Java sources.
Package runtime jars and component classes into a deployable archive (e.g., a .jar or .zip expected by OpenCCM).

Gradle example:
groovy
Copy CodeCopied
task fatJar(type: Jar) {
  manifest { attributes ‘Main-Class’: ‘greeting.DeploymentMain’ }
  from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
  with jar }

6. Start OpenCCM runtime and ORB

Start the ORB and OpenCCM container, usually via provided scripts:

run OpenCCM NameService (if required)
run OpenCCM Containe r/Node


Example:

Code
Copy CodeCopied
java -jar openccm-nameservice.jar -ORBInitialPort 1050 java -jar openccm-daemon.jar -ORBInitialPort 1050 
7. Deploy the assembly

Use OpenCCM command-line administration tool or web UI to deploy the assembly descriptor and component package.
Example command:

Code
Copy CodeCopied
openccm-admin deploy GreetingAssembly.osa 
8. Client code to call the microservice

Obtain the component’s CORBA object reference via naming service or component context and invoke the facet:

java
Copy CodeCopied
ORB orb = ORB.init(args, null);
org.omg.CORBA.Object obj = orb.string_to_object(“corbaloc::localhost:1050/Greeter”);
Greeter greeter = GreeterHelper.narrow(obj);
System.out.println(greeter.say_hello(“Alice”));

9. Testing and debugging

Use ORB logging and OpenCCM monolog logs.
Verify servant activation in POA and naming registration.
Test concurrent calls and measure latency.

10. Packaging for production

Containerize the assembled runtime and ORB using Docker.
Expose required ports and manage configuration via environment variables.
Add health-check endpoints (a small HTTP wrapper that calls sayhello) for orchestration systems.


Example Dockerfile (simplified)
dockerfile
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
FROM eclipse-temurin:8-jre COPY build/libs/greeter-fat.jar /app/greeter.jar COPY lib/openccm-runtime.jar /app/lib/ WORKDIR /app CMD [“java”,“-jar”,“greeter.jar”] 
Conclusion
You now have a basic microservice built with OpenCCM: IDL definition, implementation, assembly, deployment, and a client example. Extend the component with additional facets, persistence, and instrumentation for production readiness.