Inter-process Communication: RPC

Transcription

1 Inter-process Communication: RPC Dr. Yong Guan Department of Electrical and Computer Engineering & Information Assurance Center Iowa State University

2 Outline for Today s Talk Inter-process Communication: RPC Remote Procedure Call

3 Readings for Today s Lecture Chapter 4 of Distributed Systems: Principles and Paradigms Online resources and man page

4 Middleware Purpose of Middleware in Distributed Systems RPC(Remote Procedure Call) Introduction RPC mechanisms Design issues Programming with RPC Case study: SUN RPC (Live demo) Java RMI CORBA

5 Purpose of Middleware in Distributed Systems Principles of transparency Hide Lower level complexities Ease the Application Development Allows to focus on Application functionality Application Middleware Server Server Server Server Distributed System

6 Building Distributed Programs: Two Paradigms Paradigms: Communication-Oriented Design Application-Oriented Design Start with communication protocol Start with application Design message format and syntax Design client and server components by specifying how they react to incoming messages Design, build, test conventional implementation Partition program Properties: Focus on communication instead of application! Focus on application program structure Design protocol first, then build applications that adhere to the protocol Example: socket Make communication transparent Example: RPC

7 Introduction-RPC 1984: Birrell & Nelson Mechanisms to call procedures on other machines Processes on machine A can call procedures on machine B A is suspended Execution continues on B When B returns, control passed back to A Goal: it appears to the programmer that a normal call is taking place 7

8 Conventional Procedure Call count = read (fd, buf, bytes) call-by-value call-by-reference a) Parameter passing in a local procedure call: the stack before the call to read b) The stack while the called procedure is active

9 Remote Procedure Call Allow programs to call procedures located on other machines Information can be transported from the caller to the callee in the parameters and come back in the procedure result. RPC enables clients to communicate with servers by calling procedures in a similar way to the conventional use of procedure calls in high-level languages. Transparency: no message passing is visible to the programmer. Challenges: Different machines Different address spaces Both machines can crash

10 RPC Model: Client (caller) and Server (callee) Principle of RPC between a client and server program CprE main program on machine 1 procedure A on machine 2 procedure B on machine 3 call remote proc A call remote proc B exit respond to caller respond to caller

11 Asynchronous RPC 2-12 a) The interconnection between client and server in a traditional RPC b) The interaction using asynchronous RPC

12 Structure of an RPC Call client RPC server packing parameters client stub packing / unpacking result server stub unpacking parameters RPC library(network routines) RPC library(network Routines) 8 3 Packaging/unpackaging of arguments into network messages is called marshaling/unmarshaling.

13 Steps of a Remote Procedure Call 1. Client procedure calls client stub in normal way 2. Client stub builds message, calls local OS 3. Client's OS sends message to remote OS 4. Remote OS gives message to server stub 5. Server stub unpacks parameters, calls server 6. Server does work, returns result to the stub 7. Server stub packs it in message, calls local OS 8. Server's OS sends message to client's OS 9. Client's OS gives message to client stub 10. Stub unpacks result, returns to client

14 RPC Stubs A client-side stub is a function that looks to the client as if it were a callable server function i.e., same API as the server s implementation of the function A server-side stub looks like a caller to the server i.e., like a hunk of code invoking the server function The client program thinks it s invoking the server but it s calling into the client-side stub The server program thinks it s called by the client but it s really called by the server-side stub The stubs send messages to each other to make the RPC happen transparently (almost!) Remote Procedure Call CS-4513, D-Term

15 Marshalling Arguments Marshalling is the packing of function parameters into a message packet the RPC stubs call type-specific functions to marshal or unmarshal the parameters of an RPC Client stub marshals the arguments into a message Server stub unmarshals the arguments and uses them to invoke the service function on return: the server stub marshals return values the client stub unmarshals return values, and returns to the client program Remote Procedure Call CS-4513, D-Term

16 RPC Model A server defines the service interface using an interface definition language (IDL) the IDL specifies the names, parameters, and types for all client-callable server procedures A stub compiler reads the IDL declarations and produces two stub functions for each server function Server-side and client-side Linking: Server programmer implements the service s functions and links with the server-side stubs Client programmer implements the client program and links it with client-side stubs Operation: Stubs manage all of the details of remote communication between client and server Remote Procedure Call CS-4513, D-Term

17 RPCs: Issues of Design What are semantics of parameter passing? E.g., pass by reference? Binding - How to bind (locate & connect) to servers? Exception Handling Performance and security Data Representation - How to handle heterogeneity? OS, language, architecture,

