Chamada Remota de Procedimento (RPC)

Transcrição

1 Chamada Remota de Procedimento (RPC)

2 padrão cliente-servidor A (cliente) send (B, pedido) receive(b, &resp) B (servidor) receive (A, ) processa pedido send(a, ) repetição de padrão de comunicação encapsulação em abstração de mais alto nível transparência

3 chamada remota A (cliente) send (B, pedido) receive(b, &resp) B (servidor) receive (A, ) processa pedido send(a, ) transformação em chamada de procedimento transparência para comunicação e suporte a passagem de parâmetros

4 chamadas locais main proc1 proc2 proc3 proc4 proc5 proc6 proc7 proc8 programa convencional organizado e entendido em como uma sequência de chamadas a procedimentos

5 chamada remota Computador 1 Computador 2 main proc1 proc2 proc3 proc4 proc5 proc6 proc7 proc8 protocolo permite chamada de procedimento remoto chamada remota pode ficar mais ou menos ênfase em estruturação do programa bastante associado ao modelo cliente-servidor

6 chamadas remotas main proc1 proc2 proc3 proc4 proc5 proc6 proc7 proc8 possibilidade de estruturas mais complexas mais comum em sistemas de objetos distribuídos

7 RPC: modelo de execução processo cliente permanece bloqueado durante execução de chamada remota A (cliente) B (servidor) resp = foo(a1, a2, ) function foo (arg1, arg2, ) return resposta end

8 RPC: modelo de execução stubs são responsáveis por intermediar a comunicação entre quem faz a chamada (caller) e quem é chamado (callee) cliente servidor stub cliente stub servidor

9 RPC - papel dos stubs processo chamador processo chamado cham local stub cliente stub servidor runtime RPC runtime RPC

10 camadas envolvidas supondo uso de TCP protocolo sobre TCP conversão de dados conversão de chamada remota em protocolo TCP prg cliente ferramenta stubs cli e srv conversão entre formatos de repres. protocolo tcp

11 ferramentas/ geração de stubs linguagens que incorporam conceito de RPC compilador gera diferentes partes do programa e stubs compilador cliente servidor programa fonte stub cliente stub servidor bibliotecas + ferramentas possivelmente com interoperabilidade entre linguagens descrição interface gerador de stubs stub cliente stub servidor

12 conversão de dados marshalling/unmarshalling empacotamento e desempacotamento problemas representações diferentes para inteiros alinhamento de dados estruturas com ponteiros

13 soluções representação em XML (web services) XDR (external data representation) rotinas de conversão escritas pelo programador

14 RPC Birrell e Nelson: 1984 PARC implementação em linguagens como CCLU Sun RPC objetos distribuídos: CORBA, RMI, J2EE, SOAP

15 Um exemplo de RPC: Sun-RPC Sistema originalmente criado para máquinas Sun. oferecido atualmente em diversos sistemas operacionais! A arquitetura definida inclui: uma linguagem para definição das interfaces (cabeçalhos de procedimentos, etc); a ferramenta RPCGEN, que gera os stubs cliente e servidor automaticamente; uma biblioteca RPC, que pode ser usada diretamente na construção de programas que não usem o RPCGEN; o protocolo de comunicação entre os stubs. Pode utilizar TCP ou UDP

16 Sun-RPC - Tradução de dados tradução entre formatos de dados: utilização de uma representação padrão, XDR (external Data Representation Standard). formato origem formato padrão formato destino conversão é especificada para um conjunto pré-definido de tipos de dados.

17 rpcgen - funcionamento procedimentos servidores programa servidor prog_proc.c stub servidor cc prog_svc prog_svc.c especificação RPC prog.x rpcgen prog.h biblioteca RPC cliente rprog.c prog_clnt.c stub cliente cc programa cliente rprog

