Configuration of Properties for ORB

attributes of propery:

name	    String (* in front means OMG std, otherwise Sun internal)
type	    int, String, boolean, float, class (or any class with a public XXX( String ) constructor) 
default

DEBUG_PROPERTY			    String		setDebugFlags( arg ) ( , list)
*INITIAL_HOST_PROPERTY		    String		set var
*INITIAL_PORT_PROPERTY		    int			set var, setInitialServicesPort
SERVER_HOST_PROPERTY		    String		set var
SERVER_PORT_PROPERRT		    int			set var
*ORB_ID_PROPERTY		    String		set var
*INITIAL_SERVICES_PROPERTY	    URL			setServicesURL
*ORB_INIT_REF_PROPERTY		    String		addORBInitRef
*DEFAULT_INIT_REF_PROPERTY	    String		setORBDefaultInitRef
NUMBER_TO_RECLAIM_PROPERTY	    int			set var
ALLOW_LOCAL_OPTIMIZATION	    boolean		set var
SOCKET_FACTORY_CLASS_PROPERTY	    Class		set var
LISTEN_SOCKET_PROPERTY		    String		add mapped to list ( , list of (S:I) )

*PI_ORB_INITIALIZER_CLASS_PREFIX.*   String		map to class, instantiate, add to list

PERSISTENT_SERVER_PORT_PROPERTY	    int			setPersistentServerPort
SERVER_ID_PROPERTY		    int			setPersistentServerId
BAD_SERVER_ID_HANDLER_CLASS_PROPERTY Class		set var (as string)
ACTIVATED_PROPERTY		    boolean		set var

GIOP transport specific properties:

HIGH_WATER_MARK_PROPERTY	    int			set var
LOW_WATER_MARK_PROPERTY		    int			set var
GIOP_VERSION			    GIOPVersion		set var (from int.int)
GIOP_FRAGMENT_SIZE		    int			set var (special checks)
GIOP_BUFFER_SIZE		    int			set var
GIOP_11_BUFFMGR			    int			set var (really enum or else 0-2) 
GIOP_12_BUFFMGR			    int			set var (really enum or else 0-2) 
GIOP_TARGET_ADDRESSING		    int			set mapped var (really enum or else 0-3)
ALWAYS_SEND_CODESET_CTX_PROPERTY    boolean		set var
USE_BOMS			    boolean		set var
USE_BOMS_IN_ENCAPS		    boolean		set var
CHAR_CODESETS			    CodeSetComponent	set var
WCHAR_CODESETS			    CodeSetComponent	set var


Parsers

class IntParserFactory {
    static IntParser makeRangeIntParser( int min, int max )  ;

}
   
Parsing process;


- construct 
- unify all args, properties into a single properties object props
- for each key k in props
    - find matching ParseAction p
    - p.parse( k, props.getProperty( k ) ) 

Design principles:

1. Get config data out of ORB
    Discussion:	beans framework does not work this way: instead, it creates the beans,
    which are themselves both configuration data and configured component.

    Two models:
	a. parse props -> create config data
	b. parse props -> create config data -> create components

    However, long-term bean persistence can be used in either model.  Separation of
    concerns (and the large size of the ORB class) argues for separating data from
    components.

2. get configuration out of ORB (except for finding config class)
    ORB responsibility:
	- gather all property, arg data together and make it available
	- load the ORB configurator and let it process the data, generate a config object
	- ORB is central registry, so ORB configurator store config data in ORB

3. Extensibility is required

    The ORB will have large subsystems that are pluggable components (examples: aobject adaptors,
    transport plugins).  Individual instances of these frameworks will have their own configuration
    data.  To solve this, the ORB class will provide (read-only perhaps?) access to the collected
    properties.

    While the component config data is not needed in the ORB, it is needed in the ORB config data 
    so that bean persistence can be used to create an XML version of the data.

    problem: properties vs. config data: same or not?

    properties: easier to use, also necessary to indicate where to get config data if not default
    config data: more powerful

4. Basic principle: A parser performs an action A based on a value V when it matches a property P. 
   Actions can be:
    
    configObject.setP( V )
    configObject.setP( A(V) )
    A(V)

5. ParserActions are composable

    Basic action: Object parse( String arg, String value )
    which nicely handles prefix parsing and sharing of actions across multiple keys

    interface Operation {
	Object operate( String arg, String value )
    }
    
    interface OperationFactory {
	Operation booleanAction() ;

	Operation integerAction() ;

	Operation stringAction() ;
	
	Operation integerRangeAction( int min, int max ) ;

	Operation listAction( char sep, Operation act ) ;
    }

    interface ParserAction {
	void parse( String arg, String value ) ;
    }

    interface ParserActionFactory {
	ParserAction setFieldAction( String fieldName ) ;

	ParserAction setFieldAction( String fieldName, Operation op ) ;

	ParserAction operationAction( Operation op ) ;
    }

6. Parsers are created incrementally:

    Constructor:
    new Parser( Class configurationDataClass )
	- has the parser class available for useful defaults

    interface PropertyParser {
	/** Option must look like a standard property name, which we require here to 
	* be ( JavaIdent "." ) * JavaIdent.  The last java ident we will call the tail.
	* If tail starts with "ORB", this option will be used in augmentWithArguments.
	* This match operates as follows:
	* Let name = tail stripped of its ORB prefix.
	* (e.g. if tail = ORBLowWaterMark, name = LowWaterMark).
	* Then if option is matched, a conversion to the result type of the method named
	* get<name> is performed, and set<name> is called on the data object to set the
	* result.  
	*/
	void addMatch( String option ) ;

	void addMatch( String option, ParserAction pa )

	void addPrefixMatch( String prefix, ParserAction pa ) 

	/** First constructs a new property object that has props as its default, 
	* then enters args into new property object that correspond to property
	* names registered in match() calls.
	*/
	Properties augmentWithArguments( Properties props, String[] args ) ;

	/** Parse all matched properties in props, updating data as required 
	* by the actions.
	*/
	void parse( Properties props, ORBConfigurationData data ) ;
    }