18 Parameter Passing Passing value parameters Parameter marshalling Passing reference parameters How to pass pointers (i.e., references), that are not meaningful on the server Possible solution: Case: pointer to an array If the size of the array is known, we can copy the array into a message and send it to the server. In this case, call-by-reference is replaced by copy/restore. We still cannot handle the most general case of a pointer to an arbitrary data structures (complex graph).

19 Passing Value Parameters 2-8 Steps involved in doing remote computation through RPC

20 RPC Binding Binding is the process of connecting the client to the server the server, when it starts up, exports its interface identifies itself to a network name server tells RPC runtime that it is alive and ready to accept calls the client, before issuing any calls, imports the server RPC runtime uses the name server to find the location of the server and establish a connection The import and export operations are explicit in the server and client programs Remote Procedure Call CS-4513, D-Term

21 Locating Servers Broadcast requests Broadcast call and process incoming replies Name servers Server registers with name server name server client stub Occurs only once register stub server Publish & Subscribe Flexible client stub subscribe name server publish stub server May occur more than once

22 Result (RPC Advantages) Writing applications is simplified RPC hides all networks codes Programmers don t have to worry about details (sockets, port numbers, byte ordering) The hard work of building messages, formatting, uniform representation, etc., is buried in the stubs Client and server designers can concentrate on the semantics of application Programs behave in familiar way Familiar Procedure call interface Remote Procedure Call CS-4513, D-Term

23 Case Study: SUN RPC rpcgen compiler Takes IDL as input and generate stub functions. Format of messages, arguments, and results. XDR (external Data Representation). RPC run-time library How to locate server and server application port. remote program proc A proc B proc C shared data

24 Interface definition language (IDL) Defines service interface between client and server A language for specifying operations (procedures or functions) parameters to these operations, other optional data types /* * date.x - Specification of remote date, time, date and time service. */ program DATE_PROG { version DATE_VERS { string DATE(long) = 1; /* procedure number = 1 */ } = 1; /* version number = 1 */ } = 0x

25 Identifying Remote Programs and Procedures CprE Conceptually, each procedure on a computer is identified by pair : ( prog, proc ) prog: 32-bit integer identifying remote program proc: integer identifying procedure Set of program numbers partitioned into 4 sets. 0x x1fffffff 0x x3fffffff 0x x5fffffff 0x xffffffff assigned by SUN assigned by local system manager temporary reserved Multiple remote program versions can be identified: ( prog, version, proc )

26 RPC Interaction CprE Client contacts portmapper to determine service port. 3. Client contacts server on the specified service port.

27 Remote Programs and Protocol Ports CprE caller port remote program program_id vs. port_id (32 bit) (16 bit) Dynamic port mapping: RPC port mapper You must know the server address first. RPC program xx RPC program registers (xx, p) port mapper p 111 port currently used by this RPC program well-known port for port manager

28 Comparison: Binding service in DCE RPC 2-15 DCE: A directory server help to locate RPC server. SUN: You should specify the RPC server.

29 XDR - external Data Representation XDR is a universally used standard from Sun Microsystems used to represent data in a network canonical form. A set of conversion functions are used to encode and decode data; for example, xdr_int( ) is used to encode and decode integers. Data is converted into a network canonical form (a standard form) to be presented in a meaningful format to the receiving host. Conversion functions exist for all standard data types. However, for complex structures, RPCGEN is used to generate conversion routines.

30 Sun RPC Message Format: XDR Specification enum msg_type { /* RPC message type constants */ CALL = 0; REPLY = 1; }; struct rpc_msg { /* format of a RPC message */ unsigned int mesgid; /* used to match reply to call */ union switch (msg_type mesgt) { case CALL : call_body cbody; case REPLY: reply_body rbody; } body; }; struct call_body { /* format of RPC CALL */ u_int rpcvers; /* which version of RPC? */ u_int rprog; /* remote program number */ u_int rprogvers; /* version number of remote prog */ u_int rproc; /* number of remote procedure */ opaque_auth cred; /* credentials for called auth. */ opaque_auth verf; /* authentication verifier */ /* ARGS */ };

31 Creating Distributed Applications with Sun RPC Example: Remote Dictionary Using rpcgen Procedure call structure: rdict1.c main rdict2.c nextin init_dic lookupw insertw deletew

