object-oriented network communication (oomi) dynamic requests emmerich – chapter 6. 7.03.2003

Object-Oriented Network Communication

(OOMI)

Dynamic Requests Emmerich – Chapter 6.

7.03.2003

of 27 © Ingeniørhøjskolen i Århus

Outline

1. Dynamic InvocationThe CORBA Dynamic Invocation Interface

2. ReflectionThe CORBA Interface Repository


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


Motivating Example: Object Browser


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


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


DynamicInvocation

ClientStubs

ORBInterface

Implementation Skeletons

Client Object Implementation

ORB Core

ObjectAdapter

Dynamic Requests in CORBA


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


Dynamic Request in CORBA

:Client

rr:Request

:Server

Op()

r=create_request(…,”Op”,…)

add_arg()

invoke()

delete()


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!");


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

);

...

};


Manipulating Dynamic CORBA Requestsinterface 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();};


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


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


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)


• 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<Player> PlayerList;

ExceptionDef

InvalidNumber

exception InvalidNumber{};

AttributeDef

members

attribute PlayerList members;

OperationDefadd void add(in short number,

in Player p); raises(InvalidNumber)

Abstract Syntax Trees (ASTs)


ContainerContainer

AST Node Types

IRObjectIRObject

ContainedContained

OperationDefOperationDef

ExceptionDefExceptionDef

TypedefDefTypedefDef AttributeDefAttributeDef

ConstantDefConstantDef

ModuleDefModuleDefInterfaceDefInterfaceDef RepositoryRepository


Container (node with children)

interface Container : IRObject {

Contained lookup(in ScopedName search_name); sequence<Contained> contents( in DefinitionKind limit_type, in boolean exclude_inherited);

sequence<Contained> lookup_name( in Identifier search_name, in long levels_to_search, in DefinitionKind limit_type, in boolean exclude_inherited); ...};


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(); ...

};


Interface Definitioninterface InterfaceDef : Container,Contained { attribute sequence<InterfaceDef> base_interfaces;

boolean is_a(in RepositoryId interface_id); struct FullInterfaceDescription {

Identifier name;

RepositoryId id;

RepositoryId defined_in;

RepositoryIdSequence base_interfaces;

sequence<OperationDescription> operations;

sequence<AttributeDescription> attributes;

...

};

FullInterfaceDescription describe_interface();

};


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


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


:Browser p:Playeri:InterfaceDef

r1: Request

i=get_interface()

name()

r1=create_request(…,“Name”,…)

describe_interface()

invoke()

r2=create_request(…,“Number”,…)

r2: Requestinvoke()

Name()

delete()

Number()

delete()

Object Browser in CORBA

Reflection part

Invocation part


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();


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]);

}


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


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

object-oriented network communication (oomi) dynamic requests emmerich – chapter 6. 7.03.2003

Documents

flags request flags

flags response flags

flags invocation flags

flags argument flags

dynamic requestsexamples

principlesany object

dual use of dynamic

request resultsslide