http://libre.act-europe.fr © act europe under the gnu free documentation license 1 franco gasperoni...

1http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License

Franco GasperoniFranco Gasperoni

gasperon@act-europe.frgasperon@act-europe.fr

http://libre.act-europe.frhttp://libre.act-europe.fr

Copyright NoticeCopyright Notice

• Permission is granted to copy, distribute and/or modify this Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free License, Version 1.1 or any later version published by the Free Software Foundation; provided its original author is mentioned Software Foundation; provided its original author is mentioned and the link to http://libre.act-europe.fr/ is kept at the bottom of and the link to http://libre.act-europe.fr/ is kept at the bottom of every non-title slide. A copy of the license is available at: every non-title slide. A copy of the license is available at:

• http://www.fsf.org/licenses/fdl.htmlhttp://www.fsf.org/licenses/fdl.html

• IntroductionIntroduction

• Distributed Prog. ParadigmsDistributed Prog. Paradigms

• Distributed Object Distributed Object

TechnologiesTechnologies

• ConclusionConclusion

• Non-distributed applicationNon-distributed application = single process = single process– running on a single computerrunning on a single computer

• Distributed applicationDistributed application = several communicating = several communicating processesprocesses– processes often run on different computers processes often run on different computers – computers are connected through a networkcomputers are connected through a network

processprocess

Single Process ApplicationSingle Process Application

Distributed Application Distributed Application

processprocess

ApplicationApplication

All Processes Can Run on the All Processes Can Run on the Same Computer Same Computer

processprocess

Or They can run on Different Or They can run on Different Computers Computers

processprocess

In All Cases This Requires In All Cases This Requires Inter-Process CommunicationInter-Process Communication

processprocess

The Main Topic of this The Main Topic of this LectureLecture

• How distributed processes communicate at How distributed processes communicate at the the programmingprogramming level level

• How the “How the “software chunkssoftware chunks” of a distributed ” of a distributed app can app can interactinteract..

• This lecture will NOT teach you how they This lecture will NOT teach you how they communicate at thecommunicate at the– physical levelphysical level– or protocol levelor protocol level

Remember OSI Layers ?Remember OSI Layers ?

PresentationPresentation

Transport

Network

Data Link

Physical

SessionSession

Transport

Network

Data Link

Physical

