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
• 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
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
Top Related