No último dia 25 de abril aconteceu em todo mundo o World Plone Day, uma iniciativa da comunidade Plone para divular o Plone com a realização de diversos eventos. Em 2012 foram realizados simultaneamente  34 eventos em 20 países diferentes.

Eu tive a oportunidade e a honra de participar do World Plone Day Brasília, organizado pela comunidade Plonegovbr e pelo Interlegis. Muito bem organizado diga-se de passagem. Diversas oficinas, palestras e uma excelente discussão sobre o compartilhamento de código pelo governo. Discussão que ainda vai render um post, mas fica para depois.

Durante o evento fiz duas palestras e uma oficina. Foram elas:

Estado do Plone

Como funciona a comunidade e o desenvolvimento do Plone.
Novidades das versões 4.2, 4,3 e 5.

Espero ter conseguido passar para as pessoas a necessidade de contribuir e participar da comunidade.

Oficina de Diazo

Conceitos básicos de Diazo, e um passo a passo bem simples para deixar claro os principais conceitos da utilização do Diazo.

Simplificando o Plone

Novidades apresentadas pela Simples Consultoria durante o World Plone Day: Core Developer Desk, Ploud.com.br e o novo Manual do Plone, que agora virou livro. Mais detalhes sobre essas novidades aqui no site.

Como bem sabemos o dia da mentira é comemorado por todos e por muitas empresas, até mesmo o Google entrou nessa, e este ano não foi diferente, porém o que venho postar não é sobre o dia da mentira ou sobre as brincadeiras que o Google tem feito, apesar de serem muito divertidas.

O que me chamou a atenção foi o tal do Elegantizr que foi divulgado como um framework que promete deixar o site até 3 vezes mais rápido, e pior, muita gente mesmo caiu nessa!

Risadas a parte, a brincadeira foi tão legal que logo eu quis saber como foi feita. É bem provável que muitos venham a dizer que é algo super simples e etc, porém vale ainda assim blogar.

A brincadeira.

<link rel="stylesheet" href="http://www.google.com/landing/elegantizr/elegantizr.css" />

:before {
  content: '\41\50\52\49\4C\20\46\4F\4F\4C\20\F4\BF\F4';
}

a:link:before {
  content: " (" attr(href) ") ";
}

Depois do texto de um link.

a:link:after {
   content: " (" attr(href) ") ";
}

Como fazer.

'\41\50\52\49\4C\20\46\4F\4F\4C\20\F4\BF\F4'

>>> text = 'APRIL FOOL ô¿ô'
>>> text.encode('hex').upper()
'415052494C20464F4F4C20C3B4C2BFC3B4'

>>> text = 'APRIL FOOL ô¿ô'
>>> text.encode('iso-8859-1').encode('hex').upper()
'415052494C20464F4F4C20F4BFF4'

'\41\50\52\49\4C\20\46\4F\4F\4C\20\F4\BF\F4'

>>> text = 'Python'
>>> text.encode('iso-8859-1').encode('hex').upper()
'507974686F6E'

:before {
  content: '\50\79\74\68\6F\6E';
}

Até a próxima.

Trabalhando em um projeto recentemente precisei gerar um arquivo menor do jQuery que eu havia modificado, e com isso comecei a me perguntar como o jquery.com o fazia com seus arquivos por exemplo: 

• jquery-1.7.1.js 244K
• jquery-1.7.1.min.js 92K
  
  

$ mkdir cobaia
$ curl -O http://code.jquery.com/jquery-1.4.4.js
$ ls -hs *.js

$ easy_install jsmin

$ pip install jsmin

$ python