32 Specification for rpcgen Interface: *.x file Specify: constants data types remote programs, their procedures, types of parameters /* rdict.x */ /* RPC declarations for dictionary program */ const MAXWORD = 50; const DICTSIZ = 100; struct example { /* unused; rpcgen would */ int exfield1; /* generate XDR routines */ char exfield2; /* to convert this structure.*/ }; /* RDICTPROG: remote program that provides insert, delete, and lookup */ program RDICTPROG { /* name (not used) */ version RDICTVERS { /* version declarat.*/ int INITW(void) = 1;/* first procedure */ int INSERTW(string)= 2;/* second proc... */ int DELETEW(string)= 3; int LOOKUP(string) = 4; } = 1; /* version definit.*/ } = 0x ; /* program no */ /* (must be unique)*/

33 Program Generation rdict.h constants, data types definitions for remote procedures rdict_xdr.c XDR conversion routines rpcgen rdict.x rdict_clnt.c client stub rdict_svc.c server stub rdict_cif.c rdict1.c rdict_clnt.c cc rdict (client) rdict.x rpcgen rdict.h rdict_xdr.c rdict_svc.c cc rdictd rdict_sif.c rdict2.c

34 Example: Date.x /* * date.x - Specification of remote date, time, date and time service. */ /* * Define 1 procedure : * date_1() accepts a long and returns a string. */ program DATE_PROG { version DATE_VERS { string DATE(long) = 1; /* procedure number = 1 */ } = 1; /* version number = 1 */ } = 0x ; /* program number */

35 #include <stdio.h> #include <string.h> #include <time.h> #include <sys/types.h> #include <rpc/rpc.h> /* standard RPC include file */ #include "date.h" /* this file is generated by rpcgen */ Client.c #define MAX_LEN 100 long get_response(void); long get_response() { long choice; } printf("===========================================\n"); printf(" Menu: \n"); printf(" \n"); printf(" 1. Date\n"); printf(" 2. Time\n"); printf(" 3. Both\n"); printf(" 4. Quit\n"); printf(" \n"); printf(" Choice (1-4):"); scanf("%ld",&choice); printf("===========================================\n"); return(choice);

36 main(int argc, char **argv) { CLIENT *cl; /* RPC handle */ char *server; char **sresult; /* return value from date_1() */ char s[max_len]; /* character array to hold output */ long response; /* user response */ long *lresult; /* pointer to user response */ CprE Pointer of data type defined in x file } if (argc!= 2) { fprintf(stderr, "usage: %s hostname\n", argv[0]); exit(1); } server = argv[1]; lresult = (&response); /* * Create the client "handle." */ Specify server address if ( (cl = clnt_create(server, DATE_PROG, DATE_VERS, "udp")) == NULL) { clnt_pcreateerror(server); exit(2); } response = get_response(); while(response!= 4) { if ((sresult = date_1(lresult, cl)) == NULL) { clnt_perror(cl, server); exit(3); } printf(" %s\n", *sresult); response = get_response(); } clnt_destroy(cl); /* done with the handle */ exit(0); Client.c (cont.) Create client handle Call ProcName_VerName with client handle

37 /* * date_proc.c - remote procedures; called by server stub. */ #include <rpc/rpc.h> /* standard RPC include file */ #include <time.h> #include <sys/types.h> #include "date.h" /* this file is generated by rpcgen */ CprE #define MAX_LEN 100 /* * Return the binary date and time. */ char ** date_1(long *option) { struct tm *timeptr; /* Pointer to time structure */ time_t clock; /* Clock value (in secs) */ static char *ptr; /* Return string */ static char err[] = "Invalid Response \0"; static char s[max_len]; Server.c clock = time(0); timeptr = localtime(&clock); Pointers of data type defined in x file switch(*option) { case 1: strftime(s,max_len,"%a, %B %d, %Y",timeptr); ptr=s; break; case 2: strftime(s,max_len,"%t",timeptr); ptr=s; break; case 3: strftime(s,max_len,"%a, %B %d, %Y - %T",timeptr); ptr=s; break; } default: ptr=err; break; } return(&ptr);

38 Program Generation Client Program Client stub cc Client Executable IDL rpcgen compiler Headers xdr routine Server stub cc Server Executable Server Program

39 Steps to Compile and Run ssh to linux-4.ece.iastate.edu with your NetID and password Save date.x, client.c and server.c into some directory. Under the directory, execute: rpcgen k date.x (-k generates code in K&R C. Needed in this machine!) gcc o client client.c date_clnt.c gcc o server server.c date_svc.c./server &./client localhost kill server_pid (run server at back end) (run client with the server on localhost) (kill the server)

40 Project - 1 Remote System Monitoring using RPC Current System time CPU Usage Memory Usage Load Procs per minute

41 Thank you! CprE