Blog

Search Engine Optimization (SEO) e o Plone

andre — 2012-01-31T19:11:19Z

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:

SEO e o Plone

View more presentations from Simples Consultoria

As Melhores Intranets de 2012

andre — 2012-01-20T17:00:59Z

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.

Varnish 3, Plone 4: Discutindo a Relação.

cleber — 2012-01-10T10:00:32Z

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].

View more presentations from Simples Consultoria

Plone e JQuery ao gosto do Cliente

thiago — 2011-10-13T12:40:33Z

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.

View more presentations from Simples Consultoria

Cmsui: Uma nova maneira de editar conteúdo no Plone

andre — 2011-10-03T13:39:09Z

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.

Cmsui: Uma nova maneira de editar conteúdo no Plone

View more presentations from Simples Consultoria

Plone é finalista do Open Source Awards 2011 - Deixe seu voto!

thiago — 2011-09-26T14:58:24Z

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:

Clique aqui e vote no Plone na categoria CMS.
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.

Regras do Diazo: questão de ordem

thiago — 2011-09-26T13:55:55Z

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.

Google Analytics e a busca dentro do seu Plone Site

andre — 2011-09-01T14:24:36Z

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:

Faça Login no Google Analytics;
Clique em 'edit' ao lado do perfil do site que deseja configurar;
Na página seguinte, clique no link 'edit' que fica na caixa 'Main Website Profile Information';
Na área 'Site Search' marque a opção 'Do Track Site Search';
No campo 'Query Parameter' informe o valor 'SearchableText';
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: O lego do Varnish 3

cleber — 2011-08-30T15:16:53Z

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.

Nota: Uma informação importante, você ainda pode dizer ao Varnish em tempo de execução para qual diretório ele deve olhar para buscar os VMODs.

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

Na prática.

Agora que já temos base do que é um VMOD e como ele funciona, vamos aos exemplos :) , estou usando alguns que encontrei na internet então vamos lá:

1º Exemplo.

Módulo: https://github.com/varnish/libvmod-example

Autor: Martin Blix Grydeland

Descrição: O módulo implementa o "Olá Mundo!", sendo bem pequeno e simples para entender.

Nota: Após instalar o módulo (como instalar em README) basta executar o seguinte trecho de código em sua VCL.

import example;

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

2º Exemplo

Módulo: https://github.com/leed25d/geoip-vmod
Autor: David Newhall
Descrição: Provê a capacidade de retornar a localização geográfica de um endereço IP.
Nota: Após instalar o módulo (como instalar em README) basta executar o seguinte trecho de código em sua VCL.

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)
}

3º Exemplo

Módulo: https://github.com/varnish/libvmod-curl
Autor: Tollef Fog Heen
Descrião: Este vmod é um dos que mais gosto, ele provê o curls para o Varnish, então podemos usar o varnish como um cliente HTTP e buscar cabeçalhos e corpo nos backends.
Nota: Após instalar o módulo (como instalar em README) basta executar o seguinte trecho de código em sua VCL.

import curl;

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

Estes são alguns dos exemplos que podemos seguir para criar nosso próprio VMOD, nota-se que precisamos saber C para isso, algumas idéias de módulos seria usar C + libxml para fazer parse de arquivos XMLs diretamente no Varnish e já manter em cache, ainda com analise de cabeçalho e etc.. Ou Usar o PIL para gerar imagens ou qualquer outra coisa que sua imaginação desejar, você agora tem o poder do C e do Varnish nas suas mãos.

Um pouco mais antes de terminar.

Agora que já estamos mais acostumados e empolgados em poder criar VMODs para trabalhar com o Vanrish, veja alguns exemplos do que podemos fazer com o que já existe.

Nota. Lembre-se que é necessário importar o módulo std ou qualquer outro que iremos utilizar, uma única vez e usar em toda a VCL.