SessionSession } {This is whatThis is whatwe will look atwe will look at

Transport

Network

Data Link

Physical

SessionSession

Telnet, ftp, …

Sending data in platform indep. manner

Establish communication bw processes

TCP, UDP, ...

IP, X.25, ...

Network drivers

The wire

Why Distributed Apps ?Why Distributed Apps ?

• Multiuser apps (e.g. e-mail, ftp)Multiuser apps (e.g. e-mail, ftp)• Sharing data (e.g. www, airline reservation)Sharing data (e.g. www, airline reservation)• Sharing resources (e.g. printers)Sharing resources (e.g. printers)• Fault toleranceFault tolerance• App may be inherently distributed (cell phones, App may be inherently distributed (cell phones,

ATM machines, …)ATM machines, …)

Distributed Prog. Is HardDistributed Prog. Is Hard

• Multiple failure modesMultiple failure modes– each individual process can fail (bugs, machine crash..)each individual process can fail (bugs, machine crash..)– the network can go ashtraythe network can go ashtray

• Security issuesSecurity issues– is someone else listeningis someone else listening

• Testing & debuggingTesting & debugging• Distributed prog. technologies not fully matureDistributed prog. technologies not fully mature

– interoperability is still an issueinteroperability is still an issue

• Distributed Prog. Distributed Prog.

ParadigmsParadigms– Message Sending (Sockets)Message Sending (Sockets)

– Remote Procedure CallsRemote Procedure Calls

– Distributed ObjectsDistributed Objects

bodybody

processprocess

specspec

processprocess

How to Formalize the Notion of an How to Formalize the Notion of an Interface in a Distributed Interface in a Distributed

Environment ?Environment ?

How to Formalize the Notion of an How to Formalize the Notion of an Interface in a Distributed Interface in a Distributed

Environment ?Environment ?

• Answer 1Answer 1: don’t formalize it, send a message: don’t formalize it, send a message– e.g. socketse.g. sockets

• Answer 2Answer 2: Remote Procedure Call (RPC): Remote Procedure Call (RPC)

• Answer 3Answer 3: RPCs + Distributed Objects: RPCs + Distributed Objects– Language dependent: Ada 95, Java RMILanguage dependent: Ada 95, Java RMI– Language independent: CORBA, COM/DCOMLanguage independent: CORBA, COM/DCOM

A Simple ComparisonA Simple Comparison

Object-OrientedObject-OrientedProgrammingProgramming

Programming withProgramming withGOTOsGOTOs

StructuredStructuredProgrammingProgramming

Distributed ObjectsDistributed ObjectsDistributed ObjectsDistributed Objects

Message SendingMessage Sending(sockets)(sockets)

RPCsRPCsRPCsRPCs

Some TerminologySome Terminology

bodybodyspecspec

Client:Client: the code that madethe code that madethe request for servicethe request for service

Client:Client: the code that madethe code that madethe request for servicethe request for service Server:Server: the code that the code that

answered the requestanswered the requestServer:Server: the code that the code that

answered the requestanswered the request

Answer 1: Don’t Formalize ItAnswer 1: Don’t Formalize ItSend a Message (e.g. Sockets)Send a Message (e.g. Sockets)

Send (…, Bytes);Send (…, Bytes); ReceiveReceive (…, & Bytes [ ]);(…, & Bytes [ ]);

Client ProcessClient ProcessClient ProcessClient Process

Server ProcessServer ProcessServer ProcessServer Process

Wait for connectionWait for connectionWait for connectionWait for connection

ComputeComputeComputeCompute

Send bytesSend bytesSend bytesSend bytes

Close socketClose socketClose socketClose socket

Open socketOpen socketOpen socketOpen socket

Get bytesGet bytesGet bytesGet bytes

Open socketOpen socketOpen socketOpen socket

Send bytesSend bytesSend bytesSend bytes

Wait for replyWait for replyWait for replyWait for reply

Close socketClose socketClose socketClose socket

Get bytesGet bytesGet bytesGet bytes

raw bytesraw bytes

What are the problemsWhat are the problems

with this approach ?with this approach ?

Problems with Problems with Sockets/Message SendingSockets/Message Sending

• No interfaces - very low-level programmingNo interfaces - very low-level programming– does not scale updoes not scale up

• Sockets exchange bytesSockets exchange bytes– How do you exchange more complex data structures ?How do you exchange more complex data structures ?– How do you handle heterogeneous systems ?How do you handle heterogeneous systems ?

ClientClientClientClient

ServerServerServerServer

Answer requestAnswer requestAnswer requestAnswer request

ComputeComputeComputeComputeWait for replyWait for replyWait for replyWait for reply

Get responseGet responseGet responseGet response

Send requestSend requestSend requestSend requestdatadata

Send responseSend responseSend responseSend response

datadata

Doesn’t this look familiar ?Doesn’t this look familiar ?Doesn’t this look familiar ?Doesn’t this look familiar ?Wait for requestWait for requestWait for requestWait for request

Answer 2: Remote Procedure CallsAnswer 2: Remote Procedure Calls

R := Foo (123);R := Foo (123);

function Foo function Foo (X : Integer)(X : Integer) return Float; return Float;

ClientClientClientClient

ServerServerServerServer

function Foo (X: Integer)function Foo (X: Integer) return Float return Float isis … …beginbegin … … return …;return …;end Foo;end Foo;

Wait for replyWait for replyWait for replyWait for reply

Get resultGet resultGet resultGet result

R := Foo (123);R := Foo (123);R := Foo (123);R := Foo (123);send parameterssend parameters

send result or modified parameterssend result or modified parameters

RPCRPCRPCRPC

RPCsRPCs

• Remote procedure call completely handled by the Remote procedure call completely handled by the systemsystem

• Parameters and results passed across the Parameters and results passed across the network without programmer interventionnetwork without programmer intervention

• Heterogeneity handled transparentlyHeterogeneity handled transparently

Where is the Magic ?Where is the Magic ?

R := Foo (123);R := Foo (123);

Client Stub & Server SkeletonClient Stub & Server Skeleton• From the server spec the system generates a From the server spec the system generates a

client stub:client stub:– Marshals the parametersMarshals the parameters– Sends the request over the networkSends the request over the network– Waits for the response and unmarshals the resultWaits for the response and unmarshals the result

• From the server spec (and server body) the From the server spec (and server body) the system generates a server skeletonsystem generates a server skeleton– Receives the RPC requestReceives the RPC request– unmarshals the parametersunmarshals the parameters– Selects and calls the appropriate subprogramSelects and calls the appropriate subprogram– Marshals the result and sends the responseMarshals the result and sends the response

SpecialSpecialCompilerCompiler

Stubs & SkeletonsStubs & Skeletons

Client Stub Client Stub Server Skeleton Server Skeleton

function Foo (X: Integer)function Foo (X: Integer) return Float return Float isis … …end Foo;end Foo;

R := Foo (123);R := Foo (123);

Client StubClient Stub

Server Server Skeleton Skeleton

function Foo (X: Integer)function Foo (X: Integer) return Float return Float isis … …end Foo;end Foo;

networknetwork

ClientClientClientClient ServerServerServerServer

function Foo (X : Integer) return Float is ...function Foo (X : Integer) return Float is ...function Foo (X : Integer) return Float is ...function Foo (X : Integer) return Float is ...

ClientClientClientClient ServerServerServerServer

function Foofunction Foofunction Foofunction Foonetworknetwork

callcall

returnreturn

callcall

returnreturn

parameterparametermarshallingmarshalling

callcall

returnreturn

resultresultunmarshallingunmarshalling

resultresultmarshallingmarshalling

resultresultunmarshallingunmarshalling

Client StubClient StubClient StubClient Stub Server SkeletonServer SkeletonServer SkeletonServer Skeleton

Enhancing RPCsEnhancing RPCs

• ExceptionsExceptions

– exceptions raised in the callee canbe transmitted to exceptions raised in the callee canbe transmitted to

the caller over the networkthe caller over the network

• Asynchronous callsAsynchronous calls

– the caller does not need to wait for the result from the the caller does not need to wait for the result from the

callee (one way procedure calls)callee (one way procedure calls)

• Pointers on remote proceduresPointers on remote procedures– RPC through a pointer. At the point of call the spec of RPC through a pointer. At the point of call the spec of

the callee is known but not its location or identitythe callee is known but not its location or identity

Service Related to RPCs:Service Related to RPCs:NamingNaming

• Records the location of the various processesRecords the location of the various processes– location of client stubs and server skeletonslocation of client stubs and server skeletons

• This service is called via RPCThis service is called via RPC

• To solve the circularity problem the naming To solve the circularity problem the naming service is at a known machine addressservice is at a known machine address

Answer 3: Distributed ObjectsAnswer 3: Distributed Objects

A: Alert’Class := Get_Alert;A: Alert’Class := Get_Alert;……Handle (A);Handle (A);

type Alert is tagged record…;type Alert is tagged record…;procedure Handle (A : in out Alert);procedure Handle (A : in out Alert);

Dynamic Dynamic

BindingBindingtype Medium_Alert is new Alert...;type Medium_Alert is new Alert...;procedure Handle (A : in out Medium_Alert);procedure Handle (A : in out Medium_Alert);

TechnologiesTechnologies– Language Dependent: Ada 95Language Dependent: Ada 95

– Language Independent: CORBALanguage Independent: CORBA

LanguageLanguage DependentDependentDistributed Objects ParadigmDistributed Objects Paradigm

bodybody

spec spec

The The samesame programming language is used to write programming language is used to write • the spec of the distributed servicesthe spec of the distributed services• the implementation of the server codethe implementation of the server code• the implementation of the client codethe implementation of the client code

LanguageLanguage IndependentIndependentDistributed Objects ParadigmDistributed Objects Paradigm

ClientClientlanguage Alanguage A

ServerServerlanguage Blanguage B

specspeclanguage Blanguage B

Different languagesDifferent languages are used to write: are used to write: • the spec of the distributed servicesthe spec of the distributed services• the implementation of the server codethe implementation of the server code• the implementation of the client codethe implementation of the client code

language indep.language indep.spec spec

Ada 95Ada 95Distributed Systems AnnexDistributed Systems Annex

Ada 95 Distributed Ada 95 Distributed ProgrammingProgramming

Ada 95Ada 95

partitionpartition(process)(process)

multi-partitionsmulti-partitions

CoreCore Annex EAnnex E

A partition comprises one or more Ada packagesA partition comprises one or more Ada packagesA partition comprises one or more Ada packagesA partition comprises one or more Ada packages

Supported ParadigmsSupported Paradigms

• Client/Server Paradigm (RPC)Client/Server Paradigm (RPC)

– Synchronous / AsynchronousSynchronous / Asynchronous

– Static / DynamicStatic / Dynamic

• Distributed Objects Distributed Objects

• Shared MemoryShared Memory

Ada Distributed ApplicationAda Distributed Application• No need for a separate interfacing language as No need for a separate interfacing language as

in CORBA (IDL)in CORBA (IDL)– Ada is the IDLAda is the IDL

• Some packages categorized using pragmasSome packages categorized using pragmas– Remote_Call_Interface (RCI)Remote_Call_Interface (RCI)– Remote_TypesRemote_Types– Shared_Passive (SP)Shared_Passive (SP)

• All packages except All packages except RCIRCI & & SPSP duplicated on duplicated on partitions using thempartitions using them

Remote_Call_Interface (RCI)Remote_Call_Interface (RCI)

• Allows subprograms to be called remotelyAllows subprograms to be called remotely

– Statically bound RPCsStatically bound RPCs

– Dynamically bound RPCs Dynamically bound RPCs (remote access to subprogram)(remote access to subprogram)

Remote_TypesRemote_Types

• Allows the definition of a remote access typesAllows the definition of a remote access types

– Remote access to subprogramRemote access to subprogram

– Remote reference to objects Remote reference to objects (ability to do dynamically dispatching calls (ability to do dynamically dispatching calls across the network)across the network)

Shared_PassiveShared_Passive

• A Shared_Passive package contains variables A Shared_Passive package contains variables that can be accessed from distinct partitionsthat can be accessed from distinct partitions

• Allows support of shared distributed memoryAllows support of shared distributed memory

• Allows persistence on some implementationsAllows persistence on some implementations

1.1. Write app as if non distributed.Write app as if non distributed.

2.2. Identify remote procedures, shared variables, and Identify remote procedures, shared variables, and distributed objects &distributed objects & categorizecategorize packages.packages.

3.3. Build & test non-distributed application.Build & test non-distributed application.

4.4. Write a configuration file for Write a configuration file for partitionningpartitionning your app.your app.

5.5. Build partitions & test distributed app.Build partitions & test distributed app.

package P is .

Building a Distributed App in Building a Distributed App in Ada 95Ada 95

Remote_Call_InterfaceRemote_Call_Interface

An ExampleAn Example

package package TypesTypes is is type type DeviceDevice is ( is (Furnace, BoilerFurnace, Boiler,…);,…); type type PressurePressure is …; is …; type type TemperatureTemperature is …; is …;end end TypesTypes;;

with with TypesTypes; use ; use TypesTypes;;package package SensorsSensors is is function function Get_PGet_P ( (D: DeviceD: Device) return ) return PressurePressure;; function function Get_TGet_T ( (D: DeviceD: Device) return ) return TemperatureTemperature;;end end SensorsSensors;;

with with TypesTypes; use ; use TypesTypes;;with with SensorsSensors;;procedure procedure Client_1Client_1 is is P := Sensors.Get_P (Boiler);P := Sensors.Get_P (Boiler);

with with TypesTypes; use ; use TypesTypes;;with with SensorsSensors;;procedure procedure Client_2Client_2 is is T := Sensors.Get_T (Furnace);T := Sensors.Get_T (Furnace);

Write AppWrite App

package package TypesTypes is is pragma pragma PurePure;; type type DeviceDevice is ( is (Furnace, BoilerFurnace, Boiler,…);,…); type type PressurePressure is …; is …; type type TemperatureTemperature is …; is …;end end TypesTypes;;

with with TypesTypes; use ; use TypesTypes;;package package SensorsSensors is is pragma pragma Remote_Call_InterfaceRemote_Call_Interface;; function function Get_P (D:Device)Get_P (D:Device) return return PressurePressure;; function function Get_T (D:Device)Get_T (D:Device) return return TemperatureTemperature;;end end SensorsSensors;;

CategorizeCategorize

Build & TestBuild & Test

configuration configuration Config_1Config_1 is is Node_ANode_A : Partition := ( : Partition := (SensorsSensors);); Node_BNode_B : Partition := ( : Partition := (Client_1Client_1);); Node_CNode_C : Partition := ( : Partition := (Client_2Client_2););end end Config_1Config_1;;

PartitionPartition

Node_ANode_A

Node_BNode_B Node_CNode_C

package package TypesTypes is is pragma pragma PurePure;; type type DeviceDevice is …; is …; type type PressurePressure is …; is …; type type TemperatureTemperature is …; is …;end end TypesTypes;;

DUPLICATEDDUPLICATED Node_ANode_A

with with TypesTypes; use ; use TypesTypes;;package package SensorsSensors is is pragma pragma Remote_Call_InterfaceRemote_Call_Interface;; function function Get_P(…)Get_P(…) return return PressurePressure;; function function Get_T(…)Get_T(…) return return TemperatureTemperature;;end end SensorsSensors;;

STUBSSTUBSNode_ANode_A

with with TypesTypes; use ; use TypesTypes;;package package SensorsSensors is is pragma pragma Remote_Call_InterfaceRemote_Call_Interface;; function function Get_P(…)Get_P(…) return return PressurePressure;; function function Get_T(…)Get_T(…) return return TemperatureTemperature;;end end SensorsSensors;;

SKELETONSKELETON+ BODY+ BODY

Node_ANode_A

…….:= Sensors.Get_P (Boiler);.:= Sensors.Get_P (Boiler);…….:= Sensors.Get_P (Boiler);.:= Sensors.Get_P (Boiler);

Sensors.Get_PSensors.Get_P StubStubSensors.Get_PSensors.Get_P StubStub

Marshal ArgumentsMarshal ArgumentsMarshal ArgumentsMarshal Arguments

SendSend ReceiveReceive

Sensors.Get_PSensors.Get_P bodybody

Unmarshal ArgumentsUnmarshal ArgumentsUnmarshal ArgumentsUnmarshal Arguments

SkeletonSkeletonSkeletonSkeletonSelect bodySelect bodySelect bodySelect body

Node_BNode_B Node_ANode_A

with Types; use Types;package Sensors is pragma Remote_Call_InterfaceRemote_Call_Interface; … procedure Log (D : Device; P : Pressure); pragma AsynchronousAsynchronous (Log);

end Bank;

with Types; use Types;package Sensors is pragma Remote_Call_InterfaceRemote_Call_Interface; … procedure Log (D : Device; P : Pressure); pragma AsynchronousAsynchronous (Log);

end Bank;

Asynchronous CallsAsynchronous Calls

+ returns immediately+ exceptions are lost+ parameters must be in

Remote_TypesRemote_Types

An ExampleAn Example

package package AlertsAlerts is is type type AlertAlert is abstract tagged private; is abstract tagged private; typetype Alert_Ref Alert_Ref is access allis access all Alert’Class; Alert’Class; procedure procedure Handle (A : Handle (A : accessaccess Alert); Alert); procedure procedure Log (A : Log (A : accessaccess Alert) Alert) is abstractis abstract;; privateprivate ......end end Alerts;Alerts;

package package Alerts.Pool Alerts.Pool isis procedure procedure Register (A : Alert_Ref);Register (A : Alert_Ref); function function Get_Alert Get_Alert return return Alert_Ref;Alert_Ref;end end Medium;Medium;

with with Alerts, Alerts.Pool;Alerts, Alerts.Pool; use use Alerts;Alerts;procedure procedure Process_Alerts Process_Alerts isisbeginbegin looploop Handle (Pool.Get_Alert);Handle (Pool.Get_Alert); end loop;end loop;end end Process_Alerts;Process_Alerts;

Write AppWrite App

package package Alerts.LowAlerts.Low is is type type Low_AlertLow_Alert is new is new Alert Alert with private;with private; procedure procedure Log (A : Log (A : accessaccess Low_Alert); Low_Alert);privateprivate ......end end Alerts.Low;Alerts.Low;

with with Alerts.Pool; Alerts.Pool; use use Alerts.Pool;Alerts.Pool;package body package body Alerts.Low Alerts.Low isis ......beginbegin Register (Register (newnew Low_Alert); Low_Alert); end end AlertsAlerts..Low;Low;

package package Alerts.Medium Alerts.Medium isis type type Medium_AlertMedium_Alert is new is new Alert Alert with private;with private; procedure procedure Handle (A : Handle (A : accessaccess Medium_Alert); Medium_Alert); procedure procedure Log (A : Log (A : accessaccess Medium_Alert); Medium_Alert);privateprivate ......end end AlertsAlerts..Medium;Medium;

with with Alerts.Pool; Alerts.Pool; use use Alerts.Pool;Alerts.Pool;package body package body Alerts.Medium Alerts.Medium isis ......beginbegin Register (Register (newnew Medium_Alert); Medium_Alert); end end AlertsAlerts..Medium;Medium;

package package AlertsAlerts is is pragmapragma Remote_TypesRemote_Types; type type AlertAlert is abstract tagged private; is abstract tagged private; typetype Alert_Ref Alert_Ref is access allis access all Alert’Class; Alert’Class; procedure procedure Handle (A : Handle (A : accessaccess Alert); Alert); procedure procedure Log (A : Log (A : accessaccess Alert) Alert) is abstractis abstract;; privateprivate ......end end Alerts;Alerts;

package package AlertsAlerts is is pragmapragma Remote_TypesRemote_Types; type type AlertAlert is abstract tagged private; is abstract tagged private; typetype Alert_Ref Alert_Ref is access allis access all Alert’Class; Alert’Class; procedure procedure Handle (A : Handle (A : accessaccess Alert); Alert); procedure procedure Log (A : Log (A : accessaccess Alert) Alert) is abstractis abstract;; privateprivate ......end end Alerts;Alerts;package package Alerts.Pool Alerts.Pool isis

pragma pragma Remote_Call_InterfaceRemote_Call_Interface;; procedure procedure Register (A : Alert_Ref);Register (A : Alert_Ref); function function Get_Alert Get_Alert return return Alert_Ref;Alert_Ref;end end Medium;Medium;

package package Alerts.Pool Alerts.Pool isis pragma pragma Remote_Call_InterfaceRemote_Call_Interface;; procedure procedure Register (A : Alert_Ref);Register (A : Alert_Ref); function function Get_Alert Get_Alert return return Alert_Ref;Alert_Ref;end end Medium;Medium;

CategorizeCategorize

package package Alerts.LowAlerts.Low is is pragmapragma Remote_TypesRemote_Types; type type Low_AlertLow_Alert is new is new Alert Alert with private;with private; procedure procedure Log (A : Log (A : accessaccess Low_Alert); Low_Alert);privateprivate ......end end Alerts.Low;Alerts.Low;

package package Alerts.Medium Alerts.Medium isis pragmapragma Remote_TypesRemote_Types; type type Medium_AlertMedium_Alert is new is new Alert Alert with private;with private; procedure procedure Handle (A : Handle (A : accessaccess Medium_Alert); Medium_Alert); procedure procedure Log (A : Log (A : accessaccess Medium_Alert); Medium_Alert);privateprivate ......end end AlertsAlerts..Medium;Medium;

package package AlertsAlerts is is pragmapragma Remote_TypesRemote_Types; type type AlertAlert is abstract tagged private; is abstract tagged private; typetype Alert_Ref Alert_Ref is access allis access all Alert’Class; Alert’Class; procedure procedure Handle (A : Handle (A : accessaccess Alert); Alert); procedure procedure Log (A : Log (A : accessaccess Alert) Alert) is abstractis abstract;; privateprivate ......end end Alerts;Alerts;

Build & Build & TestTest

configuration configuration Config_2Config_2 is is Node_ALNode_AL : Partition := ( : Partition := (Alerts.LowAlerts.Low);); Node_AMNode_AM : Partition := ( : Partition := (Alerts.MediumAlerts.Medium);); Node_BNode_B : Partition := ( : Partition := (Alerts.PoolAlerts.Pool);); Node_CNode_C : Partition := ( : Partition := (Process_AlertsProcess_Alerts););end end Config_2Config_2;;

PartitionPartition

What HappensWhat HappensWhen ExecutingWhen Executing

the Distributed Program ?the Distributed Program ?

Node_ALNode_AL Node_AMNode_AM

Step 1: A Low_Alert object in Node_AL registers itself with Node_BStep 1: A Low_Alert object in Node_AL registers itself with Node_BStep 1: A Low_Alert object in Node_AL registers itself with Node_BStep 1: A Low_Alert object in Node_AL registers itself with Node_B

Step 2: A Medium_Alert object in Node_AM registers itself with Node_BStep 2: A Medium_Alert object in Node_AM registers itself with Node_BStep 2: A Medium_Alert object in Node_AM registers itself with Node_BStep 2: A Medium_Alert object in Node_AM registers itself with Node_B

Step 3: Process_Alerts in Node_C does an RPC to Get_Alert in Node_BStep 3: Process_Alerts in Node_C does an RPC to Get_Alert in Node_BStep 3: Process_Alerts in Node_C does an RPC to Get_Alert in Node_BStep 3: Process_Alerts in Node_C does an RPC to Get_Alert in Node_B

Step 4: Get_Alert returns a pointer to an Alert object (Low_Alert or Medium_Alert)Step 4: Get_Alert returns a pointer to an Alert object (Low_Alert or Medium_Alert)Step 4: Get_Alert returns a pointer to an Alert object (Low_Alert or Medium_Alert)Step 4: Get_Alert returns a pointer to an Alert object (Low_Alert or Medium_Alert)

Step 5: Node_C performs a dispatching RPC. It calls Handle in Node_AL or Node_AMStep 5: Node_C performs a dispatching RPC. It calls Handle in Node_AL or Node_AMStep 5: Node_C performs a dispatching RPC. It calls Handle in Node_AL or Node_AMStep 5: Node_C performs a dispatching RPC. It calls Handle in Node_AL or Node_AM

What Does Get_Alert Return ?What Does Get_Alert Return ?

PointerPointer

MachineMachineAddress of Address of Alert object Alert object

on the on the MachineMachine

Get_AlertGet_AlertGet_AlertGet_Alert

Remote Access to Class Wide Remote Access to Class Wide TypeType

• At compile time:At compile time:

– You do not know what operation you’ll You do not know what operation you’ll dispatch todispatch to

– On what node that operations will be On what node that operations will be executed onexecuted on

LanguageLanguage IndependentIndependentDistributed Objects ParadigmDistributed Objects Paradigm

ClientClientlanguage Alanguage A

ServerServerlanguage Blanguage B

specspeclanguage Blanguage B

Different languagesDifferent languages are used to write: are used to write: • the spec of the distributed servicesthe spec of the distributed services• the implementation of the server codethe implementation of the server code• the implementation of the client codethe implementation of the client code

language indep.language indep.Spec (IDL) Spec (IDL)

CORBA InterfacesCORBA Interfaces

• In Corba interfaces are described in IDL In Corba interfaces are described in IDL – (Interface Description Language) (Interface Description Language)

• The IDL is independent of programming languagesThe IDL is independent of programming languages• Each interface is translated inEach interface is translated in

– Language A used for the client (client stub)Language A used for the client (client stub)– Language B used for the server (server skeleton)Language B used for the server (server skeleton)

• To implement the server the programmer completes To implement the server the programmer completes the skeleton in language Bthe skeleton in language B

• To implement the client the programmer uses the To implement the client the programmer uses the services provided by th estub in language Aservices provided by th estub in language A

The CORBA ArchitectureThe CORBA Architecture

• RPC go through the ORB RPC go through the ORB – (Object Request Broker)(Object Request Broker)

• The ORB is a software busThe ORB is a software bus

• ORBs communicate with a set of standardised ORBs communicate with a set of standardised protocols protocols – IIOP, GIOPIIOP, GIOP

The IDLThe IDL

• Syntax similar to C++ with some Ada additionsSyntax similar to C++ with some Ada additions

• IDL must be translatable in various prog. LanguagesIDL must be translatable in various prog. Languages

– Ada, C, C++, Java, …Ada, C, C++, Java, …

• There are limitations in what you can write in the IDLThere are limitations in what you can write in the IDL

• Programmer must understand how the IDL is Programmer must understand how the IDL is

translated in the host language translated in the host language

– to complete the server skeleton to complete the server skeleton

– to use the client stubto use the client stub

ExampleExample

package M ispackage M is pragma Remote_Types;pragma Remote_Types; type T is tagged …;type T is tagged …; procedure P (O : in access T);procedure P (O : in access T);end M;end M;

module M {module M { interface T {interface T { void P ();void P (); };};};};

ExempleExemplemodule Echo {

string echoStringechoString (in string mesg);

Module foo {

interface Buffer {

exception Empty;

void put (in string content);

string get() raises (Empty);

Example of IDL translation in AdaExample of IDL translation in Ada

with Corba.Object;package Echo is type Ref is new Corba.Object.Ref with null record; function To_Echo (Self : in Corba.Object.Ref’Class) return Ref’Class; function To_Ref (From : in Corba.Any) return Ref; function To_Any (From : in Ref) return Corba.Any; function echoStringechoString (Self : in Ref; msg : in Corba.String) return Corba.String; Null_Ref : constant Ref := (Corba.Object.Null_Ref with null record); Echo_R_Id : constant Corba.RepositoryId := Corba.To_Unbounded_String («IDL:Echo:1.0»);end Echo;

CORBA ServicesCORBA Services

• The CORBA core services are very fewThe CORBA core services are very few

• Lot ’s of external servicesLot ’s of external services– Naming (distributed and hierarchical)Naming (distributed and hierarchical)– PersistancePersistance– TransactionTransaction– SecuritySecurity– ......

ApplicationApplicationObjectsObjects

Object ServicesObject Services

CommonCommonFacilitiesFacilities

O R BO R B

Code you Code you writewrite

Domain Domain IndependentIndependent

Domain Domain SpecificSpecificDomain Domain SpecificSpecific

TechnologiesTechnologies

• ConclusionConclusion

Developing a Distributed AppDeveloping a Distributed App

• Using network services directlyUsing network services directly– SocketsSockets

• Using middlewareUsing middleware– CORBACORBA– COM/DCOMCOM/DCOM

• Using a distributed languageUsing a distributed language– Ada 95 DSAAda 95 DSA– Java RMIJava RMI

Similar issueswith

Tasking

Similar issueswith

Tasking

Impact on Development PhasesImpact on Development Phases

GeneralGeneralDesignDesign

DistributedDistributedDesignDesign

CodingCodingCodingCoding

TestingTestingTestingTesting

SocketsSockets

Ad HocAd Hoc

Very low levelVery low level

Distributed Distributed mode onlymode only

Very low levelVery low level

• Everything must be done with socketsEverything must be done with sockets• Data marshaling/unmarshallingData marshaling/unmarshalling• Handle heterogeneous systems directlyHandle heterogeneous systems directly

CORBACORBA

IDLIDL

Must invoke high-level Must invoke high-level services directlyservices directly

Distributed Distributed mode onlymode only

Ada 95 DSAAda 95 DSA

Ada 95Ada 95

distributeddistributed& non-distributed& non-distributed

Regular AdaRegular AdaCodingCoding

Ada 95 DSA & CORBA:Ada 95 DSA & CORBA:BenefitsBenefits

• Save developer’s time, in socket programming:Save developer’s time, in socket programming:– Defining a client/server protocolDefining a client/server protocol– Defining a message formatDefining a message format– Marshalling of dataMarshalling of data– Unmarshalling dataUnmarshalling data

• Raise the level of abstractionRaise the level of abstraction

http://libre.act-europe.fr © act europe under the gnu free documentation license 1 franco gasperoni...

act europe

typeswith types

type pressure

p boilerwith types

pragma pure type device

typespackage sensors

pragma remote

interface function

Documents

act workkeys® administration manual for state and district...

act factory act

sportswear 2019 / 2020 - triple volley · 2019. 5. 15. ·...

act 613 migration act

nouveau jeep grand cherokee 2014 - jeeppress-europe.fr ·...

a case study system to software integrity matteo bordin...

customs act, 2015 customs act, 2015 act 891 … act,...

high integrity systems development for integrated · pdf...

actuation index - hammondvalve.com · pneumatic actuation...

chapter 89 employment act - parliament of...

act act act act

introduction 1 notation and model 1 cox model with a ... ·...

introduction to software construction franco gasperoni...

act act act act oct i act oct act act act dtrdoc003a...

act.3 - act.4

competition policy · § republic act no 8800, safeguard...

act reservation act 2004

act 82 municipal act

act 1 act 5 act 2 act 6 act 3 act 7 act 4 act 8 · act 3...

introduction aux applications d’analyse des contraintes...