Para usar o Assistant, você precisa ligar sua aplicação com as seguintes bibliotecas:

Os arquivos e diretórios tem o seguinte padrão de nomenclatura, com exceção da biblioteca OpenSSL:

Dessa forma, a biblioteca da API básica compilada em multithread, com debug e em compilação estática teria o nome, no linux: libopenbus-mico-mt-s-d.a.

Para a biblioteca MICO, como não definimos seu processo de compilação, ele não segue esse mesmo padrão. Porém, para que os vários binários, resultado da compilação do mico, não conflitem um com o outro, separamos eles em diretórios diferentes. O nome desses diretórios seguem esse padrão, conforme descrito a seguir:

openbus-cpp-mico
├── bin
│   ├── mico-mt
│   ├── mico-mt-d
│   ├── mico-st
│   └── mico-st-d
...
├── include
│   ├── mico-mt
│   ├── mico-mt-d
│   ├── mico-st
│   └── mico-st-d
...
├── lib
│   ├── mico-mt
│   ├── mico-mt-d
│   ├── mico-st
│   └── mico-st-d
...

Portanto, o caminho, no pacote binário do Assistant, encontramos a biblioteca MICO, compilada para multithread, em static e com debug em: lib/mico-mt-d/mico-2.3.13.a. Veja que no nome do diretório, o -s não aparece. Isso é porque a compilação é feita em conjunto entre static e shared e o resultado dessa compilação é colocado na mesma pasta.

Algumas macros personalizam o comportamento da biblioteca de acesso padrão e do Assistant. Algumas são opcionais, e outras obrigatórias para que os headers possam levar determinada configuração em conta. Iremos aqui documentar, também as macros de todos os projetos desenvolvidos no Openbus que são dependencia do Assistant.

Iremos aqui fazer a construção de um Makefile que faça a compilação do demo Hello usando a configuração multithread, static e com debug. Usaremos o compilador gcc como exemplo.

Important

A construção desse Makefile não representa uma indicação de como fazer o build de código de cliente usando o Assistant. É apenas uma demonstração que serve como documentação para que o usuário se sinta mais confortável ao incluir o Openbus no seu próprio sistema de build, levando em consideração quais bibliotecas deve selecionar para determinada configuração e quais macros devem estar definidas em seu próprio código para fazer uso da biblioteca de acesso do Openbus.

Primeiramente, encontramos no pacote o demo hello no caminho demo/hello. Lá, temos as seguintes pastas:

Para compilarmos o demo, precisamos antes compilar a IDL hello.idl e os arquivos client.cpp e server.cpp e depois ligar os intermediários com as bibliotecas nos executáveis finais client e server.

bin/stubs/hello.cc bin/stubs/hello.h: idl/hello.idl
	mkdir -p bin/stubs
	cd bin/stubs; LD_LIBRARY_PATH=$(MICO_LIB):${LD_LIBRARY_PATH} PATH=${PATH}:$(MICO_BIN) $(MICO_BIN)/idl --typecode --poa --no-paths ../../idl/hello.idl

Esse comando faz a compilação de hello.idl para bin/hello.cc e bin/hello.h com os stubs da interface CORBA, que serão usados nos códigos fontes server/server.cpp e client/client.cpp. Usamos aqui as variáveis MICO_BIN e MICO_LIB para parametrizar a localização da biblioteca compartilhada do mico e o diretório aonde estão as ferramentas do mico, como o compilador idl.

Veja que, o compilador idl do mico, faz uso de outra ferramenta chamada mico-cpp, que se encontra no mesmo diretório que o próprio compilador idl. Por isso, definimos a variável de ambiente PATH com o caminho para o compilador IDL, para que o mesmo possa encontrar a ferramenta mico-cpp.

Também, o compilador IDL depende da biblioteca compartilhada do próprio mico. E então definimos a variável de ambiente LD_LIBRARY_PATH com o caminho para a mesma.

Os parâmetros de linha de comando --typecode, --poa e --no-paths significam respectivamente:

Como sabemos nossa configuração, podemos definir as variáveis MICO_LIB e MICO_BIN para o seguinte no início de nosso Makefile

MICO_BIN= $(CURDIR)/../../bin/mico-mt-d
MICO_LIB= $(CURDIR)/../../lib/mico-mt-d

A variável CURDIR é uma variável especial para o make que representa o path corrente de onde o make foi executado. Estamos aqui assumindo que o Makefile está sendo construído dentro do diretório do demo. Como as pastas bin e lib se encontram na raiz do pacote, precisamos voltar dois diretórios, e como estamos usando a configuração multithread, static e debug, o diretório do mico é então mico-mt-d.

Para compilação do servidor para um arquivo objeto, intermediário, fazemos o seguinte

bin/server.o: server/server.cpp bin/stubs/hello.h
	g++ -c $< -o $@ $(CXXFLAGS)

Para compilarmos o server/server.cpp, precisamos do header bin/hello.h já gerado pelo compilador IDL. Porém, não alimentamos o header no comando de compilação. O simbolo $< é um simbolo especial que expande para a primeira dependencia, no caso server/server.cpp. Enquanto que o simbolo $@ expande para o alvo, que no caso é bin/server.o. Definimos também a variável CXXFLAGS, que deverá conter todos os parâmetros de compilação que deverão ser passados ao compilador, como os caminhos de inclusão, e etc.

Agora, atribuimos então à variável CXXFLAGS

CXXFLAGS= -Ibin -Ibin/stubs -I../../include/mico-mt-d -I../../include    \
 -I../../include/openbus/cpp -I../../include/boost                       \
 -I../../include/openssl-1.0.0 -g -O0 -pthread                           \
 -DOPENBUS_SDK_MULTITHREAD -DSCS_THREADING_ENABLED

Adicionamos o diretório de include do mico de configuração que queremos, e então os includes de cada projeto que está também no pacote. Como iremos compilar em debug, não estamos usando nenhuma otimização, passando -O0, e passando -g para inclusão de simbolos de depuração na compilação do demo.

Também fazemos a definição das macros OPENBUS_SDK_MULTITHREAD e SCS_THREADING_ENABLED pois estamos compilando a versão multithread do demo. Porém, não fazemos a definição de ASSISTANT_SDK_MULTITHREAD pois o código dessa demo não faz uso do Assistant.