Adicionando o std.collect(), coletamos vários cabeçalhos HTTP para um único cabeçalho.

import std;

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

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

Retornando uma URL em caixa alta ou uma string.

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

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

Retorna o contrário do toupper, ou seja, strings todas em caixa baixa.

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:

Como adicionar Eventos do Plone no Google Calendar

thiago — 2011-08-19T14:35:05Z

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

Migrando Varnish 2.1 para Varnish 3.0

cleber — 2011-08-15T02:11:32Z

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.

Para uma lista mais detalhada de alterações leia o documento de alterações.

Alterações na VCL.

log foi movido para o vmod std.[4]

log "Olá mundo";

torna-se

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

Nota. A importação do std só é preciso ser feito uma única vez e usada por toda a VCL.

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

purge() e purge_url() são agora, respectivamente ban() e ban_url(), sendo assim deve-se substituir todas as ocorrências:

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

para

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

purge continua existindo porém não leva nenhum argumento mais, e ainda pode ser usado em vcl_hit ou vcl_miss para fazer purge de itens do cache, onde você iria reduzir o ttl a 0 no Varnish 2.1.

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

torna-se

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()

Não apendamos mais o hash com +=

set req.hash += req.url;

Agora torna-se

hash_data(req.url);

esi substituído por beresp.do_esi

Não habilitamos ESI com esi.

esi;

no vcl_fetch tonar-se

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.

Como criar um tema para Plone usando o Diazo

thiago — 2011-07-26T20:20:10Z

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.

Plone 4, velocidade e Chameleon tudo em comum.

cleber — 2011-08-14T02:35:18Z

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?

No site oficial a melhor definição é "Chameleon is an open-source template engine written in Python.

", de fato, trata-se de um modelo de templates escrito em Python, ele foi escrito para gerar documentos de marcação HTML ou XML para aplicações Web.

Ele usa a linguagem do Page Template, só que sua implementação é bem mais rápida e independente, no qual trás um conjunto de novos recursos e podemos usar em qualquer aplicação escrita em Python (2.5 e superior, incluindo 3.x e PyPy), algumas de suas características são:

Rápido - Os templates são compilados para byte-code.
Extensível - É fácil de estender uma linguagem ou criar sua própria.
Testado - Testes automatizados que protege contra regressões.

Para o Python 2.7 e superior não existem dependências de bibliotecas, já nas versões 2.5 e 2.6 a ordereddict e unittest2 são pacotes definidos como dependências, mas para se ter uma idéia de como Chameleon é independente, seu sistema de tradução é plugável e baseado em gettext.

Não há um suporte embutido para o pacote zope.i18n. Mas se o pacote for instalado, ele será usado por padrão. O pacote translationstring[3] oferece algumas das mesmas classes de utilidades auxiliares, sem a interface do Zope.

Usando Chameleon no seu buildout.

Adicione as linhas em seu buildout:

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

Estes testes foram efetuados nas versões 4.0.7 e 4.1rc3 do Plone, para um teste simples crie um Page template e coloque o seguinte conteúdo:

<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>

Note que não precisei colocar tal:content para imprimir o texto da variável name, abaixo mais 2 exemplos:

<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>

Para realizar outros testes e aproveitar bem o Chameleon, leia a documentação[1] e sugiro a leitura dos códigos dos produtos Chameleon e five.pt.

[1] http://pagetemplates.org/docs/latest

Buildout, para o que der e vier Parte 2

cleber — 2011-06-28T20:14:46Z

Em um post anterior mostrei que podemos utilizar o buildout para instalar praticamente qualquer aplicação que desejarmos, seja ela compilada ou não.

Como no caso do WordPress, no qual se trata apenas de um pacote compactado e que exige a alteração de seus arquivos de configuração, e também a compilação do aplicativo spawn-fcgi, vale lembrar que caso desejado poderia até compilar o próprio PHP.

