CprE 450-550

Dr. Yong Guan

Department of Electrical and Computer Engineering& Information Assurance CenterIowa State University

Inter-process Communication: RPC

CprE 450-550

Outline for Today’s TalkInter-process Communication: RPC

Remote Procedure Call

CprE 450-550

Readings for Today’s Lecture

Chapter 4 of “Distributed Systems: Principles and Paradigms”

Online resources and man page

CprE 450-550

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 RMICORBA

CprE 450-550

Purpose of Middleware in Distributed Systems

Middleware

Application

Distributed System

Server Server ServerServer

•Principles of transparency – Hide Lower level complexities•Ease the Application Development •Allows to focus on Application functionality

CprE 450-550

Building Distributed Programs: Two Paradigms

Communication-Oriented Design Start with communication protocol Design message format and syntax Design client and server components

by specifying how they react to incoming messages

Focus on communication instead of application!

Design protocol first, then build applications that adhere to the protocol

Example: socket

Application-Oriented Design Start with application Design, build, test conventional

implementation Partition program

Focus on application program structure

Make communication “transparent” Example: RPC

Properties:

Paradigms:

CprE 450-550

7

Introduction-RPC1984: Birrell & Nelson

Mechanisms to call procedures on other machinesProcesses on machine A can call procedures on machine B

A is suspendedExecution continues on BWhen B returns, control passed back to A

Goal: it appears to the programmer that a normal call is taking place

CprE 450-550

Conventional Procedure Call

a) Parameter passing in a local procedure call: the stack before the call to read

b) The stack while the called procedure is active

count = read (fd, buf, bytes)

call-by-value

call-by-reference

CprE 450-550

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

CprE 450-550

RPC Model: Client (caller) and Server (callee)Principle of RPC between a client and server program

call remoteproc A

call remoteproc B

respond to caller

exit

main programon machine 1

procedure Aon machine 2

procedure Bon machine 3

respond to caller

CprE 450-550

Asynchronous RPC

a) The interconnection between client and server in a traditional RPCb) The interaction using asynchronous RPC

2-12

CprE 450-550

Structure of an RPC Call

client

client stub

RPC library(network routines)

server

server stub

RPC library(Network Routines)

1

2

3

8

7

6 5

49

10

packingparameters

unpackingparameters

packing /unpacking

result

RPC

Packaging/unpackaging of arguments into network messages is called marshaling/unmarshaling.

CprE 450-550

Steps of a Remote Procedure Call

1. Client procedure calls client stub in normal way2. Client stub builds message, calls local OS3. Client's OS sends message to remote OS4. Remote OS gives message to server stub5. Server stub unpacks parameters, calls server6. Server does work, returns result to the stub7. Server stub packs it in message, calls local OS8. Server's OS sends message to client's OS9. Client's OS gives message to client stub10. Stub unpacks result, returns to client

CprE 450-550

Remote Procedure Call CS-4513, D-Term 2007 14

RPC StubsA 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 functionA server-side stub looks like a caller to the server

i.e., like a hunk of code invoking the server functionThe client program thinks it’s invoking the server

but it’s calling into the client-side stubThe server program thinks it’s called by the client

but it’s really called by the server-side stubThe stubs send messages to each other to make the RPC happen transparently (almost!)

CprE 450-550

Remote Procedure Call CS-4513, D-Term 2007 15

Marshalling ArgumentsMarshalling 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 messageServer stub unmarshals the arguments and uses them to invoke the service function

on return:the server stub marshals return valuesthe client stub unmarshals return values, and returns to the client program

CprE 450-550

Remote Procedure Call CS-4513, D-Term 2007 16

RPC ModelA 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-sideLinking:–

Server programmer implements the service’s functions and links with the server-side stubsClient 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

CprE 450-550

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, …

CprE 450-550

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

CprE 450-550

Passing Value Parameters

Steps involved in doing remote computation through RPC

2-8

CprE 450-550

Remote Procedure Call CS-4513, D-Term 2007 20

RPC BindingBinding is the process of connecting the client to the server