E para a compilação do cliente, fazemos o mesmo que na compilação do servidor, mas trocando o arquivo alvo e o arquivo fonte:

bin/client.o: client/client.cpp bin/stubs/hello.h
	g++ -c $< -o $@ $(CXXFLAGS)

Assim, temos a compilação dos arquivos server.cpp e client.cpp e a compilação da idl hello.idl. Falta ainda fazer a compilação dos stubs para arquivo objeto também.

bin/hello.o: bin/stubs/hello.cc bin/stubs/hello.h
	g++ -c $< -o $@ $(CXXFLAGS)

Agora temos todos os arquivos objetos que precisamos para gerar os executáveis, falta apenas fazer o ligamento dos objetos com as dependências e gerar o executável final do servidor e cliente:

bin/client: bin/client.o bin/hello.o
	g++ $^ -o $@ $(LDFLAGS)

bin/server: bin/server.o bin/hello.o
	g++ $^ -o $@ $(LDFLAGS)

O simbolo $^ representa todas as dependencias, queremos fazer o ligamento de todos os dois objetos, e não fazer uso apenas do primeiro como estávamos fazendo na compilação. Também, acrescentamos a variável LDFLAGS, que deve conter as flags de ligamento que serão passadas ao ligador. Elas devem incluir as bibliotecas que serão ligadas, e levar em conta a configuração que se deseja gerar, para pegar as versões corretas de cada dependência.

#
LDFLAGS= -L$(MICO_LIB) -L$(CURDIR)/../../lib -Wl,--start-group           \
  -Wl,-Bstatic -lmico2.3.13 -lassistant-mico-mt-s-d -lboost_chrono-mt-d  \
  -lboost_system-mt-d -lboost_thread-mt-d -lboost_program_options-mt-d   \
  -lscs-mico-mt-d -lcrypto -llogger-mt-d -lopenbus-mico-mt-s-d -lssl     \
  -Wl,-Bdynamic -ldl -Wl,--end-group -g -pthread

Passamos, com o parâmetro -L, dois diretórios de busca de bibliotecas. Uma do mico da configuração que queremos, e o outro de todo o diretório lib do pacote com as outras bibliotecas.

Passamos o resto dos argumentos diretamente ao ligador com a opção -Wl e como nossa configuração final é de ligamento estático, passamos também a opção -Bstatic para determinar que estamos querendo somente as versões estáticas das bibliotecas, e então passamos uma a uma as dependências, usando o padrão de nomenclatura no início do documento.

Para finalizar, definimos o alvo chamado all, que irá construir os dois executáveis.

all: bin/client bin/server

E então podemos compilar o demo fazendo um make all

As aplicações mais comuns, e as que são melhores implementadas usando o Assistant tem o seguinte em comum:

Geralmente um aplicativo que se conecta ao barramento é um de dois tipos, ou um híbrido:

Um servidor adiciona ofertas no barramento, disponibilizando um ou mais serviços através destas ofertas. Um cliente, pelo outro lado, consulta o barramento por ofertas de serviços que deseja consumir.

Por ser uma abstração mais simples e focada em um grupo de casos de uso, naturalmente o Assistant não consegue resolver todos os problemas que a API básica, da qual o Assistant é implementado, pode.

Portanto, os seguintes casos só conseguem ser implementados com uso da API básica:

O Assistant recebe as informações de autenticação como usuário, senha, chave privada, etc, na construção do Assistant, assim como outras informações necessárias para uso de CORBA.

Com essas informações, o Assistant se autentica com o barramento, de forma assíncrona e mantém válida essa autenticação, renovando a autenticação quando esta expira. Também é refeita a autenticação se a mesma ficar inválida por qualquer outro motivo, como por remoção através de ferramentas de governança do barramento Openbus.

	Warning
	A construção do Assistant não implica que a autenticação já tenha ocorrido com sucesso. O que significa que funções sincronas, como findServices podem falhar com a exceção NO_PERMISSION por não estar ainda autenticado com o barramento Openbus

Para as aplicações que estão no escopo do Assistant, usar o Assistant possui várias vantagens. Dentre as principais:

Como foi dito anteriormente, a autenticação ocorre de forma assíncrona. O mesmo ocorre com o registro de ofertas. Essa diferença entre Assistant e a API básica é crucial para entender as vantagens de se usar o Assistant.

O registro de oferta ocorre de forma assíncrona e se por qualquer motivo o registro se perder, como por perder autenticação com o barramento, o Assistant automaticamente faz um novo registro de oferta. Assim, o usuário não precisa se preocupar com os vários casos de erros que possam acontecer num sistema distribuido para garantir que suas ofertas estão visiveis para outros serviços.

Para funções que são sincronas, como as que se espera um retorno, como busca por ofertas. O Assistant recebe também um parâmetro de número de tentativas, assim o usuário pode usar o tratamento de erro automático do Assistant para essas chamadas remotas, que podem falhar por inúmeros motivos.

Named Parameters é uma forma de passagem de argumentos, aonde cada argumento e parâmetro é casado no ponto de chamada. Um exemplo hipotético de named parameters seria o seguinte:

using namespace openbus::assistant::keywords;
openbus::assistant::Assistant assistant
  (_host = "localhost", _port = 2089, _username = "tutorial"
   , _password = "tutorial");

	Note
	No Assistant todos os parâmetros começam com um underscore, esse é o padrão seguido pela biblioteca Boost.Parameter que é usada no Assistant

Os seguintes parâmetros existem no Assistant:

Table 5. Named parameters existentes no Assistant

