1. Fontes no Fluxbox

    Fluxbox é um gerenciador de janelas para o linux extremamente leve, que eu utilizo quando preciso focar os recursos da máquina em alguma outra coisa.

    O problema principal pra mim com o Fluxbox é que as fontes são estranhamente renderizadas, fazendo com que eu acabe voltando para o  gnome ou unity depois de usá-lo por um tempo.

    Hoje encontrei uma solução aceitável para o problema, para isso, criei o arquivo \~/.Xresources com o seguinte conteúdo:

    1
    2
    3
    4
    5
    6
    7
    Xft.dpi: 96
    Xft.antialias: true
    Xft.hinting: true
    Xft.rgba: rgb
    Xft.autohint: false
    Xft.hintstyle: hintslight
    Xft.lcdfilter: lcddefault
    

    Reiniciei o lightdm e agora as fontes renderizadas no aplicativo estão muito mais próximas (senão idênticas) ao que estou acostumado em outros ambientes gráficos.

    fonte: Fixing ugly Qt fonts in Openbox, Fluxbox, etc. 


  2. ScribeFire

    Acabei de descobrir que o ScribeFire agora também tem uma extensão para o Opera, e já estou usando-a, o que facilita bastante na hora de escrever um post, já que é possível usá-la mesmo estando sem acesso a internet e a mesma tem suporte a markdown (mesmo eu não tendo conseguido usar ainda.

    Vou tentar novamente me acostumar a usar o ScribeFire, já que ás vezses usar o editor do Wordpress fica meio complicado por causa da conexão (ou falta dela)

    O único real problema para mim é a falta do “preview”, mas para usar apenas para realmente escrever, parece uma boa opção.


  3. Um gitignore para a todos governar

    Existem certos arquivos que você nunca vai querer no seu repositório, como por exemplo os arquivos .swp gerados pelo vim.

    Uma opção seria adicionar esses arquivos em arquivos.gitignore de todos os projetos, mas existe uma opção melhor, criar um gitignore global, que assim como as configurações globais do git, se aplique a todos os seus repositórios.

    Isso pode ser conseguido com um comando:

    1
    git config --global core.excludesfile ~/.gitignore
    

    Pronto, agora só é necessário adicionar as regras dos arquivos que você não quer em nenhum repositório no arquivo \~/.gitignore


  4. UserDir vs. VirtualHost

    Durante a preparação de um ambiente de teste me deparei com duas opções, ativar o módulo UserDir do apache para acessar uma pasta do meu home usando um endereço como “http://localhost/\~usuario” ou setar um VirtualHost apontando para a pasta onde estava colocando o projeto.

    Usando UserDir:

    1
    2
    3
    cd /etc/apache2/mods-enabled
    sudo ln -s ../mods-available/userdir.conf userdir.conf
    sudo ln -s ../mods-available/userdir.load userdir.load
    

    Depois disso, reinicie o apache

    1
    sudo /etc/init.d/apache2 restart
    

    Por default, o userdir.conf aponta para a pasta “public_html” mas você pode alterar isso no userdir.conf (como eu já tinha uma pasta para os projetos, foi isso que eu fiz, para não precisar alterar as coisas)

    Uma observação, se for fazer uso de arquivos .htaccess, é interessante alterar a configuração do AllowOverride, se estiver com preguiça (como eu) permitir tudo pode resolver um erro 500. (que foi o erro que encontrei quando ativei o tema roots do wordpress nesse cenário).

    1
    AllowOverride All
    

    VirtualHost

    No caso de uso de VirtualHosts, é necessário criar um arquivo com o nome que você quiser dentro de /etc/apache2/sites-available/

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    <VirtualHost *>
         ServerName projetos.local
         DocumentRoot /home/daniloshiga/projetos
    
         <Directory /home/daniloshiga/projetos>
             DirectoryIndex index.php
             AllowOverride All
             Order allow,deny
             Allow from all
         </Directory>
    </VirtualHost>
    

    Com o arquivo criado, é necessário ativá-lo no apache (o que irá gerar uma cópia dele na pasta sites-enabled):

    1
    sudo a2ensite projetos.local
    

    E adicionar uma linha ao arquivo /etc/hosts para que ao acessar o endereço do virtual host, o linux saber que pra qual IP direcionar a requisição (no caso, localhost):

    127.0.0.1 projeto.local

    E finalmente, reiniciar o apache:

    1
    sudo /etc/init.d/apache2 restart
    

    é isso, no caso do VirtualHost também é possível criar um endereço específico para cada site em desenvolvimento, mas talvez seja algo que gere muito trabalho sem muitas vantagens, por enquanto estou utilizando a solução do UserDir.

    Fontes:

    How to Create Multiple Virtual Hosts in Ubuntu

    Por

    Em infra.

    tags: apache


  5. Desenvolvimento e Implantação do Wordpress usando Git

    Nesse post vou detalhar a estrutura de desenvolvimento e implantação do wordpress usando git que estou usando para este blog, onde consigo enviar mudanças feitas no ambiente de teste para produção usando um simples “git push prod”.

    Eu irei detalhar apenas os passos que dei para criar esse ambiente, sem me aprofundar nos conceitos do git.

    Meu objetivo é usar ao máximo as funcionalidades do git para fazer a implantação do blog, para isso, vou usar um repositório do wordpress mantido no github, originalmente o código do wordpress é mantido em um repositório svn, mas felizmente exite um clone no github, que é atualizado de 30 em 30 minutos.

    Clonando o repositório do wordpress, selecionando a versão que será usada e criando um branch de desenvolvimento a partir dela:

    1
    2
    3
    git clone https://github.com/markjaquith/WordPress.git blog.daniloshiga.com
    git checkout origin/3.3-branch
    git checkout -b dev
    

    Adicionando o tema “roots” como um “submódulo falso” (ou seja, sem o uso dos “submodules”) do git.

    1
    2
    3
    cd wp-content/themes
    git clone https://github.com/retlehs/roots.git
    git add roots/
    

    Fiz desse modo para facilitar a implantação, de modo que tanto o wordpress quanto o tema fiquem no mesmo repositório, sem haver a necessidade de executar comandos para ativação e uso dos submódulos.

    quando ativado, o tema roots gera um .htacess na base da instalação do wordpress, talvez seja interessante adicionar o .htaccess no .gitignore para evitar sobrepor o arquivo que será gerado na ativação do tema em produção com o usado durante o desenvolvimento.

    É necessário criar um repositório onde será feita a implantação, o uso do comando “git init —bare” faz com que o repositório seja criado na pasta atual, e não criada uma outra pasta .git com ele.

    1
    2
    mkdir blog.git && cd blog.git
    git init --bare
    

    O ponto central da implantação será o uso de um “hook”, no caso o post-receive, que é um script que irá executar quando novos dados forem recebidos no repositório.

    o script é o blog.git/hooks/post-receive

    1
    2
    3
    4
    5
    6
    7
    8
    #!/bin/sh
    LIVE="[caminho para pasta do wordpress em produção]"
    read oldrev newrev refname
     if [ $refname = "refs/heads/dev" ]; then
     echo "===== DEPLOYING TO LIVE SITE ====="
     GIT_WORK_TREE=$LIVE git checkout -f dev
     echo "===== DONE ====="
     fi
    

    Detalhando: ele limita o envio de dados para produção para apenas quando for um push do branch “dev” dando um checkout no repositório na pasta de produção, a vantagem de executar um checkout assim é que o repositório em si não fica nessa pasta, não sendo necessário adicionar alguma regra no servidor para bloquear o acesso ao repositório.

    Feito isso, basta adicionar o repositório

    1
    2
    git remote add prod ssh://[usuario]@[host]/[caminho_repositório]/blog.git
    git push prod +dev:refs/heads/dev
    

    Para a implantação, farei uso do post-receive hook, ou seja, irei permitir que, ao executar o git push para um repositório remoto (mantido no servidor de produção) os arquivos sejam colocados na pasta pública utilizando um checkout.

    Vantagens dessa técnica:

    Facilidade na implantação de novidades, e também na reversão das mudanças caso necessário.

    A pasta .git não fica na pasta pública, não sendo necessário assim retirar o acesso a ela através do .htaccess.

    O uso do submódulo falso simplifica a implantação, evitando a necessidade de usar os comandos “git submodule init” e “git submodule update” para conseguir obter os submódulos, adicionando-os diretamente dentro do repositório faz com que um único checkout já os traga também.

    Desvantagens:

    As alterações que forem realizadas em desenvolvimento relacionadas a ativação e configuração de temas e plugins vão precisar ser reaplicadas no servidor de produção, já que cada ambiente está usando um banco separado, tornando o controle das alterações complicado nesse sentido.

    Referências:

    Parte da solução, só que usa git pull

    Solução usando checkout

    Speed Up Your WordPress Development Cycle With Git

    Git Fake Submodules


  6. #! /** Insira seu código aqui **/

    And it has started!

    Todo blog precisa de um post inaugural, e aqui estamos.

    Mas no post inaugural não acontece muita coisa, só um título tentando ser engraçadinho e um pouco de como o blog será, de que postarei aqui as coisas que for aprendendo, relacionadas a programação, linux, internet, etc…

    Usarei o próprio desenvolvimento do blog como tema para muitos desses posts, criação de temas, otimização de performance, controle de versão, etc…

    Tentararei manter uma certa frequência nas postagens, uma por semana, mais talvez, tudo vai depender do desenrolar e da aceitação do que eu colocar aqui.

    Talvez tenhamos posts de outras pessoas por aqui, vai depender da minha habilidade em convencê-las.

    Por enquanto é isso, esperem pelos próximos posts.

    Por

    Em meta.

« Página 3 / 3