>>> from os import path
>>> from os.path import join
>>>
>>> # Usei o cStringIO por ser mais rápido que o StringIO implementado em Python
>>> from cStringIO import StringIO
>>> 
>>> # As linha abaixo é o que nos garante o uso do jsmin
>>> import jsmin
>>> jmin = jsmin.JavascriptMinify()
>>>
>>> base = path.dirname(path.abspath(path.realpath(__name__)))
>>>
>>> # Abrimos o arquivo original apenas como leitura 
>>> filejs = open(join(base, 'jquery-1.4.4.js'),'r')
>>>
>>> # Pegamos o nome do arquivo original e concatenamos com .min.js
>>> filename_out =  str(str(filejs.name.split('/')[-1]).split('.js')[0] + '.min.js')
>>>
>>> file_out = StringIO()
>>> file_out.write("")
>>>
>>> # Gerando um novo arquivo com modo de escrita
>>> file_out = open(join(base, filename_out),'wb')
>>>
>>> # Por fim passamos para o minify um arquivo de entrada e o de saída
>>> jmin.minify(filejs,file_out)
>>> file_out.close()

$ ls -hs *.js

Outra forma de fazer.

$ gcc jsmin.c -o jsmin
$ ./jsmin < jquery-1.4.4.js > jquery-1.4.4.min.js

O pulo do gato.

O World Plone Day é um evento realizado pela Comunidade Internacional de Plone em diversas cidades do mundo, com o objetivo de divulgar o Plone. A edição de 2012 já tem data definida: será realizado no dia 25 de abril.

No Brasil, diversos grupos de usuários já se movimentaram para organizar eventos e até agora temos a confirmação de eventos em 5 cidades:  

• Aracaju
• Brasília
• João Pessoa
• São Bernardo
• São Paulo

Mais eventos

Ainda estamos em busca de novas cidades para aumentar essa lista. Se você conhece Plone e mora em uma cidade que não faz parte da lista acima você é um sério candidato a realizar um evento. Entre em contado comigo pelo twitter @agnogueira ou pelo formulário de contato aqui do site que podemos orienta-lo. E não se preocupe, não precisa ser um grande evento, pode ser apenas uma pequena palestra ou reunião de amigos.
 
Mais informações sobre o evento podem ser encontradas no site do evento: http://plone.org/events/wpd/

Ano passado fiz um post aqui no Blog da Simples mostrando o passo a passo para instalar o Plone no Windows utilizando o instalador disponibilizado no Plone.org. Mas nos meses seguintes o processo mudou um pouco. Na verdade ele foi simplificado, removendo diversos passos da instalação, como a definição de senha e diversas autorizações necessárias.

Para manter o blog atualizado vou refazer o passo a passo aqui, mostrando o funcionamento novo.

Baixando o arquivo e iniciando a instalação

Para começar, acesse o site do Plone e baixe a versão mais recente do instalador. Isso pode ser feito diretamente nesta página: http://plone.org/products/plone.

Escolha o arquivo de instalação para o windows e faça o download. Nesse tutorial vamos usar como exemplo a instalação para windows utilizando o windows 7. 

O arquivo para windows tem 32MB e deve demorar alguns minutos para baixar. Assim que terminar, basta executar o arquivo para iniciar o processo.

Ao executar o arquivo, você deve receber uma mensagem perguntando se você realmente deseja executar o arquivo.

Clique no botão "Executar" para permitir a instalação. Em alguns casos, de acordo coma configuração de seu computador, você pode ver uma segunda janela perguntando se você autoriza o programa Plone.exe a realizar modificações em seu computador. Dê a permissão para continuar.

A próxima tela que você vai ver é a tela do inicio da instalação propriamente dita:

Clique no botão "Next" e você será redirecionado a seguinte tela:

Basta clicar em "Instal" que a mágica vai começar. O instalador vai fazer tudo sozinho, criar pastas, rodar buildout, criar usuários. VOcê só terá que aguardar alguns minutos até que a seguinte tela apareça:

Basta clicar no botão finalizar e pronto, não será necessário nem reiniciar os eu computador. Basta acessar o endereço http://localhost:8080/ em seu navegador para criar seu novo site:

Clique no botão "Criar novo site Plone". Quando perguntado, informe o usuário admin e a senha admin que são criados automaticamente pelo instalador.

Na tela seguinte basta escolher o id e o nome do seu site, clicar no botão 'Criar Plone site' e começar a se divertir com seu site Plone.

Qualquer dúvida com o processo, deixe seu recado nos comentários

