Integração de aplicações em
Luiz Eduardo Borges
http://ark4n.wordpress.com/

Sumário
● Integração de aplicações
● Aplicações distribuídas
● Camada de comunicação
● Formatos de dados
● Aplicações externas

Integração de aplicações (tradicional)
Aplicação Aplicação
A B
Funções
Bibliotecas disponíveis para
as aplicações.
Dados e regras de
negócio precisam Ambiente que requer
estar em um SGBD muita administração
para garantir a para se manter
Dados
integridade e sigilo. organizado.

Integração através de middleware
Aplicação Aplicação
A B
Funções
disponíveis para
Regras de negócio todas as
Middleware aplicações.
podem ficar em
componentes.
O ambiente requer
muita padronização
para se manter
Dados
organizado.

Middleware
● É uma camada de software que conecta componentes
ou aplicações, tendo como o objetivo a
interoperabilidade.
● Várias opções:
– ZOPE (Z Object Publishing Environment)
– WSGI (Web Server Gateway Interface)
– Twisted
– Muitos outros
● O próprio Python pode ser encarado como um
middleware.

Aplicações distribuídas
Arquiteturas:
● Computacional
● De recursos
● De aplicação ou híbrida

Modelo computacional
O servidor distribui as
requisições e centraliza os
resultados.
A B
C D
Os outros nós (workers)
recebem as tarefas e
calculam os resultados.

Modelo de recursos
Os clientes enviam as
A B requisições e recebem
os resultados.
C D E F
Os servidores recebem as
requisições e devolvem os G H
resultados.

Modelo híbrido ou de aplicação
A aplicação se confunde com
a infraestrutura, provendo os
recursos.
A B
C D
Cada nó pode atuar como
servidor e cliente, inclusive
ao mesmo tempo.

Modelos (comparação)
Computacional Recursos Híbrido
Escalabilidade Média Alta Alta
Complexidade Baixa Média Alta
Tolerância a
Média Alta Alta
falhas
Principal Processamento
Infra Arquivos
Aplicação memória
Servidores
Exemplo SETI@home P2P
Web

Aplicações distribuídas (requisito I)
Primeiro requisito: definir
a forma de comunicação
entre os nós.
A B
C D

Aplicações distribuídas (requisito II)
Segundo requisito: manter
os metadados sobre os
nós, usuários, arquivos e
outros recursos.
A B
C D

Aplicações distribuídas (requisito III)
Terceiro requisito: fazer o
monitoramento e
controle dos componentes
do sistema.
A B
C D

Aplicações distribuídas (requisito IV)
A B
C D
Quarto requisito: manter a
segurança (sigilo, integridade
e disponibilidade) dos dados e
sistemas envolvidos.

Camada de comunicação
A camada torna
transparente os
Rede
protocolos de
rede. Máquina Máquina
Framework Framework
Aplicação Aplicação

Camadas de comunicação em Python
● PYRO
● XML-RPC
● Socket

PYRO (Python Remote Objects)
Implementa:
● Um protocolo que permite a execução remota via
TCP/IP de métodos de um objeto.
● Envio de estruturas de dados “serializáveis” como
parâmetros.
● Servidor de nomes que facilita a localização
automática dos métodos.
● Validadores para verificar as credenciais do cliente.

PYRO (servidor)
import numpy
Classe do objeto que será
import Pyro.core
publicado na rede pelo PYRO.
class Dist(Pyro.core.ObjBase):
def fft(self, l): Método que calcula a
return numpy.fft.fft(l) transformada de Fourier.
# Inicia a thread do servidor
Pyro.core.initServer()
# Cria o servidor
daemon = Pyro.core.Daemon()
# Publica o objeto
uri = daemon.connect(Dist(),'dist')
# Coloca o servidor em estado operacional
daemon.requestLoop()

PYRO (cliente)
# -*- coding: utf-8 -*-
import numpy
import Pyro.core
# Dados de teste
dados = numpy.random.rand(100)
# Cria um objeto local para acessar o objeto remoto
proxy = Pyro.core.getProxyForURI('PYROLOC://127.0.0.1/dist')
# Evoca um método do objeto distribuído
print proxy.fft(dados)

