Table of Contents
Esse manual oferece uma visão geral de implementação de serviços com uso do barramento Openbus, assim como a explicação de várias características e opções. Os seguintes conhecimentos são assumidos pelo documento:
A proposta do manual é capacitar o indivíduo, que atenda aos pré-requisitos do documento, a escrever serviços para o barramento Openbus dentro do escopo dessa API.
Para usar o SDK, primeiro você precisa fazer o seu Download. Baixe a versão binária que seja mais próxima de sua configuração e descompacte-a em alguma pasta aonde será feito o seu desenvolvimento.
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:
Table 1. Padrão de nomenclatura de bibliotecas
Simbolo |
Descrição |
---|---|
|
Se a biblioteca for compilada para o ORB Mico. É o caso para todas as bibliotecas que usam CORBA na versão 2.0.0 do Openbus. É possível que outros ORBs venham a ser suportados no futuro. |
|
Se a biblioteca for compilada com suporte a múltiplas threads |
|
Se a biblioteca for compilada estaticamente. Em linux isso também
significa que o arquivo termina em |
|
Se a biblioteca for compilada com simbolos de debug e sem otimização. |
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.
Table 2. Padrão de nomenclatura de bibliotecas
Projeto |
Macro |
Descrição |
---|---|---|
Logger - Biblioteca de Log |
|
Macro que deve ser definida sempre que usando um dos pacotes da
biblioteca logger sem o prefixo |
SCS |
|
Macro que deve ser definida sempre que usando um dos pacotes da
biblioteca SCS com o prefixo |
API Básica |
|
Macro que deve ser definida sempre que usando um dos pacotes da
biblioteca Openbus com o prefixo |
|
Macro que deve ser definida sempre que usando um dos pacotes da
biblioteca Assistant com o prefixo
| |
|
Macro que pode ser definida para eliminar a dependência do Assistant com a biblioteca Boost.Parameter
. Remove a interface de Named Parameters do construtor de |
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 |
Primeiramente, encontramos no pacote o demo hello no caminho demo/hello
.
Lá, temos as seguintes pastas:
Table 3. Árvore do demo Hello
Diretório |
Descrição |
---|---|
|
Se o pacote contiver os demos compilados |
|
Diretório que contém o arquivo |
|
Diretório que contém o arquivo |
|
Diretório que contém o arquivo |
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:
Table 4. Parâmetros de linha de comando básicos do compilador IDL
Parâmetro |
Descrição |
---|---|
|
Faz geração de código para os objetos globais de typecode de cada interface gerada pelo compilador IDL |
|
Faz geração de código para uso do Portable Object Adapter |
|
Não leva em consideração o caminho dos arquivos para construção
das directivas de |
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-s-d -lcrypto -llogger-mt-s-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
Assistant é o nome de uma abstração da biblioteca de acesso do Openbus. Ela visa facilitar os recursos mais utilizados pelos clientes do barramento. Para atingir esse objetivo, alguns sacrifícios foram feitos e portanto o Assistant não é tão flexível quanto o uso direto da API básica, mas atende a maioria dos casos de usos involvendo o barramento Openbus.
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.
Prover um serviço no Openbus usando o Assistant é bem simples. Para isso, precisamos construir uma instância da classe Assistant que nos proverá as funções necessárias para ofertar serviços no barramento.
Em C++ instancia-se a classe openbus::assistant::Assistant
usando, preferencialmente, named parameters.
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 | ||||||
---|---|---|---|---|---|---|---|
|
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 | ||||||
|
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
| ||||||
|
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. | ||||||
|
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. | ||||||
|
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. | ||||||
|
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 | ||||||
|
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. | ||||||
|
Function object de assinatura | ||||||
|
Número de segundos de espera em caso de erros. Esse argumento modifica o tempo entre tentativas de operações com o barramento. | ||||||
|
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: | ||||||
|
Número de argumentos no array passado em
_argv. Esse parâmetro é usado para passar o par argc e argv da
função | ||||||
|
Array de argumentos de linha de comando. Esse
parâmetro é usado para passar o par argc e argv da função
| ||||||
|
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.
| ||||||
|
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
| ||||||
|
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.
|
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 |
Como vimos nos parâmetros disponíveis para construção do Assistant, temos disponíveis três métodos de autenticação:
A autenticação por usuário e senha se faz com os parâmetros _username
e _password
.
using namespace openbus::assistant::keywords; openbus::assistant::Assistant assistant ("localhost", 2089, _username = "usuario" , _password = "senha");
Como vimos anteriormente, após a construção de openbus::assistant::Assistant
,
a autenticação não necessariamente já ocorreu, pois a mesma é feita
assincronamente e pode se repetir indefinidamente, sem intervenção do
usuário. O Assistant assume que o cliente
pretende se manter logado por todo o tempo em que o Assistant
se mantiver vivo. E por isso em qualquer erro que implique na perda de
autenticação o Assistant tratará-lo
tentando se autenticar novamente até conseguir. Esse é uma das principais
vantagens de se usar o Assistant.
Existem duas formas de se autenticar por chave privada no Assistant do C++:
openbus::PrivateKey
como argumento
Nem sempre a chave se encontra em um arquivo, como por exemplo no caso
de construção de uma chave privada dinamicamente, ou recebida por algum
método de IPC. Neste caso faz mais sentido usar openbus::PrivateKey
com um de seus construtores.
CORBA::OctetSeq key = GetPrivateKey(); using namespace openbus::assistant::keywords; openbus::assistant::Assistant assistant ("localhost", 2089, _entity = "tutorial" , _private_key = openbus::PrivateKey(key));
Porém, se a chave estiver em um arquivo seria muito mais fácil passar
o nome do arquivo do que fazer a leitura do mesmo em um OctetSeq. Neste
caso é só usar o parâmetro _private_key_filename
:
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 |
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 |
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 |
Warning | |
---|---|
O compilador Visual C++ 2005 possui um bug, aonde o |
Toda operação remota está sujeita a falhas. Como a operação precisa coordenar programas diferentes, rodando em arquiteturas e localidades diferentes, inúmeras falhas são possíveis, sendo as mais comuns uma falha de comunicação física como por exemplo o cabo de rede desconectado. Ou o serviço pode não estar mais rodando, ou ter sido fechado.
Portanto, é essencial que toda chamada remota esteja protegida, de algum
modo, por tratamentos de erros. Tratamento de erro em CORBA
é feito através de exceções. A exceção CORBA::TRANSIENT
significa que o serviço não conseguiu se comunicar com o outro ponto;
a exceção CORBA::COMM_FAILURE
significa a mesma coisa,
mas a conexão não conseguiu ser iniciada por algum motivo; A exceção
CORBA::OBJECT_NOT_EXIST
significa que o serviço
que deveria prover esse objeto CORBA já não mais
possui esse objeto em sua memória, e a sua referência deve ser descartada.
Outras exceções herdam de CORBA::SystemException
.
Se fossemos tratar erros para que o programa não termine inesperadamente,
poderíamos fazer o seguinte:
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&) {}
Esse programa exemplo retornará com sucesso se nenhuma oferta for retornada
ou se nenhuma operação remota obtiver sucesso. Se quisermos que a aplicação
tente indefinidamente até obter sucesso, como fizemos com findServices
, podemos mudar para o seguinte:
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); } } }
openbus::assistant::Assistant — Classe Openbus com API do assistants.
// 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); };
A classe Openbus deve ser instanciada por um de seus dois named parameters startByPassword e startByCertificate. Essa instancia mantera as ofertas adicionadas a ela e um login validos no barramento indicado em sua construcao enquanto um erro fatal nao ocorre e/ou um shutdown nao e invocado.
Assistant
public
construct/copy/destructAssistant(NamedParameters...);
Assistant(Assistant const & other);
Assistant();
Assistant
public member functionsOPENBUS_ASSISTANT_DECL void onLoginError(login_error_callback_type f);Atribui uma funcao callback para erros de login.
OPENBUS_ASSISTANT_DECL void onRegisterError(register_error_callback_type f);Atribui uma funcao callback para erros de registro de ofertas.
OPENBUS_ASSISTANT_DECL void onFatalError(fatal_error_callback_type f);Atribui uma funcao callback para erros fatais que impossibilitam a continuacao da execucao do assistant.
OPENBUS_ASSISTANT_DECL void registerService(scs::core::IComponent_var component, idl_or::ServicePropertySeq properties = idl_or::ServicePropertySeq());Solicita que o assistente registre um serviço no barramento.
Esse método notifica o assistente de que o serviço fornecido deve ser mantido como uma oferta de serviço válida no barramento. Para tanto, sempre que o assistente restabelecer o login esse serviço será registrado novamente no barramento.
Para que o registro de serviços seja bem sucedido é necessário que o ORB utilizado pelo assistente esteja processando chamadas, por exemplo, fazendo com que a aplicação chame o método 'ORB::run()'.
Caso ocorram erros, a callback de tratamento de erro apropriada será chamada.
Parameters: |
|
OPENBUS_ASSISTANT_DECL idl_or::ServiceOfferDescSeq findServices(idl_or::ServicePropertySeq properties, int retries) const;Busca por ofertas que apresentem um conjunto de propriedades definido.
Serão selecionadas apenas as ofertas de serviço que apresentem todas as propriedades especificadas. As propriedades utilizadas nas buscas podem ser aquelas fornecidas no momento do registro da oferta de serviço, assim como as propriedades automaticamente geradas pelo barramento.
Caso ocorram erros, a callback de tratamento de erro apropriada será chamada. Se o número de tentativas se esgotar e não houver sucesso, uma sequência vazia será retornada.
Parameters: |
| ||||
Returns: | Sequência de descrições de ofertas de serviço encontradas. |
OPENBUS_ASSISTANT_DECL idl_or::ServiceOfferDescSeq getAllServices(int retries) const;Devolve uma lista de todas as ofertas de serviço registradas.
Caso ocorram erros, a callback de tratamento de erro apropriada será chamada. Se o número de tentativas se esgotar e não houver sucesso, uma sequência vazia será retornada.
Parameters: |
| ||
Returns: | Sequência de descrições de ofertas de serviço registradas. |
OPENBUS_ASSISTANT_DECL std::pair< idl_ac::LoginProcess_ptr, idl::OctetSeq > startSharedAuth(int retries);Inicia o processo de login por autenticação compartilhada.
A autenticação compartilhada permite criar um novo login compartilhando a mesma autenticação do login atual da conexão. Portanto essa operação só pode ser chamada enquanto a conexão estiver autenticada, caso contrário a exceção de sistema CORBA::NO_PERMISSION{NoLogin} é lançada. As informações fornecidas por essa operação devem ser passadas para a operação 'loginBySharedAuth' para conclusão do processo de login por autenticação compartilhada. Isso deve ser feito dentro do tempo de lease definido pelo administrador do barramento. Caso contrário essas informações se tornam inválidas e não podem mais ser utilizadas para criar um login.
Parameters: |
| ||
Returns: | Objeto que representa o processo de login iniciado. |
OPENBUS_ASSISTANT_DECL void shutdown();Encerra o funcionamento do assistente liberando todos os recursos alocados por ele.
Essa operação deve ser chamada antes do assistente ser descartado, pois como o assistente tem um funcionamento ativo, ele continua funcionando e consumindo recursos mesmo que a aplicação não tenha mais referências a ele. Em particular, alguns dos recursos gerenciados pelo assistente são:
Login no barramento;
Ofertas de serviço registradas no barramento;
Observadores de serviço registrados no barramento;
Threads de manutenção desses recursos no barramento;
Conexão default no ORB sendo utilizado;
Em particular, o processamento de requisições do ORB (e.g. através da operação 'ORB::run()') não é gerido pelo assistente, portanto é responsabilidade da aplicação iniciar e parar esse processamento (e.g. através da operação 'ORB::shutdown()')
CORBA::ORB_var orb() const;ORB utilizado pelo assistente.
logger::logger & logging() const;
Assistant
public static functionsstatic OPENBUS_ASSISTANT_DECL idl_or::ServicePropertySeq createFacetAndEntityProperty(const char * facet, const char * entity);Constroi sequencia de propriedades para determinada faceta e entidade.
Parameters: |
|
static OPENBUS_ASSISTANT_DECL idl_or::ServiceOfferDescSeq filterWorkingOffers(idl_or::ServiceOfferDescSeq offers);Filtra ofertas e retorna somente as que se encontram responsivas.
Parameters: |
|
static OPENBUS_ASSISTANT_DECL Assistant createWithPassword(const char * username, const char * password, const char * host, unsigned short port, int & argc, char ** argv, login_error_callback_type login_error = login_error_callback_type(), register_error_callback_type register_error = register_error_callback_type(), fatal_error_callback_type fatal_error = fatal_error_callback_type(), find_error_callback_type find_error = find_error_callback_type(), logger::level l = logger::warning_level);Constroi um Openbus com informacao de autenticacao por usuario e senha.
static OPENBUS_ASSISTANT_DECL Assistant createWithPrivateKey(const char * entity, const PrivateKey privKey, const char * host, unsigned short port, int & argc, char ** argv, login_error_callback_type login_error = login_error_callback_type(), register_error_callback_type register_error = register_error_callback_type(), fatal_error_callback_type fatal_error = fatal_error_callback_type(), find_error_callback_type find_error = find_error_callback_type(), logger::level l = logger::warning_level);Constriu um Openbus com informacao de autenticacao por certificado.
static OPENBUS_ASSISTANT_DECL Assistant createWithSharedAuth(shared_auth_callback_type shared_auth_callback, const char * host, unsigned short port, int & argc, char ** argv, login_error_callback_type login_error = login_error_callback_type(), register_error_callback_type register_error = register_error_callback_type(), fatal_error_callback_type fatal_error = fatal_error_callback_type(), find_error_callback_type find_error = find_error_callback_type(), logger::level l = logger::warning_level);Constriu um Openbus com informacao de autenticacao por Shared Authentication.
API - SDK Openbus C++
TECGRAF_SDK_OPENBUS_LRUCACHE_H_
namespace openbus { struct BusChanged; struct AlreadyLoggedIn; struct InvalidLoginProcess; struct InvalidPropertyValue; class Connection; bool operator==(const Connection::SecretSession & lhs, const Connection::SecretSession & rhs); bool operator!=(const Connection::SecretSession & lhs, const Connection::SecretSession & rhs); namespace interceptors { } }
openbus::BusChanged
// In header: <include/openbus/Connection.hpp> struct BusChanged : public exception { // public member functions const char * what() const; };
openbus::AlreadyLoggedIn
// In header: <include/openbus/Connection.hpp> struct AlreadyLoggedIn : public exception { // public member functions const char * what() const; };
openbus::InvalidLoginProcess
// In header: <include/openbus/Connection.hpp> struct InvalidLoginProcess : public exception { // public member functions const char * what() const; };
openbus::InvalidPropertyValue
// In header: <include/openbus/Connection.hpp> struct InvalidPropertyValue : public exception { // 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; };
openbus::Connection — Conexão para acesso identificado a um barramento.
// 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; // member classes/structs/unions struct SecretSession { // construct/copy/destruct SecretSession(); // public data members CORBA::ULong id; std::string remote_id; boost::array< unsigned char, secret_size > secret; CORBA::ULong ticket; }; // construct/copy/destruct Connection(const std::string, const unsigned short, CORBA::ORB_ptr, boost::shared_ptr< interceptors::orb_info >, 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; };
Uma conexão é usada para realizar acessos identificados a um barramento. Denominamos esses acessos identificados ao barramento de login. Cada login possui um identificador único e está sempre associado ao nome de uma entidade que é autenticada no momento do estabelecimento do login. Há basicamente três formas de autenticação de entidade disponíveis:
Por Senha: veja a operação 'loginByPassword'
Por Certificado de login: veja a operação 'loginByCertificate'
Por Autenticação compartilhada: veja a operação 'loginBySharedAuth'
A entidade associada ao login é responsável por todas as chamadas feitas através daquela conexão e essa entidade deve ser levada em consideração pelos serviços ofertados no barramento para decidir aceitar ou recusar chamadas.
É possível uma aplicação assumir múltiplas identidades ao acessar um ou mais barramentos criando múltiplas conexões para esses barramentos.
É importante notar que a conexão não é usada diretamente pela aplicação ao realizar ou receber chamadas, pois as chamadas ocorrem usando proxies e servants de um ORB. As conexões que são efetivamente usadas nas chamadas do ORB são definidas através do OpenBusContext associado ao ORB.
Connection
public
typestypedef boost::function< void(Connection &, idl_ac::LoginInfo)> InvalidLoginCallback_t;
Tipo que representa um objeto função ('function object') a ser chamado quando uma notificação de login inválido é recebida. Caso alguma exceção ocorra durante a execução do método e não seja tratada, o erro será capturado pelo interceptador e registrado no log.
O tipo InvalidLoginCallback_t é um typedef de boost::function. Para documentação dessa biblioteca acesse http://www.boost.org/doc/libs/1_47_0/doc/html/function.html
Connection
public
construct/copy/destructConnection(const std::string host, const unsigned short port, CORBA::ORB_ptr, boost::shared_ptr< interceptors::orb_info >, OpenBusContext &, const ConnectionProperties & props);
Connection
deve ser adquirido atraves de: OpenBusContext::createConnection()
Connection(const Connection &);
Connection& operator=(const Connection &);
~Connection();
Connection
public member functionsvoid loginByPassword(const std::string & entity, const std::string & password);
Efetua login no barramento como uma entidade usando autenticação por senha.
A autenticação por senha é validada usando um dos validadores de senha definidos pelo adminsitrador do barramento.
Parameters: |
| ||||
Throws: | AlreadyLoggedIn A conexão já está logada. Senha fornecida para autenticação da entidade não foi validada pelo barramento. Ocorreu uma falha interna nos serviços do barramento que impediu a autenticação da conexão. |
void loginByCertificate(const std::string & entity, const PrivateKey &);Efetua login de uma entidade usando autenticação por certificado.
A autenticação por certificado é validada usando um certificado de login registrado pelo adminsitrador do barramento.
Parameters: |
| ||
Throws: | AlreadyLoggedIn A conexão já está autenticada. A chave privada fornecida não corresponde ao certificado da entidade registrado no barramento indicado. Não há certificado para essa entidade registrado no barramento indicado. Ocorreu uma falha interna nos serviços do barramento que impediu a autenticação da conexão. |
std::pair< idl_ac::LoginProcess_ptr, idl::OctetSeq > startSharedAuth();Inicia o processo de login por autenticação compartilhada.
A autenticação compartilhada permite criar um novo login compartilhando a mesma autenticação do login atual da conexão. Portanto essa operação só pode ser chamada enquanto a conexão estiver autenticada, caso contrário a exceção de sistema CORBA::NO_PERMISSION{NoLogin} é lançada. As informações fornecidas por essa operação devem ser passadas para a operação 'loginBySharedAuth' para conclusão do processo de login por autenticação compartilhada. Isso deve ser feito dentro do tempo de lease definido pelo administrador do barramento. Caso contrário essas informações se tornam inválidas e não podem mais ser utilizadas para criar um login.
Returns: | Um par composto de um objeto que representa o processo de login iniciado e de um segredo a ser fornecido na conclusão do processo de login. |
Throws: | idl::ServiceFailure Ocorreu uma falha interna nos serviços do barramento que impediu o estabelecimento da conexão. |
void loginBySharedAuth(idl_ac::LoginProcess_ptr loginProcess, const idl::OctetSeq & secret);Efetua login de uma entidade usando autenticação compartilhada.
A autenticação compartilhada é feita a partir de informações obtidas a através da operação 'startSharedAuth' de uma conexão autenticada.
Parameters: |
| ||||
Throws: | InvalidLoginProcess O LoginProcess informado é inválido, por exemplo depois de ser cancelado ou ter expirado. A conexão já está autenticada. O segredo fornecido não corresponde ao esperado pelo barramento. Ocorreu uma falha interna nos serviços do barramento que impediu o estabelecimento da conexão. |
bool logout();Efetua logout da conexão, tornando o login atual inválido.
Após a chamada a essa operação a conexão fica desautenticada, implicando que qualquer chamada realizada pelo ORB usando essa conexão resultará numa exceção de sistema 'CORBA::NO_PERMISSION{NoLogin}' e chamadas recebidas por esse ORB serão respondidas com a exceção 'CORBA::NO_PERMISSION{UnknownBus}' indicando que não foi possível validar a chamada pois a conexão está temporariamente desautenticada.
Returns: | Verdadeiro se o processo de logout for concluído com êxito e falso se a conexão já estiver desautenticada (login inválido) ou se houver uma falha durante o processo remoto do logout. |
void onInvalidLogin(InvalidLoginCallback_t p);Callback a ser chamada quando o login atual se tornar inválido.
Esse atributo é utilizado para definir um objeto função (function object) que implementa uma interface de callback a ser chamada sempre que a conexão receber uma notificação de que o seu login está inválido. Essas notificações ocorrem durante chamadas realizadas ou recebidas pelo barramento usando essa conexão. Um login pode se tornar inválido caso o administrador explicitamente o torne inválido ou caso a thread interna de renovação de login não seja capaz de renovar o lease do login a tempo. Caso esse atributo seja um InvalidLoginCallback_t 'default-constructed', nenhum objeto de callback é chamado na ocorrência desse evento.
Durante a execução dessa callback um novo login pode ser restabelecido. Neste caso, a chamada do barramento que recebeu a notificação de login inválido é refeita usando o novo login, caso contrário, a chamada original lança a exceção de de sistema 'CORBA::NO_PERMISSION{NoLogin}'.
O tipo InvalidLoginCallback_t é um typedef de boost::function. Para documentação dessa biblioteca acesse http://www.boost.org/doc/libs/1_47_0/doc/html/function.html
InvalidLoginCallback_t onInvalidLogin() const;Retorna a callback configurada para ser chamada quando o login atual se torna inválido.
const idl_ac::LoginInfo * login() const;Informações do login dessa conexão ou 'null' se a conexão não está autenticada, ou seja, não tem um login válido no barramento.
const std::string busid() const;
Identificador do barramento ao qual essa conexão se refere.
Connection
private member functionsvoid login(idl_ac::LoginInfo & loginInfo, idl_ac::ValidityTime validityTime);
void checkBusid() const;
bool _logout(bool local = 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;
openbus::Connection::SecretSession
// In header: <include/openbus/Connection.hpp> struct SecretSession { // construct/copy/destruct SecretSession(); // public data members CORBA::ULong id; std::string remote_id; boost::array< unsigned char, secret_size > secret; CORBA::ULong ticket; };
TECGRAF_SDK_OPENBUS_LRUCACHE_H_
// In header: <include/openbus/Connection.hpp>
TECGRAF_SDK_OPENBUS_LRUCACHE_H_
namespace openbus { struct InvalidPrivateKey; class PrivateKey; }
openbus::InvalidPrivateKey
// In header: <include/openbus/crypto/PrivateKey.hpp> struct InvalidPrivateKey : public exception { // public member functions const char * what() const; };
openbus::PrivateKey
// 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 &); PrivateKey(const PrivateKey &); PrivateKey& operator=(const PrivateKey &); // 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 &); };
PrivateKey
public
construct/copy/destructPrivateKey();
PrivateKey(const CORBA::OctetSeq & key);
PrivateKey(const char * key, std::size_t size);
explicit PrivateKey(const std::string & filename);
PrivateKey(const PrivateKey &);
PrivateKey& operator=(const PrivateKey &);
API - SDK Openbus C++
namespace openbus { struct CallerChain; class OpenBusContext; bool operator!=(CallerChain const & lhs, CallerChain const & rhs); namespace interceptors { } }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); } } } } } }
openbus::CallerChain — Cadeia de chamadas oriundas de um barramento.
// In header: <include/openbus/OpenBusContext.hpp> struct CallerChain { // construct/copy/destruct CallerChain(); CallerChain(const std::string &, const std::string &, const idl_ac::LoginInfoSeq &, const idl_ac::LoginInfo &, const idl_cr::SignedCallChain &); CallerChain(const std::string &, const std::string &, const idl_ac::LoginInfoSeq &, const idl_ac::LoginInfo &); // public member functions const std::string busid() const; const std::string 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); };
Coleção de informações dos logins que originaram chamadas em cadeia através de um barramento. Cadeias de chamadas representam chamadas aninhadas dentro do barramento e são úteis para que os sistemas que recebam essas chamadas possam identificar se a chamada foi originada por entidades autorizadas ou não.
CallerChain
public
construct/copy/destructCallerChain();Construtor default que indica o valor de CallChain "vazio".
O valor de um CallerChain
default-constructed pode ser usado para verificar a ausencia de CallerChain
da seguinte forma:
CallerChain
chain = openbusContext.getCallerChain(); if(chain != CallerChain()) // Possui CallerChain
else // Nao possui CallerChain
CallerChain(const std::string & busid, const std::string & target, const idl_ac::LoginInfoSeq & originators, const idl_ac::LoginInfo & caller, const idl_cr::SignedCallChain & chain);
CallerChain(const std::string & busid, const std::string & target, const idl_ac::LoginInfoSeq & originators, const idl_ac::LoginInfo & caller);
CallerChain
public member functionsconst std::string busid() const;
Barramento através do qual as chamadas foram originadas.
const std::string target() const;
Entidade para a qual a chamada estava destinada. Só é possível fazer chamadas dentro dessa cadeia (através do método joinChain da interface OpenBusContext
) se a entidade da conexão corrente for o mesmo do target.
No caso de conexões legadas, este campo armazenará o nome da entidade da conexão que atendeu a requisição. Todas as chamadas feitas como parte de uma cadeia de uma chamada legada serão feitas utilizando apenas o protocolo do OpenBus 1.5 (apenas com credenciais legadas) e portanto serão recusadas por serviços que não aceitem chamadas legadas (OpenBus 1.5).
const idl_ac::LoginInfoSeq & originators() const;
Lista de informações de login de todas as entidades que originaram as chamadas nessa cadeia. Quando essa lista é vazia isso indica que a chamada não está inclusa em outra cadeia de chamadas.
const idl_ac::LoginInfo & caller() const;
Informação de login da entidade que realizou a última chamada da cadeia.
openbus::OpenBusContext
// In header: <include/openbus/OpenBusContext.hpp> class OpenBusContext : public LocalObject { 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, boost::shared_ptr< interceptors::orb_info >); 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(); };
OpenBusContext
public
construct/copy/destructOpenBusContext(CORBA::ORB_ptr, boost::shared_ptr< interceptors::orb_info >);
OpenBusContext
deve ser adquirido atraves de: orb->resolve_initial_references("OpenBusContext")
OpenBusContext(const OpenBusContext &);
OpenBusContext& operator=(const OpenBusContext &);
OpenBusContext
public member functionsvoid onCallDispatch(CallDispatchCallback c);
CallDispatchCallback onCallDispatch() const;
std::auto_ptr< Connection > createConnection(const std::string host, unsigned short port, const Connection::ConnectionProperties & props = Connection::ConnectionProperties());Cria uma conexão para um barramento.
Cria uma conexão para um barramento. O barramento é indicado por um nome ou endereço de rede e um número de porta, onde os serviços núcleo daquele barramento estão executando.
Parameters: |
| ||||||
Returns: | Conexão criada. | ||||||
Throws: | InvalidPropertyValue O valor de uma propriedade não é válido. |
Connection * setDefaultConnection(Connection *);Define a conexão padrão a ser usada nas chamadas.
Define uma conexão a ser utilizada como "Requester" e "Dispatcher" de chamadas sempre que não houver uma conexão "Requester" e "Dispatcher" específica definida para o caso específico, como é feito através das operações 'setCurrentConnection' e 'setDispatcher'.
Connection * getDefaultConnection() const;Devolve a conexão padrão.
Veja operação 'setDefaultConnection'.
Returns: | Conexão definida como conexão padrão. OpenBusContext não possui ownership dessa conexão e o mesmo não é transferido para o código de usuário na execução desta função |
Connection * setCurrentConnection(Connection *);Define a conexão "Requester" do contexto corrente.
Define a conexão "Requester" a ser utilizada em todas as chamadas feitas no contexto atual. Quando 'conn' é 'null' o contexto passa a ficar sem nenhuma conexão associada.
Connection * getCurrentConnection() const;Devolve a conexão associada ao contexto corrente.
Returns: | Conexão a barramento associada a thread corrente. OpenBusContext não possui ownership dessa conexão e o mesmo não é transferido para o código de usuário na execução desta função |
Throws: | CORBA::Exception |
CallerChain getCallerChain();Devolve a cadeia de chamadas à qual a execução corrente pertence.
Caso a contexto corrente (e.g. definido pelo 'CORBA::PICurrent') seja o contexto de execução de uma chamada remota oriunda do barramento dessa conexão, essa operação devolve um objeto que representa a cadeia de chamadas do barramento que esta chamada faz parte. Caso contrário, devolve uma cadeia de chamadas 'vazia', representada por um CallerChain
'default-constructed'.
Para verificar se a cadeia retornada é válida, o seguinte idioma é usado:
CallerChain
chain = connection.getCallerChain() if(chain != CallerChain()) // chain é válido else // chain é inválido
Returns: | Cadeia da chamada em execução. |
void joinChain(const CallerChain & chain);Associa uma cadeia de chamadas ao contexto corrente.
Associa uma cadeia de chamadas ao contexto corrente, de forma que todas as chamadas remotas seguintes neste mesmo contexto sejam feitas como parte dessa cadeia de chamadas.
Parameters: |
| ||
Throws: | CORBA::NO_PERMISSION {minor = NoLoginCode} {minor = InvalidChainCode} |
void exitChain();Faz com que nenhuma cadeia de chamadas esteja associada ao contexto corrente.
Remove a associação da cadeia de chamadas ao contexto corrente, fazendo com que todas as chamadas seguintes feitas neste mesmo contexto deixem de fazer parte da cadeia de chamadas associada previamente. Ou seja, todas as chamadas passam a iniciar novas cadeias de chamada.
CallerChain getJoinedChain();Devolve a cadeia de chamadas associada ao contexto corrente.
Devolve um objeto que representa a cadeia de chamadas associada ao contexto corrente nesta conexão. A cadeia de chamadas informada foi associada previamente pela operação 'joinChain'. Caso o contexto corrente não tenha nenhuma cadeia associada, essa operação devolve uma cadeia 'vazia' 'default-constructed'
Para verificar se a cadeia retornada é válida, o seguinte idioma é usado:
CallerChain
chain = openbusContext.getCallerChain() if(chain != CallerChain()) // chain é válido else // chain é inválido
Returns: | Cadeia de chamadas associada ao contexto corrente ou uma cadeia 'vazia'. |
Throws: | CORBA::Exception |
CORBA::ORB_ptr orb() const;
ORB utilizado pela conexão.
idl_or::OfferRegistry_ptr getOfferRegistry() const;
idl_ac::LoginRegistry_ptr getLoginRegistry() const;
OpenBusContext
private member functionsvoid orb(CORBA::ORB_ptr o);
Connection * getDispatchConnection();
namespace openbus { OPENBUS_SDK_DECL CORBA::ORB_ptr ORBInitializer(int &, char **); }
openbus::ORBInitializer — Inicializa um ORB utilizado exclusivamente para chamadas através de barramentos OpenBus.
// In header: <include/openbus/ORBInitializer.hpp> OPENBUS_SDK_DECL CORBA::ORB_ptr ORBInitializer(int & argc, char ** argv);
Inicializa um ORB utilizado exclusivamente para chamadas através de barramentos OpenBus, ou seja, esse ORB não pode ser utilizado para fazer chamadas CORBA ordinárias sem o controle de acesso do OpenBus que permite identificação da origem das chamadas. Esse controle de acesso é feito através conexões que são obtidas e manipuladas através de um OpenBusContext
. Cada ORB possui um OpenBusContext
associado, que pode ser obitido através do comando: CORBA::ORB::resolve_initial_reference("OpenBusContext")
O ORB é inicializado da mesma forma feita pela operação 'CORBA::ORB_init' definida pelo padrão CORBA. Em particular, algumas implementações de CORBA não permitem inicialização de múltiplos ORBs num mesmo processo, como por exemplo o ORB Mico 2.3.13.
Chamadas realizadas e recebidas através deste ORB são interceptadas pela biblioteca de acesso do OpenBus e podem lançar exceções de sistema de CORBA definidas pelo OpenBus. A seguir são apresentadas essas exceções:
CORBA::NO_PERMISSION{NoLogin}: Nenhuma conexão "Requester" com login válido está associada ao contexto atual, ou seja, a conexão "Requester" corrente está desautenticada.
CORBA::NO_PERMISSION{InvalidChain}: A cadeia de chamadas associada ao contexto atual não é compatível com o login da conexão "Requester" desse mesmo contexto. Isso ocorre pois não é possível fazer chamadas dentro de uma cadeia recebida por uma conexão com um login diferente. - CORBA::NO_PERMISSION{UnknownBus}: O ORB remoto que recebeu a chamada indicou que não possui uma conexão com login válido no barramento através do qual a chamada foi realizada, portanto não é capaz de validar a chamada para que esta seja processada.
CORBA::NO_PERMISSION{UnverifiedLogin}: O ORB remoto que recebeu a chamada indicou que não é capaz de validar a chamada para que esta seja processada. Isso indica que o lado remoto tem problemas de acesso aos serviços núcleo do barramento.
CORBA::NO_PERMISSION{InvalidRemote}: O ORB remoto que recebeu a chamada não está se comportando de acordo com o protocolo OpenBus 2.0, o que indica que está mal implementado e tipicamente representa um bug no servidor sendo chamado ou um erro de implantação do barramento.
Atenção: O Mico 2.3.13 não permite a inicialização de mais de um ORB. Após uma primeira chamada bem sucedida de ORBInitializer(), todas as chamadas consecutivas retornarão o mesmo ORB que foi criado na primeira chamada.
Parameters: |
| ||||
Returns: | O ORB inicializado, similar à operação 'CORBA::ORB_init' definida pelo padrão CORBA. | ||||
Returns: | O ORB inicializado. | ||||
Throws: | CORBA::Exception |
namespace tecgraf { namespace openbus { namespace core { namespace v2_0 { namespace services { namespace access_control { struct LoginAuthenticationInfo; struct LoginInfo; struct CallChain; 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. const unsigned long UnavailableBusCode; // Minor code de NO_PERMISSION: barramento indisponível. const unsigned long InvalidTargetCode; // Minor code de NO_PERMISSION: login do alvo da chamada é inválido. } } } } } }
tecgraf::openbus::core::v2_0::services::access_control::LoginAuthenticationInfo — Dados secretos do login de uma entidade no barramento.
// 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. };
tecgraf::openbus::core::v2_0::services::access_control::LoginInfo — Informações públicas do login de uma entidade no barramento.
// In header: <src/access_control.idl> struct LoginInfo { // public data members Identifier id; // Identificador da login. Identifier entity; // Identificador da entidade que fez login. };
tecgraf::openbus::core::v2_0::services::access_control::CallChain — Informações sobre uma cadeia de chamada aninhadas no barramento.
// In header: <src/access_control.idl> struct CallChain { // public data members Identifier target; // Nome da entidade 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). };
tecgraf::openbus::core::v2_0::services::access_control::InvalidCredentialCode — Minor code de NO_PERMISSION: credencial inválida.
// In header: <src/access_control.idl> const unsigned long InvalidCredentialCode;
tecgraf::openbus::core::v2_0::services::access_control::InvalidChainCode — Minor code de NO_PERMISSION: cadeia inválida.
// In header: <src/access_control.idl> const unsigned long InvalidChainCode;
tecgraf::openbus::core::v2_0::services::access_control::InvalidLoginCode — Minor code de NO_PERMISSION: login inválida.
// In header: <src/access_control.idl> const unsigned long InvalidLoginCode;
tecgraf::openbus::core::v2_0::services::access_control::UnverifiedLoginCode — Minor code de NO_PERMISSION: não foi possível verificar o login.
// In header: <src/access_control.idl> const unsigned long UnverifiedLoginCode;
tecgraf::openbus::core::v2_0::services::access_control::UnknownBusCode — Minor code de NO_PERMISSION: barramento desconhecido.
// In header: <src/access_control.idl> const unsigned long UnknownBusCode;
tecgraf::openbus::core::v2_0::services::access_control::InvalidPublicKeyCode — Minor code de NO_PERMISSION: chave pública inválida.
// In header: <src/access_control.idl> const unsigned long InvalidPublicKeyCode;
tecgraf::openbus::core::v2_0::services::access_control::NoCredentialCode — Minor code de NO_PERMISSION: credencial não foi encontrada.
// In header: <src/access_control.idl> const unsigned long NoCredentialCode;
tecgraf::openbus::core::v2_0::services::access_control::NoLoginCode — Minor code de NO_PERMISSION: ausência de login.
// In header: <src/access_control.idl> const unsigned long NoLoginCode;
tecgraf::openbus::core::v2_0::services::access_control::InvalidRemoteCode — Minor code de NO_PERMISSION: servidor chamado é inválido.
// In header: <src/access_control.idl> const unsigned long InvalidRemoteCode;
tecgraf::openbus::core::v2_0::services::access_control::UnavailableBusCode — Minor code de NO_PERMISSION: barramento indisponível.
// In header: <src/access_control.idl> const unsigned long UnavailableBusCode;
tecgraf::openbus::core::v2_0::services::access_control::InvalidTargetCode — Minor code de NO_PERMISSION: login do alvo da chamada é inválido.
// In header: <src/access_control.idl> const unsigned long InvalidTargetCode;
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 { } } } } }
tecgraf::openbus::core::v2_0::MajorVersion — Major da versão.
// In header: <src/core.idl> const octet MajorVersion;
tecgraf::openbus::core::v2_0::MinorVersion — Minor da versão.
// In header: <src/core.idl> const octet MinorVersion;
tecgraf::openbus::core::v2_0::BusLogin — Login usado pelo Barramento.
// In header: <src/core.idl> const string BusLogin;
tecgraf::openbus::core::v2_0::BusEntity — Nome da entidade do Barramento.
// In header: <src/core.idl> const string BusEntity;
tecgraf::openbus::core::v2_0::BusObjectKey — Chave da entidade do Barramento.
// In header: <src/core.idl> const string BusObjectKey;
tecgraf::openbus::core::v2_0::HashValueSize — Tamanho do hash.
// In header: <src/core.idl> const unsigned short HashValueSize;
tecgraf::openbus::core::v2_0::EncryptedBlockSize — Tamanho do bloco encriptado.
// 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. } } } } }
tecgraf::openbus::core::v2_0::credential::SignedCallChain — Estrutura que possui a cadeia de chamadas aninhadas da requisição.
// 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 };
tecgraf::openbus::core::v2_0::credential::CredentialData — Estrutura trafegada durante as comunicações realizadas dentro do barramento, que assegura a identidade da entidade que iniciou a chamada.
// 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. };
tecgraf::openbus::core::v2_0::credential::CredentialReset — Estrutura trafegada para combinar uma sessão para a realização de uma comunicação dentro do barramento.
// In header: <src/credential.idl> struct CredentialReset { // public data members Identifier target; // UUID do alvo da comunicação (receptor) unsigned long session; // Identificador da sessão. EncryptedBlock challenge; // Valor aleatório de 16-bytes encriptado. };
tecgraf::openbus::core::v2_0::credential::CredentialContextId — Identificador de contexto do service context utilizado para transmitir a credencial.
// 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; 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. } } } } } }
tecgraf::openbus::core::v2_0::services::offer_registry::ServiceProperty — Propriedade que descreve um aspecto de uma oferta de serviço.
// In header: <src/offer_registry.idl> struct ServiceProperty { // public data members string name; string value; // nome da propriedade };
tecgraf::openbus::core::v2_0::services::offer_registry::ServiceOfferDesc — Descreve uma oferta de serviço.
// In header: <src/offer_registry.idl> struct ServiceOfferDesc { // public data members OfferedService service_ref; ServicePropertySeq properties; // Referência para o serviço ofertado. ServiceOffer ref; // Propriedades do serviço ofertado. };
tecgraf::openbus::core::v2_0::services::offer_registry::OfferObserverSubscriptionDesc — Descreve uma inscrição de observador de oferta de serviço.
// In header: <src/offer_registry.idl> struct OfferObserverSubscriptionDesc { // public data members OfferObserver observer; OfferedService offer; // Referência para o observador. };
tecgraf::openbus::core::v2_0::services::offer_registry::OfferRegistryObserverSubscriptionDesc — Descreve uma inscrição de observador de oferta de serviço.
// In header: <src/offer_registry.idl> struct OfferRegistryObserverSubscriptionDesc { // public data members OfferRegistryObserver observer; ServicePropertySeq properties; // Referência para o observador. };