Introdução à Arquitetura CORBA - Campus Rio Pomba

Introdução à
Arquitetura CORBA

Roteiro
Introdução à Arquitetura CORBA
Introdução
Visão Geral
Criando uma Aplicação CORBA

Introdução
Vamos nos mover momentaneamente do estudo dos
princípios para a construção de SDs para o estudo
de um paradigma de organização de SDs
Objetos Distribuídos
Paradigma importante
Fácil esconder aspectos de distribuição por trás da
interface do objeto
Paradigma poderoso
Objetos podem ser virtualmente qualquer coisa
Dois ambientes importantes
CORBA
DCOM

Introdução
CORBA (Common Object Request Broker
Architecture)
Arquitetura padrão criada pelo Object Management
Group (OMG) para estabelecer e simplificar a troca de
dados entre componentes de um sistema distribuído
heterogêneo
OMG criada em 1989
Foco: interoperabilidade e portabilidade de aplicações
distribuídas orientadas a objetos
Mais de 800 filiados: IBM, Microsoft, Hewlett­Packard,
SunSoft...
Primeiro padrão lançado em 1990
Atualmente na versão 3.0

Introdução
OMG define especificações
Criadas com idéias e tecnologia dos filiados
Empresas desenvolvem produtos baseados
nas especificações
O modelo de objeto especificado através
da OMA (Object Management Architecture)
OMA define facilidades necessárias para a
criação de um ambiente distribuído
orientado a objeto

Visão Geral
Objetos da
Aplicação
Facilidades
Verticais
(Específicas do
Domínio)
Facilidades
Horizontais
(Propósito
Geral)
Object Request Broker
Serviços
Comuns aos
Objetos

Visão Geral
Object Request Broker
Principal componente da OMA
Permite transparência para a localização,
ativação e comunicação entre objetos
Módulo intermediário entre cliente e objeto
Responsável por:
Aceitar a requisição do cliente
Enviá-la para o objeto responsável por atendê-la e
Entregar resposta ao cliente

Visão Geral
Object Request Broker
Processo de tradução e transferência de
parâmetros e resultados transparente aos clientes
Mesmo que módulos usem linguagens de programação
diferentes, rodem em máquinas com arquiteturas e SOs
diferentes
Clientes não precisam saber em que parte da rede
os objetos estão localizados, como são
implementados, como executam, etc.
Arquitetura de interface definida de modo a
separar conceitos de interface e implementação.

Visão Geral
Objetos construídos como parte de aplicações
específicas
Facilidades CORBA
Construídas como composição de serviços
CORBA
Horizontais: serviços de alto nível de propósito
geral, que são independentes do domínio da
aplicação
Gerenciamento de informação, do sistema e de
tarefas
Verticais: serviços de alto nível desenvolvidos
especificamente para um domínio de aplicação
Comércio eletrônico, bancário, manufaturas...

Modelo de Objetos
CORBA usa modelo de objetos remotos
Implementação do objeto reside no espaço de
endereçamento do servidor
Especificação não afirma que objetos devem
ser implementados apenas como objetos
remotos
Entretanto, virtualmente todos os sistemas CORBA
suportam apenas este modelo
Objetos e serviços CORBA especificados
com IDL (Interface Definition Language)
Linguagem de Definição de Interface

Modelo de Objetos
IDL
Similar a outras linguagens de definição de
interface
Provê sintaxe precisa para a definição de métodos
e parâmetros
NÃO descreve semântica
Sintaxe semelhante ao C++ (e portanto Java)
IDL providencia tipos de dados básicos (short,
long, float, double e Boolean), estruturas (como
struct e union) e templates (como sequence)
Interface de um objeto definida independentemente
da linguagem de programação

Modelo de Objetos
Linguagem de Definição de Interface (IDL)
Compilador IDL traduz construções da
linguagem IDL para a linguagem alvo
C, C++, Ada, Java, Smalltalk, COBOL
Basicamente dois arquivos gerados: o stub do
cliente e do servidor
Contém as classes necessárias para a
execução de chamadas estáticas

Modelo de Objetos

Modelo de Objeto
ORB
Suporte ao cliente e ao servidor
Sistema de tempo de execução
Lida com comunicação entre cliente e servidor
Encontra serviços disponíveis
Oferece suporte para encontrar referências iniciais
para objetos implementando serviços CORBA
Proxy
Oferece mesma interface que servidor
Recebe requisição do cliente e a repassa ao
servidor
Resposta do servidor repassada ao cliente

Modelo de Objeto
Nem sempre definições de interfaces
disponíveis aos clientes estaticamente
Serviço necessário para buscar interface em
tempo de execução
Com interface, requisição pode ser montada
dinamicamente
Dynamic Invocation Interface (DII) ou interface
de invocação dinâmica

Modelo de Objetos
Interface de Invocação Dinâmica (DII)
Interpreta, em tempo de execução, parâmetros
necessários às chamadas
Várias sub­chamadas são feitas:
Obtenção da interface do objeto;
Obtenção de informações sobre operações suportadas pelo
objeto;
Criação do objeto solicitado pelo cliente;
Obtenção de cada argumento necessário para a chamada do
método;
Solicitação para a execução de um método do objeto.
Mais eficiente fazer chamadas através de stubs IDL
estáticos