XML-RPC
Implementa:
● Protocolo de execução remota de procedimentos.
● Transferências de dados em XML usando HTTP ou
HTTPS (criptografado) como protocolo de transporte.
● Suporte a tipos básicos: inteiro, ponto flutuante,
texto, ...

XML-RPC (servidor)
import numpy
from SimpleXMLRPCServer import SimpleXMLRPCServer
# Cria um servidor
server = SimpleXMLRPCServer(('localhost', 8888))
server.register_introspection_functions()
Conversão para tipos que o
def fft(l): XML-RPC aceita.
return [ float(x) for x in numpy.fft.fft(l) ]
server.register_function(fft)
# Inicia o loop do servidor
server.serve_forever()

XML-RPC (cliente)
import numpy
import xmlrpclib Conversão para tipos que o
XML-RPC aceita.
# Dados de teste
dados = [ float(x) for x in numpy.random.rand(100) ]
server = xmlrpclib.Server(\"http://localhost:8888\")
# Evoca o procedimento remoto
print server.fft(dados)

Socket
Implementa:
● Acesso de baixo nível a biblioteca de sockets que
disponível em praticamente qualquer sistema
operacional atual.
● Conexões ponto a ponto vai TCP/IP.

Socket (servidor I)
import cPickle
import socket
import threading
import numpy Classe que implementa as
threads para o servidor.
class Server(threading.Thread):
def __init__(self, skt):
self.skt = skt
threading.Thread.__init__ (self)
Método que é executado na
thread.
def run(self):
# Recebe os dados Dados foram serializados no
rec = self.skt.recv(5000) cliente.
# Calcula o resultado
ff = numpy.fft.fft(cPickle.loads(rec))
# Retorna a resposta
self.skt.send(cPickle.dumps(ff))
Continua...

Socket (servidor II)
# cria um socket INET STREAM
server = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
# Associa o socket a uma porta na interface de rede
server.bind((socket.gethostname(), 8000))
# Passa a \"ouvir\" a porta
server.listen(5)
while True:
# aceita acesso externo
(skt, addr) = server.accept()
svr =Server(skt)
svr.start()

Socket (cliente)
import cPickle
import socket
import numpy
# Dados
dados = numpy.random.rand(100)
# cria um socket INET STREAM
svr = socket.socket(
socket.AF_INET, socket.SOCK_STREAM)
# Conecta na interface de rede
svr.connect((socket.gethostname(), 8000))
svr.send(cPickle.dumps(dados))
# Recebe a resposta
rec = svr.recv(5000) Os resultados foram
print cPickle.loads(rec) serializados no servidor.

Comunicação (comparação)
PYRO XML-RPC Socket
Performance Alta Baixa Alta
Portabilidade Baixa Alta Alta
Depende da
Escalabilidade Alta Baixa
aplicação
Complexidade Baixa Média Alta
Dependências Média Baixa Baixa

YAML (YAML Ain't a Markup Language)
Implementa:
● Formato de serialização de dados para texto, amigável
para humanos.
● Representação de dados através de combinações de
listas, dicionários e escalares.
● Convenções de sintaxe similares as linguagens
dinâmicas, com forte influência do Python.
● Um superset do JSON (JavaScript Object Notation).

YAML (exemplo)
- Artista: King Crimson [{'Artista': 'King Crimson',
Faixas: 'Faixas': ['Starless',
- Starless 'Frature',
- Frature 'Red', 'Lizard']},
- Red {'Artista': 'Genesis',
- Lizard 'Faixas': [\"Supper's Ready\",
- Artista: Genesis 'In The Cage',
Faixas: 'The Lamia']}]
- Supper's Ready
- In The Cage
- The Lamia
Documento Estrutura
YAML Python

Formatos (comparação)
YAML / JSON XML (c)Pickle
Performance Média Baixa Alta
Portabilidade Alta Alta Baixa
Escalabilidade Média Alta Alta
Complexidade Baixa Média Baixa
Dependências Média Baixa Baixa

Aplicações externas
Aplicações “pythônicas”:
● BrOffice.org
● Blender
● GIMP
● Inkscape
● PostgreSQL

BrOffice.org
Implementa:
● Suporte ao Python como linguagem de macro,
permitindo a automatização de tarefas e a construção
de extensões (add ons).
● Serviço para atender conexões, através de uma API
chamada UNO (Universal Network Objects).

BrOffice.org (serviço)
Interpretador
PyUNO BrOffice.org
Python UNO
Bridge Aceita conexões
remotas via
named pipes ou
sockets.
Aplicação

BrOffice.org (exemplo I)
# -*- coding: latin1 -*-
# Para iniciar o BrOffice.org como servidor:
# swriter.exe -headless
# \"-accept=pipe,name=py;urp;StarOffice.ServiceManager\"
import os
import uno
from com.sun.star.beans import PropertyValue
# Dados...
mus = [('Artista', 'Faixa'),
('King Crimson', 'Starless'), ('Yes', 'Siberian Khatru'),
('Led Zeppellin', 'No Quarter'), ('Genesis', 'Supper\\'s Ready')]
rows = len(mus)
cols = len(mus[0])
Continua...

BrOffice.org (exemplo II)
# Inicio do \"Boiler Plate\"...
# Contexto de componente local
loc = uno.getComponentContext()
# Para resolver URLs
res = loc.ServiceManager.createInstanceWithContext(
'com.sun.star.bridge.UnoUrlResolver', loc)
# Contexto para a URL
con = res.resolve('uno:pipe,name=py;urp;StarOffice.ComponentContext')
# Documento corrente
desktop = con.ServiceManager.createInstanceWithContext(
'com.sun.star.frame.Desktop', con)
# Fim do \"Boiler Plate\"...
Continua...

BrOffice.org (exemplo III)
# Cria um documento novo no Writer
doc = desktop.loadComponentFromURL('private:factory/swriter',
'_blank', 0, ())
# Cursor de texto
cursor = doc.Text.createTextCursor()
# Muda propriedades Texto
cursor.setPropertyValue('CharFontName', 'Verdana') inserido
cursor.setPropertyValue('CharHeight', 20)
cursor.setPropertyValue('CharWeight', 180)
doc.Text.insertString(cursor, 'Músicas favoritas\\n', 0)
# Cria tabela
tab = doc.createInstance('com.sun.star.text.TextTable')
tab.initialize(rows, cols)
doc.Text.insertTextContent(cursor, tab, 0)
Continua...

BrOffice.org (exemplo IV)
# Preenche a tabela
for row in xrange(rows):
for col in xrange(cols):
cel = chr(ord('A') + col) + str(row + 1)
tab.getCellByName(cel).setString(mus[row][col]) Tabela
# Propriedades para exportar o documento
props = []
p = PropertyValue()
p.Name = 'Overwrite'
p.Value = True # Sobrescreve o documento anterior
props.append(p)
p = PropertyValue()
p.Name = 'FilterName'
p.Value = 'writer_pdf_Export' # Writer para PDF
props.append(p)
Continua...

BrOffice.org (exemplo V)
# URL de destino
url = uno.systemPathToFileUrl(os.path.abspath('musicas.pdf'))
# Salva o documento como PDF
doc.storeToURL(url, tuple(props))
# Fecha o documento
doc.close(True)
Arquivo de
saída

Referências
PYRO:
● http://pyro.sourceforge.net/
Socket Programming HOWTO:
● http://www.amk.ca/python/howto/sockets/
YAML Cookbook:
● http://yaml4r.sourceforge.net/cookbook/
Python – OpenOffice.org Wiki:
● http://wiki.services.openoffice.org/wiki/Python

Integração de aplicações em
Luiz Eduardo Borges
http://ark4n.wordpress.com/
Fim