OpenCCM - The Execution Tool Chain

The OpenCCM Execution Tool Chain

The OpenCCM Execution Tool Chain provides a set of tools to control the OpenCCM distributed execution infrastructure for deploying and running CORBA component based applications. This allows you to start and stop:

  • the CosNaming, CosTrading, and CosTransactions Service daemons,
  • the OpenCCM Component Server, Node, Domain, and Assembly Factory managers, and
  • the OpenCCM Comanche server.

The OpenCCM Execution Tool Chain is composed of the following tools:

ToolDescription
ccm_install Installs the OpenCCM Configuration Repository.
ccm_installed Checks if the OpenCCM Configuration Repository is installed.
ccm_deinstall Deinstalls the OpenCCM Configuration Repository.
comanche_start Starts the OpenCCM Comanche Server.
comanche_stop Stops the OpenCCM Comanche Server.
ns_start Starts the CosNaming Service.
ns_set Sets the CosNaming Service to use.
ns_started Checks if the CosNaming Service is started.
ns_ior Obtains the IOR of the running CosNaming Service.
ns_gui Starts a client GUI on the running CosNaming Service.
ns_stop Stops the CosNaming Service.
trader_start Starts the CosTrading Service.
trader_set Sets the CosTrading Service to use.
trader_started Checks if the CosTrading Service is started.
trader_ior Obtains the IOR of the running CosTrading Service.
trader_gui Starts a client GUI on the running CosTrading Service.
trader_feed Feeds the CosTrading Service Type Repository.
trader_stop Stops the CosTrading Service.
ots_start Starts the CosTransactions Service.
ots_set Sets the CosTransactions Service to use.
ots_started Checks if the CosTransactions Service is started.
ots_ior Obtains the IOR of the running CosTransactions Service.
ots_stop Stops the CosTransactions Service.
dci_start Starts an OpenCCM Distributed Computing Infrastructure Manager.
dci_set Sets the OpenCCM Distributed Computing Infrastructure Manager to use.
dci_started Checks if an OpenCCM DCI Manager is started.
dci_ior Obtains the IOR of the current OpenCCM Distributed Computing Infrastructure Manager.
dci_stop Stops an OpenCCM Distributed Computing Infrastructure Manager.
node_start Starts an OpenCCM Node Manager.
node_stop Stops an OpenCCM Node Manager.
factory_start Starts an OpenCCM Assembly Factory Manager.
factory_stop Stops an OpenCCM Assembly Factory Manager.
jcs_start Starts an OpenCCM Java Component Server.
jcs_stop Stops an OpenCCM Java Component Server.
ccm_deploy Deploys a CORBA component assembly archive.
tear_down Tears down a deployed CORBA component assembly.
ccm_browser Starts the OpenCCM graphical console.

In the following sections, all OpenCCM Execution Tool Chain scripts are illustrated on top of the ORBacus 4.1.0 product running on a Linux system.

However all these following scripts could be used in the same way on any ORB products and operating systems supported by OpenCCM.

Installing the OpenCCM Configuration Repository

The OpenCCM Execution Tool Chain is mainly based on the use of the OpenCCM Configuration Repository.

Let's note that before using any OpenCCM Execution Tool Chain tool, it is required to install the OpenCCM Configuration Repository.

The ccm_install script installs the OpenCCM Configuration Repository, e.g.:

$ ccm_install
The OpenCCM Platform will be installed.
Creating the $OpenCCM_CONFIG_DIR directory.
Creating the $OpenCCM_CONFIG_DIR/DCIManagers directory.
Creating the $OpenCCM_CONFIG_DIR/NodeManagers directory.
Creating the $OpenCCM_CONFIG_DIR/ComponentServers directory.
Creating the $OpenCCM_CONFIG_DIR/AssemblyFactoryManagers directory.
Creating the $OpenCCM_CONFIG_DIR/log directory.
Copying the default Trace Service config file.
The OpenCCM Platform is installed.
$

Let's note that this script automatically creates the $OpenCCM_CONFIG_DIR and its subdirectories. The DCIManagers, NodeManagers, ComponentServers, and AssemblyFactoryManagers subdirectories will store the standard output, the IOR, and the PID of all started OpenCCM DCI Managers, Node Managers, Component Servers, and Assembly Factory Managers respectively. The log subdirectory will store trace output files.

$ ls $OpenCCM_CONFIG_DIR
AssemblyFactoryManagers/  ComponentServers/  DCIManagers/  NodeManagers/  log/
$

Warning: This script can be started only once, e.g.:

$ ccm_install
Error: The OpenCCM Platform is already installed!
$

See the ccm_deinstall script to deinstall the OpenCCM Configuration Repository.

Checking if the OpenCCM Configuration Repository is installed

The ccm_installed script checks if the OpenCCM Configuration Repository is installed, e.g.:

$ ccm_deinstall
. . .
$ ccm_installed
Error: The OpenCCM Platform is not installed!
$