Neste post pretendo dar continuidade na instalação do ambiente, mostrando como compilamos o servidor Nginx para servir as páginas em PHP, ou em nosso caso, servir o WP, também iremos instalar o Supervisord (Sistema cliente/servidor que permite monitorar e controlar número de processos em sistemas operacionais UNIX-like.)

O buildout.

[buildout]
parts =
    ...
    supervisor
    nginx-build
    nginxctl
    default-server-config

...


[nginx-build]
recipe = zc.recipe.cmmi
url = http://nginx.org/download/nginx-1.0.4.tar.gz
extra_options =
    --with-http_gzip_static_module
    --with-http_stub_status_module
    --with-http_dav_module
    --with-http_ssl_module
    --with-http_flv_module
    --http-client-body-temp-path=${buildout:directory}/tmp
    --http-proxy-temp-path=${buildout:directory}/tmp/proxy
    --http-fastcgi-temp-path=${buildout:directory}/tmp/fastcgi
    --with-md5-asm --with-md5=/usr/include
    --with-sha1-asm
    --with-sha1=/usr/include
    --with-http_realip_module

[nginxctl]
recipe = gocept.nginx
nginx = nginx
configuration =
    daemon off;
    worker_processes 1;

    events {
        worker_connections  1024;
    }

    http {
        include            ${nginx:location}/conf/mime.types;
        default_type       application/octet-stream;
        sendfile           on;
        keepalive_timeout  65;

        include ${buildout:directory}/etc/nginx.conf;
    }


[default-server-config]
recipe = collective.recipe.template
input = ${buildout:directory}/etc/nginx.conf.in
output = ${buildout:directory}/etc/nginx.conf


[supervisor]
recipe = collective.recipe.supervisor
logfile = ${buildout:directory}/var/log/supervisord.log
logfile-backups = 10
loglevel = info
pidfile = ${buildout:directory}/var/supervisord.pid
plugins = superlance
user = admin
password = secret
port = 9001
programs =
	10 fcgi  ${buildout:directory}/parts/fcgi/bin/spawn-fcgi [ -a 127.0.0.1 -p 53217 -P ${buildout:directory}/tmp/fastcgi-php.pid -- /usr/bin/php-cgi] true
	20 nginx ${buildout:directory}/parts/nginxctl/sbin/nginx [ -c ${buildout:directory}/parts/nginxctl/nginxctl.conf] true

Pois bem, adicionamos mais 4 seções, e antes mesmo de continuar, vamos aos detalhes. No post anterior criamos uma pasta com o nome de tmp, agora note que na seção [nginx-build], indicamos alguns diretórios a serem usados pelo Nginx, que são: proxy e fastcgi.

Então crie estes dois diretórios e vamos seguir em frente, também teremos que criar dentro do diretório etc um arquivo com o nome nginx.conf, este contém as configurações para rodar-mos o WP, abaixo o conteúdo deste arquivo.

server {
    listen 80;
    server_name *.meusite.com;
    rewrite ^ http://www.meusite.com$request_uri permanent;
}

server {
        location / {
                root /home/cleber/buildout/wordpress;
                index  index.php index.html index.htm;
                fastcgi_index   index.php;

                # this sends all non-existing file or directory requests to index.php
                if (!-e $request_filename) {
                        rewrite ^(.+)$ /index.php?q=$1 last;
                }

                autoindex on;
        }

        location = /favicon.ico {
                empty_gif;
                log_not_found off;
                access_log off;
        }

        # Deny all attempts to access hidden files such as .htaccess, .htpasswd, .DS_Store (Mac).
        location ~ /\. {
                deny all;
                access_log off;
                log_not_found off;
        }

        try_files $uri $uri/ /index.php;

        location ~ \.php$ {
            include        /home/cleber/buildout/parts/nginx-build/conf/fastcgi_params.default;
            fastcgi_pass   127.0.0.1:53217;
            fastcgi_param  SCRIPT_FILENAME  /home/cleber/buildout/wordpress/$fastcgi_script_name;
        }
}

