Sistemas Distribuídos

RPC – Remote Procedure Call

Fonte: Alcides Calsavara e Thais V. Batista

1

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

Kernel Kernel

cliente servidor

empacota

parâmetro

s

desempacota

resultados

desempacota

parâmetros

empacota

resultados

transporte de mensagens

via rede

12

3

4

0 56

7

8

9

1011

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

Implementado RPC em Java

através do NetBeans - passos• 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:

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

}

@Override

public String frase(String frase) throws RemoteException{

return("Servidor retornou sua frase: "+ frase);

}

//***************************************************************

}

17

Implementado RPC em Java

através do NetBeans - passos• 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ção18

Implementado RPC em Java

através do NetBeans - passos• Passos:

4. Escreva o superclasse do servidor que implementa a interface,

inicializado, antes, o registro do RMI (rmiregistry) - continuação:

try {

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

Implementado RPC em Java

através do NetBeans - passos• 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

Implementado RPC em Java

através do NetBeans - passos• 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

do NetBeans ao professor.21

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