Let's note that this OpenCCM script is mainly used by other OpenCCM scripts to check if the OpenCCM Configuration Repository is installed or not.

Deinstalling the OpenCCM Configuration Repository

The ccm_deinstall script deinstalls the previously installed OpenCCM Configuration Repository, e.g.:

$ ccm_install
. . .
$ ccm_deinstall
The OpenCCM Platform will be deinstalled.
Removing the $OpenCCM_CONFIG_DIR directory.
The OpenCCM Platform is deinstalled.
$

Let's note that this script stops all currently started OpenCCM processes and removes the $OpenCCM_CONFIG_DIR directory.

Starting the OpenCCM Comanche Server

The OpenCCM Comanche Server is a micro HTTP and a Multicast server allowing you to remotely access to the content of the OpenCCM Configuration Repository, e.g. the IOR of started OpenCCM services.

The comanche_start script starts the OpenCCM Comanche Server, e.g.:

$ comanche_start
The OpenCCM Comanche Server will be started.
Launching the OpenCCM Comanche Server.
The OpenCCM Comanche Server is waiting Multicast requests on mcast://224.0.0.100
The OpenCCM Comanche Server is waiting HTTP requests on http://host.domain:8080
The OpenCCM Comanche Server is started.
$

The comanche_start script supports the following options:

OptionDescription
--port portSet the TCP/IP port, default is 8080.
--group groupAddressSet the Multicast group address, default is 224.0.0.100.

Then you could access to the IOR of the started OpenCCM services via URL or Multicast group address:

ServiceURL
CosNaminghttp://host.domain:8080/NameService.IOR
mcast://multicast_group_address/NameService.IOR
CosTradinghttp://host.domain:8080/TradingService.IOR
mcast://multicast_group_address/TradingService.IOR
CosTransactionshttp://host.domain:8080/TransactionService.IOR
mcast://multicast_group_address/TransactionService.IOR
DCI Managerhttp://host.domain:8080/DCI.IOR
mcast://multicast_group_address/DCI.IOR

Let's note that this script automatically launches an OpenCCM Comanche Server process and stores its output and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR
. . . Comanche.IOR Comanche.PID
$

Warning: Only one OpenCCM Comanche Server can be started for an OpenCCM Configuration Repository, e.g.:

$ comanche_start
Error: The OpenCCM Comanche Server is already started!
$

See the comanche_stop script to stop the started OpenCCM Comanche Server.

Stopping the OpenCCM Comanche Server

The comanche_stop script stops the previously started OpenCCM Comanche Server, e.g.:

$ comanche_stop
The OpenCCM Comanche Server will be stopped.
The OpenCCM Comanche Server is stopped.
$
$ comanche_stop
Error: The OpenCCM Comanche Server is not started!
$

Let's note that this script shutdowns the OpenCCM Comanche Server process and removes its output and PID files from the OpenCCM Configuration Repository.

Starting the CosNaming Service

The ns_start script starts the CosNaming Service used by the OpenCCM Execution Tool Chain, e.g.:

$ ns_start
The CosNaming Service will be started.
Launching the ORBacus-4.1 CosNaming Service.
The CosNaming Service is started.
$

Let's note that this script automatically launches a CosNaming Service process and stores its IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR
. . . NameService.IOR NameService.PID
$

Warning: Only one CosNaming Service can be started for an OpenCCM Configuration Repository, e.g.:

$ ns_start
Error: The CosNaming Service is already started!
$

See the ns_stop script to stop the started CosNaming Service.

Setting the CosNaming Service to use

In a distributed configuration, you could want to use a CosNaming Service already started on another remote node instead of starting the CosNaming Service on the local node. Then the ns_set script allows you to set locally the IOR or the URL to the remote CosNaming Service to use, e.g.:

$ ns_set
usage: ns_set [IOR | URL]
$
$ ns_set IOR:...
The CosNaming Service is set.
$
$ ns_set http://host.domain:port/file
The CosNaming Service is set.
$
$ ns_set mcast://address_group/file
The CosNaming Service is set.
$

If the CosNaming Service to use is started on a node where the OpenCCM Comanche Server is also started, then you could set the CosNaming Service to use as following:

$ ns_set http://host.domain:8080/NameService.IOR
The CosNaming Service is set.
$

Warning: The ns_set script does not control the correctness of the IOR or URL given as parameter, it just copies it into the local $OpenCCM_CONFIG_DIR/NameService.IOR file.

Checking if the CosNaming Service is started

The ns_started script checks if the CosNaming Service is started or not, e.g.:

$ ns_stop
. . .
$ ns_started
Error: The CosNaming Service is not started!
$

Let's note that this OpenCCM script is mainly used by other OpenCCM scripts when they need to check if the CosNaming Service is started or not.

Obtaining the IOR of the running CosNaming Service

The ns_ior displays the IOR of the running CosNaming Service, e.g.:

$ ns_ior
file:$OpenCCM_CONFIG_DIR/NameService.IOR
$

Starting a client GUI on the running CosNaming Service

The ns_gui starts a client GUI on the running CosNaming Service, e.g.:

$ ns_gui
An ORBacus 4.1 CosNaming Service GUI will be started.

Warning: Currently this script is only provided for the ORBacus and JacORB products!

See the ccm_browser script to start the OpenCCM generic browser which provides a generic plug-in for browsing the CosNaming Service.

Stopping the CosNaming Service

The ns_stop script stops the previously started CosNaming Service, e.g.:

$ ns_stop
The CosNaming Service will be stopped.
The CosNaming Service is stopped.
$
$ ns_stop
Error: The CosNaming Service is not started!
$

Let's note that this script shutdowns the CosNaming Service process and removes its associated IOR and PID files from the OpenCCM Configuration Repository.

Starting the CosTrading Service

The trader_start script starts the CosTrading Service used by the OpenCCM Execution Tool Chain, e.g.:

$ trader_start
The CosTrading Service will be started.
Launching the ORBacus 4.1 CosTrading Service.
Feeding the CosTrading Service Type Repository with OpenCCM basic service types.
trader_feed 0.8.2: Reading from file $OpenCCM_HOMEDIR/xml/trading/basic.xml...
trader_feed 0.8.2: Compiling $OpenCCM_HOMEDIR/xml/trading/basic.xml file...
trader_feed 0.8.2: Compilation completed.
The CosTrading Service is started.
$

Let's note that this script automatically launches a CosTrading Service process and stores its IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR
. . . TradingService.IOR TradingService.PID
$

This script also feeds the CosTrading Service Type Repository with some OpenCCM service types. These service types are described in the $OpenCCM_HOMEDIR/xml/trading/basic.xml file conform to the Trading Service Type Descriptor XML DTD.

Warning: Only one CosTrading Service can be started for an OpenCCM Configuration Repository, e.g.:

$ trader_start
Error: The CosTrading Service is already started!
$

See the trader_stop script to stop the started CosTrading Service.

Setting the CosTrading Service to use

In a distributed configuration, you could want to use a CosTrading Service already started on another remote node instead of starting the CosTrading Service on the local node. Then the trader_set script allows you to set locally the IOR or the URL to the remote CosTrading Service to use, e.g.:

$ trader_set
usage: trader_set [IOR | URL]
$
$ trader_set IOR:...
The CosTrading Service is set.
$
$ trader_set http://host.domain:port/file
The CosTrading Service is set.
$

If the CosTrading Service to use is started on a node where the OpenCCM Comanche Server is also started, then you could set the CosTrading Service to use as following:

$ trader_set http://host.domain:8080/TradingService.IOR
The CosTrading Service is set.
$

Warning: The trader_set script does not control the correctness of the IOR or URL given as parameter, it just copies it into the local $OpenCCM_CONFIG_DIR/TradingService.IOR file.

Checking if the CosTrading Service is started

The trader_started script checks if the CosTrading Service is started or not, e.g.:

$ trader_stop
. . .
$ trader_started
Error: The CosTrading Service is not started!
$

Let's note that this OpenCCM script is mainly used by other OpenCCM scripts when they need to check if the CosTrading Service is started or not.

Obtaining the IOR of the running CosTrading Service

The trader_ior displays the IOR of the running CosTrading Service, e.g.:

$ trader_ior
file:$OpenCCM_CONFIG_DIR/TradingService.IOR
$

Starting a client GUI on the running CosTrading Service

The trader_gui starts a client GUI on the running CosTrading Service, e.g.:

$ trader_gui
An ORBacus 4.1 CosTrading Service GUI will be started.

Warning: Currently this script is only provided for the ORBacus product!

See the ccm_browser script to start the OpenCCM generic browser which provides a generic plug-in for browsing the CosTrading Service.

Feeding the CosTrading Service Type Repository

The trader_feed script feeds the CosTrading Service Type Repository used by the OpenCCM Execution Tool Chain with some service type descriptions provided in an XML file, e.g.:

$ trader_feed test/trading/various.xml
trader_feed 0.8.2: Reading from file test/trading/various.xml...
trader_feed 0.8.2: Compiling test/trading/various.xml file...
trader_feed 0.8.2: Compilation completed.
$

The Trading Service Type Descriptor XML DTD is described here.

Stopping the CosTrading Service

The trader_stop script stops the previously started CosTrading Service, e.g.:

$ trader_stop
The CosTrading Service will be stopped.
The CosTrading Service is stopped.
$
$ trader_stop
Error: The CosTrading Service is not started!
$

Let's note that this script shutdowns the CosTrading Service process and removes its associated IOR and PID files from the OpenCCM Configuration Repository.

Starting the CosTransactions Service

The ots_start script starts the CosTransactions Service used by the OpenCCM Execution Tool Chain, e.g.:

