API Java do SCS Tecgraf PUC-Rio Setembro de 2013

A API do SCS A API fica encapsulada em uma classe chamada ComponentBuilder, utilizada para “montar” um componente Definindo suas facetas, receptáculos e ComponentId Um componente SCS-Java é representado por uma interface Java ComponentContext Existem classes auxiliares

Criação de um Componente São necessários alguns passos: 1.Alterar facetas básicas (opcional) 2.Implementar suas facetas (opcional) 3.Criar o ComponentId 4.Instanciar a representação local do componente 5.Adicionar facetas (opcional) 6.Adicionar receptáculos (opcional)

Criação de um Componente Outra opção é utilizar descritores XML Externalizam como deve ser a construção do componente Não é necessário recompilar o código para mudar a configuração do componente Os passos passam a ser: Descrever o componente em um arquivo XML Implementar suas facetas (opcional) Utilizar a API para construir o componente a partir do arquivo XML

Implementação de uma Faceta

Criação de Facetas Uma faceta SCS nada mais é do que uma implementação de uma interface CORBA O SCS adiciona algumas convenções, mas a implementação da interface se dá da mesma forma Por herança ou delegação public class MyFacetServant extends MyFacetPOA { }

Criação de Facetas Pode ser útil também ter um construtor que receba a representação local do componente ao qual essa faceta pertencerá Assim pode-se ter acesso a outras facetas e dados comuns ao componente como um todo Essa representação local é chamada de contexto do componente (classe ComponentContext) Não é obrigatório, a não ser na construção por XML

Criação de Facetas Método _get_component() –Inicialmente criado para o CCM e CORBA 3.0 –Presente na especificação de CORBA 2.3.x Suportado em Java pelo JacORB mas não pelo ORB da Sun –Fornece a interface mais básica de um componente, a partir de qualquer outra de suas interfaces. Isso geralmente permite obter uma interface que acesse outras interfaces No SCS, a interface mais básica é a IComponent, da qual pode-se obter as outras facetas do componente

Criação de Facetas Definição do método _get_component() –Basta retornar o resultado do método auxiliar getIComponent existente na interface ComponentContext –Opcional, mas uma mensagem de aviso será impressa caso o método não seja implementado –Possibilidade do método ser adicionado automaticamente no futuro Desistimos da idéia por enquanto pois estamos investigando outras soluções para versões futuras do SCS public org.omg.CORBA.Object _get_component() { return context.getIComponent(); }

Criação de Facetas Exemplo de faceta completa public class MyFacetServant extends MyFacetPOA { private ComponentContext context; public MyFacetServant(ComponentContext context) { this.context = context; } public org.omg.CORBA.Object _get_component() { return context.getIComponent(); }... }

Representação Local do Componente (ComponentContext)

Criação do ComponentId Definição do ComponentId Idêntico ao demonstrado na IDL ComponentId cpId = new ComponentId( “MyComponentName”, (byte) 1, (byte) 0, (byte) 0, “windows” );

O Componente Java ComponentContext –Atua como um envólucro que facilita o uso do componente como uma entidade única e não apenas um aglomerado de facetas e receptáculos Representação local do componente Acesso a todas as facetas (incluindo as básicas) e receptáculos Guarda os metadados, como descrições de facetas e receptáculos e identificador do componente (ComponentId)

O Componente Java ComponentContext –A classe pode ser estendida para adicionar outros dados de uso global no componente Dados acessados por mais de uma faceta Dados referentes ao componente em si, não a uma faceta específica Métodos

Classe Java ComponentContext public ComponentContext(ORB orb, POA poa, ComponentId id) –Construtor que recebe o ORB e POA a serem utilizados nas facetas do componente e o ComponentId –Adiciona automaticamente as facetas básicas (já ativadas no POA fornecido) public ComponentId getComponentId() –Retorna o ComponentId fornecido no construtor

Classe Java ComponentContext public void addFacet(String name, String interfaceName, Servant servant) –Adiciona uma faceta ao componente –Ativa o objeto CORBA no POA public void removeFacet(String name) –Remove uma faceta do componente –Desativa o objeto CORBA no POA public void updateFacet(String name, Servant servant) –Desativa o objeto CORBA da faceta no POA –Substitui o objeto CORBA pelo novo fornecido –Ativa o novo objeto CORBA no POA

Classe Java ComponentContext public void addReceptacle(String name, String interfaceName, boolean isMultiplex) –Adiciona um receptáculo ao componente public void removeReceptacle(String name) –Remove um receptáculo do componente

