An Infrastructure for Development of Dynamically Adaptable Distributed Components

14/2/2006 PUC-Rio 1 An Infrastructure for Development of Dynamically Adaptable Distributed Components Renato Figueiró Maia DOA 2004 Agya Napa, Cyprus

Agenda Introduction Software Components Dynamic Adaptation CCM Model LOAF Use Examples Conclusions Future Work

Introduction Challenges in software evolution Flexibility to incorporate unexpected changes Larger the amount of software requirements Apropriate programming abstractions More complex and tenologically advanced Changes at run time (dynamic adaptation) More essential (e.g. financial, medical, military). Run for months or even years.

Software Components Enables modularity and reuse Black-box components Interactions through connectors and contracts Offered services Dependencies with other components Complements object orientation Objects are too small Dependencies are not explicit and are spread thorugh many objects

Dynamic Adaptation Definition Changes of a running system prior of changes on their requirements Types of change Expected Mobile computing, software agents Unexpected Long-term systems, computer-intensive systems Mechanisnms (computational reflection) Introspection (interfaces) Java reflrection API, CORBA Interface Repository. Intercesstion (variation points) Interceptors, function pointers, etc.

Coarse-grained adaptations Alterações na estrutura (macro) do sistema Modular Substituição dos módulos. Orientação a objetos Troca de objetos e relacionamentos. Componentes Troca de conexões entre os componentes. Reconfiguração de componentes Substituição Reconexão

Adaptação em Ponto Pequeno Alterações internas aos componentes que formam o sistema. Estruturas mais fundamentais. Nível de detalhe maior. Níveis de detalhe Linguagem de programação. Arquitetura ou middleware. Componentes. Introspecção da estrutura do componente Intercessão da implementação do componente.

Ponto Grande vs. Ponto Pequeno Ponto Grande Mais simples e eficiente. Exige planejamento da arquitetura pra acomodar alterações. Adequada para alterações esperadas. Aplicações auto-adaptáveis (alterações no contexto). Ponto Pequeno Mais flexível, porém mais complexa. Adequada para alterações não esperadas. Manutenção dinâmica de sistemas.

CCM Model Facetas Receptores de eventos Home Atributos e interfaces oferecidas Componente instancia Composição Receptáculos Fontes de eventos component MyComponent supports SupportedInterface : SuperComponent { attribute string myattribute; provides Interface myfacet; uses Interface myreceptacle; publishes Event mypublisher; emits Event myemitter; consumes Event myconsumer; }; home MyHome manages MyComponent {};

CCM Container Protected execution environment Different types of components Intercepts all interactions with the external world Simplifies the implementation Manages instances Creation and activation. Offers services Transaction, persistence. Manages connections. Executor callback internas Contêiner externa

LOAF LuaOrb Adaptation Framework LuaCCM Protocols and roles Handlers

LuaCCM Ambiente para construção de componentes reflexivos Motivação Incorporar os conceitos do CCM ao LuaOrb. Simplicidade e flexibilidade. Estrutura de implementação: CORBA LuaCCM CCM LuaOrb LOOP Lua

Contêiner Lua Executor Principal Servant LuaOrb Tratador de evento Servant LuaOrb Executor de faceta Servant LuaOrb Contexto Contêiner Lua

Contêiner Lua Instâncias de Componente Contêiner Lua Classe do Envoltório instanciado delega consulta define Envoltório (objeto Lua) Repositório de Interfaces de Componentes (serviço de objetos) Gerenciador de Definição (objeto Lua) Classe de Contexto instanciado usa Executor (objeto Lua) Contexto (objeto Lua)

Componentes LuaCCM Recursos reflexivos Introspecção (interfaces do CCM) Obter informações sobre portas. Estabelecer e desfazer conexões em portas. Intercessão (LuaCCM::Adaptable) Adicionar e remover portas. Substituir a implementação de portas. Associar interceptadores a portas. Alterações em níveis de abrangência (mesmo servidor) Por Definição (através do contêiner) Por Home (através do home do componente) Por Instância (através da instância do componente)

Interfaces de Adaptação interface Adaptable { void add_facet(in string name, in string iface, in LuaCode code); void add_receptacle(in string name, in string iface, in boolean ismultiple);... void set_implementation(in string port, in LuaCode code);... void intercept(in string point, in LuaCode code); }; interface AdaptableContainer : ::Components::Container { Adaptable get_component_adaptor(in string absolute_name); };