$ ots_start
The CosTransactions Service will be started.
Launching the ORBacus 4.1 CosTransactions Service.
The CosTransactions Service is started.
$

Let's note that this script automatically launches a CosTransactions Service process and stores its IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR
. . . TransactionService.IOR TransactionService.PID
$

Warning: Only one CosTransactions Service can be started for an OpenCCM Configuration Repository, e.g.:

$ ots_start
Error: The CosTransactions Service is already started!
$

See the ots_stop script to stop the started CosTransactions Service.

Setting the CosTransactions Service to use

In a distributed configuration, you could want to use a CosTransactions Service already started on another remote node instead of starting the CosTransactions Service on the local node. Then the ots_set script allows you to set locally the IOR or the URL to the remote CosTransactions Service to use, e.g.:

$ ots_set
usage: ots_set [IOR | URL]
$
$ ots_set IOR:...
The CosTransactions Service is set.
$
$ ots_set http://host.domain:port/file
The CosTransactions Service is set.
$

If the CosTransactions Service to use is started on a node where the OpenCCM Comanche Server is also started, then you could set the CosTransactions Service to use as following:

$ ots_set http://host.domain:8080/TransactionService.IOR
The CosTransactions Service is set.
$

Warning: The ots_set script does not control the correctness of the IOR or URL given as parameter, it just copies it into the local $OpenCCM_CONFIG_DIR/TransactionService.IOR file.

Checking if the CosTransactions Service is started

The ots_started script checks if the CosTransactions Service is started or not, e.g.:

$ ots_stop
. . .
$ ots_started
Error: The CosTransactions Service is not started!
$

Let's note that this OpenCCM script is mainly used by other OpenCCM scripts when they need to check if the CosTransactions Service is started or not.

Obtaining the IOR of the running CosTransactions Service

The ots_ior displays the IOR of the running CosTransactions Service, e.g.:

$ ots_ior
file:$OpenCCM_CONFIG_DIR/TransactionService.IOR
$

Stopping the CosTransactions Service

The ots_stop script stops the previously started CosTransactions Service, e.g.:

$ ots_stop
The CosTransactions Service will be stopped.
The CosTransactions Service is stopped.
$
$ ots_stop
Error: The CosTransactions Service is not started!
$

Let's note that this script shutdowns the CosTransactions Service process and removes its associated IOR and PID files from the OpenCCM Configuration Repository.

Starting an OpenCCM Distributed Computing Infrastructure Manager

An OpenCCM Distributed Computing Infrastructure (DCI) is the federation of a set of distributed nodes in order to form a unified distributed deployment domain.

An OpenCCM DCI Manager provides functionalities to manage an OpenCCM DCI domain, to (un)register OpenCCM Node Managers, to install and manage CORBA component assemblies, to access meta information about the DCI domain. This manager also implements the ComponentHomeFinder service.

The dci_start script starts an OpenCCM DCI Manager.

Its usage is the following:

$ dci_start
usage: dci_start [-h|--help] <dci_name>
$

Each OpenCCM DCI Manager must be started with an unique name, e.g.:

$ dci_start MyDCIName
The OpenCCM DCI Manager MyDCIName will be started.
Launching the OpenCCM DCI Manager MyDCIName.
Default DCI Manager set.
The OpenCCM DCI Manager MyDCIName is started.
$

Warning: Each started OpenCCM DCI Manager must have a distinct name, e.g.:

$ dci_start MyDCIName
Error: The OpenCCM DCI Manager MyDCIName is already started!
$

Let's note that the CosNaming Service must be started before, see the ns_start script, e.g.:

$ ns_stop
 . . .
$
$ dci_start MyDCIName
Error: The CosNaming Service is not started!
$

The dci_start script automatically launches an OpenCCM DCI Manager process and stores its standard output, IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR/DCIManagers
MyDCIName.IOR  MyDCIName.output  MyDCIName.PID
$

The started OpenCCM DCI Manager is bound into the CosNaming Service under the name OpenCCM/DCIManagers/MyDCIName.

See the dci_stop script to stop a started OpenCCM DCI Manager.

Setting the OpenCCM Distributed Computing Infrastructure Manager to use

In a distributed configuration, you could want to use an OpenCCM DCI Manager already started on another remote node instead of starting the OpenCCM DCI Manager on the local node. Then the dci_set script allows you to set locally the IOR or the URL to the remote OpenCCM DCI Manager to use, e.g.:

$ dci_set
usage: dci_set [IOR | URL]
$
$ dci_set IOR:...
The OpenCCM DCI Manager is set.
$
$ dci_set http://host.domain:port/file
The OpenCCM DCI Manager is set.
$

If the OpenCCM DCI Manager to use is started on a node where the OpenCCM Comanche Server is also started, then you could set the OpenCCM DCI Manager to use as following:

$ dci_set http://host.domain:8080/DCI.IOR
The OpenCCM DCI Manager is set.
$

