Tutorial Corba 1

Tutorial Corba

Introdução

Este trabalho, tem como finalidade o desenvolvimento de um estudo mais detalhado de como a linguagem de programação Java utiliza a arquitetura CORBA (Commom Object Request Broker Arquiteture) e a interface IDL (Interaface Definiton Language) para desenvolvimento de aplicações Cliente / Servidor.

O que é CORBA?

O CORBA é um padrão que foi definido em 1991 pela OMG (Object Management Group), uma organização que reúne cerca de 800 empresas do mundo todo, inclusive gigantes como IBM, Digital, Oracle, Sun e Sybase. O padrão CORBA é um sistema que permite que aplicações distribuídas em uma rede (local ou mesmo na internet) comuniquem-se entre si e troquem informações. Estas aplicações podem estar sendo executadas em diferentes plataformas (Intel, Sun, etc) e sistemas operacionais (Windows, Linux, Unix, etc) e podem ter  sido construídas em diferentes linguagens de programação. Utilizando o padrão CORBA é possível ter aplicações completamente distribuídas, potencialmente com cada pedaço de software sendo executado em qualquer parte da rede e em qualquer plataforma, sem que o usuário perceba que isto está acontecendo e sem que o desenvolvedor precise se preocupar em criar soluções que resolvam os problemas de interoperabilidade entre os diferentes pedaços da aplicação. Atualmente, diversas ferramentas já suportam o padrão CORBA, como Delphi 4, JBuilder 2, Oracle 8i, Cold Fusion e C++ Builder. Uma grande vantagem de CORBA é ser um padrão diretamente suportado por empresas em todo o mundo e com dezenas de implementações disponíveis, incluindo algumas gratuitas.

Na prática, essa padronização significa que você não precisa ficar preso a determinados fornecedores, plataformas ou produtos, como acontece quando são escolhidas soluções proprietárias.

O que é o padrão ORB?  

O ORB é o middleware que estabelece os relacionamentos cliente-servidor entre os objetos. Utilizando um ORB, um cliente pode invocar transparentemente um método de um objeto no servidor, que pode estar na mesma máquina ou em qualquer ponto da rede. O ORB intercepta a chamada por parte do cliente e tem a responsabilidade: localizar  o objeto que implementa a chamada,passar os  parâmetros necessários a este objeto, fazer a chamada dos métodos e retornar dos resultados. O cliente, por sua vez, não precisa preocupar-se com a localização  do objeto que está sendo invocado, na que linguagem que o mesmo foi programado ou, mesmo, no sistema operacional que está sendo utilizado. Para o cliente a única coisa que importa é a interface. Ao realizar esta tarefa, o ORB oferece uma solução para a interoperabilidade entre aplicações em máquinas diferentes em ambientes distribuídos e heterogêneos, ao mesmo tempo que interconecta múltiplos sistemas baseados em objetos.

O segredo desta arquitetura reside na definição das interfaces, ou seja, na forma como os objetos vão interagir entre si e que serviços (métodos) estarão disponíveis. A correta definição das interfaces é, sem dúvida, o maior desafio desta arquitetura.  Geralmente, nas aplicações cliente-servidor clássicas, os desenvolvedores utilizam um protocolo próprio ou reconhecem um protocolo

Fabio Lopes Licht Fev/2002

Tutorial Corba 2

padrão para estabelecer a comunicação entre  módulos. A definição do protocolo depende da linguagem de implementação, do protocolo da rede e uma dezena de outros fatores. ORBs simplificam este processo. No caso do ORB, o protocolo é definido através da aplicação de interfaces através da IDL - Interface Definition Language uma implementação linguagem independente. O ORB na realidade oferece flexibilidade. Desenvolvedores tem a liberdade de escolher o sistema operacional, o ambiente de desenvolvimento e execução de cada um dos componentes que está sendo desenvolvido. Mais do que isto, através da utilização de ORBs é possível a integração de componentes já existentes.

Alguns Exemplos(O desenvolvimento dos exemplos que se seguem, bem como os compiladores utilizados, fazem parte do pacote do jdk 1.4 versão beta)

“Hello World” Transiente.

Definição de uma interface.A sintaxe utilizada para a IDL, é similar à utilizada em C++.

“Hello.idl”

1. module HelloApp2. {3. interface Hello4. {5. string sayHello();6. oneway void shutdown();7. };8. };

A linha 1 “module HelloApp” especifica um diretório, que será criado, e onde após a compilação com o comando “idlj -fall Hello.idl” , serão criados os arquivos-fonte:

HelloPOA.java – Esta classe abstrata é baseada no esqueleto do servidor. Extende org.omg.PortableServer.Servant, e implementa a interface InvokeHandler e a interface HelloOperations. A classe de servidor, HelloServant, extende HelloPOA

_HelloStub.java – Esta classe é o stub do cliente. Extende

org.omg.CORBA.portable.ObjectImpl e implementa a interface Hello.java

Hello.java – Esta classe contém a versão da interface IDL Java. Extende org.omg.CORBA.Object, a interface HelloOperations e org.omg.CORBA.portable.IDLEntity

HelloHelper.java – A classe HelloHelper é responsável pela leitura e escrita dos dados do CORBA.

HelloHolder.java – Esta classe final assegura um método de solicitação público (Public) do tipo Hello, além de fornecer operações para org.omg.CORBA.portable.OutputStream e org.omg.CORBA.portable.InputStream

Fabio Lopes Licht Fev/2002

Tutorial Corba 3

argumentos, que CORBA permite. Esta classe, implementa org.omg.CORBA.portable.Streamable.

HelloOperations.java - Esta interface contém o método sayHello() e shutdown(). O idlj coloca as operações definidas na interface IDL dentro este arquivo, que é compartilhado por ambos o stubs e esqueletos.

Definição da Classe “HelloServer.java”

1. // HelloServer.java2. import HelloApp.*;3. import org.omg.CosNaming.*;4. import org.omg.CosNaming.NamingContextPackage.*;5. import org.omg.CORBA.*;6. import org.omg.PortableServer.*;7. import org.omg.PortableServer.POA;8.9. import java.util.Properties;10.11. class HelloImpl extends HelloPOA {12. private ORB orb;13.14. public void setORB(ORB orb_val) {15. orb = orb_val; 16. }17. 18. // implementação do método sayHello()19. public String sayHello() {20. return "\nHello world !!\n";21. }22. 23. // implementação do método shutdown()24. public void shutdown() {25. orb.shutdown(false);26. }27. }28.29.30. public class HelloServer {31.32. public static void main(String args[]) {33. try{34. // Criação e inicialização do ORB35. ORB orb = ORB.init(args, null);36.37. // obtém a referência do rootpoa e ativa o POAManager38. POA rootpoa =

POAHelper.narrow(orb.resolve_initial_references("RootPOA"));39. rootpoa.the_POAManager().activate();40.41. // cria o servant e registra com o ORB42. HelloImpl helloImpl = new HelloImpl();43. helloImpl.setORB(orb); 44.45. // obtém referência do objeto servant

Fabio Lopes Licht Fev/2002

Tutorial Corba 4

46. org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloImpl);47. Hello href = HelloHelper.narrow(ref);48. 49. org.omg.CORBA.Object objRef =50. orb.resolve_initial_references("NameService");51. // Especifica o servidor de nomes(INS)52. NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);53.54. // Especifica uma referência de objeto55. String name = "Hello";56. NameComponent path[] = ncRef.to_name( name );57. ncRef.rebind(path, href);58.59. System.out.println("HelloServer ready and waiting ...");60.61. // Aguarda a invocação de clientes62. orb.run();63. } 64.65. catch (Exception e) {66. System.err.println("ERROR: " + e);67. e.printStackTrace(System.out);68. }69. 70. System.out.println("HelloServer Exiting ...");71.72. }73. }74.  

Definição da Classe “HelloClient.java”

1. import HelloApp.*;2. import org.omg.CosNaming.*;3. import org.omg.CosNaming.NamingContextPackage.*;4. import org.omg.CORBA.*;5.6. public class HelloClient7. {8. static Hello helloImpl;9.10. public static void main(String args[])11. {12. try{13. // Cria e inicializa o ORB14. ORB orb = ORB.init(args, null);15.16. org.omg.CORBA.Object objRef = 17. orb.resolve_initial_references("NameService");18. NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);19. 20. String name = "Hello";21. helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));22.23. System.out.println("Obtained a handle on server object: " +

helloImpl);

Fabio Lopes Licht Fev/2002

Tutorial Corba 5

24. System.out.println(helloImpl.sayHello());25. helloImpl.shutdown();26.27. } catch (Exception e) {28. System.out.println("ERROR : " + e) ;29. e.printStackTrace(System.out);30. }31. }32.33. }

 Compilando e executando o Exemplo:

Para se executar o exemplo acima, algumas tarefas deverão ser cumpridas “exatamente” da maneira como for especificado adiante:

Windows (no prompt do DOS)idlj -fall Hello.idljavac *.java HelloApp/*.javatnameserv -ORBInitialPort 1050start java HelloServer -ORBInitialPort 1050java HelloClient -ORBInitialPort 1050

Linux (Na janela do editor)idlj -fall Hello.idljavac *.java HelloApp/*.javatnameserv -ORBInitialPort 1050&java HelloServer -ORBInitialPort 1050&java HelloClient -ORBInitialPort 1050&

Para executar o servidor, e o cliente em máquinas diferentes:

Windows (no prompt do DOS)Na máquina Servidoridlj -fall Hello.idljavac *.java HelloApp/*.javatnameserv -ORBInitialPort 1050start java HelloServer -ORBInitialPort 1050

A partir da máquina clientejava HelloClient -ORBInitialPort 1050 -ORBInitialHost <IP_do_servidor>

Linux (Na janela do editor)Na máquina Servidoridlj -fall Hello.idljavac *.java HelloApp/*.javatnameserv -ORBInitialPort 1050&

Fabio Lopes Licht Fev/2002

Tutorial Corba 6

start java HelloServer -ORBInitialPort 1050&

A partir da máquina clientejava HelloClient -ORBInitialPort 1050 -ORBInitialHost <IP_do_servidor>&

“Hello World” Persistente.A diferença entre o exemplo mostrado anteriormente (Transiente) e o que vou mostrar agora

(Persistente), é que no anterior o servidor fica rodando na máquina mesmo quando não está sendo invocado, e desta maneira, está ocupando memória desnecessariamente, enquanto que o “Hello Wolrd Persistente”, é registrado em um servidor de nomes (servertool) que é uma ferramenta de registro de servidores, que possibilita aos clientes localizar o objeto servidor e invocá-lo somente na hora em que for necessário, com isso, a memória fica livre para ser usada por outros aplicativos.

Definição de uma interface.A sintaxe utilizada para a IDL, é similar à utilizada em C++.

“PersistentHello.idl”

1. module Persistent {2. interface Hello {3. string sayHello( );4. oneway void shutdown();5. };6. };

Definição da Classe “PersistentServer.java”

1. // PersistentServer.java2. // Copyright and License 3. import java.util.Properties;4. import org.omg.CORBA.Object;5. import org.omg.CORBA.ORB;6. import org.omg.CosNaming.NameComponent;7. import org.omg.CosNaming.NamingContextExt;8. import org.omg.CosNaming.NamingContextExtHelper;9. import org.omg.CORBA.Policy;10. import org.omg.PortableServer.POA;11. import org.omg.PortableServer.*;12. import org.omg.PortableServer.Servant;13.14. public class PersistentServer {15.16. public static void main( String args[] ) {17. Properties properties = System.getProperties();18. properties.put( "org.omg.CORBA.ORBInitialHost",19. "localhost" );20. properties.put( "org.omg.CORBA.ORBInitialPort",21. "1050" );22. 23. try {24. // Step 1: Instantiate the ORB25. ORB orb = ORB.init(args, properties);26.

Fabio Lopes Licht Fev/2002

Tutorial Corba 7

27. // Step 2: Instantiate the servant28. PersistentHelloServant servant = new

PersistentHelloServant(orb); 29.30. // Step 3 : Create a POA with Persistent Policy31. // ******************* 32. // Step 3-1: Get the rootPOA 33. POA rootPOA =

POAHelper.narrow(orb.resolve_initial_references("RootPOA"));34. // Step 3-2: Create the Persistent Policy35. Policy[] persistentPolicy = new Policy[1];36. persistentPolicy[0] = rootPOA.create_lifespan_policy(37. LifespanPolicyValue.PERSISTENT);38. // Step 3-3: Create a POA by passing the Persistent Policy39. POA persistentPOA = rootPOA.create_POA("childPOA", null, 40. persistentPolicy ); 41. // Step 3-4: Activate PersistentPOA's POAManager, Without this42. // All calls to Persistent Server will hang because POAManager43. // will be in the 'HOLD' state.44. persistentPOA.the_POAManager().activate( );45. // ***********************46. 47. // Step 4: Associate the servant with PersistentPOA48. persistentPOA.activate_object( servant );49.50. // Step 5: Resolve RootNaming context and bind a name for the51. // servant.52. // NOTE: If the Server is persistent in nature then using

Persistent53. // Name Service is a good choice. Even if ORBD is restarted

the Name54. // Bindings will be intact. To use Persistent Name Service use55. // 'NameService' as the key for resolve_initial_references()

when56. // ORBD is running.57. org.omg.CORBA.Object obj = orb.resolve_initial_references(58. "NameService" );59. NamingContextExt rootContext =

NamingContextExtHelper.narrow( obj );60.61. NameComponent[] nc = rootContext.to_name( 62. "PersistentServerTutorial" );63. rootContext.rebind( nc, persistentPOA.servant_to_reference( 64. servant ) );65.66. // Step 6: We are ready to receive client requests67. orb.run();68. } catch ( Exception e ) {69. System.err.println( "Exception in Persistent Server Startup "

+ e );70. }71. }72. }

Definição da Classe “PersistentHelloServant.java”

Fabio Lopes Licht Fev/2002

Tutorial Corba 8

1. // PersistentHelloServant.java2. // Copyright and License 3. import org.omg.CORBA.ORB;4.5. public class PersistentHelloServant extends Persistent.HelloPOA {6. private ORB orb;7. 8. public PersistentHelloServant( ORB orb ) {9. this.orb = orb;10. }11.12. /**13. * sayHello() method implementation returns a simple message.14. */15. public String sayHello( ) {16. return "Hello From Persistent Server...";17. }18.19. /**20. * shutdown() method shuts down the Persistent Server.21. * See NOTE below.22. */23. public void shutdown( ) {24. orb.shutdown( false );25. }26. }

