Muitas empresas utilizam soluções de cache que são muito mais rápidas e eficientes, e entre as opções disponíveis, eu gostaria de destacar o memcached. Empresas como Facebook, Google, Wikipedia fazem uso bem intenso dessa ferramenta e ela é bem otimizada para uso em larga escala.

Apesar de ser projetado para Linux, há um port para windows no qual eu uso para testes ( nunca testado em ambiente de produção). Basicamente sua função é armazenar coleções em memória, servindo os dados via socket para os clientes que conectarem ao servidor.  Usa UDP como protocolo de comunicação e um mecanismo muito eficiente para gerenciamento de dados.

Um exemplo prático de como seria usado o mecanismo de cache:

• Usuário A chama uma página e requisita cidades do estado de SP e a mesma não está em cache;
• Aplicação chama consulta no banco de dados, adiciona a chave ao cache: cache.set(“cidades”,coleção);
• Usuário B chama a aplicação e verifica que os dados estão no cache. Aplicação consulta cache e retorna os dados para serem tratados: cache.get(“cidades”);

Se não tenha ficado claro, um pseudo-código pode ajudar:

• se existir cache.get(“cidade”) então:
  -> popular controles com essa coleção
• caso contrário:
  -> buscar dados de cidade do banco;
  -> setar cache cache.set(“cidade”, dados_do_banco);
  -> popular controles com essa coleção;

Problemas de um cenário real:

Na teoria parece muito simples, certo ? Se você estiver pensando em um ambiente que não haja restrição por condições de corrida ( usuários simultâneos realizando a mesma operação ), então é realmente simples.

Mas imagine um momento em que você precisa incrementar um registro no cache, e esse registro só pode ser incrementado se ninguém mais estiver fazendo o processo. Como você resolveria essa questão ?

Pesquisando um pouco, acabei lembrando dos mecanismos de semáforo e de entrada em região crítica, o que me levou a criar um modelo que tenta fazer algo parecido. Só para lembrar o processo de região crítica (retirado do link acima da wikipedia):

Para entrar numa região crítica, uma linha de execução deve obter um semáforo, que será descartado na saída da região crítica. Cada recurso compartilhado, ou um conjunto de recursos compartilhados em comum, possui um semáforo próprio. Qualquer outra linha de execução deverá esperar para entrar numa região crítica em uso, mas poderá usar a CPU para executar qualquer outro código, incluindo regiões críticas protegidas por outro semáforo.

Logo abaixo, postei o exemplo criado em Python, porém estou escrevendo um pseudo-código que pode ser facilmente migrado para qualquer linguagem:

1. Conectar no memcache;
2. Tentar adicionar a chave(“lock”);
3. Se adicionar, então não tem ninguém esperando – incremente o registro que você precisa, remova a chave lock;
4. Caso tenha a chave, tente esperar alguns micro-segundos, e executar a operação “N” vezes. Se “N” for atingido, retornar erro, caso contrário, basta executar o procedimento anterior;
5. Desconectar do memcache;

import memcache
import time

def lock_update(key):

    # parametrizacoes, todo passar para um cfg
    m = memcache.Client(['127.0.0.1:11211'], debug=0)
    lock = "lock_" + key
    max_tries = 5 #tenta 5 vezes
    tries = 0
    expiration = 60 #segundos
    got_lock = False
    number = -1
    wait_time_between_tries = 101 #microsegundos

    # teste inicial, apenas para colocar algo na chave, caso não tenha no cache
    if m.get(key) is None:
        m.set(key,0)

    if(m):
        # roda o numero de tentativas para adquirir o lock
        for tries in range(0, max_tries):
            # se conseguir adicionar, adquire o lock
            if(m.add(lock, 1, expiration)):
                got_lock = True
                break

            # se nao conseguiu, espera um pouco
            time.sleep(wait_time_between_tries / 1000000.0)

        # consegui adquirir o lock
        if(got_lock):
            number = m.incr(key)
            m.delete(lock, 0)

        # retorna o valor
        return number

# só para teste pela linha de comando
if __name__=="__main__":
    print lock_update("teste")

Simples, não ?

Espero que ajude

abs

Robson Dantas

Bookmarks

My app is AppEngine based and I´m algo using xmlrpclib and wordpress-library to make web calls. After playing a while with wordpress-library, I got some things missing and started to patch to make it work for me.