Pronto, rode o buildout, e depois você já poderá desfrutar de sua aplicação, o supervisor irá criar um um script no diretório bin da instância, agora você pode startar as aplicações usando o comando:

./bin/supervisord

Nota. Vale lembrar que a porta 80 só pode ser aberta pelo root ou por um usuário com poder igual, neste caso estamos falando que o comando acima deverá ser rodado por um usuário com poderes de sudo ou root.

Até a próxima!

Buildout, para o que der e vier

cleber — 2011-06-28T20:02:14Z

Começo dizendo que durante algum tempo fui assombrado pelo buildout, desde a minha entrada na Simples até alguns meses depois, eu tremia sempre que eu tinha de rodar um, a primeira coisa que vinha na cabeça era: "Pronto, agora o ambiente vai ser destruído :(".

Trabalhar com alho no pescoço, pé de coelho e até mesmo trevo de 4 folhas não estava em meu escopo de trabalho, e não é muito meu tipo, pois bem, depois de algumas brigas decidi me tornar o melhor amigo do buildout, após alguns copos de café, e saindo juntos, decidimos fazer as pazes.

Hoje posso garantir, que em qualquer situação onde preciso instalar alguma aplicação que vá ou não rodar com o Plone, penso no meu amigo buildout.

Duas pessoas que me tiraram esse medo e me deram coragem foi o amigo e inesquecível Dorneles, e também o amigo Érico.

E agora a novidade é que não vou falar de como instalar Plone usando buildout, isso tudo para poder mostrar todo o poder do buildout, caso não saiba ainda do que estou falando acesso em http://www.buildout.org/docs/tutorial.html.

Buildout

É simples de usar e de manter se você fizer configurações simples e legíveis.
Trabalha com eggs.
Evita conflitos com os pacotes instalados no site_packages.
Evita a instalação diretamente no Python do sistema.
Instala dependências a partir das definições dos eggs.
Podemos instalar por exemplo:

Bancos de dados: PostgreSql, Mysql, Oracle e etc...
Serviço de autenticação como o LDAP.
Aplicações como: Versões diferentes de Python, Varnish,Squid, Supervisor e etc..
Frameworks: Django, Web2Py, Zope
CMS: Plone, WordPress e etc..
Servidores web: Apache, Nginx e etc...
E etc...

Vamos manter as coisas simples, então crie um diretório chamado mybuildout, dentro deste diretório crie a seguinte estrutura de pastas:

mybuildout

|- tmp

|- etc

|- src

Essa não é uma estrutura requerida pelo buildout, mas gosto de montar assim, garantindo que qualquer arquivo temporário vá ficar em tmp por exemplo, arquivos de configurações em etc e aplicações em desenvolvimento em src, dois arquivos são requeridos, são eles: bootstrap.py e buildout.cfg.

Podemos não usar o buildout.cfg e montar o ambiente com outros aquivos, mas isso não vem ao caso, vamos a um exemplo do não uso do Plone, e para não dizerem que não gosto de PHP, iremos instalar o WordPress, então vamos lá.

NOTA. A instalação a seguir foi feita no sistema operacioal Linux (Ubuntu) sendo assim, não garanto que funcione no Windows, mas sim, temos como fazer funcionar da mesma forma no Windows e outros sistemas operacionais.

Também estou partindo do ponto que já temos php instalado no sistema, não quero ter que ficar compilando no buildut o PHP, ainda que dê claro ;)

Comento o buildout logo abaixo.

Instalando o WordPress usando Python, ironia?

[buildout]
parts =
    fcgi
    wp

[wpconf]
wpversion = latest.tar.gz
mydb_name = wp 
mydb_user = wp
mydb_pass = wpnginx
mydb_charset = utf8
mydb_host = localhost

