Sistemas Distribuídos RPC Remote Procedure Call 1 Fonte: Alcides Calsavara e Thais V. Batista
Chamada de Procedimentos Remotos (RPC) Motivação: comunicação baseada em operações de entrada/saída Ideal: programar um sistema distribuído como se fosse centralizado RPC objetiva permitir chamada de procedimento remoto como se fosse local, ocultando entrada/saída de mensagens 2
Visão geral Um processo A chama um procedimento p de um processo B, entrando em estado de espera O processo B passa a executar o procedimento p, e ao seu término faz um reply para o processo A O processo A volta à sua execução normal após ter recebido o reply 3
Chamadas e mensagens em RPC Máquina do Cliente Máquina do Servidor 2 4 1 empacota 0 desempacota 5 parâmetro parâmetros s desempacota empacota 11 7 resultados resultados 10 8 cliente 6 servidor Kernel Kernel 3 9 transporte de mensagens via rede 4
Stubs Definição: São partes (fragmentos) de códigos que provêm a abistração de uma chamada (local) de procedimento, através de um método, fazendo a ligação deste com o mecanismo de comunicação. O stub é parte do código que faz a chamada remota, é utilizado no cliente e no servidor. Funções dos stubs: Cliente stub (passo 1) intercepta a chamada empacota os parâmetros (marshalling) envia mensagem de request ao servidor (através do núcleo) Servidor stub (passo 2) recebe a mensagem de request (através do núcleo) desempacota os parâmetros (unmarshalling) chama o procedimento, passando os parâmetros empacota o resultado envia mensagem de reply ao cliente (através do núcleo) Cliente stub (passo 3) recebe a mensagem de reply (através do núcleo) desempacota o resultado passa o resultado para o cliente 5
Falhas em RPC O cliente não é capaz de localizar o servidor A mensagem de request do cliente para o servidor é perdida A mensagem de reply do servidor para o cliente é perdida O servidor pára após ter recebido a mensagem de request O cliente pára após ter enviado a mensagem de request 6
Falha do servidor Passos normais: recebe mensagem de request executa procedimento envia mensagem de reply Falha pode ocorrer: após a execução antes da execução Semânticas de chamada: pelo menos um no máximo um exatamente um 7
Implementação de RPC em Java Java RMI Java Remote Method Invocation (RMI) é um protocolo Java para comunicação entre processos Permite objetos Java invocar transparentemente métodos de outros objetos (que podem estar em máquinas diferentes objetos remotos) Java RMI libera o programador de tratar de detalhes como endereçamento e codificação decodificação de mensagens 8
Implementação de RPC em Java RPC Implementação em Java Stubs do lado do cliente: Stubs Stubs do lado do servidor: Skeleton 9
Implementação de RPC em Java Compilador rmic recebe como entrada a descrição dos métodos remotos gera dois arquivos: Stub e Skeleton. 10
Implementação de RPC em Java Localização de Objetos Remotos Seria impraticável se para cada invocação de método remoto fosse necessário incluir o par (máquina,porta) para identificar onde se encontra o objeto que contém o método O RMI oferece um Serviço de Nomes (RMI Registry) que oferece informações sobre a localização de objetos remotos. o rmiregistry executa em um endereço bem conhecido. 11
Implementação de RPC em Java RMI Registry 12
Implementação de RPC em Java O modelo RMI: O servidor define objetos que o cliente pode usar remotamente Os clientes podem invocar métodos nesse objeto remoto como se ele estivesse executando localmente. O RMI esconde o mecanismo subjacente de transporte, via rede, de argumentos dos métodos e valores de retorno. 13
Implementação de RPC em Java O modelo RMI: 14
Implementado RPC em Java através do NetBeans Com o NetBeans fica mais fácil implementar RPC com RMI, visto que o processo de compilação dos objetos e interfaces RMI, que pela linha de comando, seria feita com o comando rmic (para obter stub e skeleton), serão feitos de forma transparente pela interface de desenvolvimento. À seguir, os passos para implementação do RPC com Java RMI através de um exemplo simples. 15
Passos: Implementado RPC em Java através do NetBeans - passos 1. Crie, em um novo projeto, no NetBeans, o pacote RPC_RMI e nele, a classe RPC_RMI_Servidor.java 2. Defina a interface do servidor, estendendo a interface java.rmi.remote, bem como a declaração dos métodos a serem invocados pelo cliente, via RPC: interface RPC_RMI_ServidorInterface extends Remote{ //*** Declaração dos métodos implementados em RPC_RMI_ServidorInterfaceImpl public double somar(double a, double b) throws RemoteException; public double multi(double a, double b) throws RemoteException; public String frase(string frase) throws RemoteException; //***************************************************************** 16
Implementado RPC em Java através do NetBeans - passos Passos: 3. Crie a classe que implementa os métodos a serem invocados via RPC: @Override public String frase(string frase) throws RemoteException{ return("servidor retornou sua frase: "+ frase); //*************************************************************** class RPC_RMI_ServidorInterfaceImpl extends UnicastRemoteObject implements RPC_RMI_ServidorInterface{ public RPC_RMI_ServidorInterfaceImpl() throws RemoteException{ // construtor padrão // *** Criação dos métodos públicos a serem utilizados tanto pelo @Override public double somar(double a, double b) throws RemoteException{ return(a + b); @Override public double multi(double a, double b) throws RemoteException{ return(a * b); 17
Passos: Implementado RPC em Java através do NetBeans - passos 4. Escreva o superclasse do servidor que implementa a interface, inicializado, antes, o registro do RMI (rmiregistry): //Classe principal, registrada com o RMI server public class RPC_RMI_Servidor { public static void main(string[] args) { //inicia o rmiregisgtry, essencial para aplicações RPC com RMI try { java.rmi.registry.locateregistry.createregistry(1099); System.out.println("RMI registry iniciado!"); catch (Exception e) { System.out.println("Exception starting RMI registry:"); e.printstacktrace(); //fim da inicialização 18
Passos: Implementado RPC em Java através do NetBeans - passos try { 4. Escreva o superclasse do servidor que implementa a interface, inicializado, antes, o registro do RMI (rmiregistry) - continuação: /* instancia a interface remota para ser utilizada * localmente ou pelo RPC */ RPC_RMI_ServidorInterface csi = new RPC_RMI_ServidorInterfaceImpl(); //**************************************************** //Referencia o Registro do RMI (RMI Registry) Registry registry = LocateRegistry.getRegistry(); registry.rebind("calculadoraserverinterfaceimpl", csi); //*********************************************** //captura a ID/IP do servidor InetAddress hostaddress = InetAddress.getLocalHost(); System.out.println("Servidor Calculadora " + csi + " registrado e pronto para aceitar solicitações."); System.out.println("IP do Servidor: "+ hostaddress); catch (Exception ex) { System.out.println("Houve um erro: " + ex.getmessage()); 19
Passos: Implementado RPC em Java através do NetBeans - passos 5. Crie, no atual projeto e no pacote RPC_RMI, a classe RPC_RMI_Cliente.java: public class RPC_RMI_Cliente { public static void main(string[] args) { try { //referenciando o IP do servidor Registry registry = LocateRegistry.getRegistry("localhost"); //instanciando a interface remota RMI RPC_RMI_ServidorInterface c = (RPC_RMI_ServidorInterface) registry.lookup("rpc_rmi_servidorinterfaceimpl"); //RPC_RMI_ServidorInterfaceImpl: ID do RMI registry System.out.println("O objeto servidor " + c + " foi encontrado com sucesso.\n"); System.out.println("A soma de 2 + 5 (chamada pelo cliente, via RPC) é: " + c.somar(2, 5)); System.out.println("A multiplicação de 2 * 5 (chamada pelo cliente, via RPC) é: "+ c.multi(2,5)); System.out.println(c.frase("Calculadora Cliente com RPC através do RMI")); catch(exception ex){ System.out.println(ex); 20
Passos: Implementado RPC em Java através do NetBeans - passos 6. Compile e execute o programa servidor (o rmiregistry tem de estar executando. O mesmo já está, pois inicializamos rmregristry no próprio código fonte do servidor, evitando ter de chamá-lo via linha de comando) 7. Execute o cliente OBS: Para ter acesso completo ao código, bem como as bibliotecas utilizadas, solicite projeto 21 do NetBeans ao professor.
Implementado RPC em Java através do NetBeans - Trabalho Definições: Cada grupo deverá criar (não copiar de terceiros) uma aplicação, utilizando interface gráfica, que permita a comunicação e troca de mensagens entre cliente e servidor (ex: chat, quiz, sistema de correção de provas, etc), utilizando Sockets ou RPC, em Java. A aplicação de cada grupo deverá ser totalmente diferente da aplicação dos outros grupos. Cada parte de código, dicas, métodos, etc que forem de terceiros deverão ser referenciados, via cometário, indicando exatamente a URL onde tal código se encontre, sob pena de ter seu trabalho anulado. Lembrem-se que a sua aplicação deverá ser desenvolvida ineiramente em Java. 22