Uma das perguntas que mais escuto durante os cursos de Gestão de Conteúdo que ministramos pelo Brasil é como podemos melhorar o desempenho de um site nos mecanismos de Busca. Para ajudar com a resposta, fiz essa apresentação no ano passado durante o World Plone Day que realizamos aqui em São Paulo.

Nela mostro tudo o que o Plone já faz a respeito e as principais ações que você pode ter com seu conteúdo para alcançar melhor resultados. Confira:

O Ano de 2012 mal começou e o pessoal do use.it já divulgou sua lista com as 10 melhores intranets de 2012. Jakob Nielsen e sua turma prepararam um relatório de mais de 400 páginas com muitas imagens de tela para explicar o motivo da escolha dos vencedores.

Veja a seguir algumas das principais constatações do relatório sobre o perfil dessas empresas e como elas encaram seu portal corporativo:

Evolução contínua da Intranet

Um portal corporativo não pode ser lançado e esquecido. O design e as funcionalidades devem evoluir constantemente para atender as necessidades da empresa e do ambiente ao redor, que mudam diariamente. Entre os vencedores apenas um foi vencedor anteriormente, o que demostra claramente a necessidade de renovação constante.

Empresas menores possuem Intranets melhores

Entre os dez vencedores a média do número de funcionários é de 19.700. Três das empresas vencedoras possuem menos de 10 mil funcionários.  Esse número é bem menor do que os anos anteriores, quando a média era maior do que 30 mil funcionários.

As equipes cresceram

Apesar da queda no número de funcionários das empresas vencedoras, o número de profissionais envolvidos com o desenvolvimento do portal aumentou. Entre os vencedores a média passou para 15 profissionais, o que nos dá um número mágico aproximado de 1 especialista de internet para cada mil funcionários. Nesse número estão incluídos os especialistas da empresa e tambem parceiros externos de consultorias e agências.

Parceria

Oito dos dez vencedores contam com a ajuda externa no desenvolvimento e no design de sua solução de intranet. Na maioria dos casos existe uma grande parceria entre a equipe interna, que possui um grande conhecimento da empresa e do negócio e uma consultoria externa, que possui o conhecimento sobre a tecnologia e as práticas de design.

Mais detalhes sobre o relatório pode ser encontrado num rápido resumo publicado no use.it:
http://www.useit.com/alertbox/intranet_design.html

Além disso o relatório completo pode ser adquirido no website da Nielsen Norman Group por U$248,00. http://www.nngroup.com/reports/intranet/design/

Interessado em construir uma intranet de sucesso? Entre em contato e conheça o que a Simples Consultoria e o Plone podem oferecer.

Não preciso dizer o quanto a PythonBrasil [7] foi um sucesso :-D , infelizmente não tive como ver todas as palestras o que seria bizarro conseguir, dado que não sou onipresente. Apesar da minha palestra ter sido em uma sexta-feira no final do dia eu pude extrapolar o tempo, e ainda ficou faltando diversos detalhes.

Um detalhe importante é que o @ericof apareceu e também participou da palestra,  conhecidencia ou não, ocorreu após eu ter invocado seu nome 3 vezes. Em minha apresentação pude mostrar o quanto o Varnish é poderoso, e o quanto a combinação Varnish [3] e Plone [4] pode ser igual a [42]. 

Dando sequência a série de posts sobre as palestras ministradas durante a PythonBrasil [7], apresentamos agora os slides da apresentação "Plone e JQuery ao gosto do Cliente" executada pelos simplificadores @cleberjsantos e @Tamosauskas

Na oportunidade foram mostrados alguns exemplos práticos de como aprimorar a interface de sites em Plone usando alguns recursos de jQuery. Em especial são mostradas maneiras de integrar os métodos e atributos dos objetos do Zope em seus scripts jQuery.

Nos próximos dias vamos começar a publicar aqui no blog todas as palestras ministradas pelos simplificadores durante a PythonBrasil [7] , que foi realizada em São Paulo entre os dias 28 de setembro e 1 de outubro.

A primeira a ser publicada é a palestra Cmsui: Uma nova maneira de editar conteúdo no Plone que ministrei na sexta-feira. A idéia principal da palestra era mostrar a evolução da edição de conteúdo no Plone e os caminhos que estamos seguindo para as próximas versões. Aproveitem e aguardem as outras palestras que serão publicadas nos próximos dias.

