Commit 69114961 authored by Renato Figueiro Maia's avatar Renato Figueiro Maia
Browse files

[OPENBUS-2352] Separação da IDL de governança da IDL do protocolo

git-svn-id: https://subversion.tecgraf.puc-rio.br/engdist/openbus/core/branches/02_00_00@143896 ae0415b3-e90b-0410-900d-d0be9363c56b
parent 4d3fe227
/**
* \mainpage Documentação da IDL
*/
#ifndef __TECGRAF_OPENBUS_CORE_V20_SERVICES_ACCESSCONTROL_ADMIN_V10_IDL__
#define __TECGRAF_OPENBUS_CORE_V20_SERVICES_ACCESSCONTROL_ADMIN_V10_IDL__
#include "access_control.idl"
/** \brief Módulo dos sistemas e aplicações do Tecgraf. */
module tecgraf {
/** \brief Módulo do middleware OpenBus. */
module openbus {
/** \brief Módulo de definições básicas do OpenBus. */
module core {
/* \brief Módulo de versionamento dos Serviços Básicos do OpenBus. */
module v2_0 {
/** \brief Módulo dos Serviços Básicos do OpenBus. */
module services {
/** \brief Módulo do Serviço de Autenticação. */
module access_control {
/** \brief Módulo de gerência do serviço. */
module admin {
/** \brief Módulo de versionamento da gerência do serviço. */
module v1_0 {
/****************************************************************************/
/* Faceta de Gerência de Certificados de Entidades **************************/
/****************************************************************************/
/** \brief Certificado que utilizado na autenticação de entidades. */
typedef sequence<octet> EntityCertificate;
/** \brief Indica que o certificado fornecido é inválido */
exception InvalidCertificate { string message; };
/**
* \brief Gerência de certificados de autenticação de entidades no barramento.
*/
interface CertificateRegistry {
/**
* \brief Registra um certificado que pode ser usado para autenticar uma
* dada entidade no barramento.
*
* \param entity Ident. da entidade a qual o certificado será associado.
* \param cert Certificado a ser associado a entidade.
*
* \exception InvalidCertificate Certificado fornecido é inválido.
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
void registerCertificate(in Identifier entity, in EntityCertificate cert)
raises (InvalidCertificate, UnauthorizedOperation, ServiceFailure);
/**
* \brief Obtém o certificado associado a uma dada entidade no barramento.
*
* \param entity Ident. da entidade a qual o certificado será associado.
*
* \return certificate Certificado a ser associado a entidade.
*
* \exception MissingCertificate Certificado não encontrado.
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
EntityCertificate getCertificate(in Identifier entity)
raises (MissingCertificate, UnauthorizedOperation, ServiceFailure);
/**
* \brief Remove um certificado associado a uma entidade.
*
* \param entity Ident. da entidade a qual o certificado está associado.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
boolean removeCertificate(in Identifier entity)
raises (UnauthorizedOperation, ServiceFailure);
};
}; // version
}; // admin
}; // access_control
}; // services
}; // core version
}; // core
}; // openbus
}; // tecgraf
#endif
/**
* \mainpage Documentação da IDL
*/
#ifndef __TECGRAF_OPENBUS_CORE_V20_SERVICES_OFFERREGISTRY_ADMIN_V10_IDL__
#define __TECGRAF_OPENBUS_CORE_V20_SERVICES_OFFERREGISTRY_ADMIN_V10_IDL__
#include "offer_registry.idl"
/** \brief Módulo dos sistemas e aplicações do Tecgraf. */
module tecgraf {
/** \brief Módulo do middleware OpenBus. */
module openbus {
/** \brief Módulo de definições básicas do OpenBus. */
module core {
/* \brief Módulo de versionamento dos Serviços Básicos do OpenBus. */
module v2_0 {
/** \brief Módulo dos Serviços Básicos do OpenBus. */
module services {
/** \brief Módulo do Serviço de Ofertas. */
module offer_registry {
/** \brief Módulo de gerência do serviço. */
module admin {
/** \brief Módulo de versionamento da gerência do serviço. */
module v1_0 {
/****************************************************************************/
/* Faceta de Gerência de Autorização de Entidades ***************************/
/****************************************************************************/
interface RegisteredEntity; /* forward declaration */
interface EntityCategory; /* forward declaration */
/** \brief Descrição de uma categoria de entidade. */
struct EntityCategoryDesc {
Identifier id; /** \brief Identificador da categoria. */
string name; /** \brief Nome descritivo da categoria. */
EntityCategory ref; /** \brief Objeto que representa a categoria. */
};
/** \brief Sequência de descrições de catergorias de entidade. */
typedef sequence<EntityCategoryDesc> EntityCategoryDescSeq;
/** \brief Descrição de uma entidade registrada. */
struct RegisteredEntityDesc {
EntityCategory category; /** \brief Categoria da entidade. */
Identifier id; /** \brief Identificador da entidade. */
string name; /** \brief Nome descritivo da entidade. */
RegisteredEntity ref; /** \brief Objeto que representa a entidade. */
};
/** \brief Sequência de descrições sobre entidades registradas */
typedef sequence<RegisteredEntityDesc> RegisteredEntityDescSeq;
/** \brief Identificação de uma interface. */
typedef string InterfaceId; /* same type of interface identifiers of SCS */
/** \brief Sequência de identificações de interface. */
typedef sequence<InterfaceId> InterfaceIdSeq;
/** \brief Indica que uma entidade com o identificador dado já está registrada. */
exception EntityAlreadyRegistered { RegisteredEntityDesc existing; };
/** \brief Indica que uma categoria com o identificador dado já existe. */
exception EntityCategoryAlreadyExists { EntityCategoryDesc existing; };
/** \brief Indica que existe entidades nessa categoria de entidade. */
exception EntityCategoryInUse { RegisteredEntityDescSeq entities; };
/** \brief Indica que a especificação de interfaces autorizadas é inválida. */
exception InvalidInterface { InterfaceId ifaceId; };
/** \brief Indica que uma oferta existente exige a autorização removida. */
exception AuthorizationInUse { ServiceOfferDescSeq offers; };
/**
* \brief Representa uma categoria de entidades no barramento.
*
* Categorias de entidade são agrupamentos usados exclusivamente para
* facilitar a gerência das diversas entidades cadastradas no barramento
* pelo administrador do sistema.
*/
interface EntityCategory {
readonly attribute Identifier id; /** \brief Identificador da categoria */
readonly attribute string name; /** \brief Nome descritivo da categoria */
/**
* \brief Devolve uma estrutura descrevedo a categoria de entidade.
*
* \return A descrição da categoria de entidade
*/
EntityCategoryDesc describe();
/**
* \brief Altera a descrição da categoria.
*
* \param name Nome descritivo da categoria.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
void setName(in string name) raises (UnauthorizedOperation, ServiceFailure);
/**
* \brief Remove a categoria de entidade.
*
* A categoria só é removida se não existir nenhuma entidade nela.
*
* \exception EntityCategoryInUse A categoria possui alguma entidade.
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
void remove()
raises (EntityCategoryInUse, UnauthorizedOperation, ServiceFailure);
/**
* \brief Remove a categoria e todas suas entidades.
*
* Se houver alguma entidade cadastrada nessa categoria ela também é
* removida.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
void removeAll() raises (UnauthorizedOperation, ServiceFailure);
/**
* \brief Cria uma nova entidade nessa categoria.
*
* \param id Identificador da entidade (deve ser único no barramento).
* \param name Nome descritivo da entidade (texto livre).
*
* \exception EntityAlreadyRegistered Indica que uma entidade com esse
* identificador já está registrada.
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
RegisteredEntity registerEntity(in Identifier id, in string name)
raises (EntityAlreadyRegistered, UnauthorizedOperation, ServiceFailure);
/**
* \brief Recupera todas entidades nessa categoria.
*
* \return Sequência de descrições das entidades nessa categoria.
*/
RegisteredEntityDescSeq getEntities() raises (ServiceFailure);
};
/**
* \brief Representa uma entidade do barramento registrada.
*
* Entidade é tudo aquilo que pode se logar ao barramento e usufruir dos
* recursos do barramento. Em particular, tanto usuários humanos como
* implantações de sistema são considerados entidades. Entidades podem ou não
* ser cadastradas no serviço. Apenas entidades cadastradas podem ser
* autorizadas a ofertar serviços.
*/
interface RegisteredEntity {
readonly attribute EntityCategory category; /** \brief Categoria da entidade */
readonly attribute Identifier id; /** \brief Identificador da entidade */
readonly attribute string name; /** \brief Nome descritivo da entidade */
/**
* \brief Devolve uma estrutura descrevedo a entidade registrada.
*
* \return A descrição da entidade registrada
*/
RegisteredEntityDesc describe();
/**
* \brief Altera o nome descritivo da entidade.
*
* \param name Nome descritivo da entidade.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
void setName(in string name) raises (UnauthorizedOperation, ServiceFailure);
/**
* \brief Remove o registro da entidade.
*
* Todas as autorizações e ofertas de serviço da entidade são removidas
* juntamente com a entidade.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
void remove() raises (UnauthorizedOperation, ServiceFailure);
/**
* \brief Autoriza que a entidade possa ofertar serviços que implementem
* essa interface.
*
* \param ifaceId Identificador da interface a ser autorizada.
*
* \result \c true caso a interface não estava autorizada e passou a ser
* autorizada ou \c false caso a interface já estava autorizada e
* a operação não resultou em nenhuma mudança.
*
* \exception InvalidInterface A interface é inválida (não está registrada).
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
boolean grantInterface(in InterfaceId ifaceId)
raises (InvalidInterface, UnauthorizedOperation, ServiceFailure);
/**
* \brief Remove a autorização da entidade de ofertar serviços que
* implementem a interface.
*
* \param ifaceId Identificador da interface a ser revogada.
*
* \result \c true caso a interface estava autorizada e deixou de ser
* autorizada ou \c false caso a interface já não era autorizada e
* a operação não resultou em nenhuma mudança.
*
* \exception InvalidInterface A interface é inválida (não está registrada).
* \exception AuthorizationInUse Existem ofertas de serviço dessa entidade
* que implementam interfaces referentes a
* essa autorização.
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
boolean revokeInterface(in InterfaceId ifaceId)
raises (InvalidInterface, AuthorizationInUse,
UnauthorizedOperation, ServiceFailure);
/**
* \brief Devolve a lista de especificações de interfaces autorizadas
* associados a essa entidade.
*
* \return Lista de especificação de interfaces autorizadas.
*/
InterfaceIdSeq getGrantedInterfaces()
raises (ServiceFailure);
};
/**
* \brief Interface de registro de entidades do barramento.
*/
interface EntityRegistry {
/**
* \brief Cria uma nova cateroria de entidade no barramento.
*
* \param id Identificador da categoria (deve ser único no barramento).
* \param name Nome descritivo da categoria (texto livre).
*
* \exception EntityCategoryAlreadyExists Indica que uma categoria com o mesmo
* identificador já está existe.
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
EntityCategory createEntityCategory(in Identifier id, in string name)
raises (EntityCategoryAlreadyExists, UnauthorizedOperation, ServiceFailure);
/**
* \brief Recupera todas as categorias de entidade existentes.
*
* \return Uma sequência de descrições das categorias.
*/
EntityCategoryDescSeq getEntityCategories() raises (ServiceFailure);
/**
* \brief Busca um categoria de entidade pelo seu identificador.
*
* \param id Identificador da categoria a ser buscada.
*
* \return Categoria encontrada com aquele identifcador ou \c null caso não
* exista nenhuma categoria com o identificador fornecido.
*/
EntityCategory getEntityCategory(in Identifier id) raises (ServiceFailure);
/**
* \brief Obtém todas entidades registradas.
*
* \return Sequência de descrições das entidades registradas.
*/
RegisteredEntityDescSeq getEntities() raises (ServiceFailure);
/**
* \brief Busca uma entidade pelo seu identificador.
*
* \param id Identificador da entidade a ser buscada.
*
* \return Entidade encontrada com aquele identifcador ou \c null caso não
* exista nenhuma entidade com o identificador fornecido.
*/
RegisteredEntity getEntity(in Identifier id) raises (ServiceFailure);
/**
* \brief Obtém todas as entidades registradas com alguma autorização de
* interface associada.
*
* \return Sequência de descrições das entidades encontradas.
*/
RegisteredEntityDescSeq getAuthorizedEntities() raises (ServiceFailure);
/**
* \brief Obtém todas as entidades registradas que tenham autorizações de
* interface que casem com um conjunto de interfaces fornecido
*
* \param interfaces Sequência de interfaces que as entidades devem estar
* autorizadas a fornecer através de serviços.
*
* \return Sequência de entidades autorizadas a fornecer as interfaces
* especificadas através de serviços.
*/
RegisteredEntityDescSeq getEntitiesByAuthorizedInterfaces(
in InterfaceIdSeq interfaces) raises (ServiceFailure);
};
/****************************************************************************/
/* Faceta de Gerência de Interfaces Autorizadas *****************************/
/****************************************************************************/
/** \brief Indica que uma interface está autorizada para algumas entidades. */
exception InterfaceInUse { RegisteredEntityDescSeq entities; };
/**
* \brief Interface de registro de interfaces do barramento.
*/
interface InterfaceRegistry {
/**
* \brief Registra uma interface autorizada no cadastro.
*
* \param ifaceId Identificador da interface.
*
* \return \c true caso a interface não estava registrada e foi registrada,
* e \c false caso a interface já estava registrada.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
boolean registerInterface(in InterfaceId ifaceId)
raises (InvalidInterface, UnauthorizedOperation, ServiceFailure);
/**
* \brief Remove uma interface autorizada do cadastro.
*
* \param ifaceId Identificador da interface.
*
* \return \c true caso a interface estava registrada e foi removida, e
* \c false caso a interface não estivesse registrada.
*
* \exception UnauthorizedOperation Entidade que chama não é administrador.
*/
boolean removeInterface(in InterfaceId ifaceId)
raises (InterfaceInUse, UnauthorizedOperation, ServiceFailure);
/**
* \brief Devolve uma lista de todas as interfaces cadastradas.
*
* \return Lista de interfaces cadastradas.
*/
InterfaceIdSeq getInterfaces() raises (ServiceFailure);
};
}; // version
}; // admin
}; // offer_registry
}; // services
}; // core version
}; // core
}; // openbus
}; // tecgraf
#endif
local _G = require "_G"
local ipairs = _G.ipairs
local unpack = _G.unpack
local makeaux = require "openbus.core.idl.makeaux"
local parsed = require "openbus.core.admin.parsed"
local types, values, throw = {}, {}, {}
for _, parsed in ipairs(parsed) do
if parsed.name == "tecgraf" then
makeaux(parsed, types, values, throw)
end
end
local idl = {
types = types.tecgraf.openbus.core.v2_0,
values = values.tecgraf.openbus.core.v2_0,
throw = throw.tecgraf.openbus.core.v2_0,
}
function idl.loadto(orb)
orb.TypeRepository.registry:register(unpack(parsed))
end
return idl
......@@ -18,14 +18,16 @@ local openbus = require "openbus"
local log = require "openbus.util.logger"
local access = require "openbus.core.Access"
local neworb = access.initORB
local idl = require "openbus.core.idl"
local BusObjectKey = idl.const.BusObjectKey
local types = idl.types.services
local logintypes = idl.types.services.access_control
local idl = require "openbus.core.admin.idl"
local admintypes = idl.types.services.access_control.admin.v1_0
local authotypes = idl.types.services.offer_registry.admin.v1_0
local printer = require "openbus.core.admin.print"
local script = require "openbus.core.admin.script"
local messages = require "openbus.core.admin.messages"
local idl = require "openbus.core.idl"
local logintypes = idl.types.services.access_control
local offertypes = idl.types.services.offer_registry
local types = idl.types.services
local BusObjectKey = idl.const.BusObjectKey
-- Alias
local lower = _G.string.lower
......@@ -475,7 +477,7 @@ handlers["add-category"] = function(cmd)
local ok, err = pcall(conn.entities.createEntityCategory, conn.entities,
id, cmd.params.name)
if not ok then
if err._repid == offertypes.EntityCategoryAlreadyExists then
if err._repid == authotypes.EntityCategoryAlreadyExists then
printf("[ERRO] Categoria '%s' já cadastrada", id)
else
printf("[ERRO] Erro inesperado ao adicionar categoria: %s", tostring(err))
......@@ -513,7 +515,7 @@ handlers["del-category"] = function(cmd)
end
local ok, err = pcall(category.remove, category)
if not ok then
if err._repid == offertypes.EntityCategoryInUse then
if err._repid == authotypes.EntityCategoryInUse then
printf("[ERRO] Categoria '%s' em uso.", id)
else
printf("[ERRO] Erro inesperado ao remover categoria: %s", tostring(err))
......@@ -621,7 +623,7 @@ handlers["add-entity"] = function(cmd)
end
local ok, err = pcall(category.registerEntity, category, id, cmd.params.name)
if not ok then
if err._repid == offertypes.EntityAlreadyRegistered then
if err._repid == authotypes.EntityAlreadyRegistered then
printf("[ERRO] Entidade '%s' já cadastrada.", id)
else
printf("[ERRO] Erro inesperado ao adicionar entidade: %s", tostring(err))
......@@ -785,7 +787,7 @@ handlers["add-certificate"] = function(cmd)
local ok, err = pcall(conn.certificates.registerCertificate,
conn.certificates, id, cert)
if not ok then
if err._repid == logintypes.InvalidCertificate then
if err._repid == admintypes.InvalidCertificate then
printf("[ERRO] Certificado inválido: '%s'", certificate)
else
printf("[ERRO] Erro inesperado ao incluir certificado: %s", tostring(ret))
......@@ -833,7 +835,7 @@ handlers["add-interface"] = function(cmd)
local id = cmd.params[cmd.name]
local ok, err = pcall(conn.interfaces.registerInterface, conn.interfaces, id)
if not ok then
if err._repid == offertypes.InvalidInterface then
if err._repid == authotypes.InvalidInterface then
printf("[ERRO] Interface '%s' inválida.", id)
else