out
27
Como instalar a placa de som da Intel (snd-hda-intel) no Ubuntu 7.10 (gutsy)
Filed Under desktop | 38 Comments
Para quem tem problemas com a placa de som dos novos notebooks da CCE, aí vai a dica, instalar o módulo mais recente sem bagunçar com os pacotes do alsa.
Se você ainda não instalou os pacotes essenciais para compilar qualquer coisa no Linux, execute:
$ sudo aptitude install build-essential
Baixe o alsa-driver mais novo, aqui estou usando o 1.0.15
$ wget ftp://ftp.alsa-project.org/pub/driver/alsa-driver-1.0.15.tar.bz2
Descompacte
$ tar -jxvf alsa-driver-1.0.15.tar.bz2
Configure e compile
$ cd alsa-driver-1.0.15
$ ./configure –with-cards=hda-intel && make
Vá na pasta de módulos do ubuntu e mova o módulo existente para que não seja carregado
$ cd /lib/modules/$(uname -r)/ubuntu/media/snd-hda-intel/
$ sudo mv snd-hda-intel.ko snd-hda-intel.no_load
$ depmod -a $(uname -r)
Agora vem o pulo do gato, não instale o alsa TODO, apenas os módulos
$ sudo make install-modules
$ sudo reboot
Pronto agora só sentir a qualidade do som.
ATUALIZADO EM 2007-11-08
Só um detalhe que não mencionei na primeira edição deste artigo, se algo der errado e você quiser instalar novamente os drivers genéricos do Ubuntu primeiro desinstale o driver compilado anteriormente com o comando
$ sudo make uninstall
Depois reinstale o kernel atual para que seja recriado a pasta de módulos
$ sudo aptitude reinstall linux-image-$(uname -r)
$ sudo aptitude reinstall linux-ubuntu-modules-$(uname -r)
Pronto, seu sistema volta ao que era antes.
out
14
Já me perguntaram bastante sobre “Qual é a melhor linguagem?” se Ruby ou Python. “Qual o melhor framework?” se Rails ou (Turbogears, Django, Pylons), mas não existe nada pior do que comentários críticos sobre algumas particularidades do Python, “Porque os espaços?”, “Porque não tem chaves?”, etc. Eu que sou um profundo admirador do Python as vezes me vejo tendo que responder algumas dessas perguntas para pessoas que se quer estão dispostas a ouvir, hoje vi no blog do Guido (criador do Python) um link para um artigo chamado “Python: Myths about Indentation” escrito por um tal de Olli, que fala exatamente sobre essas particularidades, recomendo a leitura para todos, principalmente para os mais críticos do Python.
out
11
Mini-curso TurboGears - Básico - Aula 1
Filed Under programação | 1 Comment
Antes de começar a codificar um sistema em TurboGears, é importante entender as partes deste framework e como elas funcionam. Neste artigo vamos entender quais são essas partes, onde elas se localizam e como cada uma destas partes se integram para o funcionamento do todo do TurboGears.
A grosso modo, quais são as partes do TurboGears?
O TurboGears é composto de 3 partes principais, o gerenciador do banco de dados (SQLObject), o servidor web (CherryPy) e o gerenciador de templates (Kid), se você ainda não instalou o TurboGears veja como instalar em um artigo postado anteriormente neste blog.
O papel principal do SQLObject é fazer todos os SELECTS, INSERTS, CREATES e etc de uma forma que eu não precise escrever os comandos do SQL, em resumo, ele lê um arquivo de modelo que criamos, o “model.py”, e cria automaticamente o banco de dados e possibilita que realizemos operações sobre ele usando apenas objetos do Python.
A função do CherryPy é levar os dados do banco de dados para uma interface comum que conhecemos, a web, ele faz isso dando respostas em HTTP para aos pedidos que fazemos usando métodos, seu arquivo principal é o “controllers.py”.
Já o Kid trabalha com em conjunto com os anteriores dando uma “cara” bonitinha para as respostas do CherryPy, usando os templates do Kid podemos desenhar nossa página como ela deve ser mostrada e o CherryPy entenderá isso e preencherá os locais apropriados com as respostas do banco de dados. Os arquivos de templates se localizam dentro do diretório “templates/”.
Resumindo, o TurboGears funciona lendo dados do banco de dados, manipulando esses dados de alguma forma e mostrando os resultados na forma desejada.
Colocando em prática a teoria
Depois do TurboGears instalado executar o comando
$ tg-admin quickstart
Responder conforme queira as perguntas, após o processo o TurboGears deverá ter criado um diretório com o nome do projeto dado, acesse este diretório e execute
$ ./start-nome_do_projeto
Em seguida acesse o endereço no seu navegador “http://localhost:8080″ e verifique seu projeto iniciado, uma característica do TurboGears é a facilidade com que se coloca um projeto no ar em questão de segundos.
Verifique as partes do TurboGears mencionadas anteriomente, edite os arquivos “model.py” e veja que não tem nenhum modelo criado, o arquivo “controllers.py” e os arquivos de templates.
Neste meio tempo procure estudar sobre a api do Kid, do CherryPy e do SQLObject, todos os links poderão ser encontrados neste blog na seção lateral em “Recomendados”, fique a vontade para fazer perguntas por e-mail ou pelo blog.
Veremos no próximo artigo desta série como criar um pequeno modelo e executar as operações básicas de adição, edição e deleção sobre ele, aguarde, veremos do básico ao avançado e ao longo do mini-curso várias dicas usadas por profissionais.
Até breve!
out
11
Del.icio.us atualizado!
Filed Under diversos | Leave a Comment
Olá, nenhum artigo técnico por ora, mas estou postando pois acabo de atualizar e publicar meu catálogo de links no del.icio.us, estou preparando vários tutoriais interesantes sobre Turbogears, Python e Redes Neurais, em breve estarei colocando no ar, por enquanto vejam os links que estão na lista, tem muito documento legal.
http://del.icio.us/allangarcia
Coloquei também no menu lateral deste blog um atalho para os links mais recentes.
out
11
Este artigo será dividido em várias partes, vou falar sobre as Redes Neurais propriamente ditas e como implementar alguns algorítmos usando Python, nesta primeira parte vamos ver o básico e a medida que os artigos forem sendo publicados ver coisas mais avançadas.
Perceba que o objetivo é demonstrar as implementações em Python e não ver teoria aprofundada de Redes Neurais, para isso recomendo o livro do Haykin.
Apresentando as Redes Neurais
O que são? - “São sistemas de processamento de sinais ou de informações, compostos por um grande número de processadores elementares chamados neurônios artificiais, operando de forma paralela e distribuída, de modo a resolver um determinado problema físico/computacional.”
Esquema! - (X1, X2, …, Xn) dot (W1, W2, …, Wn) — F(x) — Y
Isso significa que uma Rede Neural, de um neurônio apenas, é um combinador linear que passa por uma função de ativação e dá um resultado Y, o mais interessante é que podemos programá-la para que ela dê o resultado que você deseje! Com isso podemos fazer, dentre outras coisas, aproximadores de funções, associadores, classificação de padrões, predição futura, controle de sistemas, filtragem de sinais, compressão de dados, datamining, etc.
Redes Neurais podem ser de vários tipos, nesta parte básica vamos ver as mais simples, as Redes Neurais supervisionadas, que são treinadas (ou programadas) usando um conjunto de exemplos conhecidos, com atributos e respostas, e desta forma a Rede Neural “se acostuma” em dar os resultados desejados e passa a responder de acordo.
Programar uma Rede Neural é ajustar os valores do vetor W, de todos os neurônios, para que determinada entrada X, quando processada, resulte num valor Y desejado.
Um algoritmo simples
Este descreve apenas o funcionamento de um neurônio .
# -*- coding: utf8 -*- from numpy import array, sign class Neuron: def __init__(self, example, factor=0.1): self._bias = -1.0 self._factor = factor x, self._d = example self._x = array([self._bias]+x) self._w = array([0.0]*(len(self._x))) self._y = None self.train(example) def train(self, example): x, self._d = example self._x = array([self._bias]+x) self._y = self._sign(self._sum()) if self._y != self._d: self._adjust_w() def execute(self, x): self._x = array([self._bias]+x) self._y = self._sign(self._sum()) return self._y def _error(self): return self._d - self._y def _sum(self): return (self._x*self._w).sum() def _sign(self, v): if sign(v) < 0: y = 0 else: y = sign(v) return y def _adjust_w(self): self._w += self._factor * self._x * self._error()
E para executar o perceptron, que é o que irá apresentar os exemplos ao neurônio, temos:
# -*- coding: utf8 -*- from Neuron import Neuron from random import randint class Perceptron: def __init__(self, examples, max_epochs=100): self._examples = examples self._this_epoch_examples = list(self._examples) self._max_epochs = max_epochs self._epoch = 0 self._neuron = Neuron(self._rand_example()) self.train() def train(self): while self._epoch <= self._max_epochs: self._this_epoch_examples = list(self._examples) for i in range(len(self._this_epoch_examples)): self._neuron.train(self._rand_example()) print "Epoch: %d" % self._epoch self._epoch += 1 def execute(self, x): return self._neuron.execute(x) def _rand_example(self): lenght = len(self._this_epoch_examples) i = randint(0,lenght-1) return self._this_epoch_examples.pop(i)
Execute as classes acima usando
# -*- coding: utf8 -*- from Perceptron import Perceptron # AND examples_and = [ [[1,1],1], [[1,0],0], [[0,1],0], [[0,0],0] ] nn = Perceptron(examples_and) nn.execute([1,0])
Analise o objeto criado, seus métodos e pesos, verifique que com o método “execute” você poderá testar se as respostas estão sendo dadas corretamente.
Aguarde a parte 2 deste artigo para mais detalhes…
out
5
Como se diferenciar no mercado de software?
Filed Under programação | 1 Comment
Estou escrevendo um artigo sobre Redes Neurais, mas como é um assunto cheio de detalhes, não estará pronto até segunda-feira, recomendo neste meio tempo a leitura do que considero uma obra prima da literatura técnica para desenvolvedores… Getting Real é uma genialidade de ideias e sugestões para quem quer ganhar dinheiro desenvolvendo software, meus conceitos mudaram completamente após a leitura deste livro.
Visite: http://gettingreal.37signals.com/
out
4
Eu tenho uma preferência pessoal por executar meus servidores usando scripts de init, uso sempre o Linux Standard Base (LSB) e suas padronizações para criá-los sempre que necessário. Em geral, o pacote de um servidor como o Apache, já vem com algum modelo ou até mesmo já cria o script de init para você, mas, por algum motivo, no Ubuntu (no Debian também) o script de init responsável por executar o iptables (carregar as regras) não existe, e por isso eu criei um próprio baseado em um monte de exemplos disponíveis na Internet.
O resultado final desse script é
#!/bin/bash
# Este script deve ser usado em Desktops apenas, não possui qualquer
# especialização para uso em servidores de segurança ou ambientes em produção
# oferece apenas o nível básico de proteção, para maiores informações consultar
# a documentação oficial do iptables e sites especializados em segurança
#
# Criado por Allan Garcia
# allan.garcia@gmail.com
# V 1.0. /lib/lsb/init-functions
IPTABLES=”/sbin/iptables”
IPTABLES_SAVE=”/sbin/iptables-save”
IPTABLES_RESTORE=”/sbin/iptables-restore”
IPTABLES_RULES=”/etc/default/iptables”
SAVE_RESTORE_OPTIONS=”-c”fillbasicrules() {
${IPTABLES} -F
${IPTABLES} -X
${IPTABLES} -P INPUT DROP
${IPTABLES} -P FORWARD DROP
${IPTABLES} -P OUTPUT DROP
${IPTABLES} -N Ubuntu-Firewall-1-INPUT
${IPTABLES} -A INPUT -j Ubuntu-Firewall-1-INPUT
${IPTABLES} -A FORWARD -j Ubuntu-Firewall-1-INPUT
${IPTABLES} -A OUTPUT -j ACCEPT
${IPTABLES} -A Ubuntu-Firewall-1-INPUT -i lo -j ACCEPT
${IPTABLES} -A Ubuntu-Firewall-1-INPUT -m state –state RELATED,ESTABLISHED -j ACCEPT
${IPTABLES} -A Ubuntu-Firewall-1-INPUT -m state –state NEW -m tcp -p tcp –dport 22 -j ACCEPT
${IPTABLES} -A Ubuntu-Firewall-1-INPUT -j REJECT –reject-with icmp-host-prohibited
}checkrules() {
if [ ! -f ${IPTABLES_RULES} ]; then
echo -n “There is no rules configured, can I suggest some (y/n) [y]?”
read input
if [ -z $input ] || [ "$input" == "y" ] || [ "$input" == "yes" ] || [ "$input" == "Y" ] || [ "$input" == "YES" ]; then
fillbasicrules
save
else
echo “Not starting iptables. First create some rules then run”
echo “\”/etc/init.d/iptables save\”"
return 1
fi
fi
}save() {
${IPTABLES_SAVE} ${SAVE_RESTORE_OPTIONS} > ${IPTABLES_RULES}
return $?
}start() {
checkrules || return 1
${IPTABLES_RESTORE} ${SAVE_RESTORE_OPTIONS} < ${IPTABLES_RULES}
return $?
}stop() {
for table in `cat /proc/net/ip_tables_names`; do
${IPTABLES} -F -t $table
${IPTABLES} -X -t $table
if [ $table == nat ]; then
${IPTABLES} -t $table -P PREROUTING ACCEPT
${IPTABLES} -t $table -P POSTROUTING ACCEPT
${IPTABLES} -t $table -P OUTPUT ACCEPT
elif [ $table == mangle ]; then
${IPTABLES} -t $table -P PREROUTING ACCEPT
${IPTABLES} -t $table -P INPUT ACCEPT
${IPTABLES} -t $table -P FORWARD ACCEPT
${IPTABLES} -t $table -P OUTPUT ACCEPT
${IPTABLES} -t $table -P POSTROUTING ACCEPT
elif [ $table == filter ]; then
${IPTABLES} -t $table -P INPUT ACCEPT
${IPTABLES} -t $table -P FORWARD ACCEPT
${IPTABLES} -t $table -P OUTPUT ACCEPT
fi
done
}restart() {
for table in `cat /proc/net/ip_tables_names`; do
${IPTABLES} -F -t $table
${IPTABLES} -X -t $table
done
start
}case “$1″ in
save)
echo -n “Saving iptables state…”
save
if [ $? -eq 0 ]; then
echo ” ok”
else
echo ” error!”
fi
;;start)
log_begin_msg “Loading iptables state and starting firewall…”
start
log_end_msg $?
;;stop)
log_begin_msg “Stopping firewall…”
stop
log_end_msg 0
;;restart)
log_begin_msg “Stopping firewall…”
restart
log_end_msg $?
;;*)
echo “Usage: /etc/init.d/iptables {start|stop|restart|save}” >&2
exit 1
;;esac
exit 0
Para instalar esse script é muito simples, copie ele para a pasta “/etc/init.d/” com o nome “iptables”, certifique-se de que seu proprietário é o root e dê a permissão 755 para ele.
$ sudo cp /tmp/iptables /etc/init.d/
$ sudo cd /etc/init.d/
$ sudo chown root.root iptables
$ sudo chmod 755 iptables
Se você iniciar o iptables sem criar regras, o próprio script irá lhe sugerir um conjunto inicial de regras, caso queira criar seu próprio conjunto de regras, faça-o e depois salve usando o comando
$ sudo /etc/init.d/iptables save
O conjunto de regras sugerido é suficiente para proteger seu computador pessoal, todavia para uma configuração mais avançada recomento uma leitura mais aprofundada na documentação do iptables (man iptables).
Após a regras salvas inicie o iptables usando o comando
$ sudo /etc/init.d/iptables start
Para habilitar a inicialização sempre que o computador ligar execute
$ sudo update-rc.d iptables defaults
Pronto! Seu firewall está configurado para carregar na inicialização do computador
out
2
Este será um artigo bem curto, não vou discutir qual é a melhor forma de fazer backup do Subversion, apenas vou mostrar como eu faço! Juntamente com o Subversion eu também faço backup da pasta do Trac.
No meu computador todos os projetos do Subversion encontram-se em “/var/lib/svn/” e os projetos do Trac em “/var/lib/trac/”, portanto fica simples fazer o backup, que no meu caso é para minha pendrive.
O script que eu utilizo é:
#!/bin/bash
PENDIR=”/media/MY FILES/”
BKPDIR=$PENDIR”backup/”
BASEDIR=”/var/lib/”
SVNPATH=$BASEDIR”svn/”
TRACPATH=$BASEDIR”trac/”
SVNCMD=”svnadmin -q”
TARCMD=”tar -czPf”
echo -n -e “\n *** Iniciando o procedimento de backup *** \n\n”
for project in projeto1 projeto2 projeto3; do
echo -n -e ” * Copiando subversion do projeto $project para $BKPDIR…”
$SVNCMD dump “$SVNPATH$project” > “$BKPDIR$project”".svndump”
echo -n -e ” OK!\n”
echo -n -e ” * Copiando trac do projeto $project para $BKPDIR…”
$TARCMD “$BKPDIR$project”"-trac.tar.gz” “$TRACPATH$project”
echo -n -e ” OK!\n”
done
echo -n -e “\n *** Finalizando backup *** \n\n”
Ou seja, o procedimento é simplesmente montar a pendrive na USB, e executar este script, caso você tenha algum dispositivo permanente de backup poderá agendar esse script no cron.
Se você está procurando apenas os comandos para backup use
$ svnadmin dump /var/lib/svn/projeto1 > projeto1.svndump
Para backup do Trac eu prefiro fazer do diretório completo, pois já vem com meus plugins e outras personalizações.
$ tar -czPf projeto1-trac.tar.gz /var/lib/trac/projeto1
Restaurando o backup
Para restaurar o backup do Subversion exige-se duas etapas, a primeira é criar o projeto vazio e depois carregar o dump salvo anteriormente.
$ sudo svnadmin create projeto1
$ sudo svnadmin load projeto1 < projeto1.svndump
Para restaurar o Trac basta descompactar o arquivo na pasta do Trac, que no meu caso é “/var/lib/trac/” e após isso seguir os passos de configuração ditos no meu outro artigo “Instalando o Trac e o Subversion em 12 passos no Ubuntu 7.04 (Feisty Fawn)”
Pronto! Seu computador está pronto para o trabalho novamente!
out
1
Como usar vários arquivos de controle no TurboGears inteligentemente?
Filed Under programação | Leave a Comment
Uma coisa que as vezes não nos damos conta quando programamos em TurboGears é que ele nada mais é do que Python, e sendo assim pode utilizar todos os recursos disponíveis na linguagem. Parece óbvio, mas eu tenho visto em várias listas de discursões perguntas como:
- Como faço para criar um instalador para meu projeto TurboGears?
- Como faço para usar projeto X que tem em TAL framework?
- Ou pior, vou usar o framework Y porque ele é “compatível” com tal e tal tecnologia.
Todas essas perguntas são simples de responder, pois todos esses projetos são feitos em Python e podem ser importados de um framework para outro sem problema nenhum. Instalador? Arquivos .egg, que é padrão do Python! Veremos respostas mais detalhadas para essas perguntas em artigos futuros.
Outra pergunta que vejo em listas com igual freqüência é: “Como faço para criar vários arquivos de controle no TurboGears? Pois com apenas um arquivo (controllers.py) meu código fica bagunçado e para projetos grandes isso não é o ideial por N motivos”. Realmente um projeto com vários arquivos de controle pode ser muito melhor estruturado e organizado!
Existem várias formas de usar vários arquivos de controle, sendo que normalmente a orientação data em listas é: 1. Cria uma pasta, tipo “modules”, 2. Cria teus arquivos lá dentro, 3. Tem que criar um arquivo “__init__.py” dentro do diretório para funcionar, sem dar nenhuma explicação do porquê disto! e 4. importa as classes para o “controllers.py” conforme tua necessidade e pronto! Funcionar até que funciona, mas não é a forma mais “Pythonista” de resolver este problema.
Entendendo Python Packages
Só esse assunto daria um artigo sozinho, mas vou tentar resumir sem falar difícil. Para o Python a estrutura de diretórios do seu S.O. não existe (pelo menos não da forma que você entende), um diretório é só mais uma forma de se agrupar classes, assim como podemos agrupar usando arquivos. O arquivo “__init__.py”, é o equivalente ao método “def __init__(self):” definido dentro de uma classe, ou seja, ao instanciarmos uma classe qualquer
class foo:
… def __init__(self):
… … print “executei!”>> objeto = foo()
executei!
Automaticamente o método __init__(self): dentro desta classe será chamado e irá imprimir a string “executei!”. De forma análoga o arquivo “__init__.py” dentro de um diretório funciona, todavia ele é executado no momento que o diretório é importado! Colocando os pingos nos i’s agora, este diretório para o Python é chamado de “Python Package” e pode ser importado da mesma forma que um arquivo. Ex. “controllers.py”.
Começaram a imaginar? Se o TurboGears em um determinado momento importa o arquivo “controllers.py” para anunciar no CherryPy os métodos que estarão disponíveis no projeto, da mesma forma ele fará, se agora, ao invés de um arquivo, tivermos um diretório.
A mágica começa!
Como tudo em Python é falado como magia (e parece mesmo!) vejamos como “sumir” com o arquivo “controllers.py” e ainda assim seu projeto continuar funcionando!
Crie um diretório chamado “controllers” no mesmo diretório do arquivo “controllers.py”
$ mkdir controllers
Mova o arquivo “controllers.py” para dentro do diretório que você acabou de criar, apenas trocando o nome para “__init__.py”.
$ mv controllers.py controllers/__init__.py
Inicie seu projeto! Ele estará funcionando perfeitamente. Isso ocorre porque no momento que o diretório “controllers” foi importado o arquivo “__init__.py” foi executado como se ainda existisse um arquivo “controllers.py”.
Criando outros controles!
Agora é só criar os arquivos de controles desejados dentro desta nova pasta (controllers), como por exemplo um arquivo “cliente.py” para guardar classes relacionadas de formulários, testes, e a classe que herda “controllers.Controllers” do CherryPy.
No arquivo “__init__.py” importe uma classe de dentro deste novo arquivo criado, usando:
>>> from cliente import ClienteControle
E dentro da classe “Root(controllers.RootController):” instancie sua classe usando:
>>> cliente = ClienteControle()
Esta classe estará disponível no endereço “/cliente” do seu projeto.
Pronto! Agora você pode organizar seu projeto com muito mais simplicidade e usar a mesma técnica para outros arquivos, caso entenda necessário. Ex. “model.py”.
out
1
Quem já utiliza o Subversion para gerenciar o desenvolvimento de seus softwares sabe como ele pode agilizar e controlar o processo. Uma função interessante do Subversion é poder “hookar” algumas ações, tais como: Após o commit, Antes do commit, Ao lockar, etc. Neste artigo veremos como fazer para que “após-um-commit” de uma nova revisão, o script feche automaticamente um ticket aberto no Trac.
A forma de utilização será “svn ci” e no log adicionar “(close #ticket-number) ou (refs #ticket-number)” antes do comentário normal da revisão.
Para começar a configuração primeiro devemos entrar na pasta do projeto Subversion, onde iremos configurar o “hook”.
$ cd /var/lib/svn/+projeto+/
Em seguida acessar a pasta “hooks”:
$ cd hooks
$ ls -l
-rw-rw-r– 1 root www-data 1996 2007-09-26 15:19 post-commit.tmpl
-rw-rw-r– 1 root www-data 1673 2007-09-26 15:19 post-lock.tmpl
-rw-rw-r– 1 root www-data 2290 2007-09-26 15:19 post-revprop-change.tmpl
-rw-rw-r– 1 root www-data 1602 2007-09-26 15:19 post-unlock.tmpl
-rw-rw-r– 1 root www-data 2969 2007-09-26 15:19 pre-commit.tmpl
-rw-rw-r– 1 root www-data 2038 2007-09-26 15:19 pre-lock.tmpl
-rw-rw-r– 1 root www-data 2764 2007-09-26 15:19 pre-revprop-change.tmpl
-rw-rw-r– 1 root www-data 1979 2007-09-26 15:19 pre-unlock.tmpl
-rw-rw-r– 1 root www-data 2137 2007-09-26 15:19 start-commit.tmpl
Veja que existem templates para várias ações que podem ser configuradas, recomendo ler mais sobre esse assunto para fazer as demais configurações, para nosso caso o que nos interessa é o “post-commit.tmpl”, devemos renomeá-lo para “post-commit” e torná-lo executável.
$ sudo mv post-commit.tmpl post-commit
$ sudo chmod +x post-commit
Depois editá-lo e adicionar as linhas que irão chamar o script do Trac, conforme abaixo:
$ sudo vim post-commit
— code —
REPOS=”$1″
REV=”$2″
LOG=`/usr/bin/svnlook log -r $REV $REPOS`
AUTHOR=`/usr/bin/svnlook author -r $REV $REPOS`
TRAC_ENV=’/var/lib/trac/+projeto+/’
TRAC_URL=’http://trac/+projeto+/’/usr/bin/python /usr/share/doc/trac/contrib/trac-post-commit-hook \
-p “$TRAC_ENV” \
-r “$REV” \
-u “$AUTHOR” \
-m “$LOG” \
-s “$TRAC_URL”
— code —
Se você está fazendo essa configuração pela primeira vez, você deve comentar todas as demais linhas deste arquivo, deixando apenas as descritas acima.
Agora vamos habilitar o script do Trac, primeiro devemos acessar o diretório “contrib” do Trac, que no Ubuntu está localizado em:
$ cd /usr/share/doc/trac/contrib/
Caso o arquivo esteja compactado, descompactá-lo usando o comando abaixo:
$ sudo gunzip trac-post-commit-hook.gz
E por fim torná-lo executável
$ sudo chmod +x trac-post-commit-hook
Pronto! Agora quando fizer o commit de uma revisão do seu projeto basta adicionar “(close #N)” para fechar um ticket ou “(refs #N)” para referenciá-lo e desta forma poder ver no futuro as alterações que foram feitas no projeto que estão relacionados a um determinado Ticket.