Definição da Classe “PersistentClient.java”

1. import java.util.Properties;2. import org.omg.CORBA.ORB;3. import org.omg.CORBA.OBJ_ADAPTER;4. import org.omg.CosNaming.NamingContext;5. import org.omg.CosNaming.NamingContextHelper;6. import org.omg.CosNaming.NameComponent;7. import org.omg.PortableServer.POA;8.9. import Persistent.HelloHelper;10. import Persistent.Hello;11.12. public class PersistentClient {13.14. public static void main(String args[]) {15.16. try {17. // Step 1: Instantiate the ORB18. ORB orb = ORB.init(args, null);19.20. // Step 2: Resolve the PersistentHelloServant by using INS's21. // corbaname url. The URL locates the NameService running on22. // localhost and listening on 1050 and resolve 23. // 'PersistentServerTutorial' from that NameService24. org.omg.CORBA.Object obj = orb.string_to_object( 25. "corbaname::localhost:1050#PersistentServerTutorial");26. 27. Hello hello = HelloHelper.narrow( obj );

Fabio Lopes Licht Fev/2002

Tutorial Corba 9

28.29. // Step 3: Call the sayHello() method every 60 seconds and

shutdown30. // the server. Next call from the client will restart the

server,31. // because it is persistent in nature.32. while( true ) {33. System.out.println( "Calling Persistent Server.." );34. String helloFromServer = hello.sayHello();35. System.out.println("Message From Persistent Server: " +36. helloFromServer );37. System.out.println( "Shutting down Persistent Server.." );38. hello.shutdown( );39. Thread.sleep( 60000 );40. }41. } catch ( Exception e ) {42. System.err.println( "Exception in PersistentClient.java..." +

e );43. e.printStackTrace( );44. }45. }46. }

Compilando e executando o Exemplo:Assim como no exemplo “Hello World Transiente”, para se executar o exemplo acima,

algumas tarefas deverão ser cumpridas “exatamente” da maneira como for especificado adiante:

Windows (no prompt do DOS)idlj -fall -td . -verbose PersistentHello.idljavac *.java HelloApp/*.javastart orbd -ORBInitialPort 1050 -serverPollingTime 200start servertool -ORBInitialPort 1050

Na janela do servertool que se inicializará:register -server PersistentServer -applicationName S1 -classpath <localização_da_classe_Servidor>

No prompt do DOSjava -classpath . PersistentClient

Para executar o servidor, e o cliente em máquinas diferentes:

Windows (no prompt do DOS)idlj -fall -td . -verbose PersistentHello.idljavac *.java HelloApp/*.javastart orbd -ORBInitialPort 1050 -ORBInitialHost localhostjava -classpath . PersistentClient -ORBInitialPort 1050 -ORBInitialHost <host_servidor>

Servertool

Fabio Lopes Licht Fev/2002

Tutorial Corba 10

É uma ferramenta de Java para registro de servidores IDL servertool fornece uma linha de comando aos programadores de aplicação para registrar, desregistrar, startar, e desligar um servidor persistente.

Sinopseservertool -ORBInitialPort <Nº_da_porta>(maior que 1024) <OPÇÕES> <COMANDOS>

OPÇÕES -ORBInitialHost <host_servidor> Especifica a máquina onde a “classe servidor” está sendo executada. O default do host_servidor é localhost se esta opção não for especificada. Se orbd e servertool estão rodando em máquinas diferentes, você deve especificar o nome ou IP do servidor em que orbd está sendo executado. -Joption Passe opção à Máquina Virtual Java, onde option é uma das opções descritas na página de referência do java application launcher na página da sun http://java.sun.com . Por Exemplo, -J-Xms48m atribui à memória do startup, 48 mb. Isto é uma convenção comum para -J.

COMANDOSregister -server <Nome_da_Classe_Servidor>  -classpath <localização_do_servidor(path)> -applicationName <Nome_da_Aplicação> -args <Argumentos_do_Servidor> -vmargs <Argumentos_Máquina_Virtual_Java>  ] Registra um novo servidor persistente com o ORBD. unregister -serverid <id_do_servidor > | -applicationName <nome_da_aplicação> Desregistra um servidor do ORBD podendo ser utilizado de duas formas com o identificador do servidor ou pelo nome da aplicação. getserverid -applicationName <nome_da_aplicação> Retorna a id de servidor correspondente.listLista informações sobre todos os servidores persistentes registrados com o ORBD. listappnames Lista a aplicação especifica de todos servidores que estão executando e registrados com o ORBD. listactive Lista informações sobre todos os servidores persistentes que têm sido lançados pelo ORBD e estão sendo executados. locate -serverid <id_do_servidor > | -applicationName <nome_da_aplicação> [-endpointType <endpointType> ] Localiza os endpoints (portas) de um tipo específico, para todos os ORBs criados por um servidor registrado. Se um servidor não estiver sendo executado, isto o ativa.

Fabio Lopes Licht Fev/2002

Tutorial Corba 11

locateperorb -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> [-orbid <Nome_ORB> ] Localiza todos os endpoints (portas) registradas por um ORB específico registrado. Se um servidor não estiver sendo executado, então isto o ativa. orblist -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> Lista o ORB_id dos ORBs definidos em um servidor. shutdown -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> Desativa um servidor ativo que é registrado com o ORBD. startup -serverid <id_do_servidor> | -applicationName <nome_da_aplicação> Ativa um servidor que é registrado com o ORBD. Se o servidor não está sendo executado, este comando lança o servidor. Se o servidor está sendo executado, uma mensagem de erro é retornada ao usuário. help Lista todos os comandos disponíveis ao servidor através da ferramenta servertool. quit Sai da ferramenta servertool.

ORBDOrbd, é um comando que é utilizado para habilitar clientes afim de localizar e invocar objetos

persistentes em servidores no ambiente CORBA.

SinopseOrbd<OPÇÕES>

OPÇÃO REQUERIDA-ORBInitialPort <Nº_da_porta>(maior que 1024) Especifica a porta em que o servidor de nomes será executado. Uma vez iniciado, orbd escutará as solicitações que entrarem nesta porta.

OUTRAS OPÇÕES- port <porta>

Fabio Lopes Licht Fev/2002

Tutorial Corba 12

Especifica a porta de ativação onde ORBD deverá iniciar, e onde o ORBD aceita solicitações para objetos persistentes. O valor de default para esta porta é 1049. -defaultdb <diretório>Especifica onde o diretório ORBD de armazenamento persistente orb.db é criado. Se esta opção não for especificada, o valor default é "./orb.db".-serverPollingTime milisegundosEspecifica quantas vezes o ORBD checa a “saúde” dos servidores persistentes registrados via servertool. O valor default é 1,000 e o valor especificado em milisegundos, deve ser um inteiro positivo válido. -serverStartupDelay milisegundos Especifica quanto tempo ORBD espera antes de enviar uma localização, depois que um servidor persistente registrado via servertool é reiniciado. O valor de default é 1,000 e o valor especificado em milisegundos, deve ser um inteiro positivo válido.-Joption Passe esta opção à Máquina Virtual Java, onde option é uma das opções descritas na página de referência do java application launcher na página da sun http://java.sun.com . Por Exemplo, -J-Xms48m atribui à memória do startup, 48 mb. Isto é uma convenção comum para -J.

Bibliografiahttp://www.omg.org - Site da OMG (Object Management Group). Excelente fonte de consulta sobre Corba para iniciantes.

Fabio Lopes Licht Fev/2002