Parametros	Descrição
_host	Nome do host aonde se encontra o barramento. Conteúdo deste named parameter é obrigatório. Pode ser passado com named parameter ou como primeiro argumento do construtor do openbus::assistant::Assistant.
_port	Porta TCP de onde se encontra o barramento. Conteúdo deste named parameter é obrigatório. Pode ser passado com named parameter ou como segundo argumento do construtor do openbus::assistant::Assistant.
_username	Nome do usuário para autenticação ao barramento. Esse parâmetro deve ser usado quando se pretende fazer uma autenticação por usuário e senha. Deve sempre ser usado junto com o named parameter _password.
_password	Senha de autenticação. Esse parâmetro deve ser usado quando se pretende fazer uma autenticação por usuário e senha. Deve sempre ser usado junto com o named parameter _username.
_entity	Nome da entidade registrada por certificado no barramento. Esse parâmetro deve ser usado quando se pretende fazer uma autenticação por certificado. Deve sempre ser usado junto com um dos dois named parameters _private_key ou _private_key_filename.
_private_key	Conteúdo de chave privada usada para criação do certificado registrado no barramento. Esse parâmetro deve ser usado quando se pretende fazer uma autenticação por certificado. Seu tipo deve ser um openbus::PrivateKey. Deve sempre ser usado com o named parameter _entity.
_private_key_filename	Nome do arquivo que contém a chave privada usada para criação do certificado registrado no barramento. Esse parâmetro deve ser usado quando se pretende fazer uma autenticação por certificado. O conteúdo deste arquivo deve ser de uma chave privada gerada com o shell script openssl-generate.sh. Deve sempre ser usado com o named parameter _entity.
_shared_auth_callback	Function object de assinatura std::pair<LoginProcess, CORBA::OctetSeq>(). Esse function object deve retornar um par contendo um LoginProcess e um segredo em CORBA::OctetSeq que tenham sido retornados por um startSharedAuth sobre uma conexão com o mesmo barramento. Essa função pode ser chamada mais de uma vez, e o seu retorno não deve se repetir, já que o objeto LoginProcess só é válido ao ser usado pela primeira vez.
_retry_wait	Número de segundos de espera em caso de erros. Esse argumento modifica o tempo entre tentativas de operações com o barramento.
_log_level	Nível de log utilizado pela implementação do Assistant em sua execução. Os níveis existentes, em ordem crescente de verbosidade, são: ::logger::disabled_level, ::logger::error_level, ::logger::warning_level, ::logger::info_level e ::logger::debug_level.
_argc	Número de argumentos no array passado em _argv. Esse parâmetro é usado para passar o par argc e argv da função int main(int argc, char* argv[]) para o ORB. Isso permite que o usuário do aplicativo configure algumas características do ORB por linha de comando do aplicativo. Deve ser usado em conjunto com named parameter _argv. Esse argumento pode ser modificado pelo ORB.
_argv	Array de argumentos de linha de comando. Esse parâmetro é usado para passar o par argc e argv da função int main(int argc, char* argv[]) para o ORB. Isso permite que o usuário do aplicativo configure algumas características do ORB por linha de comando do aplicativo. Deve ser usado em conjunto com named parameter _argc, que indica o número de argumentos que contém o array. Esse argumento pode ser modificado pelo ORB.
_on_login_error	Polymorphic function object de tratamento de erros de login. O function object passado como argumento deve ter um operador de chamada polimórfico com um parâmetro. O argumento passado é a exceção que foi tratatada pelo Assistant. Note Essa função deve receber o argumento por referência para objeto constante para evitar uma cópia, que pode causar um problema de slicing da exceção. Note Essa função pode ser executada em outra thread em um ambiente multithread.
_on_register_error	Polymorphic function object de tratamento de erros de registro de ofertas. O function object passado como argumento deve ter um operador de chamada polimórfico com três parâmetros. A assinatura deve ser do tipo void(IComponent_var, ServicePropertySeq, Error const&), aonde Error é um tipo parametrizado, um typename de uma template. O argumento IComponent_var é a referência CORBA usada para tentativa de registro; o argumento ServicePropertySeq é o conjunto de propriedades a serem registradas na oferta e o argumento Error passado é a exceção que foi tratatada pelo Assistant durante o erro. Note Essa função deve receber o argumento Error por referência para objeto constante para evitar uma cópia, que pode causar um problema de slicing da exceção. Note Essa função pode ser executada em outra thread em um ambiente multithread.
_on_fatal_error	Polymorphic function object de tratamento de erros fatais. O function object passado como argumento deve ter um operador de chamada polimórfico com um parâmetro. O argumento passado é a exceção que foi tratatada pelo Assistant durante o erro. Note Essa função deve receber o argumento por referência para objeto constante para evitar uma cópia, que pode causar um problema de slicing da exceção. Note Essa função pode ser executada em outra thread em um ambiente multithread.

Os parâmetros _host e _port são obrigatórios, e portanto é possível passar os argumentos sem referenciar os parâmetros, apenas passando-os como os primeiros argumentos na construção do Assistant, da seguinte forma:

using namespace openbus::assistant::keywords;
openbus::assistant::Assistant assistant
  ("localhost", 2089, _username = "tutorial"
   , _password = "tutorial");

	Caution
	Se o seu compilador não suportar Boost.Parameter , então é possível definir a macro OPENBUS_ASSISTANT_DISABLE_NAMED_PARAMETERS na compilação do projeto e usar uma das funções createWithPassword, createWithPrivateKey ou createWithSharedAuth para criar o Assistant

Como vimos nos parâmetros disponíveis para construção do Assistant, temos disponíveis três métodos de autenticação:

using namespace openbus::assistant::keywords;
openbus::assistant::Assistant assistant
  ("localhost", 2089, _username = "usuario"
   , _password = "senha");

CORBA::OctetSeq key = GetPrivateKey();

using namespace openbus::assistant::keywords;
openbus::assistant::Assistant assistant
  ("localhost", 2089, _entity = "tutorial"
   , _private_key = openbus::PrivateKey(key));

using namespace openbus::assistant::keywords;
openbus::assistant::Assistant assistant
  ("localhost", 2089, _entity = "tutorial"
   , _private_key_filename = "filename.key");

O propósito principal do Assistant para um servidor, é o de autenticar ao barramento Openbus e ofertar os serviços no Registro de Ofertas.

Primeiramente fazemos o #include do header do Assistant para que possamos construir um openbus::assistant::Assistant.

#include <openbus/assistant.hpp>

Feito isto, podemos instanciar a classe openbus::assistant::Assistant, que cuidará da autenticação por nós:

int main()
{
  using namespace openbus::assistant::keywords;
  openbus::assistant::Assistant assistant
    ("localhost", 2089, _username = "usuario"
     , _password = "senha");

Se formos ofertar algum serviço, esse serviço precisa estar definido em alguma IDL. Usaremos como base a seguinte IDL, que não poderia ser mais simples:

interface Hello {
  void sayHello();
};

Dada esta IDL, precisamos fazer o #include do header do stub gerado pelo Mico e fazer a implementação de seu Servant.

#include <stubs/hello.h>

	Note
	Estamos usando como padrão neste documento que os stubs gerados pelo compilador IDL do Mico se encontrem em um diretório chamado stubs, porém, essa é apenas um padrão de uso e para projetos mais simples não é necessário e nem sempre vantajoso separar este header de outros, dependendo de qual sistema de build se está usando

E então a construção do Servant CORBA:

struct HelloImpl : ::POA_Hello
{
  void sayHello()
  {
    std::cout << "Hello World" << std::endl;
  }
};

Definido o Servant, fazemos sua instanciação para inclusão em um componente SCS,que será finalmente ofertado no barramento:

HelloImpl helloImpl;

	Note
	Por não haver necessidade de alocação dinâmica, instanciamos o Servant na automatic storage, aonde o objeto será desalocado automaticamente no fim de seu escopo. Facilitando o raciocínio sobre o software, assim como elimina uma possibilidade de memory leak

Instanciado o Servant, podemos incluir este como faceta do componente que será ofertado, mas para isto primeiro o componente precisa ser também instanciado:

scs::core::ComponentId id = {"name", 1, 0, 0, "C++"};
scs::core::ComponentContext component(assistant.orb(), id);

E então a faceta adicionada:

component.addFacet("hello", _tc_Hello->id(), &helloImpl);

	Note
	Usamos aqui o objeto de TypeCode para retornar o RepoID da nossa interface Hello. Assim diminuimos uma redundância e adicionamos uma checagem estática se o nome da classe mudar. Porém, é necessário lembrar de passar o parâmetro --typecode para o compilador IDL do Mico

Vejamos nosso pequeno servidor como fica ao criar o componente com nossa faceta:

#include <openbus/assistant.hpp>

#include <stubs/hello.h>

#include <iostream>

struct HelloImpl : ::POA_Hello
{
  void sayHello()
  {
    std::cout << "Hello World" << std::endl;
  }
};

int main()
{
  using namespace openbus::assistant::keywords;
  openbus::assistant::Assistant assistant
    ("localhost", 2089, _username = "usuario"
     , _password = "senha");
  HelloImpl helloImpl;
  scs::core::ComponentId id = {"name", 1, 0, 0, "C++"};
  scs::core::ComponentContext component(assistant.orb(), id);
  component.addFacet("hello", _tc_Hello->id(), &helloImpl);

Agora só nos resta registrar o serviço e passar a linha de execução para o __ORB__. Registrando o serviço:

assistant.registerService(component.getIComponent());

E chamando run() no __ORB__:

assistant.orb()->run();

E assim terminamos a construção de nosso pequeno serviço ofertado no barramento:

#include <openbus/assistant.hpp>

#include <stubs/hello.h>

#include <iostream>

struct HelloImpl : ::POA_Hello
{
  void sayHello()
  {
    std::cout << "Hello World" << std::endl;
  }
};

int main()
{
  using namespace openbus::assistant::keywords;
  openbus::assistant::Assistant assistant
    ("localhost", 2089, _username = "usuario"
     , _password = "senha");
  HelloImpl helloImpl;
  scs::core::ComponentId id = {"name", 1, 0, 0, "C++"};
  scs::core::ComponentContext component(assistant.orb(), id);
  component.addFacet("hello", _tc_Hello->id(), &helloImpl);
  assistant.registerService(component.getIComponent());
  assistant.orb()->run();
}

Já criamos o servidor, agora para completar é necessário construir um consumidor deste serviço. Alguém que irá buscar esse serviço no Registro de Ofertas e chamar sayHello(), que é o que nosso serviço atualmente faz.

Para tal, precisamos, assim como no servidor, autenticar-nos ao barramento. Porém, as coincidências acabam aí. No cliente não criaremos Servants e nem criaremos ofertas, apenas faremos uma busca e de posse da oferta, faremos uso desta.

Vejamos aqui novamente a autenticação, mas desta vez de nosso cliente:

int main()
{
  using namespace openbus::assistant::keywords;
  openbus::assistant::Assistant assistant
    ("localhost", 2089, _username = "usuario"
     , _password = "senha");

Como vimos, a instanciação da classe openbus::assistant::Assistant coloca o Assistant em responsabilidade por nos autenticar ao barramento de forma assincrona. Agora, nos resta fazer uso do Registro de Ofertas através do Assistant. Para fazermos uma busca no barramento por serviços, fazemos uso da função findServices.

Mas, para podermos fazer a busca, precisamos saber o que buscar. Sabemos que nosso serviço possui uma faceta chamada hello, e que o mesmo se autenticou no barramento com usuário: usuario. Este usuário representa a entidade deste serviço. Em posse dessas informações, podemos usar uma função auxiliar do Assistant que constroi uma lista de propriedades com essas duas propriedades. O nome desta função é createFacetAndEntityProperty. E então de posse dessa lista de propriedades podemos fazer a busca imediatamente.

A função findServices de busca de serviços recebe dois parâmetros: uma lista de propriedades, que construiremos com a função createFacetAndEntityProperty; e um inteiro que representa o número de re-tentativas que a função deve fazer em caso de erros. Esse número pode ser -1, que indica que a função deve tentar indefinidamente; pode ser o número 0, que indica que a função deve retornar uma exceção se qualquer falha ocorrer e nenhuma nova tentativa se a mesma falhar; e qualquer número maior que zero, que indica o número de novas tentativas em caso de falhas.

using tecgraf::openbus::core::v2_0::services::offer_registry::ServiceOfferDescSeq;
ServiceOfferDescSeq offers = assistant.findServices(assistant.createFacetAndEntityProperty("hello", "usuario"), -1);

	Note
	Passamos -1 para findServices para que a função tente indefinidamente até a função obter sucesso

Obtemos o objeto offers contendo uma lista de ofertas que condizem com as propriedades passadas para findServices.

Podemos então chamar a função sayHello para cada uma das ofertas recebidas.

for(CORBA::ULong i = 0; i != offers.length(); ++i)
  if( ::Hello_var p = ::Hello::_narrow(offers[i].service_ref))
    p->sayHello();

	Caution
	A função findServices possui tratamento de erros, tais como em caso de falha de comunicação com o barramento e outros, porém, o for sobre as ofertas retornadas no código acima não faz qualquer tipo de tratamento de erros. Se alguma das operações, como _narrow e sayHello, executadas sobre as ofertas falharem, então toda a aplicação terminará.

Warning

O compilador Visual C++ 2005 possui um bug, aonde o operator[] definido como membro de variáveis _var não são prioritários e o lookup continua com o operator[] livre através de uma conversão do objeto _var para T*. O erro se manifesta como uma ambiguidade quando o argumento para operator[] não é um MICO::ULong, geralmente o caso quando se utiliza um literal. Para evitar esse erro de compilação é só usar o operator* antes do operator[] da seguinte forma (*offers)[0u].

for(CORBA::ULong i = 0; i != offers.length(); ++i)
  try
  {
    if( ::Hello_var p = ::Hello::_narrow(offers[i].service_ref))
      p->sayHello();
  }
  catch(CORBA::SystemException const&) {}

using tecgraf::openbus::core::v2_0::services::offer_registry::ServiceOfferDescSeq;
bool retry = true;
do
{
  ServiceOfferDescSeq offers = assistant.findServices(assistant.createFacetAndEntityProperty("hello", "usuario"), -1);
  for(CORBA::ULong i = 0; i != offers.length(); ++i)
    try
    {
      if( ::Hello_var p = ::Hello::_narrow(offers[i].service_ref))
      {
        p->sayHello();
        retry = false;
      }
    }
    catch(CORBA::SystemException const&) {}
}
while(retry);

openbus::OpenBusContext é uma classe cuja instância representa o contexto atual da chamada. É através dessa função que temos acesso a várias informações do contexto atual. Como:

Para obter uma instância dessa classe, é necessário obtê-la do ORB através da função resolve_initial_references. Da seguinte maneira:

openbus::OpenBusContext* openbusContext = dynamic_cast<openbus::OpenBusContext*>
  (assistant.orb()->resolve_initial_references("OpenBusContext"));

O cast dynamic_cast é necessário porque essa classe pode ter uma herança virtual, que um static_cast não seria suficiente para executar.

Com essa classe em mãos, podemos fazer uso de informações específicas de contexto, como o uso de Cadeias.

A maior evolução no barramento Openbus na versão 2.0 foi a reformulação do sistema de segurança do mesmo. Com este novo sistema de segurança que foi desenvolvido, é possível para um serviço saber qual entidade que fez a chamada, e também é possível para algum serviço intermediário passar para um serviço que ele é usuário a identidade de quem está usando esse intermediário. Isso cria uma cadeia de entidades que pode ser lida pelo serviço final para autorizar ou não a chamada.

Veremos o caso mais simples, modificando o serviço de Hello' que implementamos anteriormente para dizer Hello Usuario'. Aonde Usuario será o nome da entidade que nos chamou. Uma aplicação mais complexa poderia usar essa informação para escolher qual banco de dados ele pegará os dados, ou como fará a autenticação para obter os dados ou simplesmente recusar a operação para determinadas entidades.

Relembrando, nosso Servant foi implementado da seguinte maneira:

struct HelloImpl : ::POA_Hello
{
  void sayHello()
  {
    std::cout << "Hello World" << std::endl;
  }
};

O openbus::OpenBusContext oferece as seguintes funções relativas a Cadeias: getCallerChain, joinChain, exitChain e getJoinedChain.

Faremos uso da função getCallerChain. Mas para tal, precisamos ter acesso ao Assistant de dentro do nosso Servant. Poderíamos usar uma variável global, assim todo programa teria acesso ao Assistant, porém como variáveis globais trazem vários problemas, modificaremos o __Servant__ para receber como argumento de construção o próprio Assistant. Assim, criaremos um construtor:

struct HelloImpl : ::POA_Hello
{
  HelloImpl(openbus::assistant::Assistant assistant)
    : assistant(assistant) {}
  openbus::assistant::Assistant assistant;

E mudamos a instanciação do Servant para passar o Assistant como argumento de construção:

HelloImpl helloImpl(assistant);

E assim, já podemos fazer a chamada de getCallerChain em sayHello usando a variável-membro assistant no Servant, para obter o openbus::OpenBusContext e com ele fazer a chamada a getCallerChain.

void sayHello()
{
  openbus::OpenBusContext* openbusContext = dynamic_cast<openbus::OpenBusContext*>
    (assistant.orb()->resolve_initial_references("OpenBusContext"));
  openbus::CallerChain chain = openbusContext->getCallerChain();
  std::cout << "Hello " << chain.caller().entity << std::endl;
}

E assim implementamos um serviço que imprime o nome da entidade que fez a chamada remota para nosso serviço. O exemplo inteiro:

#include <openbus/assistant.hpp>

#include <stubs/hello.h>

#include <iostream>

struct HelloImpl : ::POA_Hello
{
  HelloImpl(openbus::assistant::Assistant assistant)
    : assistant(assistant) {}
  openbus::assistant::Assistant assistant;

  void sayHello()
  {
    openbus::OpenBusContext* openbusContext = dynamic_cast<openbus::OpenBusContext*>
      (assistant.orb()->resolve_initial_references("OpenBusContext"));
    openbus::CallerChain chain = openbusContext->getCallerChain();
    std::cout << "Hello " << chain.caller().entity << std::endl;
  }
};

int main()
{
  using namespace openbus::assistant::keywords;
  openbus::assistant::Assistant assistant
    ("localhost", 2089, _username = "usuario"
     , _password = "senha");
  HelloImpl helloImpl(assistant);
  scs::core::ComponentId id = {"name", 1, 0, 0, "C++"};
  scs::core::ComponentContext component(assistant.orb(), id);
  component.addFacet("hello", _tc_Hello->id(), &helloImpl);
  assistant.registerService(component.getIComponent());
  assistant.orb()->run();
}

namespace openbus {
  namespace assistant {
    struct Assistant;
    namespace keywords {
       BOOST_PARAMETER_NAME(host);
       BOOST_PARAMETER_NAME(port);
       BOOST_PARAMETER_NAME(username);
       BOOST_PARAMETER_NAME(entity);
       BOOST_PARAMETER_NAME(password);
       BOOST_PARAMETER_NAME(private_key);
       BOOST_PARAMETER_NAME(private_key_filename);
       BOOST_PARAMETER_NAME(shared_auth_callback);
       BOOST_PARAMETER_NAME(argc);
       BOOST_PARAMETER_NAME(argv);
       BOOST_PARAMETER_NAME(on_login_error);
       BOOST_PARAMETER_NAME(on_register_error);
       BOOST_PARAMETER_NAME(on_fatal_error);
       BOOST_PARAMETER_NAME(on_find_error);
       BOOST_PARAMETER_NAME(retry_wait);
       BOOST_PARAMETER_NAME(log_level);
    }
  }
}

// In header: <include/openbus/assistant.hpp>


struct Assistant {
  // types
  typedef assistant::login_error_callback_type                                    login_error_callback_type;   
  typedef assistant::register_error_callback_type                                 register_error_callback_type;
  typedef assistant::fatal_error_callback_type                                    fatal_error_callback_type;   
  typedef assistant::find_error_callback_type                                     find_error_callback_type;    
  typedef boost::function< std::pair< idl_ac::LoginProcess_ptr, idl::OctetSeq >)> shared_auth_callback_type;   

  // construct/copy/destruct
  Assistant(NamedParameters...);
  Assistant(Assistant const &);
  Assistant();

  // public member functions
  OPENBUS_ASSISTANT_DECL void onLoginError(login_error_callback_type);
  OPENBUS_ASSISTANT_DECL void onRegisterError(register_error_callback_type);
  OPENBUS_ASSISTANT_DECL void onFatalError(fatal_error_callback_type);
  OPENBUS_ASSISTANT_DECL void 
  registerService(scs::core::IComponent_var, 
                  idl_or::ServicePropertySeq = idl_or::ServicePropertySeq());
  OPENBUS_ASSISTANT_DECL idl_or::ServiceOfferDescSeq 
  findServices(idl_or::ServicePropertySeq, int) const;
  OPENBUS_ASSISTANT_DECL idl_or::ServiceOfferDescSeq getAllServices(int) const;
  OPENBUS_ASSISTANT_DECL std::pair< idl_ac::LoginProcess_ptr, idl::OctetSeq > 
  startSharedAuth(int);
  OPENBUS_ASSISTANT_DECL void shutdown();
  CORBA::ORB_var orb() const;
  logger::logger & logging() const;

  // public static functions
  static OPENBUS_ASSISTANT_DECL idl_or::ServicePropertySeq 
  createFacetAndEntityProperty(const char *, const char *);
  static OPENBUS_ASSISTANT_DECL idl_or::ServiceOfferDescSeq 
  filterWorkingOffers(idl_or::ServiceOfferDescSeq);
  static OPENBUS_ASSISTANT_DECL Assistant 
  createWithPassword(const char *, const char *, const char *, unsigned short, 
                     int &, char **, 
                     login_error_callback_type = login_error_callback_type(), 
                     register_error_callback_type = register_error_callback_type(), 
                     fatal_error_callback_type = fatal_error_callback_type(), 
                     find_error_callback_type = find_error_callback_type(), 
                     logger::level = logger::warning_level);
  static OPENBUS_ASSISTANT_DECL Assistant 
  createWithPrivateKey(const char *, const PrivateKey, const char *, 
                       unsigned short, int &, char **, 
                       login_error_callback_type = login_error_callback_type(), 
                       register_error_callback_type = register_error_callback_type(), 
                       fatal_error_callback_type = fatal_error_callback_type(), 
                       find_error_callback_type = find_error_callback_type(), 
                       logger::level = logger::warning_level);
  static OPENBUS_ASSISTANT_DECL Assistant 
  createWithSharedAuth(shared_auth_callback_type, const char *, 
                       unsigned short, int &, char **, 
                       login_error_callback_type = login_error_callback_type(), 
                       register_error_callback_type = register_error_callback_type(), 
                       fatal_error_callback_type = fatal_error_callback_type(), 
                       find_error_callback_type = find_error_callback_type(), 
                       logger::level = logger::warning_level);
};

API - SDK Openbus C++

namespace openbus {
  struct BusChanged;
  struct AlreadyLoggedIn;
  struct InvalidLoginProcess;
  struct InvalidPropertyValue;

  class Connection;
}

// In header: <include/openbus/Connection.hpp>


struct BusChanged {

  // public member functions
  const char * what() const;
};

// In header: <include/openbus/Connection.hpp>


struct AlreadyLoggedIn {

  // public member functions
  const char * what() const;
};

// In header: <include/openbus/Connection.hpp>


struct InvalidLoginProcess {

  // public member functions
  const char * what() const;
};

// In header: <include/openbus/Connection.hpp>


struct InvalidPropertyValue {
  // construct/copy/destruct
  InvalidPropertyValue(const std::string &, const std::string &);
  ~InvalidPropertyValue();

  // public member functions
  const char * what() const;

  // public data members
  const std::string property;
  const std::string value;
};

// In header: <include/openbus/Connection.hpp>


class Connection {
public:
  // types
  typedef std::vector< std::pair< std::string, std::string > >    ConnectionProperties;  
  typedef boost::function< void(Connection &, idl_ac::LoginInfo)> InvalidLoginCallback_t;

  // construct/copy/destruct
  Connection(const std::string, const unsigned short, CORBA::ORB_ptr, 
             IOP::Codec *, PortableInterceptor::SlotId, 
             PortableInterceptor::SlotId, PortableInterceptor::SlotId, 
             PortableInterceptor::SlotId, OpenBusContext &, 
             const ConnectionProperties &);
  Connection(const Connection &);
  Connection& operator=(const Connection &);
  ~Connection();

  // public member functions
  void loginByPassword(const std::string &, const std::string &);
  void loginByCertificate(const std::string &, const PrivateKey &);
  std::pair< idl_ac::LoginProcess_ptr, idl::OctetSeq > startSharedAuth();
  void loginBySharedAuth(idl_ac::LoginProcess_ptr, const idl::OctetSeq &);
  bool logout();
  void onInvalidLogin(InvalidLoginCallback_t);
  InvalidLoginCallback_t onInvalidLogin() const;
  const idl_ac::LoginInfo * login() const;
  const std::string busid() const;

  // private member functions
  void login(idl_ac::LoginInfo &, idl_ac::ValidityTime);
  void checkBusid() const;
  bool _logout(bool = true);
  CORBA::ORB_ptr orb() const;
  idl_ac::LoginRegistry_var login_registry() const;
  idl_ac::AccessControl_var access_control() const;
  const idl_ac::LoginInfo * _login() const;
  idl_or::OfferRegistry_var getOfferRegistry() const;
  idl_ac::LoginRegistry_var getLoginRegistry() const;
};

namespace openbus {
  struct InvalidPrivateKey;

  class PrivateKey;
}

// In header: <include/openbus/crypto/PrivateKey.hpp>


struct InvalidPrivateKey {

  // public member functions
  const char * what() const;
};

// In header: <include/openbus/crypto/PrivateKey.hpp>


class PrivateKey {
public:
  // construct/copy/destruct
  PrivateKey();
  PrivateKey(const CORBA::OctetSeq &);
  PrivateKey(const char *, std::size_t);
  explicit PrivateKey(const std::string &);

  // public member functions
  OPENBUS_SDK_DECL CORBA::OctetSeq 
  decrypt(const unsigned char *, std::size_t) const;
  OPENBUS_SDK_DECL CORBA::OctetSeq pubKey();
  const CORBA::OctetSeq & octetSeq() const;

  // private member functions
  void set_pkey(const CORBA::OctetSeq &);
};

API - SDK Openbus C++

namespace openbus {
  struct CallerChain;

  class OpenBusContext;
  bool operator!=(CallerChain const & lhs, CallerChain const & rhs);
}namespace tecgraf {
  namespace openbus {
    namespace core {
      namespace v2_0 {
        namespace services {
          namespace access_control {
            bool operator==(const LoginInfo & lhs, const LoginInfo & rhs);
            bool operator!=(const LoginInfo & lhs, const LoginInfo & rhs);
          }
        }
      }
    }
  }
}

// In header: <include/openbus/OpenBusContext.hpp>


struct CallerChain {
  // construct/copy/destruct
  CallerChain();
  CallerChain(const std::string, const idl_ac::LoginInfo &, 
              const idl_ac::LoginInfoSeq &, const idl_ac::LoginInfo &, 
              const idl_cr::SignedCallChain &);
  CallerChain(const std::string, const idl_ac::LoginInfo &, 
              const idl_ac::LoginInfoSeq &, const idl_ac::LoginInfo &);

  // public member functions
  const std::string busid() const;
  const idl_ac::LoginInfo & target() const;
  const idl_ac::LoginInfoSeq & originators() const;
  const idl_ac::LoginInfo & caller() const;

  // private member functions
  const idl_cr::SignedCallChain * signedCallChain() const;
  void signedCallChain(idl_cr::SignedCallChain);
};

// In header: <include/openbus/OpenBusContext.hpp>


class OpenBusContext {
public:
  // types
  typedef boost::function< Connection *(OpenBusContext &context, const std::string busId, const std::string loginId, const std::string operation)> CallDispatchCallback;

  // construct/copy/destruct
  OpenBusContext(CORBA::ORB_ptr, IOP::Codec *, PortableInterceptor::SlotId, 
                 PortableInterceptor::SlotId, PortableInterceptor::SlotId, 
                 PortableInterceptor::SlotId, PortableInterceptor::SlotId);
  OpenBusContext(const OpenBusContext &);
  OpenBusContext& operator=(const OpenBusContext &);

  // public member functions
  void onCallDispatch(CallDispatchCallback);
  CallDispatchCallback onCallDispatch() const;
  std::auto_ptr< Connection > 
  createConnection(const std::string, unsigned short, 
                   const Connection::ConnectionProperties & = Connection::ConnectionProperties());
  Connection * setDefaultConnection(Connection *);
  Connection * getDefaultConnection() const;
  Connection * setCurrentConnection(Connection *);
  Connection * getCurrentConnection() const;
  CallerChain getCallerChain();
  void joinChain(const CallerChain &);
  void exitChain();
  CallerChain getJoinedChain();
  CORBA::ORB_ptr orb() const;
  idl_or::OfferRegistry_ptr getOfferRegistry() const;
  idl_ac::LoginRegistry_ptr getLoginRegistry() const;

  // private member functions
  void orb(CORBA::ORB_ptr);
  Connection * getDispatchConnection();
};

namespace openbus {
  OPENBUS_SDK_DECL CORBA::ORB * ORBInitializer(int &, char **);
}

// In header: <include/openbus/ORBInitializer.hpp>


OPENBUS_SDK_DECL CORBA::ORB * ORBInitializer(int & argc, char ** argv);

namespace tecgraf {
  namespace openbus {
    namespace core {
      namespace v2_0 {
        namespace services {
          namespace access_control {
            struct LoginAuthenticationInfo;
            struct LoginInfo;
            struct CallChain;

            typedef sequence< octet > EntityCertificate;  // Certificado que utilizado na autenticação de entidades. 
            typedef sequence< LoginInfo > LoginInfoSeq;  // Lista de informações de login. 
            typedef unsigned long ValidityTime;  // Representa o tempo de validade de um login (em segundos). 

            const unsigned long InvalidCredentialCode;            // Minor code de NO_PERMISSION: credencial inválida. 
            const unsigned long InvalidChainCode;            // Minor code de NO_PERMISSION: cadeia inválida. 
            const unsigned long InvalidLoginCode;            // Minor code de NO_PERMISSION: login inválida. 
            const unsigned long UnverifiedLoginCode;            // Minor code de NO_PERMISSION: não foi possível verificar o login. 
            const unsigned long UnknownBusCode;            // Minor code de NO_PERMISSION: barramento desconhecido. 
            const unsigned long InvalidPublicKeyCode;            // Minor code de NO_PERMISSION: chave pública inválida. 
            const unsigned long NoCredentialCode;            // Minor code de NO_PERMISSION: credencial não foi encontrada. 
            const unsigned long NoLoginCode;            // Minor code de NO_PERMISSION: ausência de login. 
            const unsigned long InvalidRemoteCode;            // Minor code de NO_PERMISSION: servidor chamado é inválido. 
          }
        }
      }
    }
  }
}

// In header: <src/access_control.idl>


struct LoginAuthenticationInfo {

  // public data members
  HashValue hash;  // Hash da chave pública a ser associada ao login. 
  OctetSeq data;  // Senha ou resposta de desafio para autenticação. 
};

// In header: <src/access_control.idl>


struct LoginInfo {

  // public data members
  Identifier id;  // Identificador da login. 
  Identifier entity;  // Identificador da entidade que fez login. 
};

// In header: <src/access_control.idl>


struct CallChain {

  // public data members
  Identifier target;  // Identificador de login a quem a cadeia se destina. 
  LoginInfoSeq originators;  // Informações de login das entidades que realizaram as chamadas em cadeia que originam essa chamada. 
  LoginInfo caller;  // Informações de login da entidades que efetivamente fez chamada atual (última da cadeia). 
};

// In header: <src/access_control.idl>

const unsigned long InvalidCredentialCode;

// In header: <src/access_control.idl>

const unsigned long InvalidChainCode;

// In header: <src/access_control.idl>

const unsigned long InvalidLoginCode;

// In header: <src/access_control.idl>

const unsigned long UnverifiedLoginCode;

// In header: <src/access_control.idl>

const unsigned long UnknownBusCode;

// In header: <src/access_control.idl>

const unsigned long InvalidPublicKeyCode;

// In header: <src/access_control.idl>

const unsigned long NoCredentialCode;

// In header: <src/access_control.idl>

const unsigned long NoLoginCode;

// In header: <src/access_control.idl>

const unsigned long InvalidRemoteCode;

namespace tecgraf {
  namespace openbus {
    namespace core {
      namespace v2_0 {
        typedef string Identifier;  // Representa um identificador único. 
        typedef sequence< Identifier > IdentifierSeq;  // Representa uma sequência de identificadores. 
        typedef octet HashValue;  // Array de um hash. 
        typedef octet EncryptedBlock;  // Bloco encriptado. 
        typedef sequence< octet > OctetSeq;  // Representa uma sequência de bytes. 

        const octet MajorVersion;        // Major da versão. 
        const octet MinorVersion;        // Minor da versão. 
        const string BusLogin;        // Login usado pelo Barramento. 
        const string BusEntity;        // Nome da entidade do Barramento. 
        const string BusObjectKey;        // Chave da entidade do Barramento. 
        const unsigned short HashValueSize;        // Tamanho do hash. 
        const unsigned short EncryptedBlockSize;        // Tamanho do bloco encriptado. 
        namespace services {
        }
      }
    }
  }
}

// In header: <src/core.idl>

const octet MajorVersion;

// In header: <src/core.idl>

const octet MinorVersion;

// In header: <src/core.idl>

const string BusLogin;

// In header: <src/core.idl>

const string BusEntity;

// In header: <src/core.idl>

const string BusObjectKey;

// In header: <src/core.idl>

const unsigned short HashValueSize;

// In header: <src/core.idl>

const unsigned short EncryptedBlockSize;

namespace tecgraf {
  namespace openbus {
    namespace core {
      namespace v2_0 {
        namespace credential {
          struct SignedCallChain;
          struct CredentialData;
          struct CredentialReset;

          const unsigned long CredentialContextId;          // Identificador de contexto do service context utilizado para transmitir a credencial. 
        }
      }
    }
  }
}

// In header: <src/credential.idl>


struct SignedCallChain {

  // public data members
  EncryptedBlock signature;  // Hash de 'encoded' assinado pelo barramento. 
  OctetSeq encoded;  // estrutura services::access_control::CallChain codificada usando CDR 
};

// In header: <src/credential.idl>


struct CredentialData {

  // public data members
  Identifier bus;  // UUID do barramento. 
  Identifier login;  // UUID de quem inicia a comunicação (requisitante) 
  unsigned long session;  // Identificador da sessão. 
  unsigned long ticket;  // Contado crescente e monotômico. 
  HashValue hash;  // Hash SHA-256 de: versão do protocolo + valor aleatório de 16-bytes + ticket + operation_name. 
  SignedCallChain chain;  // Cadeia de chamadas assinada. 
};

// In header: <src/credential.idl>


struct CredentialReset {

  // public data members
  Identifier login;  // UUID do alvo da comunicação (receptor) 
  unsigned long session;  // Identificador da sessão. 
  EncryptedBlock challenge;  // Valor aleatório de 16-bytes encriptado. 
};

// In header: <src/credential.idl>

const unsigned long CredentialContextId;

namespace tecgraf {
  namespace openbus {
    namespace core {
      namespace v2_0 {
        namespace services {
          namespace offer_registry {
            struct ServiceProperty;
            struct ServiceOfferDesc;
            struct OfferObserverSubscriptionDesc;
            struct OfferRegistryObserverSubscriptionDesc;
            struct EntityCategoryDesc;
            struct RegisteredEntityDesc;

            typedef string FacetName;  // Identificação de uma faceta de componente SCS. 
            typedef sequence< FacetName > FacetNameSeq;  // Sequência de facetas de componentes SCS. 
            typedef sequence< ServiceProperty > ServicePropertySeq;  // Sequência de propriedades que descrevem uma oferta de serviço. 
            typedef scs::core::IComponent OfferedService;  // Referência para um serviço ofertado. 
            typedef sequence< ServiceOfferDesc > ServiceOfferDescSeq;  // Sequência de descrições de oferta de serviço. 
            typedef sequence< OfferObserverSubscriptionDesc > OfferObserverSubscriptionDescSeq;  // Sequência de descrições de inscrições de observadores. 
            typedef sequence< OfferRegistryObserverSubscriptionDesc > OfferRegistryObserverSubscriptionDescSeq;  // Sequência de descrições de inscrições de observadores. 
            typedef long Cookie;  // Identificador da inscrição de um observador. 
            typedef sequence< EntityCategoryDesc > EntityCategoryDescSeq;  // Sequência de descrições de catergorias de entidade. 
            typedef sequence< RegisteredEntityDesc > RegisteredEntityDescSeq;  // Sequência de descrições sobre entidades registradas. 
            typedef string InterfaceId;  // Identificação de uma interface. 
            typedef sequence< InterfaceId > InterfaceIdSeq;  // Sequência de identificações de interface. 
          }
        }
      }
    }
  }
}

// In header: <src/offer_registry.idl>


struct ServiceProperty {

  // public data members
  string name;
  string value;  // nome da propriedade 
};