Basically I´ve added some stuff like post status, custom fields and filter posts by categories. I dont know why Wordpress don´t give a simple wrapper function inside xmlrpc.php to make things generic, allowing other users to extend functionalities. Anyway, I did it and will suggest to add support for it, because makes easier to give some maitenance.

To make the patch, you must understand the get_post function, exposed on wp-includes/post.php. Looking inside, the function body is:

function get_posts($args = null) {
    $defaults = array(
                             'numberposts' => 5, 'offset' => 0,
                             'category' => 0, 'orderby' => 'post_date',
                             'order' => 'DESC', 'include' => '',
                             'exclude' => '', 'meta_key' => '',
                             'meta_value' =>'', 'post_type' => 'post',
                             'suppress_filters' => true
                             );

…. continue

Based on that function, it becomes easier to make your on function on xmlrpc.php:

First:  Include your function entrypoint on $this->methods array. My implementation is ‘wp.getPostsByCategory’   => ‘this:wp_getPostsByCategory’. I decided to use this name, because it´s a specific function for wordpress, not a MetaWebLog structure.

Second: Change mw_wp_get_recent_posts to receive other args and change the call wp_get_recent_posts($num_posts) to use get_posts . You´ll also need to change the ways that arrays are accessed, because get_posts function returns an Object, instead of array. Example: $entry['ID'] becomes $entry->ID.

After that, just make your call to wp.getPostsByCategory, passing username, password and categoryId. Like magic

Just to finish, a simple python example using xmlrpclib to call a server method:

import xmlrpclib

server = xmlrpclib.ServerProxy("http://www.mywebsite.com/xmlrpc.php")
posts = server.wp.getPostsByCategory(categoryId, 'user', 'password')

for post in posts:
   print post['post_title']

.
Piece of cake ! If you have any doubt, leave a comment here.

Bookmarks

Vou começar uma série de artigos sobre o desenvolvimento de aplicações WEB usando Python com o Django, um poderoso framework web, no qual eu comecei a respeitar, tanto quanto a comunidade Ruby respeita o Ruby on Rails.

Antes de entrar nos detalhes do modelo de implementação do Django com Python, estou postando um simples tutorial de como configurar o Apache e o mod_python para que você possa desenvolver aplicações.

Para o meu tutorial, eu usei o Apache 2.2 para Windows e a mesma versão para o Ubuntu. Caso queira ver a lista dos pré-requisitos, sugiro que acesse a página do mod_python pois a versão do módulo só funciona com a versão certa do apache. Veja:  Requisitos para o mod_python

Passo 1:

Verifique a versão do Python que você possui instalado na sua máquina. Para poder rodar o mod_python, você precisa do python 2.5.x, pois por alguns problemas relativos à compilação, o mod_python ainda não suporta o python 2.6 .

Para fazer isso, entre num prompt do dos e digite python –version . Se estiver tudo certo, verificará algo como “Python 2.5.xx” .

Caso apresente um erro que o executável não foi encontrado, certifique-se que a pasta do Python está no seu path.

Passo 2:

Faça download do mod_python . No momento em que esse tutorial foi escrito, a versão era (ou é) a 3.3 . Para windows, existe um instalador e basta seguir o processo NNF (next, next, finish).

Para *Nix, é necessário baixar os fontes e compilar na mão. Verifique se a sua distribuição não oferece o pacote pronto, assim você economiza tempo e CPU . Antes da compilação, caso você opte por fazer na mão, precisa decidir como quer carregar o módulo: por DSO ( Dynamic Shared Object) ou estáticamente. Se for pra linha do estático, vai precisar recompilar o Apache.

Eu escolhi compilar usando DSO. Só para deixar claro, o utilitário que faz o processo da carga dinâmica de módulos é chamado de APXS  Verifique se o mesmo está no seu path!

Rodei um configure bem simples: ./configure –with-apxs=/usr/local/apache/bin/apxs

Depois disso, os famosos comandos make e depois make install. Lembre-se que para rodar o make install você precisa estar logado como root, pois ele copiará a biblioteca para o seu libexec.

Passo 3:

Depois disso tudo, vem o truque necessário para o Python rodar no Apache. Eu apanhei algumas vezes pois as documentações além de desatualizadas, estão cheias de erro.

Para fazer rodar você precisa editar o arquivo httpd.conf. No windows, está na pasta “conf” e nos linux, normalmente fica em /etc/httpd.conf .

Abra o arquivo no seu editor favorito e procure por linhas que comecem por “LoadModule”. Você vai achar várias linhas, uma embaixo da outra, com um monte de módulos. Essas linhas falam ao Apx para carregar o módulo e depois da última, inclua uma nova linha:

LoadModule python_module modules/mod_python.so

Só garanta que a pasta que o módulo está, foi configurada corretamente. É possível colocar o caminho completo por lá também.

Depois de carregado o módulo, é necessário configurar um diretório para que os scripts python seja interpretados. Procure por linhas que comecem por “<Directory “ no httpd.conf e inclua uma nova, com o seguinte formato:

Para windows:

<Directory "c:/diretorio_apache/www/py/">
        SetHandler mod_python
        PythonHandler mptest
        PythonDebug On
</Directory>

Para Linux:

<Directory "/pasta/diretorioapache/www/py/">
        SetHandler mod_python
        PythonHandler mptest
        PythonDebug On
</Directory>

Pronto! Depois desse processo, salve o arquivo e reinicie seu apache. Verifique nos arquivos de log se não ocorreu nenhum erro com a carga do módulo e passe para a etapa seguinte.

Passo 4:

Vamos gerar um arquivo de teste, para que seja executado pelo navegador. Abra um editor qualquer e digite o seguinte conteúdo:

from mod_python import apache

def handler(req):
	req.content_type = 'text/plain'
	req.write("Funcionou. Minha aplicacao python esta ok.")
	return apache.OK

Salve o arquivo na pasta py que você criou no arquivo de configuração do apache e chame-o através do browser. Ex: http://localhost/py/teste.py . Se tudo ocorreu bem, você deve ver “Funcionou. Minha aplicacao python esta ok”.

É isso. O segredo está no “SetHandler”, que muitas documentações passam outra forma.

Caso tenha alguma dúvida, faça um comentário e consulte também a documentação no site do mod_python.

Até a próxima com Django.

Bookmarks

1- Estou hospedando meu site de graça, em uma estrutura da Google. Apenas registrei meu domínio no registro.br, usei um serviço de DNS GRATUITO – nesse caso o Zoneedit (zoneedit.com), me cadastrei no Google Applications (google.com/a) e alterei as entradas CNAME para o Google;

2- O Google App Engine fornece uma estrutura de CDN (content delivery network), onde o seu site fica dentro de uma estrutura com balanceamento de carga e um algoritmo determina a melhor rota para servir uma página, fazendo com que o mecanismo fique muito mais rápido;

3- Além de fornecer tudo isso, permite hospedagens de páginas Python de uma maneira bem simples: basta editar um arquivo .yaml e rodar um programa python que o processo de upload está feito;

Se quiser mais detalhes disso que estou falando, tem um post interessante no 24 ways:  http://24ways.org/2008/using-google-app-engine-as-your-own-cdn

Enfim… o assunto principal aqui não é como subir o seu CDN e sim como habilitar chamadas AJAX em domínios externos. A solução, é bem simples por sinal: subir um proxy escrito em python que redirecione as requisições de GET e POST para um servidor final, lendo e imprimindo os resultados.

Como é de conhecimento de muitos, os browsers não permitem requisição HTTP fora do domínio e apresentam erros como “Security error”, óbvio.  Para resolver isso, siga a minha receita de bolo…

a) Edite o arquivo app.yaml e inclua as seguintes linhas dentro de handlers:

- url: /xpto
script: x.py

O resultado do meu arquivo app.yaml é algo do tipo:

application: meuapp
version: 1
runtime: python
api_version: 1

handlers:
- url: /
static_files: assets/*.html
upload: assets/index.html

- url: /xpto
script: x.py

- url: /
static_dir: assets

Esse parâmetro diz para redirecionar todas as requisições http que tem como destino a pasta “xpto”, para o script x.py. Depois disso precisamos criar nosso script python para fazer o proxy. Estou dando o exemplo apenas com o método GET:

Salve na pasta raiz e depois disso, com o jQuery faça um teste…

$.get(“/xpto”,{campo1: “aaa”, campo2: “bbb”}, function(data){

alert(data);

});

Embora muita gente defenda o uso de JSONP, acredito que o modelo de proxy seja mais eficiente. A implementação do POST fica por sua conta, basta seguir a lógica

Dúvida, comentário, sugestão ? Utilize o formulário aqui do blog.

–Robson

Bookmarks