Warning: The dci_set script does not control the correctness of the IOR or URL given as parameter, it just copies it into the local $OpenCCM_CONFIG_DIR/DCI.IOR file.

Checking if an OpenCCM DCI Manager is started

The dci_started script checks if an OpenCCM DCI Manager is started or not, e.g.:

$ dci_started
Error: None OpenCCM DCI Manager is not started!
$

Let's note that this OpenCCM script is mainly used by other OpenCCM scripts when they need to check if an OpenCCM DCI Manager is started or not.

Obtaining the IOR of the current OpenCCM Distributed Computing Infrastructure Manager

The dci_ior displays the IOR of the current running OpenCCM DCI Manager, e.g.:

$ dci_ior
file:$OpenCCM_CONFIG_DIR/DCIManagers/MyDCIName.IOR
$

Stopping an OpenCCM Distributed Computing Infrastructure Manager

The dci_stop script stops a previously started OpenCCM DCI Manager.

Its usage is the following:

$ dci_stop
usage: dci_stop [-h|--help] <dci_name>
$

To stop an OpenCCM DCI Manager, it is required to provide its name, e.g.:

$ dci_stop MyDCIName
The OpenCCM DCI Manager MyDCIName will be stopped.
The OpenCCM DCI Manager MyDCIName is stopped.
$

When providing an invalid name, an error obscurs, e.g.:

$ dci_stop MyDCIName
Error: The OpenCCM DCI Manager MyDCIName is not started!
$

Let's note that this script shutdowns the specified OpenCCM DCI Manager process and removes its associated files from the OpenCCM Configuration Repository.

$ ls $OpenCCM_CONFIG_DIR/DCIManagers
$

Starting an OpenCCM Node Manager

An OpenCCM Node Manager represents a logical node in an OpenCCM Distributed Computing Infrastructure. It provides functionalities to start and stop OpenCCM Component Servers, to install and manage CORBA component archives, to access meta information about the node. This manager implements the CORBA Components Deployment ServerActivator and ComponentInstallation interfaces.

The node_start script starts an OpenCCM Node Manager.

Its usage is the following:

$ node_start
usage: node_start [-h|--help] [-InpdFile] <node_name>
$

Each OpenCCM Node Manager must be started with an unique node name, e.g.:

$ node_start MyNodeName
The OpenCCM Node Manager MyNodeName will be started.
Creating the .../NodeManagers/MyNodeName.ComponentInstallation directory.
Launching the OpenCCM Node Manager MyNodeName.
No User Node Properties File define, use default properties.
The OpenCCM Node Manager MyNodeName is started.
$

Warning: Each started OpenCCM Node Manager must have a distinct node name, e.g.:

$ node_start MyNodeName
Error: The OpenCCM Node Manager MyNodeName is already started!
$

The optional argument -InpdFile allows you to provide meta information describing the node to start, e.g. operating system, processor, installed software, etc. For instance, this information will be used later by tools for automatic assigments of CORBA component assemblies. More information and tools will be provided in next OpenCCM releases.

Let's note that an OpenCCM DCI Manager must be started before, see the dci_start script, e.g.:

$ node_start MyNodeName
Error: None OpenCCM DCI Manager is not started!
$

Let's note that the CosNaming Service must be started before, see the ns_start script, e.g.:

$ ns_stop
 . . .
$
$ node_start MyDCIName
Error: The CosNaming Service is not started!
$

The node_start script automatically launches an OpenCCM Node Manager process and stores its standard output, IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR/NodeManagers
MyNodeName.ComponentInstallation/
MyNodeName.IOR
MyNodeName.npd
MyNodeName.output
MyNodeName.PID
$

The started OpenCCM Node Manager is bound into the CosNaming Service under the name OpenCCM/NodeManagers/MyNodeName.

See the node_stop script to stop a started OpenCCM Node Manager.

Stopping an OpenCCM Node Manager

The node_stop script stops a previously started OpenCCM Node Manager.

Its usage is the following:

$ node_stop
usage: node_stop [-h|--help] <node_name>
$

To stop an OpenCCM Node Manager, it is required to provide its node name, e.g.:

$ node_stop MyNodeName
The OpenCCM Node MyNodeName will be stopped.
The OpenCCM Node MyNodeName is stopped.
$

When providing an invalid node name, an error obscurs, e.g.:

$ node_stop MyNodeName
Error: The OpenCCM Node Manager MyNodeName is not started!
$

Let's note that this script shutdowns the specified OpenCCM Node Manager process and removes its associated files from the OpenCCM Configuration Repository.

$ ls $OpenCCM_CONFIG_DIR/NodeManagers
$

Starting an OpenCCM Assembly Factory Manager

An OpenCCM Assembly Factory Manager provides functionalities to create, build, tear down and manage CORBA component assemblies. This manager implements the CORBA Components Deployment AssemblyFactory and Assembly interfaces.

