avalon-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mcconn...@apache.org
Subject cvs commit: jakarta-avalon-cornerstone/apps/enterprise/orb/src/etc PROPOSAL.TXT README.TXT
Date Sat, 02 Feb 2002 18:40:21 GMT
mcconnell    02/02/02 10:40:21

  Added:       apps/enterprise/orb build.properties build.xml
               apps/enterprise/orb/src/etc PROPOSAL.TXT README.TXT
  addition of proposal and redme
  Revision  Changes    Path
  1.1                  jakarta-avalon-cornerstone/apps/enterprise/orb/build.properties
  Index: build.properties
  # The pss.properties file is read in by the build.xml file.  It 
  # contains information related to resource dependencies and paths
  # to related cornerstone resource
  1.1                  jakarta-avalon-cornerstone/apps/enterprise/orb/build.xml
  Index: build.xml
  PSS Service.
  Copyright 2001-2002 OSM SARL, All Rights Reserved.
  <project name="orb" default="help" basedir=".">
    <property file="local.properties"/>
    <property file="build.properties"/>
    <target name="help" >
        ORB related experiments.
        General Targets:
        build            - invokes the general build target
        javadoc          - javadoc API generation
        dist             - executes build, javadoc and support file creation
        clean            - destroy the build directory
    <property name="MAJOR" value="2"/>
    <property name="MINOR" value="0"/>
    <property name="MICRO" value="1"/>
    <property name="VERSION" value="${MAJOR}.${MINOR}.${MICRO}"/>
    <property name="compiler.jar" value="psdl-${VERSION}.jar"/>
    <property name="orb.manager.jar" value="orb-manager-${VERSION}.jar"/>
    <property name="enterprise" value=".." />
    <property name="lib" value="lib" />
    <property name="src" value="src" />
    <property name="idl" value="${src}/idl" />
    <property name="etc" value="${src}/etc" />
    <property name="build"  value="build" />
    <property name="dist"  value="dist" />
    <property name="javadoc.root.path"  value="${dist}/javadoc" />
    <property name="avalon.href"  value="http://jakarta.apache.org/avalon/api/" />
    <property name="jdk.href"  value="http://java.sun.com/j2se/1.4/docs/api/" />
    <path id="project.classpath">
        <fileset dir="${orb.path}">
          <include name="${orb.jar}" />
          <include name="${idl.jar}" />
        <fileset dir="../../../lib">
          <include name="*.jar" />
    <!-- PREPARE -->
    <target name="prepare"  >
      <mkdir dir="${build}" />
      <mkdir dir="${dist}" />
    <!-- ORB BLOCK/MANGER -->
    <target name="orb.context" depends="prepare" >
      <mkdir dir="${build}/orb" />
      <mkdir dir="${build}/orb/src" />
      <mkdir dir="${build}/orb/lib" />
    <target name="orb.build.context" depends="orb.context">
      <uptodate property="orb.uptodate" targetfile="${dist}/${orb.manger.jar}">
        <srcfiles dir="${build}/orb/src"/>
        <srcfiles dir="${src}/java">
           <include name="org/apache/orb/**"/>
    <target name="orb" depends="orb.build.context" unless="orb.uptodate" >
        <echo message="Building ORB Manager Implementation."/>
        <javac debug="off" destdir="${build}/orb/lib" deprecation="true">
  	    <path refid="project.classpath" />
          <src path="${build}/orb/src" />
          <src path="${src}/java" />
          <include name="org/apache/orb/**"/>
        <copy todir="${build}/orb/lib">
          <fileset dir="${src}/java">
            <include name="org/apache/orb/config.xml"/>
        <jar file="${dist}/${orb.manager.jar}" basedir="${build}/orb/lib" />
    <!-- MAIN TARGETS -->
    <target name="clean">
       <delete dir="${build}"/>
    <target name="build" depends="orb"/>
    <target name="dist" depends="build,javadoc,support"/>
    <target name="all" depends="clean,dist"/>
    <!-- UTILITY TARGETS -->
    <target name="support">
      <copy todir="${dist}">
         <fileset dir="${enterprise}/etc">
           <include name="LICENSE.TXT"/>
           <include name="EXOLAB.TXT"/>
         <fileset dir="${etc}">
           <include name="README.TXT"/>
    <target name="javadoc" depends="prepare" >
      <mkdir dir="${javadoc.root.path}" />
      <copy todir="${javadoc.root.path}/">
         <fileset dir="${enterprise}/etc">
           <include name="LICENSE.HTML"/>
           <include name="license.css"/>
           <include name="EXOLAB.TXT"/>
      <javadoc destdir="${javadoc.root.path}" 
  	doctitle="&lt;h1&gt;Object Request Broker (ORB)&lt;/h1&gt;" 
        noindex="false" author="false" 
  	windowtitle="Apache ORB 2.4" 
        bottom="&lt;a href='{@docRoot}/LICENSE.HTML'/&gt;License, Disclaimer and due
        additionalparam="-breakiterator -J-Xmx128m"
        packagenames="org.*" >
          <sourcepath path="${src}/java"/>
          <sourcepath path="${build}/orb/src"/>
  	    <path refid="project.classpath" />
            <pathelement path="${dist}/${orb.manager.jar}" />
  	  <link href="${jdk.href}" />
  	  <link href="${avalon.href}" />
  1.1                  jakarta-avalon-cornerstone/apps/enterprise/orb/src/etc/PROPOSAL.TXT
  ORB Component Manager Proposal
  The current ORBServer/ORBService implementation under the CVS 
  is problamatic in that the reference to an ORB by a managed 
  component can only be referenced by its role.  It is not possible
  to access a ORB that fulfils a specific swervice project unless
  the defintion of the ORB is controlled in the ORB configuration 
  block.  This leads to multiple block defintions and restrinctions
  concerning the scope of declarations associated to individual ORB
  An alternative ORB management framework is proposed below.  The 
  object model is based on a ORBFactory service, exposed by an 
  ORBService.  The factory service takes confitguration and context
  information of the priocipal argume t to the creation of a new ORB
  instance. An implementation of ORBFactory would leverage extensions
  to the static ORB init method, allow the passing of native 
  configuration and context information to the ORB singleton 
  implementation.  The result ORB instance is then in a position to 
  handle configutration anf contextualization of interceptors based 
  on the innitalization atrguments.
      1. An application block would be configured as dependent a 
         block exposing the an ORBService interface.
      2. The ORBService interface would provide an ORBFactory
      3. The ORBFactory interface would look something like the 
           public interface ORBFactory extends Component
              * Creation of a new ORB instance based on a 
              * supplied configuration and runtime context.
              * @param config a <code>Configuration</code> instance
              *   describing a static ORB profile.
              * @param context the runtime <code>Context</code>.
              * @return ORB an object request broker
              ORB createORB( Configuration config, Context context );
      4. The implementation of createORB is basically a wrapper on 
         the variant of the static ORB.init method that would take 
         a configuration and context argument directly.
       | Phoenix or embedded-bootstap-kernel           |
       | Handles log hierachy creation, establishment  |
       | of a root configuration and application       |
       | context.                                      |
              | handles component lifecycle
              | processing (setting log channel, configuring
              | contextualizing, initializing, etc)
       | ORBService  |
              | Is a component manager that provides an 
              | ORB factory service to the components it manages
              |    The ORBFactory implmenetation
              |    leverages a variant of the static ORB.init 
              |    operation that handles configuration and 
              |    context information directly.
       ---------------     --------------------------------------
       | ORBFactory  |<--->| static ORB,init( Config, Context ) |
       ---------------     --------------------------------------
              |                 |
              | provides        | enables logging, configures and contextualizes
              | ORB instance    | the internal components it needs tyo build the 
              |                 | ORB instance
              V *               |        
       ---------------          |      * -----------------
       |     ORB     |          |------->| Interceptor   |
       ---------------                   -----------------  
      5. Application block (as a component manager) can then 
         provide the configured ORB or multiple ORB instances 
         to its own sub-systems.
  1. The ORB core can be used independently of this framework.
  2. Alows a much simpler ORB creation process
  3. Seperates static from dynamic properties of the creation 
  4. Is totaly in synchronization with (future) internal ORB 
     logging nad configuraition approach
  5. Non-OMG operations leverage Apache Avalon fromaework 
  6. In principal the manager could work with other vendor
     ORBs (not an immediate priority).
  1.1                  jakarta-avalon-cornerstone/apps/enterprise/orb/src/etc/README.TXT
  This package contains very ALPHA code related to the delivery of a
  configurable, composable and contextualizable ORB component manager.
  These solurces are and subject to change without any 
  consideration for the consequences.

To unsubscribe, e-mail:   <mailto:avalon-cvs-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:avalon-cvs-help@jakarta.apache.org>

View raw message