the server, when it starts up, exports its interfaceidentifies itself to a network name servertells RPC runtime that it is alive and ready to accept calls

the client, before issuing any calls, imports the serverRPC 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

CprE 450-550

Locating ServersBroadcast requests

Broadcast call and process incoming replies

Name serversServer registers with name server

stubclient

name server

stubserver

register

stubclient

name server

stubserver

publishsubscribe

Publish & Subscribe

Occurs only once

May occur more than once

Flexible

CprE 450-550

Remote Procedure Call CS-4513, D-Term 2007 22

Result (RPC Advantages)Writing applications is simplified

RPC hides all networks codesProgrammers 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

CprE 450-550

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.

shared data

proc A proc B proc C

remote program

CprE 450-550

Defines service interface between client and serverA 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 */

} = 0x31234567

Interface definition language (IDL)

CprE 450-550

Conceptually, each procedure on a computer is identified by pair : ( prog, proc )

prog: 32-bit integer identifying remote programproc: integer identifying procedure

Set of program numbers partitioned into 4 sets.

0x00000000 - 0x1fffffff assigned by SUN0x20000000 - 0x3fffffff assigned by local system manager0x40000000 - 0x5fffffff temporary0x60000000 - 0xffffffff reserved

Multiple remote program versions can be identified:( prog, version, proc )

Identifying Remote Programs and Procedures

CprE 450-550

RPC Interaction

2. Client contacts portmapper to determine service port.3. Client contacts server on the specified service port.

CprE 450-550

Remote Programs and Protocol Ports

Dynamic port mapping: RPC port mapper

caller remote programport

program_id vs. port_id

(32 bit) (16 bit)

RPC program

xx

portmapper

RPC program registers

(xx, p)

p 111

port currently usedby this RPC program

well-known portfor port manager

You must know theserver address first.

CprE 450-550

Comparison: Binding service in DCE RPC

DCE: A directory server help to locate RPC server.SUN: You should specify the RPC server.

2-15

CprE 450-550

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.

CprE 450-550

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 */

};

CprE 450-550

Creating Distributed Applications with Sun RPC Example: Remote Dictionary Using rpcgen

Procedure call structure:

main

init_dic

insertw deletew

lookupwnextin

rdict1.crdict2.c

CprE 450-550

Specification for rpcgen

Interface:*.x file

Specify:constantsdata typesremote 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.*/} = 0x30090949; /* program no */

/* (must be unique)*/

CprE 450-550

Program Generation

rpcgen rdict.x

rdict.h• constants, data types• definitions for remote procedures

rdict_xdr.c• XDR conversion routines

rdict_clnt.c• client stub

rdict_svc.c• server stub

rdict.x

rdict_clnt.c

rdict.h

rdict_xdr.c

rdict_svc.c

rdict_sif.c rdict2.c

cc

cc

rdict_cif.c rdict1.c

rdict (client)

rdictd

rpcgen

CprE 450-550

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 */

} = 0x31234567; /* program number */

CprE 450-550

#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 */

#define MAX_LEN 100long 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);

}

Client.c

CprE 450-550main(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 */

if (argc != 2) {fprintf(stderr, "usage: %s hostname\n", argv[0]);exit(1);

}server = argv[1];lresult = (&response);/** Create the client "handle."*/

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.)Pointer of data

type defined in x file

Specify server address

Create client handle

Call ProcName_VerNamewith client handle

CprE 450-550/** 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 */

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

clock = time(0);timeptr = localtime(&clock);

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

}

Server.c

Pointers of datatype defined in x file

CprE 450-550

Program Generation

IDL

Client stub

Headers

xdr routine

Server stub

Server Program

cc

cc

Client Program

Client Executable

Server Executable

rpcgencompiler

CprE 450-550

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 & (run server at back end)

./client localhost (run client with the server on localhost)

kill server_pid (kill the server)

CprE 450-550

Project - 1

Remote System Monitoring using RPC –•Current System time•CPU Usage•Memory Usage •Load Procs per minute

CprE 450-550

Thank you!