1. Object-Oriented Network Communication (OOMI) Dynamic Requests Emmerich – Chapter 6. 7.03.2003

2. Slide 2 of 27 © Ingeniørhøjskolen i Århus Outline 1. Dynamic Invocation The CORBA Dynamic Invocation Interface 2. Reflection The CORBA Interface Repository

3. Slide 3 of 27 © Ingeniørhøjskolen i Århus What is a Dynamic Request? Sometimes clients need to be built before their server interfaces are defined They need to defer request definition until they are executed These are dynamic requests Examples: –Object browser –Automatic test programmes

4. Slide 4 of 27 © Ingeniørhøjskolen i Århus Motivating Example: Object Browser

5. Slide 5 of 27 © Ingeniørhøjskolen i Århus Commonalities Discovery of type information at run-time Use of type information to build client objects that can cope with any type of server objects Definition of object requests at run-time Requires two primitives from middleware: –Dynamic invocation interfaces –Reflection mechanisms

6. Slide 6 of 27 © Ingeniørhøjskolen i Århus 1. Dynamic Requests: Principles Any object request has to identify –server object –operation name –actual parameters –data structure for operation result In Dynamic Requests: –server object identified by object reference –operation name identified by string –actual parameters as list of name/value pairs –operation result determined by an address

7. Slide 7 of 27 © Ingeniørhøjskolen i Århus Dynamic Invocation Client Stubs ORB Interface Implementation Skeletons Client Object Implementation ORB Core Object Adapter Dynamic Requests in CORBA

8. Slide 8 of 27 © Ingeniørhøjskolen i Århus Dynamic Requests in CORBA Dynamic invocation interface (DII) supports dynamic creation of requests Requests are objects themselves Request objects have attributes for operation name, parameters and results Request objects have operations to –change operation parameters –issue the request and –obtain the request results

9. Slide 9 of 27 © Ingeniørhøjskolen i Århus Dynamic Request in CORBA :Client rr:Request :Server Op() r=create_request(…,”Op”,…) add_arg()invoke() delete()

10. Slide 10 of 27 © Ingeniørhøjskolen i Århus Using DII with Java … //obtain the obj stub – e.g. from IOR org.omg.CORBA.Object obj = orb.string_to_object(ref) ; // Create a DII request and set the arguments and result org.omg.CORBA.Request r = obj._request("sayHello"); r.set_return_type(orb.get_primitive_tc(org.omg.CORBA.TCKind.tk_string)); // call the Hello server object and print results r.invoke(); java.lang.Exception ex = r.env().exception(); //handling of exception … // extract the result String result; result = r.return_value().extract_string(); System.out.println("Result from DII: " + result + "Now without stubs!");