7. A useful model:

    Provide 

    abstract class ConfigDataBase {
	ConfigDataBase( Properties props )
	{
	    ...
	}
    }

    and then a specific class

    public class ORBConfigData extends ConfigDataBase {
	ORBConfigData( Properties props ) 
	{
	    super( props ) ;
	}

	private int foo1 = fooDefault ;
	private String foo2 = fooDefault2 ;
	private boolean foo3 = fooDefault3 ;
	private SomeObject foo4 = fooDefault4 ;

	public int getFoo1() { return foo1 ; }
	// and similarly
    }

    The constructor then uses reflection to automatically handle all of these variables with a number of
    assumptions:
    a. Standard names:
	private <type> foo { = <default> } 
	public <type> getFoo() { return foo ; }
	as argument: -ORBfoo
	as property: com.sun.CORBA.foo  (problems here)
    b. type specific parsing
	int: from Integer
	String: no-op
	boolean: true/false (from Boolean)
	Class: must be able to load class
	class XXX: XXX must have a public XXX( String ) constructor

    Custom parsing?

    What are valid prefixes?
    1. provide com.sun.corba.prefix.XXX where XXX defines a prefix to look for
       (some security implications)
    2. Extend security model to ORB implementation (I like this approach best so far)

8. ORB config

    public interface ORBConfigurator {
	/** This method is called from ORB.init after all ORB properties have been
	* collected.  The corba.ORB constructor will make sure that all required
	* registries are initialized and empty.  This constructor will also initialize
	* some data used in the corba ORB public API, such as support for deferred
	* asynchronous invocation.  However, all regisitration including things like
	* the dyanmic any factory should take place in the configurator.  This method
	* is resonsible for making PI ORBInitializer calls, if PI is configured.
	*/
	void configure( com.sun.corba.se.impl.core.ORB orb ) ;
    }

   The ORB will have a default configurator named

    com.sun.corba.se.impl.core.ORBConfiguratorImpl

   and also a property

    com.sun.CORBA.ORBConfiguratorClass

   than can be set to the name of the ORB configurator class to use.  Note that this
   implementation can either be a straight Java implementation, or something more
   interpretive, such as an XML-based config description.

9. We need to construct a list of all properties, and then make sure that security is respected. 
   The basic security check is just:

    SecurityManager sman = System.getSecurityManager() ;
    if (sman != null)
	sman.checkPropertyAccess( key )

    and also

    sman.checkPropertiesAccess()

   We can construct a list of all properties as we do now, which allows the ORB
   to call System.getProperties() inside a doPrivileged() block.  Then we create
   a subclass of java.util.Properties that overrides getProperty to
   do the checkPropertyAccess( key ) call.  We also need to overload the
   enumerate method, either to make it illegal, call sman.checkPropertiesAccess,
   or just filter it to include only the accessible properties.
   And we also need to overload store, because it does not call enumerate internally.

   This allows us to provide all properties to an ORBConfigurator, while still preserving
   the security model.  Then anyone that needs security can set up property permissions
   like com.foo.corba.* to allow access to only the properties they care about.

10. ORB APIs

    The ORB needs registry support including:
	getSubcontractRegistry
	getServiceContextRegistry

    The ORB needs to provide access to a basic (and extensible) ORB configuration object,
    which supports at a minimum all of the standard CORBA defined properties.

    Also need registries for:
	ObjectAdapter (actually already in SubcontractRegistry, but needs extensions to
	    ObjectAdapterFactory to work fully)
	TaggedComponentFactory
	TaggedProfileFactory

    What does an empty ORB provide?
	- Registration of all ORB components
	- Request dispatching to object adapters
	- Access to ORB properties data (as secure Properties object)
	- Access to ORB arguments
	- Access to ORB configuration data (base class, plus collections of base config
	  data for plugins such as OAs and transports)
	- shutdown support (separate tracking of invocations vs. OA tracking in POA case?
	  How should this be designed?)
	- INS support? (perhaps this could be pluggable too?)
	- How does create_output_stream get plugged in?
	- Can we separate the current IIOP transport into a TransportPluging?
	- PI support
	- CORBA::ORB API
	    - NVList, DII
	    - object <-> string (which includes INS?)
	    - (dis)connect API for TOA (move all impl to TOAImpl?)
	    - typecode/any
	    - FVD 
	    - initial services registry
	    - value factory registry
	    - logging, other M&M support as needed

ORB classes:

    core.ORB:				abstract class providing internal interface
    corba.ORBImpl:			internal implementation of CORBA APIs
    corba.ORBSingleton:			the singleton ORB (not much change needed)
    corba.ConfigurationDataCollector:	collects all source of config data and canonicalizes it
    Interceptor.PIHandler:		the interface for PI
    Interceptor.PIHandlerImpl:		standard implementation of PIHandler
    corba.ORBConfigurationData:		extensible bean containing all ORB config data

11. RequestHandler and ORB

    The RH interface is currently implemented in the ORB class, but might better be a separate
    class.  The API is currently almost the same as a ServerSubcontract.  Should we regularize
    this?  Also, the API would need to be extended to handle shutdown properly.

    Extended API:
	- void run(): does not return until shutdown(boolean) is called.
	- shutdown(boolean) needs to be here so that requests can be 
	  synchhronized with shutdown.  This is also a point where OAs
	  need to be included (currently in shutdownServants)