Papéis e Protocolos Papel Conjunto de alterações no componente para realizar uma nova função (papel) Protocolo Regras de como os papéis são aplicados e os componentes são reconectados para fornecer a nova funcionalidade. Novas portas Protocolo Scripts Papel aplica e conecta faz requisições Componente Novas interações

Manipuladores Complexidade de manipulação de portas Diversos nomes de operações connect, subscribe, get, provide, etc. Utilização específica de acordo com o tipo de porta Obter uma faceta e então conectá-la ao receptáculo. Objeto consumidor de eventos é obtido e então conectado ou registrado à fonte de eventos. Geração automática de id. de conexão. Identificador gerado não apresenta signifcado para a aplicação. Aplicação mantém um mapeamento do identificador gerado para outro que possua significado (e.g. nome de um usuário).

Manipuladores Complexidade de manipulação de portas CCM CCM: messager:subscribe_out(printer:get_consumer_in()) LOAF: printer.in = messager.out

Aplicação de Exemplo rver = loaf.handler(producers:create()) ent1 = loaf.handler(processorsa:create()) ent2 = loaf.handler(processorsb:create()) raw Cliente A : Processor done rver.name = "Servidor" ent1.name = "Cliente A" ient2.name = "Cliente B" ient1.raw = server.produced ient2.raw = server.produced rver.request = client1.done rver.request = client2.done rver.controller:start() request Servidor : Producer controller Controla a produção de eventos Console : LuaCCM produced interfaces de configuração raw Cliente B : Processor done

Sincronização de Fluxo FlowWatcher = loaf.role { before = { raw = { code = [[...]] }}, after = { raw = { code = [[...]] }}, provides = { limit = { interface = "Limited", code = [[...]]}}, uses = { regulator = { interface = "Rateable"}}} FlowRegulator = loaf.role { before = { produced = { code = [[...]] }}, provides = { rater = { interface = "Rateable", code = [[...]]}}} request Servidor : Processor rater Console : LuaCCM Insere atrasos no envio de eventos de acordo com a taxa de vazão definida produced FlowRegulator Define nova taxa de vazão de eventos no servidor raw raw Cálcula taxa de vazão de eventos FlowWatcher Define valor de vazão limite para disparar a regulagem regulator Cliente A : Producer Cliente B : Producer limit done done

Depuração Distribuída BreakPoint = loaf.role { uses = { pauser = { interface = "Pauser" }}, before = { done = { code = [[ function(self, request) local c = request.context local p = c:get_connection_pauser() if p then while p:locked() do sleep(1) end end end ]]}}} request Inspectable Servidor : Processor Console : LuaCCM produced evaluator Inspeciona os campos dos segmentos do componente raw raw Inspectable evaluator Consulta se a execução no ponto de parada deve continuar pausada Cliente A : Producer Cliente B : Producer done BreakPoint done

Replicação Passiva adaptor = container:get_component_adaptor( "Processor ) Replicator:assign(adaptor) raw Cliente A : Processor done replica1 = loaf.handler(replicas:create()) replica2 = loaf.handler(replicas:create()) request Servidor : Producer produced raw Replicator Cliente B : Processor copied done done Replica 1 : Processor raw replica1.name = "Replica 1" replica2.name = "Replica 2" replica1.raw = client2.copied replica2.raw = client3.copied Replicator raw copied Cliente C : Processor done raw Replica 2 : Processor done

Conclusões LuaOrb Adaptation Framework Fornece recursos úteis para adaptação dinâmica. Alteração de componentes sem perda de estado. Níveis de abrangência das alterações. Alterações através de papéis e protocolos. Simplificação da reconfiguração de componentes CCM. Ambiente para experimentação de novas ferramentas Arquiteturas de aplicações adaptatívas. Novas abstrações para inserção de alterações.

Trabalhos Futuros Implementação completa da especificação CCM Implementação completa da arquitetura de implantação proposta pelo modelo CCM. Contêiner com suporte a componentes persistentes e serviços de objetos. Diminuição das limitações do modelo Mecanismos para manter consistência das adaptações (inter e intra componentes). Definir mecanismos de segurança para controlar alterações. Validação das ferramentas propostas Implementação de sistemas reais. Arquiteturas para aplicações adaptáveis. Avaliação de outras abstrações Contratos de coordenação dinâmicos. Aspectos dinâmicos.

FIM Dúvidas Críticas Comentários