Classe Java ComponentContext public Collection getFacets() –Retorna uma coleção com todas as facetas do componente –A classe Facet contém o objeto CORBA e os metadados associados public Facet getFacetByName(String name) –Retorna uma faceta específica public Collection getReceptacles() –Retorna uma coleção com todos os receptáculos do componente public Receptacle getReceptacleByName(String name) –Retorna um receptáculo específico

Classe Java ComponentContext public IComponent getIComponent() –Retorna a faceta IComponent do componente public String getComponentIdAsString() –Retorna as informações do ComponentId em uma string public POA getPOA() –Retorna o POA fornecido no construtor e utilizado na ativação dos objetos CORBA do componente public ORB getORB() –Retorna o ORB fornecido no construtor

Como obter uma faceta a partir de outra? Como acessar uma faceta externa conectada a um receptáculo? Exemplos context.getReceptacleByName(“ReceptacleName”).get Connections() context.getFacetByName(“FacetName”).getServant()

Alteração de Facetas Básicas Novas implementações podem ser fornecidas para as facetas básicas A implementação é feita normalmente como em qualquer faceta / objeto CORBA, basta seguir a interface desejada Após criar o ComponentContext, deve-se substituir o servant da faceta desejada pelo novo (método updateFacet)

Outras Funcionalidades

XMLComponentBuilder É possível montar um componente a partir de um arquivo descritor em XML ‒ Substitui os passos demonstrados anteriormente O descritor deve conter no mínimo: ‒ Identificador do componente Pode-se fornecer, opcionalmente: ‒ Descrições de facetas (nome, interface, e classe a ser instanciada) A classe da faceta deve conter um construtor que receba apenas um ComponentContext como parâmetro ‒ Descrições de receptáculos (nome, interface, multiplex) ‒ Classe a ser usada como ComponentContext

XMLComponentBuilder Exemplo de arquivo XML MyComponent Java 1.6 MyFacet IDL:module/Interface:1.0 mypackage.InterfaceImpl AnotherFacet IDL:module/AnotherInterface:1.0 mypackage.AnotherInterfaceImpl

XMLComponentBuilder Exemplo de uso da API … ORB orb = ORB.init(args, orbProps); POA poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); poa.the_POAManager().activate(); XMLComponentBuilder xmlBuilder = new XMLComponentBuilder(orb, poa); File is = new File("resources/" + args[0]); ComponentContext context; try { context = xmlBuilder.build(is); } catch (SCSException e) { e.getCause().printStackTrace(); return; } …

Aplicação Exemplo

Exemplo passo-a-passo Veremos um exemplo, passo-a-passo, de desenvolvimento de uma aplicação SCS usando Java Para desenvolver a aplicação, usaremos o JacORB como ORB tanto para o cliente quanto para o servidor, e as bibliotecas do SCS

Exemplo de Aplicação StockSeller StockServer Stock Exchange StockLogger ExchangePrinter O componente StockSeller implementa duas facetas: StockServer e StockExchange O componente StockSeller tem um receptáculo para componentes que implementem a faceta ExchangePrinter O componente StockLogger implementa a faceta ExchangePrinter

Passo 1: Alterando a IDL // StockMarket.idl // O módulo StockMarket consiste das definições // úteis para desenvolvimento de aplicações // que lidam com mercado de ações. module StockMarket {... // A interface ExchangePrinter é a interface que // representa uma impressora de negociações de ações. interface ExchangePrinter { // Imprime que houve uma negociação da ação indicada. // A saída utilizada para impressão não é especificada. // Exemplos de saídas: tela, arquivo, clients remotos. void print(in StockSymbol symbol); }; // A interface StockExchange é a interface que permite // a compra de ações. interface StockExchange { // Usa os componentes ExchangePrinter que estejam // conectados para imprimir a negociaçao efetuada. boolean buyStock(in StockSymbol symbol); };};

Passo 2: Implementando as facetas Facetas são interfaces CORBA e, portanto, sua implementação segue as mesmas regras que vimos nos exemplos de CORBA Precisaremos alterar a classe StockServerImpl para que ela se torne uma Faceta SCS Além disso, precisaremos implementar as facetas StockExchange e ExchangePrinter

StockServerImpl /** * StockServerImpl implementa a interface IDL StockServer */ public class StockServerImpl extends StockServerPOA { /** * Construtor context o contexto do componente dono da faceta. */ public StockServerImpl(ComponentContext context) { } /** * Retorna o valor corrente a determinada ação do mercado, dado o * símbolo que a representa. public float getStockValue(String symbol) { } /** * Retorna a sequência com todos os símbolos que definem as ações * de mercado mantidas por esse StockServer. public String[] getStockSymbols() { } /** * Obtém a faceta IComponent do componente. a faceta IComponent */ public org.omg.CORBA.Object _get_component() { } }