Modelo de Objetos
Adaptador de objetos (OA)
Encaminha requisição para objeto correto
Parâmetros são retirados (unmarsharling)
por stub, chamado skeleton em CORBA
Também possível que este papel seja
desempenhado pela implementação do objeto
Assim como no caso do cliente, stubs do
servidor podem ser estáticos (IDL) ou
dinâmicos
Dynamic Skeleton Interface

Modelo de Objetos
Juntando os componentes
Cada objeto possui uma interface IDL padrão
Aplicação cliente pode invocar uma operação:
Estaticamente, através de stubs IDL
Dinamicamente, usando o stub de chamada
dinâmica e o repositório de interfaces
Pedido passa para o ORB
Utiliza referência do objeto para localizar
implementação
Entrega pedido ao adaptador de objetos
responsável por aquele objeto.

Modelo de Objetos
Juntando os componentes
Adaptador de objetos transfere a requisição
para o “esqueleto” gerado pelo compilador IDL
do lado do servidor
Finalmente passado a implementação do objeto
Qualquer valor de retorno é passado de volta
ao “esqueleto” e ao adaptador de objetos e em
seguida para o núcleo ORB
Dependendo da origem da chamada, núcleo
ORB retorna os valores para o cliente, via stub
IDL ou stub de chamada dinâmica

Criando uma aplicação CORBA
Passos:
1. Definir interface utilizando IDL
2. Compilar interface usando um compilador IDL
3. Implementar a aplicação servidora
Implementação do método
Iniciação do processo na máquina
Registro no ORB em tempo de execução
4. Criar a aplicação cliente

Criando uma aplicação CORBA
(1 e 2)
module Counter {
interface Count {
attribute long sum;
long increment();
};
}
Compilação: idlj -fall Counter.idl

Criando uma aplicação CORBA
(3)
import Counter.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import java.util.Properties;
class CountImpl extends CountPOA {
private ORB orb;
private int sum;

Criando uma aplicação CORBA
(3)
}
public void setORB(ORB orb_val) { orb = orb_val; }
// implementacao da consulta do valor da variavel sum
public int sum() throws SystemException { return sum; }
// implementacao da atribuicao da variavel sum
public void sum(int val) throws SystemException { sum = val; }
// implementacao do metodo incremento
public int increment() throws SystemException {
}
sum++;
return sum;

Criando uma aplicação CORBA
(3)
import Counter.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
public class CountServer {
public static void main(String args[]) {
try{
// cria e inicia o ORB
ORB orb = ORB.init(args, null);
// consegue referencia para rootpoa e ativa o gerente POA
POA rootpoa =
POAHelper.narrow(orb.resolve_initial_references("RootPOA"));

Criando uma aplicação CORBA
(3)
rootpoa.the_POAManager().activate();
// cria objeto servidor e o registra no ORB
CountImpl countImpl = new CountImpl();
countImpl.setORB(orb);
// consegue referencia para servidor
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(countImpl);
Count href = CountHelper.narrow(ref);
// consegue referencia para o contexto de nomes raiz
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
// Usa NamingContextExt, que eh parte do servico de nomes
// interoperaceis
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);

Criando uma aplicação CORBA
(3)
// liga a referencia para objeto ao nome
String name = "Count";
NameComponent path[] = ncRef.to_name( name );
ncRef.rebind(path, href);
System.out.println("CountServer pronto e aguardando requisicoes ...");
// aguarda invocacoes
orb.run();
}
catch (Exception e) {
System.err.println("ERROR: " + e);
e.printStackTrace(System.out);
}
System.out.println("CountServer saindo ...");
}
}

Criando uma aplicação CORBA
(4)
import Counter.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
public class CountClient{
static Count counter;
public static void main(String args[]) {
try{
// cria e inicia o ORB
ORB orb = ORB.init(args, null);
// pega o contexto de nomes raiz
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");

Criando uma aplicação CORBA
(4)
// Usa classe NamingContextExt ao inves de NamingContext.
// Esta eh parte do servico de nomes interoperavel
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// resolve a referencia para o objeto (veja topico Nomes)
String name = "Count";
counter = CountHelper.narrow(ncRef.resolve_str(name));
System.out.println("Referencia para objeto obtida: " + counter);
System.out.println("Atribuindo 0 a sum");
counter.sum((int)0);

Criando uma aplicação CORBA
(4)
// Incrementando 1000 vezes
System.out.println("Aguarde... Incrementando 1000 vezes!");
for (int i = 0 ; i < 1000 ; i++ ){ counter.increment(); }
System.out.println("Valor de Sum => " + counter.sum());
} catch(Exception e) {
System.err.println("System Exception");
System.err.println(e);
}
}
}

Criando uma aplicação CORBA
Compilar os códigos fontes
javac *.java Counter/*.java
Iniciar o serviço ORD:
orbd -ORBInitialPort 2050 -ORBInitialHost localhost
Iniciar servidor:
java CountServer -ORBInitialPort 2050
-ORBInitialHost localhost
Iniciar o cliente:
java CountClient -ORBInitialPort 2050
-ORBInitialHost localhost
Se todos forem executados na mesma máquina, não
precisa suar opção -ORBInitialHost nomedoservidor

Próxima Aula
CORBA (cont.)
Repositório de Interface e Implementações
Facilidades CORBA
Comunicação
Nomes
Sincronização
Tolerância a Falhas
Segurança