11. Slide 11 of 27 © Ingeniørhøjskolen i Århus Creating Dynamic CORBA Requests interface Object { ORBstatus create_request( in Context ctx, // operation context in Identifier operation,// operation to exec in NVList arg_list, // args of operation inout NamedValue result,// operation result out Request request // new request object in Flags req_flags // request flags );... };

12. Slide 12 of 27 © Ingeniørhøjskolen i Århus Manipulating Dynamic CORBA Requests interface Request { Status add_arg ( in Identifier name, // argument name in TypeCode arg_type,// argument datatype in void* value, // argument to be added in long length, // length of argument value in Flags arg_flags // argument flags ); Status invoke( in Flags invoke_flags // invocation flags ); Status send( in Flags invoke_flags // invocation flags ); Status get_response( in Flags response_flags // response flags ) raises (WrongTransaction); Status delete(); };

13. Slide 13 of 27 © Ingeniørhøjskolen i Århus Transparency of Dynamic Invocation In both COM and CORBA: –Client programs have to be written differently  Use of dynamic invocation interfaces is not transparent to client programmers In COM: –Interfaces of server objects have to be designed as dual  Use of dynamic invocation not transparent in server design In CORBA: –Server objects are unaware of dynamic invocation –  Use of DII is transparent

14. Slide 14 of 27 © Ingeniørhøjskolen i Århus 2. Reflection Principles How do clients discover attributes & operations that servers have? Need to –capture type information during interface compilation –store type information persistently –provide an interface for clients to obtain type information during run-time Reflection interfaces provided by –CORBA Interface Repository

15. Slide 15 of 27 © Ingeniørhøjskolen i Århus CORBA Interface Repository Service Makes type information of interfaces available at run-time Achieves type-safe dynamic invocations Supports construction of interface browser Used by CORBA implementations themselves (need a IR server running) –Not supported by Orbacus Java & SUNs ORB –Very vendor specifik implementation Persistent storage of IDL interfaces in abstract syntax trees (ASTs)

16. Slide 16 of 27 © Ingeniørhøjskolen i Århus Interface repository persistently stores ASTs of IDL modules, interfaces, types, operations etc. module SoccerMgmt { }; ModuleDef SoccerMgmt InterfaceDef Player interface Player; InterfaceDef Team interface Team { }; TypedefDef PlayerList typedef sequence PlayerList; ExceptionDef InvalidNumber exception InvalidNumber{} ; AttributeDef members attribute PlayerList members; OperationDef add void add(in short number, in Player p); raises(InvalidNumber) Abstract Syntax Trees (ASTs)

17. Slide 17 of 27 © Ingeniørhøjskolen i Århus Container AST Node Types IRObject Contained OperationDef ExceptionDef TypedefDef AttributeDef ConstantDef ModuleDef InterfaceDef Repository

18. Slide 18 of 27 © Ingeniørhøjskolen i Århus Container (node with children) interface Container : IRObject { Contained lookup (in ScopedName search_name); sequence contents( in DefinitionKind limit_type, in boolean exclude_inherited); sequence lookup_name ( in Identifier search_name, in long levels_to_search, in DefinitionKind limit_type, in boolean exclude_inherited);... };

19. Slide 19 of 27 © Ingeniørhøjskolen i Århus Contained (child) interface Contained : IRObject { attribute Identifier name; attribute RepositoryId id; attribute VersionSpec version; readonly attribute Container defined_in ; struct Description { DefinitionKind kind; any value; }; Description describe ();... };

20. Slide 20 of 27 © Ingeniørhøjskolen i Århus Interface Definition interface InterfaceDef : Container,Contained { attribute sequence base_interfaces; boolean is_a (in RepositoryId interface_id); struct FullInterfaceDescription { Identifier name; RepositoryId id; RepositoryId defined_in; RepositoryIdSequence base_interfaces; sequence operations; sequence attributes;... }; FullInterfaceDescription describe_interface (); };

21. Slide 21 of 27 © Ingeniørhøjskolen i Århus Locating CORBA Interface Definitions Alternatives: Any interface inherits the operation InterfaceDef get_interface() from Object Associative search using lookup_name() Navigation through the interface repository using contents and defined_in attributes

22. Slide 22 of 27 © Ingeniørhøjskolen i Århus Example: Object Browser Use run-time type information to find out about –object types and –attribute names Use dynamic invocation interfaces to obtain attribute values

23. Slide 23 of 27 © Ingeniørhøjskolen i Århus :Browser p:Player i:InterfaceDefr1: Request i=get_interface() name() r1=create_request(…,“Name”,…) describe_interface() invoke() r2=create_request(…,“Number”,…) r2: Request invoke() Name() delete()Number() delete() Object Browser in CORBA Reflection part Invocation part

24. Slide 24 of 27 © Ingeniørhøjskolen i Århus CORBA Java Reflection I // Java import org.omg.CORBA.*;... org.omg.CORBA.ORB =... // initialize the ORB org.omg.CORBA.Object obj =... // get object reference somehow org.omg.CORBA.Object defObj = obj._get_interface_def(); if(defObj == null) { System.err.println("No Interface Repository available"); System.exit(1); } InterfaceDef def = InterfaceDefHelper.narrow(defObj); org.omg.CORBA.InterfaceDefPackage.FullInterfaceDescription desc = def.describe_interface();

25. Slide 25 of 27 © Ingeniørhøjskolen i Århus CORBA Java Reflection II int i; System.out.println("name = " + desc.name); System.out.println("id = " + desc.id); System.out.println("defined_in = " + desc.defined_in); System.out.println("version = " + desc.version); System.out.println("operations:"); for(i = 0 ; i < desc.operations.length ; i++) { System.out.println(i + ": " + desc.operations[i].name); } System.out.println("attributes:"); for(i = 0 ; i < desc.attributes.length ; i++) { System.out.println(i + ": " + desc.attributes[i].name); } System.out.println("base_interfaces:"); for(i = 0 ; i < desc.base_interfaces.length ; i++) { System.out.println(i + ": " + desc.base_interfaces[i]); }

26. Slide 26 of 27 © Ingeniørhøjskolen i Århus Static Invocation Advantages: –Requests are simple to define –Availability of operations checked by programming language compiler –Requests can be implemented fairly efficiently Disadvantages: –Generic applications cannot be build –Recompilation required after operation interface modification

27. Slide 27 of 27 © Ingeniørhøjskolen i Århus Dynamic Invocation Advantages: –Components can be built without having the interfaces they use –Higher degree of concurrency through deferred synchronous execution –Components can react to changes of interfaces Disadvantages: –Less efficient –More complicated to use and –Not type safe! –And not supported by all