Search

Ada 95 - Distributed systems

Loading...

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

0 comments

Post a comment

    Post a comment
    Embed Video
    Edit your comment Cancel

    Notes on slide 1

    1 Group

    Ada 95 - Distributed systems - Presentation Transcript

    1. Franco Gasperoni gasperon@act-europe.fr http://libre.act-europe.fr 1 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    2. Copyright Notice • © ACT Europe under the GNU Free Documentation License • Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; provided its original author is mentioned 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: • http://www.fsf.org/licenses/fdl.html 2 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    3. 3 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    4. • Introduction • Distributed Prog. Paradigms • Distributed Object Technologies • Conclusion 4 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    5. • Non-distributed application = single process – running on a single computer • Distributed application = several communicating processes – processes often run on different computers – computers are connected through a network 5 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    6. Single Process Application spec body spec main body spec process body 6 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    7. Distributed Application spec body spec main spec body spec body process spec body main body spec process body spec body Application spec main body spec process body 7 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    8. All Processes Can Run on the Same Computer spec body spec main spec body spec body process spec body main body spec process body spec body spec main body spec process body 8 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    9. Or They can run on Different Computers spec body spec main body spec process spec body body spec main body spec process body spec body spec main body spec process body 9 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    10. In All Cases This Requires Inter-Process Communication spec body spec main spec body spec body process spec body main body spec process body spec body spec main body spec process body 10 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    11. spec body spec main ? body spec process spec body body spec main body ? spec process body spec body spec main body spec process body 11 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    12. The Main Topic of this Lecture • How distributed processes communicate at the programming level • How the “software chunks” of a distributed app can interact. • This lecture will NOT teach you how they communicate at the – physical level – or protocol level 12 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    13. Remember OSI Layers ? } { Application Application This is what Presentation Presentation we will look at Session Session Transport Transport Network Network Data Link Data Link Physical Physical 13 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    14. Telnet, ftp, … Application Sending data in platform indep. manner Presentation Establish communication bw processes Session TCP, UDP, ... Transport Network IP, X.25, ... Data Link Network drivers Physical The wire 14 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    15. Why Distributed Apps ? • Multiuser apps (e.g. e-mail, ftp) • Sharing data (e.g. www, airline reservation) • Sharing resources (e.g. printers) • Fault tolerance • App may be inherently distributed (cell phones, ATM machines, …) 15 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    16. Distributed Prog. Is Hard • Multiple failure modes – each individual process can fail (bugs, machine crash..) – the network can go ashtray • Security issues – is someone else listening • Testing & debugging • Distributed prog. technologies not fully mature – interoperability is still an issue 16 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    17. • Introduction • Distributed Prog. Paradigms – Message Sending (Sockets) – Remote Procedure Calls – Distributed Objects 17 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    18. How to Formalize the Notion of an Interface in a Distributed Environment ? ? spec body process process 18 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    19. How to Formalize the Notion of an Interface in a Distributed Environment ? • Answer 1: don’t formalize it, send a message – e.g. sockets • Answer 2: Remote Procedure Call (RPC) • Answer 3: RPCs + Distributed Objects – Language dependent: Ada 95, Java RMI – Language independent: CORBA, COM/DCOM 19 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    20. A Simple Comparison Programming with Message Sending GOTOs (sockets) Structured RPCs Programming Object-Oriented Distributed Objects Programming 20 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    21. Some Terminology spec body Client: the code that made Server: the code that the request for service answered the request 21 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    22. Answer 1: Don’t Formalize It Send a Message (e.g. Sockets) Send (…, Bytes); Receive (…, & Bytes [ ]); 22 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    23. Client Process Server Process Client Process Server Process Open socket Open socket Wait for connection Compute raw bytes Send bytes Get bytes Wait for reply Compute Send bytes Get bytes raw bytes Close socket Close socket 23 time time http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    24. What are the problems with this approach ? 24 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    25. Problems with Sockets/Message Sending • No interfaces - very low-level programming – does not scale up • Sockets exchange bytes – How do you exchange more complex data structures ? – How do you handle heterogeneous systems ? 25 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    26. Client Server Client Server Doesn’t this look familiar ? Compute Wait for request data Send request Answer request Wait for reply Compute Send response Get response data 26 time time http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    27. Answer 2: Remote Procedure Calls function Foo (X : Integer) return Float; R := Foo (123); 27 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    28. Client Server Client Server RPC Compute send parameters R := Foo (123); function Foo (X: Integer) return Float is Wait for reply … begin … Get result return …; send result or modified parameters end Foo; 28 time time http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    29. RPCs • Remote procedure call completely handled by the system • Parameters and results passed across the network without programmer intervention • Heterogeneity handled transparently 29 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    30. Where is the Magic ? function Foo (X : Integer) return Float; R := Foo (123); 30 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    31. Client Stub & Server Skeleton • From the server spec the system generates a client stub: – Marshals the parameters – Sends the request over the network – Waits for the response and unmarshals the result • From the server spec (and server body) the system generates a server skeleton – Receives the RPC request – unmarshals the parameters – Selects and calls the appropriate subprogram – Marshals the result and sends the response 31 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    32. Stubs & Skeletons function Foo (X: Integer) return Float is function Foo … (X : Integer) end Foo; Foo; return Float; Special Special Compiler Compiler Client Stub Server Skeleton 32 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    33. function Foo (X : Integer) return Float; Client Stub Server function Foo (X: Integer) return Float Skeleton is R := Foo (123); … end Foo; Foo; 33 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    34. Client Server Client Server call function Foo (X : Integer) return Float is ... network return Client Server Client Client Stub Server Skeleton Server call parameter marshalling call result unmarshalling function Foo network result marshalling return result unmarshalling return 34 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    35. Enhancing RPCs • Exceptions – exceptions raised in the callee canbe transmitted to the caller over the network • Asynchronous calls – the caller does not need to wait for the result from the callee (one way procedure calls) • Pointers on remote procedures – RPC through a pointer. At the point of call the spec of the callee is known but not its location or identity 35 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    36. Service Related to RPCs: Naming • Records the location of the various processes – location of client stubs and server skeletons • This service is called via RPC • To solve the circularity problem the naming service is at a known machine address 36 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    37. Answer 3: Distributed Objects type Alert is tagged record…; procedure Handle (A : in out Alert); ? A: Alert’Class := Get_Alert; … Handle (A); Dynamic Binding type Medium_Alert is new Alert...; procedure Handle (A : in out Medium_Alert); 37 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    38. • Introduction • Distributed Prog. Paradigms • Distributed Object Technologies – Language Dependent: Ada 95 – Language Independent: CORBA 38 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    39. Language Dependent Distributed Objects Paradigm spec body The same programming language is used to write • the spec of the distributed services • the implementation of the server code • the implementation of the client code 39 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    40. Language Independent Distributed Objects Paradigm language indep. spec spec language B Server Client language B language A Different languages are used to write: • the spec of the distributed services • the implementation of the server code • the implementation of the client code 40 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    41. • Introduction • Distributed Prog. Paradigms • Distributed Object Technologies – Language Dependent: Ada 95 – Language Independent: CORBA 41 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    42. Ada 95 Distributed Systems Annex 42
    43. Ada 95 Distributed Programming Ada 95 Core Annex E partition multi-partitions (process) A partition comprises one or more Ada packages 43 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    44. Supported Paradigms • Client/Server Paradigm (RPC) – Synchronous / Asynchronous – Static / Dynamic • Distributed Objects • Shared Memory 44 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    45. Ada Distributed Application • No need for a separate interfacing language as in CORBA (IDL) – Ada is the IDL • Some packages categorized using pragmas – Remote_Call_Interface (RCI) – Remote_Types – Shared_Passive (SP) • All packages except RCI & SP duplicated on partitions using them 45 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    46. Remote_Call_Interface (RCI) • Allows subprograms to be called remotely – Statically bound RPCs – Dynamically bound RPCs (remote access to subprogram) 46 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    47. Remote_Types • Allows the definition of a remote access types – Remote access to subprogram – Remote reference to objects (ability to do dynamically dispatching calls across the network) 47 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    48. Shared_Passive • A Shared_Passive package contains variables that can be accessed from distinct partitions • Allows support of shared distributed memory • Allows persistence on some implementations 48 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    49. Building a Distributed App in Ada 95 1. Write app as if non distributed. 2. Identify remote procedures, shared variables, and distributed objects & categorize packages. 3. Build & test non-distributed application. 4. Write a configuration file for partitionning your app. 5. Build partitions & test distributed app. pac kag pac eP kag is package eP . P is is pac package pac . . kag package P is kag eP P is . eP is . is package package package . . P is P is P is . . . 49 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    50. Remote_Call_Interface An Example 50 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    51. package Types is Write App type Device is (Furnace, Boiler,…); type Pressure is …; type Temperature is …; end Types; with Types; use Types; with Types; use Types; package Sensors is package Sensors is function Get_P ((D:Device) return Pressure; function Get_P D: Device) return Pressure; function Get_T ((D:Device) return Temperature; function Get_T D: Device) return Temperature; end Sensors; end Sensors; with Types; use Types; with Types; use Types; with Sensors; with Sensors; procedure Client_1 is procedure Client_2 is P := Sensors.Get_P (Boiler); T := Sensors.Get_T (Furnace);51 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    52. package Types is Categorize pragma Pure; type Device is (Furnace, Boiler,…); type Pressure is …; type Temperature is …; end Types; with Types; use Types; with Types; use Types; package Sensors is package Sensors is pragma Remote_Call_Interface; pragma Remote_Call_Interface; function Get_P (D:Device) return Pressure; function Get_P (D:Device) return Pressure; function Get_T (D:Device) return Temperature; function Get_T (D:Device) return Temperature; end Sensors; end Sensors; with Types; use Types; with Types; use Types; with Sensors; with Sensors; procedure Client_1 is procedure Client_2 is P := Sensors.Get_P (Boiler); T := Sensors.Get_T (Furnace);52 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    53. package Types is pragma Pure; Build & Test type Device is (Furnace, Boiler,…); type Pressure is …; type Temperature is …; end Types; with Types; use Types; with Types; use Types; package Sensors is package Sensors is pragma Remote_Call_Interface; pragma Remote_Call_Interface; function Get_P (D:Device) return Pressure; function Get_P (D:Device) return Pressure; function Get_T (D:Device) return Temperature; function Get_T (D:Device) return Temperature; end Sensors; end Sensors; with Types; use Types; with Sensors; procedure Client_1 is P := Sensors.Get_P (Boiler); 53 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    54. package Types is pragma Pure; Build & Test type Device is (Furnace, Boiler,…); type Pressure is …; type Temperature is …; end Types; with Types; use Types; with Types; use Types; package Sensors is package Sensors is pragma Remote_Call_Interface; pragma Remote_Call_Interface; function Get_P (D:Device) return Pressure; function Get_P (D:Device) return Pressure; function Get_T (D:Device) return Temperature; function Get_T (D:Device) return Temperature; end Sensors; end Sensors; with Types; use Types; with Sensors; procedure Client_2 is T := Sensors.Get_T (Furnace);54 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    55. Partition configuration Config_1 is Node_A : Partition := (Sensors); Node_B : Partition := (Client_1); Node_C : Partition := (Client_2); end Config_1; 55 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    56. Partition Node_A Node_B Node_C 56 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    57. package Types is pragma Pure; type Device is …; type Pressure is …; type Temperature is …; end Types; DUPLICATED Node_A Node_B Node_C 57 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    58. with Types; use Types; with Types; use Types; package Sensors is package Sensors is pragma Remote_Call_Interface; pragma Remote_Call_Interface; function Get_P(…) return Pressure; function Get_P(…) return Pressure; function Get_T(…) return Temperature; function Get_T(…) return Temperature; end Sensors; end Sensors; Node_A STUBS Node_B Node_C 58 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    59. with Types; use Types; with Types; use Types; package Sensors is package Sensors is pragma Remote_Call_Interface; pragma Remote_Call_Interface; function Get_P(…) return Pressure; function Get_P(…) return Pressure; function Get_T(…) return Temperature; function Get_T(…) return Temperature; end Sensors; end Sensors; Node_A SKELETON + BODY Node_B Node_C 59 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    60. ….:= Sensors.Get_P (Boiler); Sensors.Get_P body Sensors.Get_P Stub Sensors.Get_P Stub Marshal Arguments Marshal Arguments Select body Select body Skeleton Unmarshal Arguments Unmarshal Arguments Send Receive Node_B Node_A 60 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    61. Asynchronous Calls with Types; use Types; package Sensors is pragma Remote_Call_Interface; Remote_Call_Interface … procedure Log (D : Device; P : Pressure); pragma Asynchronous (Log); end Bank; + returns immediately + exceptions are lost + parameters must be in 61 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    62. Remote_Types An Example 62 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    63. package Alerts is Write App type Alert is abstract tagged private; type Alert_Ref is access all Alert’Class; procedure Handle (A : access Alert); procedure Log (A : access Alert) is abstract; private ... end Alerts; package Alerts.Pool is procedure Register (A : Alert_Ref); function Get_Alert return Alert_Ref; end Medium; with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is begin loop Handle (Pool.Get_Alert); end loop; 63 © ACT Europe Process_Alerts; end under the GNU Free Documentation License http://libre.act-europe.fr
    64. package Alerts.Low is type Low_Alert is new Alert with private; procedure Log (A : access Low_Alert); private ... end Alerts.Low; with Alerts.Pool; use Alerts.Pool; package body Alerts.Low is ... begin Register (new Low_Alert); end Alerts.Low; 64 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    65. package Alerts.Medium is type Medium_Alert is new Alert with private; procedure Handle (A : access Medium_Alert); procedure Log (A : access Medium_Alert); private ... end Alerts.Medium; with Alerts.Pool; use Alerts.Pool; package body Alerts.Medium is ... begin Register (new Medium_Alert); end Alerts.Medium; 65 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    66. package Alerts is Categorize pragma Remote_Types; Remote_Types type Alert is abstract tagged private; type Alert_Ref is access all Alert’Class; procedure Handle (A : access Alert); procedure Log (A : access Alert) is abstract; private package Alerts.Pool is ... end Alerts; pragma Remote_Call_Interface; procedure Register (A : Alert_Ref); function Get_Alert return Alert_Ref; end Medium; with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is begin loop Handle (Pool.Get_Alert); end loop; 66 © ACT Europe Process_Alerts; end under the GNU Free Documentation License http://libre.act-europe.fr
    67. package Alerts.Low is pragma Remote_Types; Remote_Types type Low_Alert is new Alert with private; procedure Log (A : access Low_Alert); private ... end Alerts.Low; package Alerts.Medium is pragma Remote_Types; Remote_Types type Medium_Alert is new Alert with private; procedure Handle (A : access Medium_Alert); procedure Log (A : access Medium_Alert); private ... end Alerts.Medium; 67 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    68. Build & package Alerts is pragma Remote_Types; Remote_Types Test type Alert is abstract tagged private; type Alert_Ref is access all Alert’Class; Alert_ Alert’Class; procedure Handle (A : access Alert); procedure Log (A : access Alert) is abstract; abstract; private ... package Alerts.Low is end Alerts; pragma Remote_Types; Remote_Types type Low_Alert is new Alert with private; procedure Log (A : access Low_Alert); private package Alerts.Medium is ... pragma Remote_Types; Remote_Types end Alerts.Low; type Medium_Alert is new Alert with private; procedure Handle (A : access Medium_Alert); procedure Log (A : access Medium_Alert); package Alerts.Pool is private pragma Remote_Call_Interface; Remote_Call_Interface; ... procedure Register (A : Alert_Ref); end Alerts.Medium; Alerts. function Get_Alert return Alert_Ref; end Medium; with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is begin loop Handle (Pool.Get_Alert); end loop; 68 end Process_Alerts; http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    69. Partition configuration Config_2 is Node_AL : Partition := (Alerts.Low); Node_AM : Partition := (Alerts.Medium); Node_B : Partition := (Alerts.Pool); Node_C : Partition := (Process_Alerts); end Config_2; 69 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    70. What Happens When Executing the Distributed Program ? 70 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    71. package Alerts.Low is package Alerts.Medium is pragma Remote_Types; pragma Remote_Types; Remote_Types Remote_Types type Low_Alert is new Alert with private; type Medium_Alert is new Alert with private; procedure Log (A : access Low_Alert); procedure Handle (A : access Medium_Alert); private procedure Log (A : access Medium_Alert); ... private end Alerts.Low; ... end Alerts.Medium; Alerts. Node_AL Node_AM Step 1: A Low_Alert object in Node_AL registers itself with Node_B with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is package Alerts.Pool is begin pragma Remote_Call_Interface; Remote_Call_Interface; loop procedure Register (A : Alert_Ref); Handle (Pool.Get_Alert); function Get_Alert return Alert_Ref; end loop; end Medium; end Process_Alerts; Node_B Node_C 71 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    72. package Alerts.Low is package Alerts.Medium is pragma Remote_Types; pragma Remote_Types; Remote_Types Remote_Types type Low_Alert is new Alert with private; type Medium_Alert is new Alert with private; procedure Log (A : access Low_Alert); procedure Handle (A : access Medium_Alert); private procedure Log (A : access Medium_Alert); ... private end Alerts.Low; ... end Alerts.Medium; Alerts. Node_AL Node_AM Step 2: A Medium_Alert object in Node_AM registers itself with Node_B with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is package Alerts.Pool is begin pragma Remote_Call_Interface; Remote_Call_Interface; loop procedure Register (A : Alert_Ref); Handle (Pool.Get_Alert); function Get_Alert return Alert_Ref; end loop; end Medium; end Process_Alerts; Node_B Node_C 72 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    73. package Alerts.Low is package Alerts.Medium is pragma Remote_Types; pragma Remote_Types; Remote_Types Remote_Types type Low_Alert is new Alert with private; type Medium_Alert is new Alert with private; procedure Log (A : access Low_Alert); procedure Handle (A : access Medium_Alert); private procedure Log (A : access Medium_Alert); ... private end Alerts.Low; ... end Alerts.Medium; Alerts. Node_AL Node_AM Step 3: Process_Alerts in Node_C does an RPC to Get_Alert in Node_B with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is package Alerts.Pool is begin pragma Remote_Call_Interface; Remote_Call_Interface; loop procedure Register (A : Alert_Ref); Handle (Pool.Get_Alert); function Get_Alert return Alert_Ref; end loop; end Medium; end Process_Alerts; Node_B Node_C 73 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    74. package Alerts.Low is package Alerts.Medium is pragma Remote_Types; pragma Remote_Types; Remote_Types Remote_Types type Low_Alert is new Alert with private; type Medium_Alert is new Alert with private; procedure Log (A : access Low_Alert); procedure Handle (A : access Medium_Alert); private procedure Log (A : access Medium_Alert); ... private end Alerts.Low; ... end Alerts.Medium; Alerts. Node_AL Node_AM Step 4: Get_Alert returns a pointer to an Alert object (Low_Alert or Medium_Alert) with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is package Alerts.Pool is begin pragma Remote_Call_Interface; Remote_Call_Interface; loop procedure Register (A : Alert_Ref); Handle (Pool.Get_Alert); function Get_Alert return Alert_Ref; end loop; end Medium; end Process_Alerts; Node_B Node_C 74 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    75. package Alerts.Low is package Alerts.Medium is pragma Remote_Types; pragma Remote_Types; Remote_Types Remote_Types type Low_Alert is new Alert with private; type Medium_Alert is new Alert with private; procedure Log (A : access Low_Alert); procedure Handle (A : access Medium_Alert); private procedure Log (A : access Medium_Alert); ... private end Alerts.Low; ... end Alerts.Medium; Alerts. ? Node_AL Node_AM Step 5: Node_C performs a dispatching RPC. It calls Handle in Node_AL or Node_AM with Alerts, Alerts.Pool; use Alerts; procedure Process_Alerts is package Alerts.Pool is begin pragma Remote_Call_Interface; Remote_Call_Interface; loop procedure Register (A : Alert_Ref); Handle (Pool.Get_Alert); function Get_Alert return Alert_Ref; end loop; end Medium; end Process_Alerts; Node_B Node_C 75 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    76. What Does Get_Alert Return ? Pointer Get_Alert Address of Alert object Machine on the Machine 76 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    77. Remote Access to Class Wide Type • At compile time: – You do not know what operation you’ll dispatch to – On what node that operations will be executed on 77 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    78. • Introduction • Distributed Prog. Paradigms • Distributed Object Technologies – Language Dependent: Ada 95 – Language Independent: CORBA 78 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    79. Language Independent Distributed Objects Paradigm language indep. Spec (IDL) spec language B Server Client language B language A Different languages are used to write: • the spec of the distributed services • the implementation of the server code • the implementation of the client code 79 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    80. CORBA Interfaces • In Corba interfaces are described in IDL – (Interface Description Language) • The IDL is independent of programming languages • Each interface is translated in – Language A used for the client (client stub) – Language B used for the server (server skeleton) • To implement the server the programmer completes the skeleton in language B • To implement the client the programmer uses the services provided by th estub in language A 80 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    81. The CORBA Architecture • RPC go through the ORB – (Object Request Broker) • The ORB is a software bus • ORBs communicate with a set of standardised protocols – IIOP, GIOP 81 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    82. The IDL • Syntax similar to C++ with some Ada additions • IDL must be translatable in various prog. Languages – Ada, C, C++, Java, … • There are limitations in what you can write in the IDL • Programmer must understand how the IDL is translated in the host language – to complete the server skeleton – to use the client stub 82 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    83. Example module M { interface T { void P (); }; }; package M is pragma Remote_Types; type T is tagged …; procedure P (O : in access T); end M; 83 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    84. Exemple module Echo { string echoString (in string mesg); }; Module foo { interface Buffer { exception Empty; void put (in string content); string get() raises (Empty); } 84 }; http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    85. Example 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 echoString (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; 85 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    86. CORBA Services • The CORBA core services are very few • Lot ’s of external services – Naming (distributed and hierarchical) – Persistance – Transaction – Security – ... 86 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    87. Common Application Code you Code you Domain Facilities Domain Objects write write Specific Specifi OR B Domain Domain Independent Independent Object Services 87 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    88. • Introduction • Distributed Prog. Paradigms • Distributed Object Technologies • Conclusion 88 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    89. Developing a Distributed App • Using network services directly – Sockets Similar issues • Using middleware with – CORBA Tasking – COM/DCOM • Using a distributed language – Ada 95 DSA – Java RMI 89 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    90. Impact on Development Phases General Design Distributed Design Coding Testing 90 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    91. Sockets General Ad Hoc Design Distributed Very low level Design Distributed Coding mode only Testing 91 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    92. • Everything must be done with sockets • Data marshaling/unmarshalling • Handle heterogeneous systems directly Very low level Coding 92 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    93. CORBA General IDL Design Must invoke high-level Distributed services directly Design Distributed Coding mode only Testing 93 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    94. Ada 95 DSA General Ada 95 Design Regular Ada Distributed Coding Design distributed Coding & non-distributed Testing 94 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License
    95. Ada 95 DSA & CORBA: Benefits • Save developer’s time, in socket programming: – Defining a client/server protocol – Defining a message format – Marshalling of data – Unmarshalling data • Raise the level of abstraction 95 http://libre.act-europe.fr © ACT Europe under the GNU Free Documentation License

    + Gneuromante canalada.orgGneuromante canalada.org, 3 years ago

    custom

    1069 views, 0 favs, 0 embeds more stats

    Author: Franco Gasperoni. License: GFDL

    More info about this document

    © All Rights Reserved

    Go to text version

    • Total Views 1069
      • 1069 on SlideShare
      • 0 from embeds
    • Comments 0
    • Favorites 0
    • Downloads 42
    Most viewed embeds

    more

    All embeds

    less

    Flagged as inappropriate Flag as inappropriate
    Flag as inappropriate

    Select your reason for flagging this presentation as inappropriate. If needed, use the feedback form to let us know more details.

    Cancel
    File a copyright complaint
    Having problems? Go to our helpdesk?

    Categories

    Tags

    Groups / Events

    -->
    Search
    RSS Feed
    What's new?

    © 2009 SlideShare Inc. All Rights Reserved