18 rpcgen Exemplo de arquivo de especificação: /* date.x especificação de serviços remotos de data e hora */ program DATE_PROG{ version DATE_VERS{ long BIN_DATE(void) = 1; string STR_DATE(long) = 2; = 1; = 0x ;

19 passo 1: projetar uma aplicaçao convencional main proxima insere remove busca inicializar

20 passo 2: dividir o programa em duas partes Cliente main Chamadas a Procedimentos Remotos inicializar Programa Remoto proxima insere remove busca Banco de Dados

21 passo 3: criar uma especificação rpcgen /* rbd.x especificação rpc para um programa de banco de dados que oferece os procedimentos INSERE, REMOVE e BUSCA */ struct example { /* estrutura não usada, declarada para ilustrar como rpcgen */ int exfield1; /* constrói rotinas XDR para converter estruturas */ char exfield2; ; program RBDPROG{ /* nome do programa remoto */ version RDBVERS{ /* declaração da versão */ int INICIALIZAR(void) = 1; /* primeiro procedimento deste programa */ int INSERE(string) = 2; /* segundo procedimento deste programa */ int REMOVE(string) = 3; /* terceiro procedimento deste programa */ int BUSCA(string) = 4; /* quarto procedimento deste programa */ = 1; /* definição da versão do programa */ = 0x ; /* número do programa remoto (deve ser único) */

22 passo 4: rodar o rpcgen rpcgen rbd.x rdb_svc.c rpcgen rdb.h rdb_clnt.c rdb_xdr.c

23 rpcgen arquivo.h /* rbd.h */ struct example { int exfield1; char exfield2; ; typedef sruct example example; bool_t xdr_example(); #define RBDPROG (u_long) 0x ) #define RDBVERS ((u_long) 1) #define INICIALIZAR ((u_long) 1) extern int *inicializar_1(); #define INSERE ((u_long) 2) extern int *insere_1(); #define REMOVE ((u_long) 3) extern int *remove_1(); #define BUSCA ((u_long) 4) extern int *busca_1();

24 rpcgen arquivo de conversão XDR /* rbd_xdr.c */ #include <rpc/rpc.h> #include rbd.h bool_t xdr_example(xdrs, objp) XDR *xdrs; example *objp; { if (!xdr_int(xdrs, &objp->exfield1)) { return(false); if (!xdr_char(xdrs, &objp->exfield2) { return(false); return(true);

25 rpcgen stub do cliente /* rbd_clnt.c */ #include <rpc/rpc.h> #include rbd.h int * inicializar_1(argp, clnt) void *argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, INICIALIZAR, xdr_void, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res); int *insere_1(argp, clnt) char **argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, INSERE, xdr_wrapstring, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res); int * remove_1(argp, clnt) char **argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, REMOVE, xdr_wrapstring, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res); int *busca_1(argp, clnt) char **argp; CLIENT *clnt; { static int res; bzero((char *)&res, sizeof(res)); if (clnt_call(clnt, BUSCA, xdr_wrapstring, argp, xdr_int, &res, TIMEOUT)!= RPC_SUCCESS) return (NULL); return (&res);

26 /* rbd_svc.c */ #include <rpc/rpc.h> #include rbd.h rpcgen stub do servidor svc_run(); (void)fprintf( SVC_RUn retornado \n ); exit(1); static void rbdprog_1(); main() { SVCXPRT *transp; (void)pmap_unset(rbdprog, RBDVERS); transp = svcudp_create(rpc_anysock); if (transp == NULL) { (void) fprintf( Não pode criar serviço udp\n ); exit(1); if (!svc_register(transp, RBCPROG, RBDVERS, rbdprog_1, IPPROTO_UDP)) { (void) fprintf( Não pode registrar tal prog.\n ); exit(1); transp = svctcp_create(rpc_anysock, 0, 0); if (transp == NULL) { (void) fprintf( Não pode criar serviço TCP\n ); exit(1); if (!svc_register(transp, RBCPROG, RBDVERS, rbdprog_1, IPPROTO_TCP)) { (void) fprintf( Não pode registrar tal prog.\n ); exit(1); static void rbdprog_1(rqstp, transp) struct svc_req *rqstp; SVCXPRT *transp; { union { char *insere_1_arg; char *remove_1_arg; char *busca_1_arg; argument; char *result; bool_t (*xdr_argument) (), (*xdr_result)(); char *(*local)(); switch (rqstp->rq_proc) { case NULLPROC: ( void)svc_sendreply(transp, xdr_void,(char *) NULL); return; case INICIALIZAR: xdr_argument = xdr_void; xdr_result = xdr_int; local = (char *(*)())inicializar_1; break; case INSERE: xdr_argument = xdr_wrapstring; xdr_result = xdr_int; local = (char *(*)()) insere_1; break;

27 rpcgen continuação stub do servidor case REMOVE: xdr_argument = xdr_wrapstring; xdr_result = xdr_int; local = (char *(*)())remove_1; break; case BUSCA: xdr_argument = xdr_wrapstring; xdr_result = xdr_int; local = (char *(*)()) busca_1; break; default: svcerr_noproc(transp); return; bzero((char*)&argument, sizeof(argument)); if (!svc_getargs(transp, xdr_argument, &argument)) { svcerr_decode(transp); return; result = (*local)(&argument, rqstp); if (result!= NULL &&!svc_sendreply(transp, xdr_result, result )) { svcerr_systemerr(transp); if (!svc_freeargs(transp, xdr_argument, &argument)) { (void)fprintf( Problema nos argumentos\n ); exit(1);

28 passo 5: escrever procedimentos de interface com o stub Rotinas de Interface do Cliente /* rbd_cif.c - inicializar, insere, remove, busca */ #include <rpc/rpc.h> #include rbd.h extern CLIENT *handle; /* handle para procedimento remoto */ int inicializar() { return *inicializar_1(handle); int insere(item) char *item; { char **arg; arg = &item; return *insere_1(arg, handle); int remove(item) char *item; { char **arg; arg = &item; return *remove_1(arg, handle); int busca(item) char *item; { char **arg; arg = &item; return *busca_1(arg, handle);

29 rotinas de interface do servidor /* rbd_sif.c - inicializar_1, insere_1, remove_1, busca_1 */ #include <rpc/rpc.h> #include rbd.h static int retcode; int *inicializar_1() { retcode = inicializar(); return &retcode; int *insere_1(i) char **i; { retcode = insere(*i); return &retcode; int *remove_1(i) char **i; { retcode = remove(*i); return &retcode; int *busca_1(i) char **i; { retcode = busca(*i); return &retcode;

30 passo 6: compilar e linkar o programa cliente cc -c rbd_cif.c rbd_cif.o cc -c rbd.c rdb.o cc -o rbd rbd.o rbd_clnt.o rbd_xdr.o rbd_cif.o

31 passo 7: compilar e linkar o programa servidor cc -c rbd_sif.c rbd_sif.o cc -c rbd_srp.c rdb_srp.o cc -o rbddaemon rbd_svc.o rbd_xdr.o rbd_sif.o rbd_srp.o

32 Programa Servidor /* rbd_srp.c - inicializar, insere, remove, busca*/ #include <rpc/rpc.h> #include rbd.h /* Procedimentos remotos do servidor e dados globais */ char bd[bdsize][maxword+1] /* armazena o dicionário de palavras */ int npalavras = 0; /* número de palavras no dicionário */ int inicializar() { npalavras = 0; return 1; int insere(palavra) char *palavra; { strcpy(bd[npalavras], palavra); npalavras++; return npalavras; int remove(palavra) char *palavra; { int i; for (i=0; i<npalavras; i++) if (strcmp(palavra, bd[i]) == 0) { npalavras--; strcpy(bd[i], bd[npalavras]); return 1; return 0; int busca(palavra) char *palavra; { int i; for (i=0; i<npalavras; i++) if (strcmp(palavra, bd[i]) == 0 ) return 1; return 0;

33 semântica de chamadas pelo menos uma vez no máximo uma vez exatamente uma vez relação com protocolo subjacente

34 binding amarração entre cliente e servidor reedita problema de localização de destinatário solução portmapper no Sun RPC em geral: chamada a servidor que detém: nome localização (IP, porta) estado e se nenhum servidor for localizado vários servidores forem localizados

35 dinamismo modelo apresentado exige conhecimento sobre interfaces antes da geração do programa cliente geração estática de stubs suficiente para maior parte das situações adaptação dinâmica servidores com diferentes otimizações cache otimização dependendo do estilo de uso do cliente chamada dentro de loop descoberta dinâmica de servidores relação com serviços de binding mais complexos

36 críticas sincronismo dificuldades de modelar outras formas de iteração, como pipes ou multicast dificuldades de tratamento de falhas

37 sincronismo processo que faz a chamada permanece bloqueado falta de interatividade local desperdício de uso da CPU processamento outras operações de comunicação

38 RPC e multithreading combinação de RPC com multithreading A A 1 2 B C sobreposição de computação e comunicação disparo de várias chamadas trocas de contexto preemptivas custo necessidade de sincronização

39 RPC assíncrona controle retorna imediatamente registravalor(novoval); em alguns casos, função de callback pode ser chamada qdo chamada se completa function funcb(v) globalval = v end obtemnovoval(args, funcb);

40 exemplo luarpc function request(peers) local acc, repl = 0, 0 local expected = table.getn(peers) function avrg (val) repl = repl+1 acc = acc + val if (repl==expected) then print ("Current Value: ", acc/repl) end end for _,p in ipairs (peers) do rpc.async(p, "currvalue", avrg)() end end

41 comunicação um a um como pensar em canais ou mailboxes onde processos espalhados por várias máquinas podem recolher chamadas? no caso de tolerância a falhas: às vezes desejável que os diversos processos recebam a mesma chamada replicação comunicação em grupo

42 tratamento de falhas como retornar informações sobre falhas no modelo de chamada remota? callbacks exceções

43 objetos distribuídos invocação remota de métodos objetos como unidades localizadas, argumentos, etc processo cliente o.main() or1.mx(ol1) or2.mz processo servidor ol1.ma () ol2.mm () or1.mx ol1.mb () ol1.mn () or2.my