Mais uma vez o Plone chega aos finalistas da premiação Open Source Awards promovida pela Packt Publishing na categoria Open Source CMS. O Plone também está concorrendo nas seguintes novas  subcategorias:

• Best Open Source CMS for performance (Melhor performance de CMS Open Source)
• Best CMS for Best Community:  (Melhor Comunidade de CSM Open Source)
  
• Best CMS for Ease of Use: (CMS Open Source Mais Fácil de Usar)

Os votos podem ser feitos até dia 31 de Outubro, logo antes do início da Plone Conference  em São Francisco. Mas se você faz parte da comunidade Plone, deixe seu voto agora para não correr o risco de esquecer.

Plone já ganhou prêmios neste concurso em 2008 e 2009. As  subcategorias devem ser votadas separadamente da categoria principal. Veja abaixo como proceder:

1. Clique aqui e vote no Plone na categoria CMS.
2. Clique aqui e adicione o Plone nas subcategorias Performance, Community e Ease of Use, respectivamente Performance, Comunidade e Facilidade de Uso.

Dica: Coloque "N/A” e “http://example.com” na categoria .NET se você não tiver nenhum favorito em mente.

A Comunidade Plone Agradece.

Ao desenhar as regras do seu tema feito em diazo para o Plone, pode ser bastante útil entender um pouco melhor como o compilador do Diazo trabalhará. Entre várias coisas importantes temos a  ordem exata na qual o diazo lerá as regras.

Independente de qual regra aparecer primeiro no seu arquivo xml, o diazo sempre levará em consideração a seguinte hierarquia:

1º lugar: <before css:theme="" /> (mas não theme-children)

2º lugar: <drop />

3º lugar: <replace css:theme="" /> (mas não theme-children)

4º lugar: <strip />.

5º lugar: Regras que usam attributes.

6º lugar: <before />, <replace /> e <after /> usando "theme-children" 

7º e último lugar: <after  css:theme="" /> (mas não theme-children).

Esta ordem explica porque não adianta usar uma regra <replace> se em qualquer lugar do xml você aplicar uma regra <drop> ou uma regra <replace> no mesmo elemento. Assim, se uma as mudanças  insistirem em não aparecer no seu tema, vale a pena dar uma revisada na sua ordem de execução.

Muita gente gostaria de poder conhecer melhor as estatísticas da busca interna do seu Plone site. Imagine só saber informações como quais são os conteúdos mais buscados, a quantidade de vezes que a busca foi utilizada, os objetos mais encontrados, entre outras coisas.

A boa notícia é que se você usa  o Google Analytics para gerar as estatísticas do seu Plone site é muito fácil ter acesso a esses dados. Basta fazer um pequeno ajuste de configuração no próprio Analytics para que ele começe a analisar a busca do seu site.

Segue um passo a passo bem rápido:

1. Faça Login no Google Analytics;
2. Clique em 'edit' ao lado do perfil do site que deseja configurar;
3. Na página seguinte, clique no link 'edit' que fica na caixa 'Main Website Profile Information';
4. Na área 'Site Search' marque a opção 'Do Track Site Search';
5. No campo 'Query Parameter' informe o valor 'SearchableText';
6. Clique no botão 'Save Changes' que fica no final da página.

Pronto, a partir de agora o Google Analytics vai começar a analisar a busca do seu site e você terá acesso aos dados. Esses dados estarão disponíveis dentro da das estatísticas dentro do menu 'Content' do seu relatório, na opção 'Site Search'

VMODs, ou simplesmente Varnish Modules é, segundo da documentação de modificações, um dos grandes sucessos obtidos na versão 3: "VMODs on the other hand, was an instant success, because they make it much easier for people to extend Varnish with new functionality".

E realmente, é o mesmo que tenho achado, como bem sabemos desde o Varnish 2.1 podemos usar C inline para criar e estender funcionalidades que por padrão o Varnish não trás, e com a chegada dos módulos essa brincadeira tona-se ainda melhor, por tudo que podemos fazer na VCL.