StockExchangeImpl /** * StockExchangeImpl implementa a interface IDL StockExchange */ public class StockExchangeImpl extends StockExchangePOA { /** * Construtor * context o contexto do componente dono da faceta. */ public StockExchangeImpl(ComponentContext context) { } /** * Quando uma ação é negociada, seu valor aumenta em uma taxa de 10%. * Usa os componentes StockLogger que estejam conectados para imprimir * a negociaçao efetuada. public boolean buyStock(String symbol) { } /** * Obtém a faceta IComponent do componente. * a faceta Icomponent */ public org.omg.CORBA.Object _get_component() { } }

DisplayExchangePrinter /** * DisplayExchangePrinterImpl implementa a interface IDL ExchangePrinter. * Essa implementação usa o display (console) para mostrar a negociação de * cada ação do mercado. */ public class DisplayExchangePrinterImpl extends ExchangePrinterPOA { /** * Construtor * context o contexto do componente dono da faceta. */ public DisplayExchangePrinterImpl(ComponentContext context) { } /** * Imprime que houve uma negociação da ação indicada. A saída utilizada * para impressão não é especificada. Exemplos de saídas: tela, arquivo, * clients remotos. public void print(String text) { } /** * Obtém a faceta IComponent do componente. * a faceta Icomponent */ public org.omg.CORBA.Object _get_component() { } }

Passo 3: Criando o componente StockSeller O componente StockSeller oferece as facetas StockServer e StockExchange O componente StockSeller possui um receptáculo para conectar um ou mais compontes que implementem a faceta ExchangePrinter

Inicia o ORB e ativa o POA A inicialização do ORB e ativação do POA, ao iniciar o servidor, são iguais ao que já usamos nos exemplos anteriores. O servidor deve, após criar o componente, deixar o ORB aguardando as requisições /* * As propriedades que informam o uso do JacORB como ORB. */ Properties orbProps = new Properties(); orbProps.setProperty("org.omg.CORBA.ORBClass", "org.jacorb.orb.ORB"); orbProps.setProperty("org.omg.CORBA.ORBSingletonClass", "org.jacorb.orb.ORBSingleton"); /* Inicializa o ORB */ ORB orb = ORB.init(args, orbProps); /* Obtém a referência para o POA e inicializa o POA */ POA poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); poa.the_POAManager().activate();... orb.run();

Criando o identificador do componente Todo componente precisa ter um identificador, que é descrito usando a classe ComponentId ComponentId componentId = new ComponentId( "StockSeller", (byte) 1, (byte) 0, (byte) 0, "Java");

Criando o componente A classe ComponentContext deve ser instanciada para servir como representação local do componente (ou uma classe mais específica definida pelo usuário) Esse componente já conterá as facetas básicas do SCS ComponentContext context = new Component(orb, poa, componentId);

Criando e adicionando as facetas // cria as facetas StockServerImpl stockServer = new StockServerImpl(context); StockExchangeImpl stockExchange = new StockExchangeImpl(context); // adiciona as facetas ao componente context.addFacet("StockServer", StockServerHelper.id(), stockServer); context.addFacet("StockExchange", StockExchangeHelper.id(), stockExchange);

Adicionando receptáculos // adiciona o receptáculo context.addReceptacle("ExchangePrinter", ExchangePrinterHelper.id(), true);

Salva o IOR em um arquivo Nessa solução, ainda usaremos um arquivo para gravar a referência para o objeto CORBA Note que estamos usando a referência para um IComponent Icomponent component = context.getIComponent(); PrintWriter ps = new PrintWriter(new FileOutputStream(new File(args[0]))); ps.println(orb.object_to_string(component)); ps.close();

Passo 4: Criando o componente StockLogger O componente StockLogger oferece a faceta ExchangePrinter O código StockLoggerMain.java é responsável por criar o componente SCS StockLogger Em nosso exemplo, o código que o conecta ao componente StockSeller é uma aplicação separada A criação do componente StockLogger é similar ao que fizemos para criar o StockSeller, exceto que não há receptáculos

Passo 5: Recuperando as referências dos componentes para conectá-los A conexão pode ser feita por um dos componentes do sistema ou por um cliente externo /* * Lê o IOR do componente StockSeller do arquivo seller.ior */ BufferedReader reader = new BufferedReader(new InputStreamReader( new FileInputStream(args[0]))); String ior_seller = reader.readLine(); reader.close(); /* * Lê o IOR do componente StockLogger do arquivo logger.ior * parâmetro 2. */ reader = new BufferedReader(new InputStreamReader( new FileInputStream(args[1]))); String ior_logger = reader.readLine(); reader.close();