The factory_start script starts an OpenCCM Assembly Factory Manager.

Its usage is the following:

$ factory_start
usage: factory_start [-h|--help] <assembly_factory_name>
$

Each OpenCCM Assembly Factory Manager must be started with an unique assembly factory name, e.g.:

$ factory_start MyAssemblyFactoryName
The OpenCCM Assembly Factory Manager MyAssemblyFactoryName will be started.
Launching the OpenCCM Assembly Factory Manager MyAssemblyFactoryName.
The OpenCCM Assembly Factory Manager MyAssemblyFactoryName is started.
$

Warning: Each started OpenCCM Assembly Factory Manager must have a distinct assembly factory name, e.g.:

$ factory_start MyAssemblyFactoryName
Error: The OpenCCM Assembly Factory Manager MyAssemblyFactoryName is already started!
$

Let's note that an OpenCCM DCI Manager must be started before, see the dci_start script, e.g.:

$ factory_start MyAssemblyFactoryName
Error: None OpenCCM DCI Manager is not started!
$

Let's note that the CosNaming Service must be started before, see the ns_start script, e.g.:

$ ns_stop
 . . .
$
$ factory_start MyAssemblyFactoryName
Error: The CosNaming Service is not started!
$

The factory_start script automatically launches an OpenCCM Assembly Factory Manager process and stores its standard output, IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR/AssemblyFactoryManagers
MyAssemblyFactoryName.IOR
MyAssemblyFactoryName.output
MyAssemblyFactoryName.PID
$

The started OpenCCM Assembly Factory Manager is bound into the CosNaming Service under the name OpenCCM/AssemblyFactoryManagers/MyAssemblyFactoryName.

See the factory_stop script to stop a started OpenCCM Assembly Factory Manager.

Stopping an OpenCCM Assembly Factory Manager

The factory_stop script stops a previously started OpenCCM Assembly Factory Manager.

Its usage is the following:

$ factory_stop
usage: factory_stop [-h|--help] <assembly_factory_name>
$

To stop an OpenCCM Assembly Factory Manager, it is required to provide its assembly factory name, e.g.:

$ factory_stop MyAssemblyFactoryName
The OpenCCM Assembly Factory Manager MyAssemblyFactoryName will be stopped.
The OpenCCM Assembly Factory Manager MyAssemblyFactoryName is stopped.
$

When providing an invalid assembly factory name, an error obscurs, e.g.:

$ factory_stop MyAssemblyFactoryName
Error: The OpenCCM Assembly Factory Manager MyAssemblyFactoryName is not started!
$

Let's note that this script shutdowns the specified OpenCCM Assembly Factory Manager process and removes its associated files from the OpenCCM Configuration Repository.

$ ls $OpenCCM_CONFIG_DIR/AssemblyFactoryManagers
$

Starting an OpenCCM Java Component Server

An OpenCCM Java Component Server is the runtime structure for hosting CORBA container, home and component instances. This server implements the CORBA Components Deployment ComponentServer and Container interfaces.

The jcs_start script starts an OpenCCM Java Component Server.

Its usage is the following:

$ jcs_start
usage: jcs_start [-h|--help] [--ots] [--trace] <server_name>
$

Each OpenCCM Java Component Server must be started with an unique server name, e.g.:

$ jcs_start MyServerName
The OpenCCM Java Component Server MyServerName will be started with [].
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName.archive_cache directory.
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName/ specific directory.
Launching an OpenCCM Java Component Server with [].
Backup the current directory.
The OpenCCM Java Component Server MyServerName is started with [].
$

Warning: Each started OpenCCM Java Component Server must have a distinct name, e.g.:

$ jcs_start MyServerName
Error: The OpenCCM Java Component Server MyServerName is already started!
$

Let's note that the CosNaming Service must be started before, see the ns_start script, e.g.:

$ ns_stop
 . . .
$
$ jcs_start MyServerName
Error: The CosNaming Service is not started!
$

The jcs_start script automatically creates a directory to store downloaded archives, launches an OpenCCM Java Component Server process and stores its standard output, IOR and PID into the OpenCCM Configuration Repository, e.g.:

$ ls $OpenCCM_CONFIG_DIR/ComponentServers
MyServerName/     MyServerName.archive_cache/
MyServerName.IOR  MyServerName.output
MyServerName.PID
$

The started OpenCCM Java Component Server is bound into the CosNaming Service with the server name given as parameter.

The --ots option starts a transactional OpenCCM Java Component Server, e.g.:

$ jcs_start --ots MyServerName
The OpenCCM Java Component Server MyServerName will be started with [ Transactional ].
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName.archive_cache directory.
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName/ specific directory.
Launching an OpenCCM Java Component Server with [ Transactional ].
Backup the current directory.
The OpenCCM Java Component Server MyServerName is started with [ Transactional ].
$