Sabermos ainda que existem coisas que não temos como fazer na VCL, por exemplo: Procurar um número de IP em um arquivo de banco de dados. Usando código C inline até temos como resolver este problema, já que o Varnish nos provê isso, e lá você pode fazer tudo, mas não é uma forma conveniente ou mesmo legível para resolver tais problemas. Eis o lugar onde VMODs entram em cena.

O que é a VMOD?

Trata-se de uma biblioteca compartilhada com algumas funções C que pode ser chamado a partir do código VCL.

A interface entre o VMOD o compilador VCL ("VCC") e o tempo de execução VCL ("VRT") é definido em um arquivo de nome vmod.vcc que um script python de nome "vmod.py" que faz todo o trabalho duro

Executando o vmod.py no arquivo vmod.vcc, será produzido dois arquivos, que são: "vcc_if.c" e "vcc_if.h", no qual devemos usar para construir o nosso arquivo de biblioteca compartilhada.

o vcc_if.c até pode ser esquecido em nosso VMOD, mas o vcc_if.h é importante, ele contém os protótipos para as funções que desejamos exportar para a VCL.

vmod_dir
Default: ${VARNISH:DIR}/lib/varnish/vmods

Na prática.

import example;

sub vcl_deliver {
	# Vamos definit o  resp.http.hello para "Hello, World"
	set resp.http.hello = example.hello("World");
}

import geoip;

sub vcl_recv {
   # Definimos um cabeçalho de solicitação X-GeoIP
   # para o geo do solicitante (ou desconhecido).
   set req.http.X-Forwarded-For = client.ip;
   set req.http.X-GeoIP = geoip.country(req.http.X-Forwarded-For)
}

import curl;

sub vcl_recv {
    curl.fetch("http://example.com/test");
    if (curl.header("X-Foo") == "bar") {
        …
    }
    curl.free();
}

Um pouco mais antes de terminar.

import std;

sub vcl_recv {
   std.collect(req.http.foo);
}

sub vcl_fetch {
   std.collect(beresp.http.bar);
}

sub vcl_deliver {
        set resp.http.foo = std.toupper(req.url);
}

set beresp.http.x-scream = std.toupper("yes!");

set beresp.http.x-nice = std.tolower("VerY");

Ainda temos random, log, set_up_tos, syslog, fileread, duration e integer, no qual adoraria escrever sobre, mas fica a dica para quem desejar conhecer, o VMOD é realmente uma verdadeira caixa de legos, e o mais legal é que você ainda pode criar novas peças e encaixar nas já existentes. Espero que tenha sido u bom post para você entender e começar a montar a sua VMOD, e espero que post aqui sobre a experiência.

Até a próxima.

Leia também:

• vmod_std
• vmod

O 'Evento' e um tipo padrão do Plone que, entre outros recursos, possui alguns links (iCal e vCal) que permitem adicionar o evento do seu site ao calendário de aplicativos como o Mozilla Sunbird, Microsoft Outlook e similares... Este é um recurso maravilhoso, que nunca vi ninguém usar o_O .

Por outro lado todos os meus heróis que não morreram de overdose usam hoje o Google Calendar para organizar seu dia a dia. Pensando nisso imaginei uma maneira de termos um link nos eventos do Plone que adicione ele as agendas do Google Calendar.

Você vai precisar:

1 - Um script python para formatar a data, que chamaremos, Dataformat.py:

from DateTime import DateTime
if not dt:
 dt = DateTime()

if not format:
 format = "%Y%m%dT%H%M00"

if not same_type(dt, DateTime()):
 dt = DateTime(dt)

print dt.strftime(format)
return printed

Este script é necessário para formatar as datas iniciais e finais do evento no formato usado pelo Google Calendar

2 - Colocar a seguinte expressão em Zope Page Template no seu template event_view.pt

<a href="#" title="Add to Google Calendar" target="_blank" 
            tal:define="atDate here/start;
                        inicio python: context.Dataformata(atDate);
                        fim python: context.Dataformata(atDate)"
            tal:attributes="href string:http://www.google.com/calendar/render?
