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>

[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

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

./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!

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

|- tmp

|- etc

|- src

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.

Cada vez mais tem crescido o número de redes sociais, e claro não tem melhor maneira de divulgar e compartilhar posts do seu Blog e notícias do seu WebSite ou portal se não através dessas redes. Você já deve ter visto em outros sites, botões para compartilhar posts nas principais redes sociais, como Twitter e Facebook.

Existem diversos produtos que proporciona funcionalidades de compartilhamento para essas redes, e dentre estes vou falar de dois que são:

• sc.social.like
• sc.social.bookmarks
  
  

Ambos os produtos nos proporcionam recursos de compartilhamento de conteúdos do nosso site Plone, porém cada qual tem sua caracteristica, o sc.social.like é um produto mais simples que após instalado irá provê os botões para compartilhamento do Twitter e Facebook, estes botões ficam localizados logo abaixo do título do conteúdo em questão.

Tendo uma interface de configuração no qual pode-se alternar entre os botões recomendar e Curtir do Facebook, e as disposições vertical ou horizontal de ambos os botões, assim como configurações para quais tipos de conteúdos serão exibidos.

Enquanto o sc.social.bookmarks mostra-se como um produto mais completo, provendo um número maior de redes sociais para compartilhamento como Delicious, Digg, Reddit e Twitter e etc... Sendo 62 serviços já inclusos, ao contrário do sc.social.like, ele se dispõe no roda pé do conteúdo.Também é configurável, no qual  pode-se escolher em para quais tipos de conteúdos será exibido.

Qual devo usar?

Como dito, cada qual tem suas caracteristicas, ainda que pareçam servir para o mesmo propósito, temos aqui um produto mais simples e outro mais completo, cabe a você escolher qual usar, o bookmarks não tem por exemplo um contador como no caso dos botões do like, neste caso para sites que desejam mostrar e também saber quantas vezes foram compartilhados determinado conteúdo de seu site, é mais recomendado o uso do like.

Agora para sites que apenas querem disponibilizar aos seus usuários um maior número de redes para que possam compartilhar, fica a recomendação o uso do bookmarks, ou ainda pode-se utilizar ambos, e aproveitar o que cada qual dispõe. Seja qual for a sua escolha, estes são produtos que acredito serem essenciais em um site.

Nos últimos meses dificilmente vemos um novo site que não tenha os botões para compartilhar o conteúdo da página com seus amigos e seguidores no Facebook e Twitter. Foi por isso que resolvemos "gastar" algumas horas na criação de um produto Plone para adicionar esses dois recursos nas páginas dos sites.

O Social Like, como foi informalmente batizado por nossa equipe, basicamente adiciona as páginas do Plone, logo abaixo do título, os botões de compartilhar do Twitter e Facebook. Alem dos botões ele mostra o número de vezes que a página foi twitada ou compartilhada.

O produto, obra do @cleberjsantos, também possui uma tela de configuração que permite alterar alguns parâmetros dos botões, como a posição dos números e os tipos de conteúdo que devem exibir os botões por exemplo.

Veja como utilizar o produto no site do Plone:
http://plone.org/products/sc.social.like

A todos que perguntaram, eis a resposta: sim, vamos realizar um evento para o World Plone Day em São Paulo este ano. O World Plone Day, ou WPD, é um evento realizado simultaneamente em todo o mundo pela comunidade Plone e tem por objetivo falar do Plone e divulgar os seus benefícios.

 Este ano vamos realizar um evento pequeno e bastante restrito, com foco na troca de informação e não apenas com palestras. Ele será realizado no Pto de Contato, um belíssimo espaço de cooworking próximo a avenida Paulista.

Confira alguns detalhes:

Data: 27 de abril de 2011, das 9h as 13h
Local: Pto de Contato - Jardins Rua Augusta, 2690 | 3° andar | São Paulo - Brazil

A programação provisória é a seguinte:

• Novidades sobre o Plone 4.0 e 4.1
  Todos as novidades do Plone 4 e do Plone 4.1, que será lançado nos próximos dias
  
• Acessibilidade e o Plone
  O que é acessibilidade e o que o Plone faz a respeito disso. Dicas de como produzir conteúdo no Plone mantendo a acessibilidade.
• SEO e o Plone
  Entenda melhor o que é SEO, conheça tudo que o Plone já faz a respeito e aprenda dicas úteis na hora de escrever seus textos e organizar seu conteúdo.
• Mesa Redonda: Edição da Página Inicial
  Discussão sobre as melhores práticas para editar e construir a página inicial de um portal. Com a ajuda de todos vamos esboçar uma ferramenta mais adequada para a edição de Homes no Plone.
  

A programação  final, com horários e nome dos palestrantes será divulgada nos próximos dias com o lançamento do site oficial do evento.

 As inscrições são gratuitas e limitadas e já podem ser feitas provisoriamente pelo formulário de contato do site. Qualquer dúvida é só entrar em contato comigo, por email ( andre at simples..... ) ou pelo twitter @agnogueira.

Quanto custa o Plone?

Plone é um Software Open Source distribuída via GNU - General Public Licence (GPL) e é gratuito para fazer download, usar, personalizar e compartilhar. Sem custos de licença, os usuários do Plone usam seus recursos na personalização do sofware para suas necessidades específicas, criação de conteúdo, identidade visual e manutenção. Mesmo após o abatimento dos custos com uma consultoria, os custos totais da implementação de uma solução Plone será em geral significativamente menor do que uma solução proprietária como Sharepoint ou Vignette, que carregam os custos de licenciamento. Para organizações que não possuem uma equipe de desenvolvedores Plone, a assistência profissional e o suporte comercial estão disponíveis em mais de 300 consultorias ao redor do mundo. No Brasil a Simples Consultoria se propõe a cumprir este papel.

Como eu posso editar/criar conteúdo usando Plone?

Usuários podem editar e criar conteúdo em seus sites Plone de qualquer computador usando apenas seus navegadores. Basta entrarem com seus usuários no site para editar as páginas existentes, criar novas seções, remover conteúdo antigo, ou fazer upload de novos vídeos e fazer isso usando apenas um editor similar ao Microsoft Word.

Que bancos de dados o Plone integra?

O Plone vem com um banco de dados orientado a objeto confiável, seguro, fácil de administrar, conhecido como ZODB (Zope Object Database). Além dele, o Plone pode se comunicar facilmente com Active Directory, LDAP, Salesforce.com, bancos de dado SQL entre outros. Um produto gratuito do Plone chamado RelStorage também permite usar Oracle, MySQL e POstgreSQL para armazenar dados integrando seu site Plone com sua infraestrutura existente de modo a poder utilizar ferramentas familiares, clustering e failover.

O Plone é amigável com os mecanismos de buscas?

Enfaticamente sim. O Plone automaticamente encoraja utilização das melhores práticas de otimização para mecanismos de buscas, como URLs ricas em palavras chaves, descrições amigáveis e sitemaps adequados. Muitos sites mudam para o Plone imediatamente percebem um salto no rankeamento dos mecanismos de busca, e na qualidade e relevância dos resultados.  Como exemplo plone.org é um dos poucos websites no mundo que possuem Rangerank 9 de 10 segundo a classificação do Google, a mesma nota de sites significativos como IBM e Microsoft.

O Plone possui suporte multi-liguagem?

O Plone está traduzido em mais de 40 idiomas. Seu conteúdo pode ser gerenciado em mas de um idioma usando LinguaPlone, um produto gratuito. LinguaPlone provê aos criadores de conteúdo uma conveniente interface para adicionar conteúdos em diversos idiomas sem a necessidade de duplicar a estrutura do site.

O Plone possui suporte a visitantes com deficiência?

Plone cumpre e excede os padrões de acessibilidade estabelecidos pela W3C na WAI-AA e pelo Governo dos Estados Unidos no padrão 508. Organizações com obrigações legais quanto a acessibilidade frequentemente escolhem o Plone justamente por esta razão.

O Plone possui suporte a versionamento?

O Plone possui a característica de permitir aos usuários mapear mudanças e sucessivas versões de um documento escrito. Plone provê um histórico detalhado do documento que permite usuários comparar versões e reverter o conteúdo para uma versão anterior.

Quão escalável é o Plone?

O Plone é apropriado para sites pequenos e para os muito grandes. O Plone possui um poderoso sistema de cacheamento que permite configurar o site para otimizar ainda mais sua performance. Além disso os administradores de sites em Plone frequentemente usam aceleradores web como Squid e Varnish para incrementar a velocidade do site. Graças ao uso do Zope, Plone possui nativamente capacidades para clustering que permite ao website dividir a carga entre múltiplos servidores para gerenciar tráfegos intensos.

Quão seguro é o Plone?

O Plone oferece segurança superior sem sacrificar seu poder e extensibilidade. Como um produto OpenSource, um grande número de desenvolvedores continuamente revê seu código para melhorar seus aspectos de segurança. Esta abordagem pró-ativa é muito melhor do que a estratégia de esperar para ver o que acontece usada por soluções proprietárias que optam por manter os assuntos de segurança em segredo ao invés de resolvê-los prontamente.

Feito em Python e Zope, duas plataformas altamente seguras, o Plone possui tecnologia de ponta que permite obter os melhores níveis de segurança de todos os grandes CMS (Fonte:CVE). Por ser orientado a objetos, Plone não é vulnerável a ataques de SQL injection, que é um dos problemas de segurança mais comuns que afetam sistemas baseados em PHP/MySQL. O Sitema de ACL do Plone para permissionamento de usuários também garante que usuários apenas verão o conteúdo que deveriam ver. De fato, segurança é uma das principais razões do porque tantos usuários estarem mudando para o Plone.

Como o Plone se compara com Sharepoint, Drupal, Afresco e Joomla?

Plone é um verdadeiro CMS baseado em web com workflow (fluxo de trabalho) de publicação e recursos de gerenciamento de documentos, ao contrário de sistemas como Sharepoint ou Afresco que são primariamente  sistemas de gerenciamento de documentos com funcionalidades web limitadas.  Isso torna o Plone ideal para intranets, extranets ou websites. Plone pode ser personalizado para atender necessidades específicas de qualquer organização em termos de tamanho estrutural, tipos de conteúdo, regras de workflow, etc. Nem todo CMS oferece este mesmo nível de flexibilidade.  Por ser feito sobre o Python e o Zope , o Plone é muito seguro, razão essa que faz muitos usuários trocarem Joomla e Drupal pelo Plone.

Plone é 100% Open Source (código-aberto), pacotes lançados de versões estáveis podem ser baixadas gratuitamente. Não há necessidade de comprar licenças por servidor ou usuário para obter suporte comercial como acontece com Alfresco e Sharepoint, e a direção do futuro do projeto não está 'travada' em uma única empresa.

Este artigo é uma tradução e aprimoramento de texto em folheto distribuido pela Jazkarta e Abstract Edge, e originalmente escrito pela Netsight Solutions Ltd licenciado em Creative Commons.