Let's note that the CosTransactions Service must be started before, see the ots_start script, e.g.:

$ ots_stop
 . . .
$
$ jcs_start MyServerName
Error: The CosTransactions Service is not started!
$

The --trace option starts an OpenCCM Java Component Server with the trace service, e.g.:

$ jcs_start --trace MyServerName
The OpenCCM Java Component Server MyServerName will be started with [ Trace ].
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName.archive_cache directory.
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName/ specific directory.
Launching an OpenCCM Java Component Server with [ Trace ].
Copying the Trace Service configuration file to the specific ComponentServer directory.
Backup the current directory.
The OpenCCM Java Component Server MyServerName is started with [ Trace ].
$

Both --ots and --trace options could be used simultaneously, e.g.:

$ jcs_start --ots --trace MyServerName
The OpenCCM Java Component Server MyServerName will be started with [ Transactional
  Trace ].
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName.archive_cache directory.
Creating the $OpenCCM_CONFIG_DIR/ComponentServers/MyServerName/ specific directory.
Launching an OpenCCM Java Component Server with [ Transactional  Trace ].
Copying the Trace Service configuration file to the specific ComponentServer directory.
Backup the current directory.
The OpenCCM Java Component Server MyServerName is started with [ Transactional  Trace ].
$

See the jcs_stop script to stop a started OpenCCM Java Component Server.

Stopping an OpenCCM Java Component Server

The jcs_stop script stops a previously started OpenCCM Java Component Server.

Its usage is the following:

$ jcs_stop
usage: jcs_stop [-h|--help] <server_name>
$

To stop an OpenCCM Java Component Server, it is required to provide its server name, e.g.:

$ jcs_stop MyServerName
The OpenCCM Java Component Server MyServerName will be stopped.
The OpenCCM Java Component Server MyServerName is stopped.
$
$ jcs_stop MyServerName
Error: The OpenCCM Java Component Server MyServerName is not started!
$

When providing an invalid server name, an error obscurs, e.g.:

Let's note that this script shutdowns the specified OpenCCM Java Component Server process and removes its associated files from the OpenCCM Configuration Repository.

$ ls $OpenCCM_CONFIG_DIR/ComponentServers
$

Deploying a CORBA Component Assembly Archive

The ccm_deploy script launches the deployment of homes, instantiates components, connects them to each other, and runs the application automatically, reading its input from an assembly archive, i.e. a ZIP file with CCM XML descriptors and CORBA component archives.

The usage of this script is the following:

$ ccm_deploy
usage: ccm_deploy [-h|--help] [--version] [--silent] [--ots] [--trace] [--tracing] [-l] [-F <AssemblyFactoryName>] <assembly.aar>
$

To start a deployment, an assembly archive must be provided as parameter, e.g.:

$ ccm_deploy MyAssembly.aar

ccm_deploy 0.8.2: Initiating deployment sequence of archives\MyAssembly.aar
http://127.0.0.1:2255/archives\MyAssembly.aar
Request received:GET /archives\MyAssembly.aar HTTP/1.1
Downloading http://134.206.11.41:2255/archives\MyAssembly.aar [**********************
**********]
AssemblyManager>>File [META-INF/MyAssembly.cad] is used for deployment
Request received:GET /archives/MyComponent.jar HTTP/1.1
Request received:GET /MyComponent.car HTTP/1.1

ccm_deploy 0.8.2: Successfully deployed archives\MyAssembly.aar

$

Deploy the given component assembly archive using the default factory connected to the current DCIManager.

$ ccm_deploy -F myAssemblyFactory MyAssembly.aar

ccm_deploy 0.8.2: Initiating deployment sequence of archives\MyAssembly.aar
Use the specified assembly factory [myAssemblyFactory]
http://127.0.0.1:2255/archives\MyAssembly.aar
Request received:GET /archives\MyAssembly.aar HTTP/1.1
Downloading http://134.206.11.41:2255/archives\MyAssembly.aar [**********************
**********]
AssemblyManager>>File [META-INF/MyAssembly.cad] is used for deployment
Request received:GET /archives/MyComponent.jar HTTP/1.1
Request received:GET /MyComponent.car HTTP/1.1

ccm_deploy 0.8.2: Successfully deployed archives\MyAssembly.aar

$

Deploy the given component assembly archive using the myAssemblyFactory assembly factory given in parameter. The assembly factory must be started by the factory_start myAssemblyFactory command.

$ ccm_deploy -l MyAssembly.aar

ccm_deploy 0.8.2: Initiating deployment sequence of archives\MyAssembly.aar
Local deployment processing
http://127.0.0.1:2255/archives\MyAssembly.aar
Request received:GET /archives\MyAssembly.aar HTTP/1.1
Downloading http://134.206.11.41:2255/archives\MyAssembly.aar [**********************
**********]
AssemblyManager>>File [META-INF/MyAssembly.cad] is used for deployment
Request received:GET /archives/MyComponent.jar HTTP/1.1
Request received:GET /MyComponent.car HTTP/1.1