action=TEMPLATE&text=${context/Title}&dates=${inicio}/${fim}&location=
${context/getLocation}&details=Detalhes:${context/absolute_url}&trp=false">
    Google Calendar
</a>

Seguindo os passos acima você terá um link que incluirá o evento em questão a sua agenda do Google Calendar. Veja um exemplo no site de um de nossos clientes: http://www.proparts.esp.br/events/copa-sram-1a-etapa-sram-50k/view

Nas últimas semanas tenho tido a oportunidade de ficar mais próximo do Varnish, e nas últimas três semanas comecei a migrar do varnish 2.1 para Varnish 3, posso dizer desde já que teve um grande salto de melhorias e também de implementações. Mas neste post irei tratar apenas de como preparar sua configuração de vcl para não ser pego de supresa quando fazer um upgrade da versão.

O exemplo de vcl a seguir foi retirado do svn do Varnish: https://www.varnish-cache.org/trac/browser/etc/zope-plone.vcl e será com base neste vcl que iremos efetuar a migração.

Breve resumo das mudanças de 2.1.5 para 3.0.0

• Suporte ao módulo VMODs [3].
• Suporte a Compressão e descompressão, incluindo compressão de fragmentos ESI.
• Suporte a carregamento preliminar de streaming, tanto em cache ou não.
• Melhor documentação.
• Melhor valores padrão para parâmetros.
• varnishncsa agora com suporte de log com formatos personalizado.
• varnishlog, varnishncsa  e varnishhist agora com suporte a filtros de registros que correspondem múltiplas expressões.
  
  

Alterações na VCL.

• log foi movido para o vmod std.[4]

log "Olá mundo";

import std;
std.log "Olá mundo";

• purge agora torna-se o chamadas ban, ou como dito na VCL, são funções ban.

purge(“req.url = ” req.url);

ban(“req.url = ” + req.url);

 sub vcl_hit {
   if (req.request == “PURGE”) {
      set obj.ttl = 0s; error 200 “Purged.”;
   }
}

sub vcl_hit {
   if (req.request == “PURGE”) {
      purge; error 200 “Purged.”;
   }
}

• beresp.cacheable está fora.

beresp.cacheable está fora do Varnish 3, mas pode ser substituído por beresp.ttl> 0s

• returns agora é feito com a função return()

pass, pipe, lookup, deliver, fetch, hash, pipe e restart não são mais palavras-chave, mas argumentos para a função return(), então:

sub vcl_pass {
   pass;
}

torna-se

sub vcl_pass {
   return(pass);
}

• req.hash foi substituído por hash_data()

set req.hash += req.url;

hash_data(req.url);

• esi substituído por beresp.do_esi

esi;

set beresp.do_esi = true;

pass em vcl_fetch foi renomeado para hit_for_pass

A diferença no comportamento do pass em vcl_recv e vcl_fetch confundem as pessoas, apenas para torna mais claro as coisas, eles são diferentes :) e agora devemos usar return(hit_for_pass) onde usava-se pass no vcl_fetch.

• NOTA.

O Varnish 3 também teve uma mudança de comportamento, isso significa que ele irá retornar um erro quando cabeçalhos forem muito grandes ao em vez de apenas ignorá-los. E se os limites são muito baixos, retornará HTTP 413, então deve-se  alterar limits por http_req_hdr_len e http_req_size. Essas alterações devem ser feitas em tempo de execução, o que significa adicionar como parâmetro do executável varnishd,   exemplo (-p http_req_hdr_len=4096 -p http_req_size=1024).

Para maiores informações sobre parâmetros em tempo de execução acesse a documentação[5].

Migrando.

Eis aqui nosso exemplo retirado do svn do Varnish, porém convertido para a versão 3.0, retirei quais quer comentários da VCL e efetuei a migração, acredito que depois da explicação dos parâmetros acima você seja capaz de migrar a sua configuração.

backend default {
	.host = "127.0.0.1";
	.port = "9673";
}

acl purge {
	"localhost";
	"192.0.2.0"/24;
}

