4 - RMI 2014.ppt [Modo de Compatibilidade]disciplinas.ist.utl.pt/~leic-sod.daemon/2013-2014/teoricas_tagus/4b... · objecto é criado no processo receptor (pode ser no cliente ou

1

Page 1

Departamento de Engenharia Informática

CORBA

Sistemas Distribuídos 2013/14


CORBA

• Tem origem no Object Management Group

(OMG) criado em 1989

• Modelo Conceptual é uma síntese entre o

modelo cliente –servidor e as arquitecturas de

objectos

• A proposta original do Corba - Object

Management Architecture foi publicada em

1990 e continha:

– Serviços de suporte ao ciclo de vida dos objectos

– Object request broker


2

Page 2


Object Request Broker

• Novo paradigma proposto consistia num serviço que

auxilia a invocação de objectos remotos – (evolução do

run-time do RPC)

• O papel do ORB é localizar o objecto, activá-lo se

necessário, enviar o pedido do cliente ao objecto

ORB

AplicaçãoCliente

ServiçoRemoto(objecto)

Activar serviçoLocalizar objecto(serviço) Estabelecer

ligação

Comunic.



CORBA

• CORBA 2.0 publicado em 1996

• Os principais elementos da plataforma são:

– IDL – linguagem object oriented com suporte para herança

– Arquitectura – define o ambiente de suporte aos objectos, à

invocação, ao ciclo de vida

– GIOP – General Inter Orb Protocol – protocolo de invocação remota

entre Orb de fabricantes diferentes

– IIOP - Internet Inter Orb Protocol – implementação do GIOP sobre

protocolos TCP/IP

• Actualmente

– Actividade de normalização reduzida

– Vários produtos disponíveis

• Visigenic/Visibroker

• IONA

• Menos utilizado vs. plataformas J2EE / .net


3

Page 3


Modelo de Objectos

• Um objecto CORBA implementa uma interface descrita

na IDL CORBA

• Um objecto CORBA pode ser invocado remotamente

através de uma referência remota

• Os objectos CORBA residem no servidor

• Os clientes podem ser objectos ou programas que

enviam as mensagens correctas para os objectos

• Os objectos CORBA não têm de ser implementados

numa linguagem Object Oriented podem ser em Cobol,

C, etc.



Passagem de Parâmetros

• Todos os parâmetros cujo tipo é especificado

pelo nome de uma interface é uma referência a

um objecto CORBA e são passados como

referências a objectos remotos.

• Os argumentos do tipo primitivo ou estruturas

são passados por valor. Na chegada um novo

objecto é criado no processo receptor (pode ser

no cliente ou no servidor). Este mecanismo é

idêntico ao do RPC


4

Page 4


CORBA IDL

• A interface é escrita em OMG IDL

– A interface é object-oriented com sintaxe muito

semelhante ao C++

• A herança é suportada

– Especifica um nome de uma interface e um conjunto

de métodos que os clientes podem invocar

– Descreve os parâmetros e o respectivo sentido in,

out, inout

– Os métodos podem ter excepções



module Accounts

{

interface Account

{

readonly attribute string number;

readonly attribute float balance;

exception InsufficientFunds (string detail);

float debit (in float amount) raises (insufficientFunds);

float credit (in float amount);

}

interface InterestAccount : Account

{

readonly attribute float rate;

}

}

Exemplo da IDL CORBA

Herança


5

Page 5


Arquitectura

Implementationrepository

interfacerepository

Clientprogram Proxy

for AORBcore

client

or dynamic skeleton

object

adapter

ORBcore

server

skeleton

ServantA

Request

Reply

Or dynamic invocation



Elementos da Arquitectura

• ORB – núcleo – run-time da invocação remota, conjunto de

funções residentes quer no cliente quer no servidor

– Implementa a infra-estrutura de comunicação

– O ORB tem funções para ser inicializado e parado

• Servidor

– Object adapters - rotina de despacho que recebe as mensagens e

invoca os stubs apropriado

• O nome do object adapter faz parte da referência remota e permite a sua

invocação

• Despacha cada invocação via um skeleton para o método apropriado

– Skeletons

• Funções de adaptação que fazem a conversão dos parâmetros de entrada

e saída e o tratamento das excepções

• Client proxies

– Para as linguagens Object-oriented

– Efectua a conversão dos parâmetros de entrada e de saídaSistemas Distribuídos 2013/14

6

Page 6


Referências Remotas

• Para invocar uma operação remota é necessário que o objecto

invocador tenha uma referência remota para o objecto

• Uma referência remota pode ser obtida como

– Resultados de invocações remotas anteriores – a servidores ou ao

gestor de nomes

– Ter sido obtida como parâmetro de um invocação a um objecto local

• É diferente de binding handle estático dos RPC

IDL interface type name Protocol and address details Object key

interface repository

identifier

IIOP host domain

name

port number adapter name object nameIOR



Invocação

• A invocação do método tem por omissão uma

semântica at-most-once

• A heterogeneidade é resolvida com a conversão

para CDR – Common Data Representation

– Inclui 15 tipos básicos

– Receiver makes it right


7

Page 7


index in

sequence of bytes

notes

on representation

0-3

4-7

8-11

12-15

16-19

20-23

24-27

5

“Smit”

“h____”

6

“Lond”

“on____”

1934

4 bytes

length of string

“Smith”

length of string

London

unsigned long

Struct Pessoa {

string Nome;

string Lugar;

unsigned long Ano;

};

Representa a struct Person com os valores: {‘Smith’, ‘London’, 1934}

CORBA CDR



Elementos da Arquitectura: Servidor de

Interfaces

• Interface repository

– Dá informação sobre as interfaces registadas

– Para uma interface pode dar a informação dos

métodos e dos respectivos parâmetros

– O compilador de IDL atribui um número único a cada

tipo IDL que compila. Esta facilidade permite a

invocação dinâmica em CORBA.

– Se um cliente recebe uma referência remota para

um novo objecto CORBA de que não tem um proxy,

pode ir buscar esta informação ao Interface

repository


8

Page 8


Elementos da Arquitectura: servidor do

código das implementações

• Implementation repository

– Contém localização das implementações dos

objectos

– Permite ao object adapter carregar o código das

classes para instanciar os respectivos objectos



CORBA – Invocação Dinâmica

• Para dinamicamente invocar um objecto em tempo de execução existe a invocação dinâmica

• O cliente não precisa de ter os proxies – As invocações remotas são construídas dinamicamente

– Novos servidores podem ser usados por clientes já existentes

• Funcionamento– O Cliente usa o Interface Repository para obter a informação sobre os

métodos e argumentos.

– Cria a mensagem de acordo com a especificação da interface, e envia o pedido para o respectivo objecto.

Account_ptr acc = ...; // Obter ref para objecto Account

acc.credit( 100 ); // Invoc. estática

CORBA::Object_ptr obj = ...;

CORBA::Request_ptr req = obj.request( “credit" );

req.add_in_arg( "amount" ) <<= (CORBA::ULong) 100;

req->invoke();

Invocação DinâmicaSistemas Distribuídos 2013/14

9

Page 9


Invocação

dinâmica

• Obter a referência para o método

• Obter a lista de parâmetros

• Criar a mensagem de invocação

• Invocar – várias alternativas




10

Page 10


.NET Remoting

Equivalente ao RMI para C# na plataforma .NET.

Vamo-nos concentrar nas novas opções fornecidas



Objectos Remotos

• Qualquer objecto pode ser usado remotamente derivando-o

de MarshalByRefObject ou de MarshalByValObject

• MarshallByValue

– Objectos serializáveis, são copiados para o cliente

– Pode ser muito ineficiente

• MarshallByRef

– Quando o cliente recebe uma referência de um objecto remoto é uma

referência a um objecto proxy local criado automaticamente pelo .NET

Remoting.


11

Page 11


Utilização de Objectos Remotos

• Requer a respectiva activação. Dois modos:

• Singleton

– Apenas uma instância em cada instante

– Criada aquando da primeira invocação

– Requer sincronização no acesso a estado partilhado

• SingleCall

– Uma nova instância é criada para cada pedido.

– Após a execução de uma chamada, a próxima chamada será

servida por outra instância.



Tempo de Vida dos Objectos

• Tempo de vida dos objectos Singleton

determinado por sistema de leases.

– Ao expirar um lease, este deve ser renovado, caso

contrário a memória ocupada pelo objecto é

recuperada pelo garbage collector.

Java RMI escolheu solução mais complexa: contagem de referência distribuída.

Problema: falhas na rede e nos servidores?

Java RMI usa adicionalmente leases para tolerar falhas


12

Page 12


Canais

• A comunicação entre dois processos distintos é realizada através de canais, cuja função é:

– Empacotar a informação de acordo com um tipo de protocolo

– Enviar esse pacote a outro computador.

• Dois tipos pré-definidos:

– TcpChannel (que envia os dados por TCP em formato binário).

– HttpChannel (que utiliza o protocolo HTTP em formato XML).

• Maior flexibilidade do que no RMI na escolha dos mecanismos de serialização e protocolos de transmissão


Resumo das Opções

• MarshallByRef vs. MarshallByValue

• Canais – TcpChannel vs. HttpChannel vs.

Custom

• Activação – Singleton vs. Single Call

• Tempo de vida – Single Call vs. Leases


13

Page 13


Exemplo: Interface

public interface Account {

float debit(float amount);

float credit(float amount);

}

public interface AccountList {

Account getAccount(int id);

}



Exemplo: Servidorclass bankServer : MarshalByRefObject, accountList {

ArrayList acList;

public bankServer () {...}

public Account getAccount(int id) {

return acList[id];

}

static void Main() {

TcpChannel chan1 = new TcpChannel(8086);

ChannelServices.RegisterChannel(chan1);

RemotingConfiguration.RegisterWellKnownServiceType(typeof(bankServer),

“accountList", WellKnownObjectMode.Singleton);

System.Console.WriteLine("<enter> para sair...");

System.Console.ReadLine();

}

}


14

Page 14


Exemplo: Cliente

class cl {

static void Main() {

TcpChannel chan = new TcpChannel();

ChannelServices.RegisterChannel(chan);

accountList acList =

(accountList) Activator.GetObject(typeof(accountList),

"tcp://localhost:8086/accountList");

if (acList == null)

System.Console.WriteLine("Could not locate server");

else {

Account a = acList.getAccount(2);

Console.WriteLine(a.debit(1000));

}

}



Comparação – IDL

C#/Remoting – IDL CORBA - IDL Java/RMI - Interface definition

using System;

namespace SimpleStocks

{

public interface StockMarket {

float get_price(string symbol);

}

module SimpleStocks

{

interface StockMarket

{

float get_price(in string symbol);

};

};

package SimpleStocks;

import java.rmi.*;

import java.util.*;

public interface StockMarket extends

java.rmi.Remote

{

float get_price( String symbol)

throws RemoteException;

}


15

Page 15



C# / Remoting - Server implementation CORBA - Server implementation Java/RMI - Server implementation

//

//

// StockMarketServer

//

//

using System.Runtime.Remoting;

public class StockMarketImpl :

MarshalByRefObject,

SimpleStocks.StockMarket

{

public float get_price( string symbol

)

{

float price = 0;

for( int i = 0; i < symbol.length();

i++ )

{

price += (int) symbol.charAt(i);

}

price /= 5;

return price;

}

}

//

//


//

//

import org.omg.CORBA.*;

import SimpleStocks.*;

public class StockMarketImpl extends

_StockMarketImplBase

{

public float get_price( String symbol

)

{

float price = 0;

for(int i = 0; i < symbol.length();

i++)

{

price += (int) symbol.charAt( i );

}

price /= 5;

return price;

}

public StockMarketImpl( String name )

{

super( name );

}

}

//

//


//

//

package SimpleStocks;

import java.rmi.*;

import

java.rmi.server.UnicastRemoteObject;

public class StockMarketImpl extends

UnicastRemoteObject implements

StockMarket

{

public float get_price( String symbol

)

{

float price = 0;

for( int i = 0; i < symbol.length();

i++ )

{

price += (int) symbol.charAt( i );

}

price /= 5;

return price;

}

public StockMarketImpl( String name )

throws RemoteException

{

try

{

Naming.rebind( name, this );

}

catch( Exception e )

{

System.out.println( e );

}

}

}



C# / Remoting - Server Main CORBA - Server Main Java/RMI - Server Main

//

//

// StockMarketServer Main

//

//

using System.Runtime.Remoting;

class StockMarketServer

{

static void Main(string[] args)

{

TcpChannel chan1 = new

TcpChannel(8086);

ChannelServices.RegisterChannel

(chan1);

RemotingConfiguration.RegisterWel

lKnownServiceType(typeof(StockMar

ket),“NASDAQ",WellKnownObjectMode

.Singleton);

System.Console.WriteLine("<enter>

para sair...");

System.Console.ReadLine();

}

}

//

//


//

//


import org.omg.CosNaming.*;


public class StockMarketServer

{

public static void main(String[] args)

{

try

{

ORB orb = ORB.init();

BOA boa = orb.BOA_init();

StockMarketImpl stockMarketImpl = new

StockMarketImpl("NASDAQ");

boa.obj_is_ready( stockMarketImpl );

org.omg.CORBA.Object object =

orb.resolve_initial_references("NameSer

vice");

NamingContext root =

NamingContextHelper.narrow( object ) ;

NameComponent[] name = new

NameComponent[1];

name[0] = new NameComponent("NASDAQ",

"");

root.rebind(name, stockMarketImpl);

boa.impl_is_ready();

}

catch( Exception e )

{

e.printStackTrace();

}

}

}

//

//


//

//

import java.rmi.*;

import

java.rmi.server.UnicastRemoteObject;


public class StockMarketServer

{

public static void main(String[] args)

throws Exception

{

if(System.getSecurityManager() == null)

{

System.setSecurityManager(new

RMISecurityManager());

}

StockMarketImpl stockMarketImpl = new

StockMarketImpl("NASDAQ");

}

}

16

Page 16


C# / Remoting - Client implementation CORBA - Client implementation Java/RMI - Client implementation

//

//

// StockMarketClient

//

//

namespace SimpleStocks

{

public class StockMarketClient

{

static void Main()

{

try {

StockMarket market =

(StockMarket)Activator.GetObject(

typeof(StockMarket),

“tcp://localhost:8086/NASDAQ”);

System.Console.WriteLine("The price

of MY COMPANY is " +

market.get_price("MY_COMPANY") );

}

}

//

//


//

//


import org.omg.CosNaming.*;



{

public static void main(String[]

args)

{

try

{

ORB orb = ORB.init();

NamingContext root =

NamingContextHelper.narrow(

orb.resolve_initial_references("NameS

ervice") );

NameComponent[] name = new

NameComponent[1] ;

name[0] = new

NameComponent("NASDAQ","");


StockMarketHelper.narrow(root.resolve

(name));

System.out.println("Price of MY

COMPANY is " +

market.get_price("MY_COMPANY"));

}

catch( SystemException e )

{

System.err.println( e );

}

}

}

//

//


//

//

import java.rmi.*;

import java.rmi.registry.*;



{

public static void main(String[]

args)throws Exception

{

if(System.getSecurityManager() == null)

{

System.setSecurityManager(new

RMISecurityManager());

}


(StockMarket)Naming.lookup("rmi://local

host/NASDAQ");

System.out.println( "The price of MY

COMPANY is "

+ market.get_price("MY_COMPANY") );

}

}


Documents

4 - RMI 2014.ppt [Modo de Compatibilidade]disciplinas.ist.utl.pt/~leic-sod.daemon/2013-2014/teoricas_tagus/4b... · objecto é criado no processo receptor (pode ser no cliente ou