Obtendo as facetas IReceptacles do StockSeller e ExchangePrinter do StockLogger Precisaremos da faceta ExchangePrinter do componente StockLogger, pois é essa faceta que será conectada ao receptáculo do StockSeller A faceta IComponent tem métodos para recuperar suas outras facetas /* Obtém a referência para o componente StockSeller. */ org.omg.CORBA.Object obj = orb.string_to_object(ior_seller); IComponent stockSeller = IComponentHelper.narrow(obj); /* Obtém a referência para o componente StockLogger. */ obj = orb.string_to_object(ior_logger); IComponent stockLogger = IComponentHelper.narrow(obj); /* Obtém a referência para IReceptacles do StockSeller */ IReceptacles irStockSeller = IReceptaclesHelper.narrow( stockSeller.getFacet(IReceptaclesHelper.id())); /* Obtém a referência para ExchangePrinter do StockLogger */ ExchangePrinter printer = ExchangePrinterHelper.narrow( stockLogger.getFacet(ExchangePrinterHelper.id()));

Conectando a faceta ExchangePrinter do StockLogger no receptáculo do StockSeller Usamos a faceta IReceptacles de StockSeller para fazer a conexão dos componentes O método connect faz a conexão do componente StockLogger usando sua faceta ExchangePrinter O exemplo não mostra para simplificar, mas deve-se tratar as exceções CORBA como no exercício anterior em toda chamada remota CORBA, assim como exceções específicas do método /* * Faz a conexão da faceta ExchangePrinter do componente StockLogger no * receptáculo do StockSeller. */ irStockSeller.connect("ExchangePrinter", printer);

Passo 6: Usando os componentes conectados ao receptáculo do StockSeller A implementação do método buyStock pela faceta StockExchange do componente StockSeller deve chamar o método print da faceta ExchangePrinter conectada a esse mesmo componte

Obtendo o receptáculo correspondente a ExchangePrinter O contexto do componente possui o método getReceptacleByName que retorna um receptáculo do componente A classe Receptacle permite então recuperar as conexões As descrições das conexões são recuperadas com o método getConnections de Receptacle O campo objref de ConnectionDescription possui a referência para a faceta do componente conectado public boolean buyStock(String symbol) { … Receptacle receptacle = context.getReceptacleByName("ExchangePrinter"); if (receptacle == null) { … } List connections = receptacle.getConnections(); for (ConnectionDescription connection : connections) { try { ExchangePrinter printer = ExchangePrinterHelper.narrow(connection.objref); printer.print("Ação " + symbol + " foi negociada"); } catch(...) {...} }... }

Passo 7: Usando o componente StockSeller O cliente usa o componente StockSeller através de suas facetas O StockMarketClient.java possui a etapa de inicialização do ORB que já vimos nos exemplos anteriores O que muda é o uso das facetas do componente para invocar os métodos remotos

Obtendo a referência para o componente StockSeller O cliente recupera a referência para o componente StockSeller lendo do arquivo recebido por parâmetro /* * Lê o IOR do componente StockSeller do arquivo seller.ior * parâmetro. */ BufferedReader reader = new BufferedReader(new InputStreamReader( new FileInputStream(args[0]))); String ior_seller = reader.readLine(); reader.close(); /* Obtém a referência para component StockSeller. */ org.omg.CORBA.Object ior = orb.string_to_object(ior_seller); IComponent stockSeller = IComponentHelper.narrow(ior);

Obtendo as facetas StockServer e StockExchange do componente StockSeller Tendo o componente, as facetas StockServer e StockExchange são recuperadas, pelo nome ou pela interface try { /* Obtém a faceta StockServer */ org.omg.CORBA.Object obj = stockSeller.getFacetByName("StockServer"); StockServer stockServerFacet = StockServerHelper.narrow(obj); /* Obtém a faceta StockExchange */ obj = stockSeller.getFacetByName("StockExchange"); StockExchange stockExchangeFacet = StockExchangeHelper.narrow(obj); } catch (…) { … }

Invocando os métodos disponibilizados em cada faceta O cliente faz as chamadas aos métodos usando as respectivas facetas try { /* Obtém os símbolos de todas as ações. */ String[] stockSymbols = stockServerFacet.getStockSymbols(); /* Mostra as ações com seus respectivos valores */ for (int i = 0; i < stockSymbols.length; i++) { System.out.println(stockSymbols[i] + " " + stockServerFacet.getStockValue(stockSymbols[i])); } if (stockSymbols.length > 0) { String first = stockSymbols[0]; System.out.println("--Compra a ação :" + first); boolean success = stockExchangeFacet.buyStock(first); if (success) { System.out.println("--Ação " + first + " depois da negociação: " + stockServerFacet.getStockValue(first)); } else { System.out.println("--Não foi possível negociar a ação " + first); } catch (…) {…}