Zdalne wywołania procedur Jarosław Kuchta Programowanie Współbieżne Zdalne wywołania procedur

Podstawy RPC – Remote Procedure Call Wywołanie procedur jednego procesu z innego procesu. Proces wywoływany – serwer Proces wywołujący - klient Wywoływana procedura jest wykonywana w przestrzeni adresowej wywoływanego procesu (serwera). RPC

RPC w sieci protokół opracowany przez firmę Sun popularny w systemie Unix obsługiwany w bibliotekach języka Java współcześnie obsługiwany przez protokoły: SOAP CORBA XML-RPC JSON-RPC RPC

XDR – External Data Representation standard jednolitej reprezentacji danych w sieci między komputerami o różnych architekturach warunki podstawowe wszystkie typy danych mają rozmiar będący wielokrotnością 4 bajtów, liczby całkowite kodowane w standardzie BigEndian (najpierw starsze bajty) liczby rzeczywiste w formacie IEEE. nadawca i odbiorca muszą znać struktury danych (nie są przekazywane) RPC

Filtry XDR xdr_int xdr_float xdr_char xdr_wrapstring (dla typu char *) RPC

Filtry XDR dla struktur struktura struct s { int i, float x } filtr int xdr_s (XDR *xptr, struct s *sptr) { return (xdr_int(xptr, &sptr->i) && xdr_float(xptr, &sptr->x); } RPC

Identyfikacja procedury trzy liczby całkowite: numer programu numer wersji numer procedury RPC

Rejestracja procedury int registerrpc( unsigned long PROG, unsigned long VERS, unsigned long PROC, char * ( * proc)(), // adres procedury int (* xdr_arg)(), // adres filtra argumentów int (* xdr_res)()); // adres filtra wyników RPC

Przykład – procedura udostępniająca czas systemowy #include <rpc/rpc.h> #define PRZYKLAD 0x20000000 #define WERSJA 1 #define CZAS 1 typedef struct { … } tt; extern void podaj_czas (tt *) { … } char *czas (void) { static tt t; podaj_czas (&t); return (char *)&t; } void main (void) { registerrpc ( PRZYKŁAD, WERSJA, CZAS, czas, xdr_void, xdr_t); svc_run(); } RPC

Wywołanie procedury zdalnej int callrpc( char *server, // nazwa serwera unsigned long PROG, unsigned long VERS, unsigned long PROC, int (* xdr_arg)(), char *arg, // struktura argumentów int (* xdr_res)(), char *res); // struktura wyników RPC

Przykład – wywołanie procedury udostępniającej czas systemowy #include <rpc/rpc.h> #define PRZYKLAD 0x20000000 #define WERSJA 1 #define CZAS 1 typedef struct { … } tt; int xdr_t (XDR *xptr, tt *tp) { … } extern void korzystaj (tt *); void main (void) { tt t; callrpc("servername", PRZYKŁAD, WERSJA, CZAS, xdr_void, NULL, xdr_t, &t); korzystaj (&t); } RPC

RPC a wykonanie równoległe zwykłe wywołanie RPC wywołanie przez rozgłaszanie main proc main proc proc registerrpc registerrpc callrpc clnt_broadcast proces wywołujący jest wstrzymywany procesy wywoływane są równolegle RPC

Wykonanie równoległe – przez rozgłaszanie int clnt_broadcast( unsigned long PROG, unsigned long VERS, unsigned long PROC, int (* xdr_arg)(), char *arg, int (* xdr_res)(), char *res, int (* res_proc)()); RPC

Przykład – wywołanie procedury przez rozgłaszanie #include <rpc/rpc.h> #define PRZYKLAD 0x20000000 #define WERSJA 1 #define CZAS 1 typedef struct { … } tt; int xdr_t (XDR *xptr, tt *tp) { … } extern void korzystaj (tt *); int po_rozgloszeniu (char *t, struct socketaddr_in *addr) { return true; } void main (void) { tt t; clnt_broadcast( PRZYKŁAD, WERSJA, CZAS, xdr_void, NULL, xdr_t, &t, po_rozgloszeniu); korzystaj (&t); } RPC

Ograniczenia Brak mechanizmu wstrzymywania procesów rozwiązanie: wysokopoziomowe mechanizmy synchronizacji w Unix RPC – blokowanie procesu wywoływanego konieczność jawnego podawania nazwy serwera rozwiązanie: rpc_bind zdalne rozgłaszanie – przynajmniej jedna procedura musi być wykonywana RPC

Asynchroniczne RPC – deklaracja procedury (IDL) [ uuid (7f6c4340-eb67-11d1-b9d7-00c04fad9a3b), version(1.0), pointer_default(unique) ] interface AsyncRPC { const long DEFAULT_ASYNC_DELAY = 10000; const short APP_ERROR = -1; const char* DEFAULT_PROTOCOL_SEQUENCE = "ncacn_ip_tcp"; const char* DEFAULT_ENDPOINT = "8765"; void NonAsyncFunc(handle_t hBinding, [in, string] unsigned char * pszMessage); void AsyncFunc(handle_t hBinding, [in] unsigned long nAsychDelay); void Shutdown(handle_t hBinding); } RPC

IDL IDL – Interface Description Language MIDL – kompilator IDL RPC

Alternatywa – atrybuty ACF ACF – Application Configuration File IDL + ACF: interface AsyncRPC { [async] AsyncFunc(); } RPC

Wywołanie asynchroniczne (1) RPC_ASYNC_STATE Async; RPC_STATUS status; // Initialize the handle. status = RpcAsyncInitializeHandle(&Async, sizeof(RPC_ASYNC_STATE)); if (status) { // Code to handle the error goes here. } Async.UserInfo = NULL; Async.NotificationType = RpcNotificationTypeEvent; Async.u.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); if (Async.u.hEvent == 0) RPC

Wywołanie asynchroniczne (2) // Call an asynchronous RPC routine here RpcTryExcept { printf("\nCalling the remote procedure 'AsyncFunc'\n"); AsyncFunc(&Async, AsyncRPC_ClientIfHandle, nAsychDelay); } RpcExcept(1) ulCode = RpcExceptionCode(); printf("AsyncFunc: Run time reported exception 0x%lx = %ld\n", ulCode, ulCode); RpcEndExcept RPC

Wywołanie synchroniczne tej samej procedury // Call a synchronous routine while the asynchronous procedure is still running RpcTryExcept { printf("\nCalling the remote procedure 'NonAsyncFunc'\n"); NonAsyncFunc(AsyncRPC_ClientIfHandle, pszMessage); fprintf(stderr, "While 'AsyncFunc' is running asynchronously,\n" "we still can send message to the server in the mean time.\n\n"); } RpcExcept(1) ulCode = RpcExceptionCode(); printf("NonAsyncFunc: Run time reported exception 0x%lx = %ld\n", ulCode, ulCode); RpcEndExcept RPC

Oczekiwanie na odpowiedź bez blokowania własnego wątku: // This code fragment assumes that Async is a valid asynchronous RPC handle. if (WaitForSingleObject(Async.u.hEvent, INFINITE) == WAIT_FAILED) { RpcRaiseException(APP_ERROR); } z blokowaniem własnego wątku: if (SleepEx(INFINITE, TRUE) != WAIT_IO_COMPLETION) RPC

Obsługa wywołania przez serwer (1) void AsyncFunc(IN PRPC_ASYNC_STATE pAsync, IN RPC_BINDING_HANDLE hBinding, IN OUT unsigned long nAsychDelay) { int nReply = 1; RPC_STATUS status; unsigned long nTmpAsychDelay; int i; if (nAsychDelay < 0) nAsychDelay = DEFAULT_ASYNC_DELAY; else if (nAsychDelay < 100) nAsychDelay = 100; RPC

Obsługa wywołania przez serwer (2) // We only call RpcServerTestCancel if the call // takes longer than ASYNC_CANCEL_CHECK ms if (nAsychDelay > ASYNC_CANCEL_CHECK) { nTmpAsychDelay = nAsychDelay/100; for (i = 0; i < 100; i++) Sleep(nTmpAsychDelay); if (i%5 == 0) fprintf(stderr, "\rRunning AsyncFunc (%lu ms) (%d%c) ... ", nAsychDelay, i+5, PERCENT); status = RpcServerTestCancel( RpcAsyncGetCallHandle(pAsync)); if (status == RPC_S_OK) { fprintf(stderr, "\nAsyncFunc has been canceled!!!\n"); break; } else if (status != RPC_S_CALL_IN_PROGRESS) printf("RpcAsyncInitializeHandle returned 0x%x\n", status); exit(status); else Sleep(nAsychDelay); RPC

Wysłanie odpowiedzi przez serwer printf("\nCalling RpcAsyncCompleteCall\n"); status = RpcAsyncCompleteCall(pAsync, &nReply); printf("RpcAsyncCompleteCall returned 0x%x\n", status); if (status) exit(status); } RPC

Przyjęcie odpowiedzi przez klienta status = RpcAsyncCompleteCall( &Async, &Reply); // W tym momencie wynik jest zwracany w Reply RPC