sub vcl_recv {
        if (req.http.host ~ "(www.)?example.com") {
                set req.http.host = "example.com";
		set req.url = regsub(req.url, "^", "/VirtualHostBase/http/example.com:80/example.com/VirtualHostRoot");
        } elsif (req.http.host ~ "(www.)?example.org") {
                set req.http.host = "example.org";
		set req.url = regsub(req.url, "^", "/VirtualHostBase/http/example.org:80/example.org/VirtualHostRoot");
        } else {
                error 404 "Unknown virtual host.";
        }

        if (req.request != "GET" && req.request != "HEAD") {
                if (req.request == "POST") {
                        return(pass);
                }
                
                if (req.request == "PURGE") {
                        if (!client.ip ~ purge) {
                                error 405 "Not allowed.";
                        }
                        return(lookup);
                }
        }
        if (req.http.Cookie && req.http.Cookie ~ "__ac(|_(name|password|persistent))=") {
		if (req.url ~ "\.(js|css)") {
                        remove req.http.cookie;
                        return(lookup);
                }
                return(pass);
        }
}

sub vcl_hit {
        if (req.request == "PURGE") {
                purge;
                error 200 "Purged";
        }
}

sub vcl_miss {
        if (req.request == "PURGE") {
                error 404 "Not in cache";
        }
}

sub vcl_fetch {
        if (beresp.ttl < 3600s) {
                set beresp.ttl = 3600s;
        }
} 

Indicação de leitura.

Diazo é uma nova forma de implementar layouts que o Plone está usando e que tem tudo para se tornar a maneira oficial para se desenvolver temas daqui para frente. Basicamente, ele permite que você aplique um tema de uma página com CSS e HTML estático e transformar em um site dinâmico com o mínimo de constrangimento. 

Existem várias vantagens nesta abordagem, entre elas:

• Abrir a porta para que mais e novos designers possam trabalhar com o Plone.
• Você pode usar um wireframe HTML criado por um webdesigner que nem conhece o Plone
• Seu tema passa pode ser facilmente reaproveitado em outros CMS e vice versa.
• É possível redesenhar uma interface do usuário sem sequer ter acesso ao código fonte da aplicação
• Você pode implementar temas em um tempo muito mais reduzido.
• O tema original permanece intocado facilitando a reutilização e manutenção.
• Há ainda um ganho de performance pois recursos estáticos como imagens, css e javascripts são fornecidos sem passar pelo Plone

Meu primeiro tema

A maneira mais rápida de usar o Diazo é instalar o produto plone.app.theming, com ele você ganha uma nova opção nas configurações do site e então tudo o que precisará fazer é subir um arquivo zipado contendo o seu tema.  Vamos criar um tema bem simples para um fácil e rápido entendimento inicial:

Crie um diretório /meutema e coloque nele o arquivo tema.html:

<html>
    <head>
        <title>Meu Diazo Feliz</title>
        <link rel="stylesheet" href="estilos.css" />
    </head>
    <body>
        <h1 id="title">Meu tema para Diazo</h1>
        <div id="content">
            Lorem ipsum
        </div>
    </body>
</html>

Coloque também nesta pasta o arquivo estilos.css:

body {
    background: #fff repeat-x;
    color: #000;
    font-family: Arial, Helvetica, sans-serif;
}

#content {width: 960px; margin: 0 auto;}

Crie então um arquivo chamado rules.xml:

<rules
    xmlns="http://namespaces.plone.org/diazo"
    xmlns:css="http://namespaces.plone.org/diazo/css"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

   <theme href="tema.html" />

   <replace css:theme="#content" css:content="#portal-column-content" />
   <drop css:content="#plone-document-byline" />

</rules>

Por fim crie um arquivo zip desta pasta e suba pelo painel de configurações do Diazo em @@theming-controlpanel

Seu mini-tema deve então estar disponível em seu site.

As regras do jogo

É no arquivo rule.xml que a mágica acontece. Este arquivo contêm as regras que unem o Plone e o tema, substituindo com o espaço do html estático com o conteúdo de verdade. Vamos entender nosso exemplo simples:

<rules>  Aqui são definidos três namespaces que fazem o Diazo funcionar. Graças a eles o Diazo permite o uso de seletores completos de CSS3 e XPath, incluindo coisas como o pseudo seletor nth-child.