[downloads]
wp_url = http://wordpress.org/${wpconf:wpversion} 
fcgi_url = http://www.lighttpd.net/download/spawn-fcgi-1.6.3.tar.gz

[ports]
fastcgi = 53217

[fcgi]
recipe = zc.recipe.cmmi
url = ${downloads:fcgi_url}
configure-options = 
    --prefix=${buildout:directory}/parts/fcgi

[wp]
recipe = plone.recipe.command
command =
    chmod 600 .installed.cfg
    if [ ! -f ${buildout:directory}/${wpconf:wpversion} ]; then wget ${downloads:wp_url}; fi
    tar xzf ${wpconf:wpversion} 
    cp ${buildout:directory}/wordpress/wp-config-sample.php ${buildout:directory}/wordpress/wp-config.php
    ln -dfs ${buildout:directory}/wordpress ${buildout:directory}/var/www/wordpress
    sed -i "s/define('DB_NAME', 'database_name_here')/define('DB_NAME', '${wpconf:mydb_name}')/" ${buildout:directory}/wordpress/wp-config.php
    sed -i "s/define('DB_USER', 'username_here')/define('DB_USER', '${wpconf:mydb_user}')/" ${buildout:directory}/wordpress/wp-config.php
    sed -i "s/define('DB_PASSWORD', 'password_here')/define('DB_PASSWORD', '${wpconf:mydb_pass}')/" ${buildout:directory}/wordpress/wp-config.php
    sed -i "s/define('DB_HOST', 'localhost')/define('DB_HOST', '${wpconf:mydb_host}')/" ${buildout:directory}/wordpress/wp-config.php
    sed -i "s/define('DB_CHARSET', 'utf8')/define('DB_CHARSET', '${wpconf:mydb_charset}')/" ${buildout:directory}/wordpress/wp-config.php
    chmod +x ${buildout:directory}/bin/spawn-fcgi
update-command = ${wp:command

Criei duas seções que servirá para instalar o WordPress e um script de inicialização do php-cgi, este script também vem quando instalamos o servidor lighttpd, que é uma forma de manter o php vivo enquanto podemos dar um restart ou reload no servidor lighttpd, mas isso não vem ao caso.

Também criamos 3 outras seções que são:

wpconf - > Colocamos aqui as configurações do nosso WP, como dados da base de dados [usuário, senha etc ] e a versão que desejamos instalar do WP.
downloads -> Urls das aplicações, WP e fcgi.
ports -> Configuração da porta no qual o fcgi irá rodar

Note que na seção [wp], usei alguns comandos para fazer a mágica acontecer, quero baixar e descompactar o tar.gz, lembrando que em casos de arquivos zip, será necessário alterar a linha. Após descompactar copiamos o arquivo wp-config-sample.php para wp-config.php, este será o que o Wp irá ler.

E por fim, setamos os dados de acesso ao bando de dados neste arquivo de configuração.

Rode o bootstrap e o buildout: python bootstrap.py && ./bin/buildout -Nvvv -t 30

Ao final teremos o o Wp instalado e pronto pra usar, é claro que faltam detalhes como instalar o servidor Apache ou Nginx, ou um de sua preferência.

Para subir o fcgi você pode executar:

./parts/fcgi/bin/spawn-fcgi -a 127.0.0.1 -p 53217 -P ./tmp/fastcgi-php.pid -- /usr/bin/php-cgi

A configuração acima, usei com o servidor Nginx, também compilado com buildout, por este motivo adicionei o fcgi, abaixo sugestões de eggs que ajudam nas instalações.

Sugestões.

zc.recipe.cmmi: Usado para executar comando configure/make/make install
plone.recipe.command: Executa comandos arbitrários para o buildout.
collective.recipe.supervisor: Receita para instalar o supervisor
z3c.recipe.usercrontab: Adicionar comandos ao Crontab do Linux
collective.recipe.template: Receita para a criação de templates de configurações
Mais :)