ccm_deploy 0.8.2: Successfully deployed archives\MyAssembly.aar

$

Deploy the given component assembly archive without any assembly factory the deployment is locally proceed. The resulting assembly will not be teardownable beacause no server hosts the assembly object.

$ ccm_deploy -l -F myAssemblyFactory MyAssembly.aar

ccm_deploy 0.8.2: Initiating deployment sequence of archives\MyAssembly.aar
Local deployment processing
http://127.0.0.1:2255/archives\MyAssembly.aar
Request received:GET /archives\MyAssembly.aar HTTP/1.1
Downloading http://134.206.11.41:2255/archives\MyAssembly.aar [**********************
**********]
AssemblyManager>>File [META-INF/MyAssembly.cad] is used for deployment
Request received:GET /archives/MyComponent.jar HTTP/1.1
Request received:GET /MyComponent.car HTTP/1.1

ccm_deploy 0.8.2: Successfully deployed archives\MyAssembly.aar

$

Deploy the given component assembly archive without any assembly factory the deployment is locally proceed. The resulting assembly will not be teardownable beacause no server hosts the assembly object. In that case the second parameter -F myAssemblyFactory is ignored because the local deployment have the highter priority.

Refer to the Writing CCM XML meta files section for more information about the XML files you can use.

The ccm_deploy script supports the following options:

OptionDescription
-h or
--help
Display usage and help information, and exit.
--versionOutput version information and exit.
--silentSilent output messages.
--otsDeploy inside a transaction.
--traceDeploy with the Trace Service running.
-lPrecise that the deployment must be local without using assembly factory.
-F <AssemblyFactoryName>Set which assembly factory must be used to deploy.

To obtain usage and help information, do:

$ ccm_deploy --help
Usage: ccm_deploy [-h|--help] [--version] [--silent] [-l] [-F factory_name] zip_file.aar

Options:
  -h, --help      Display this information and exit
  --version       Output version information and exit
  --silent        Silent output messages
  -l              This flag indicates that the deployment must be done locally without using an assembly factory
  -F factory_name The name of the factory to use, default is DefaultFactory

Description:
  Deploy an assembly archive

$

To obtain version information, do:

$ ccm_deploy --version
ccm_deploy 0.8.2

Copyright (C) 2000-2003 INRIA - USTL - LIFL - GOAL
. . .
$

By default, the ccm_deploy script displays messages. To silent this output messages, do:

$ ccm_deploy --silent MyAssembly.zip
$

Warning: Both --ots and --trace options will be supported in future releases.

Tearing down an assembly

$ tear_down MyAssembly
    No print if successfull.

$

The tear_down command allows to stop the assembly MyAssembly given in parameter from the console. The tear_downed assembly is not destroy to destroy it you can use the ccm_browser. The parameter MyAssembly is the componentassembly id described in the component assembly descriptor.

Starting the OpenCCM Browser

The ccm_browser script starts a graphical console which allows you to browse and manage components at runtime, e.g.:

$ ccm_browser
Error: The OpenCCM Platform is not installed!
$ ccm_install
...
$ ccm_browser
The OpenCCM Browser will be started.

The ccm_browser script supports the following options:

OptionDescription
-h or
--help
Display usage and help information, and exit.
--versionOutput version information and exit.
--silentSilent output messages.
--defaultContextDefault context XML file (You don't have to use this option !).
--defaultBrowserDefault browser XML file (You don't have to use this option !).
--configSet an additional config file

To obtain usage and help information, do:

$ ccm_browser --help
The OpenCCM Browser will be started.
Usage: ccm_browser [-h|--help] [--version] [--silent]
                   [--defaultContext file] [--defaultBrowser file] [--config file]

Options:
  -h, --help            Display this information and exit
  --version             Output version information and exit
  --silent              Silent output messages
  --defaultContext file Default context XML file (You don't have to use this option !)
  --defaultBrowser file Default browser XML file (You don't have to use this option !)
  --config file         Set the config XML file

Description: 
  Display the OpenCCM browser console

$

To obtain version information, do:

$ ccm_browser --version
OpenCCM ccm_browser 0.8.2

Copyright (C) 2000-2003 INRIA - USTL - LIFL - GOAL
. . .
$

Let's note that the --config option adds configuration entries to the default ones.

Lots of OpenCCM demos (demo1, demo3, dinner, chat, filetransfer) have been customized. So, when one of this demo is running, you can start the browser with the specific command line:

$ ccm_browser --config browser.xml

The browser.xml configuration file contains the customization of the demo.

The description of current available plug-ins for the OpenCCM Browser is available in the following document.

The description of the OpenCCM Browser Configuration XML DTD is available in the following document.

Copyright © 1999-2005, ObjectWeb Consortium | contact | webmaster | Last modified at 2005-07-07 02:04 PM