<theme> Dá a referencia para o arquivo de html estático que será usado no tema.

<drop> Usado para apagar elementos do tema ou do conteúdo. No nosso exemplo estamos eliminando a tag plone-document-byline e tudo o que há dentro dela.

<replace> Uma das mais usadas na implementação de um tema. Isso porque, como o nome já diz, ela substitui um conteúdo estático por um conteúdo dinâmico que você indicar. No nosso exemplo o Diazo colocará todo o #portal-column-content do Plone dentro da tag #content definida em nosso tema estático.


Existem ainda outras tags que podem ser usadas como <before>, <after>, <strip>. <copy>, <notheme> e <merge>. Para  um conhecimento mais aprofundado consulte a documentação do Diazo ou aguarde futuros posts aqui no nosso blog.

Perigos do Diazo

É necessário destacar que o Diazo facilitará bastante o desenvolvimento de temas no futuro, mas ele também abre a possibilidade de estragarmos o Plone no processo (Como fizemos neste tutorial). O Plone possui uma história de preocupação com a experiência de uso e possui uma interface poderosa que agora pode ser destruída com poucas linhas. Entre outras coisas o uso indiscriminado do Diazo pode significar:

• Perda das validações de código
• Perda de usabilidade
• Perda de portabilidade
• Perda de acessibilidade
• Perda na otimização para buscas
• Possível incompatibilidade com alguns produtos

Sendo assim é necessário mais do que nunca implementar um tema preocupando-se em manter estas e muitas outras vantagens nativas do Plone. Isso significa atenção aos detalhes, auto-crítica e constante acompanhamento do código gerado pelo Plone. Pode ser uma tarefa trabalhosa, mas o resultado é compensador.

Num post anterior escrito pelo amigo simplificador @Tamosauskas (Plone mais rápido com Chameleon), foi mencionado a preocupação e empenho que a comunidade Plone tem tido quando o assunto é desempenho. Pois bem, neste post pretendo reforçar este aspecto, lembrando que essa é umas das preocupações da comunidade, tenho também como maior delas a segurança é claro.

Como dito no post do @Tamosauskas, a cada nova versão do Plone percebemos um ganho de desempenho, desde a versão 2.5 até a mais atual em desenvolvimento 4.1rc3 (Atual até a data que estou escrevendo este post), e claro, ganho de novas funcionalidades mudanças significativas para  criação de novos produtos e tipos e a mudança da skin padrão.

O que exatamente é o tal do Chameleon?

Usando Chameleon no seu buildout.

eggs =
   ...
   five.pt>=2.1
zcml =
   ...
   five.pt

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      xmlns:i18n="http://xml.zope.org/namespaces/i18n"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="plone">
 <body>
  <metal:main fill-slot="main" tal:define="name string:world">
   Hello ${name}!
  </metal:main>
 </body>
</html>

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      xmlns:i18n="http://xml.zope.org/namespaces/i18n"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="plone">

 <body>
  <metal:main fill-slot="main">
   <div tal:replace="python:'here==context:'+str(here==context)" />
   <div tal:replace="python:'here==container:'+str(here==container)" />
   <div tal:replace="string:root:${root/getPhysicalPath}" />
   <div tal:replace="string:nothing:${nothing}" />
   <div tal:define="cgi python:modules['cgi']"
        tal:replace="python: dir(cgi)" />
  </metal:main>
 </body>
</html>

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en"
      xmlns:tal="http://xml.zope.org/namespaces/tal"
      xmlns:metal="http://xml.zope.org/namespaces/metal"
      xmlns:i18n="http://xml.zope.org/namespaces/i18n"
      lang="en"
      metal:use-macro="context/main_template/macros/master"
      i18n:domain="plone">

 <body>
  <metal:main fill-slot="main">
    <table border="1">
      <tr tal:repeat="row python:['apple', 'banana', 'pineapple']">
        <td tal:repeat="col python:['juice', 'muffin', 'pie']">
           ${row/capitalize} ${col}
        </td>
      </tr>
    </table>
  </metal:main>
 </body>
</html>