sexta-feira, 26 de agosto de 2011

Rails 3.1 + Mountable Engines

Engines do Rails 3.1 permitem dividir a aplicação em módulos funcionais, incluindo uma aplicação dentro da outra.

Verificar a versao do Rails que deve ser a 3.1 ou superior:
$ rvm use 1.9.2@rails3.1
$ rails -v
Criar uma nova engine:
$ rails plugin new uhoh --mountable
$ cd uhoh
$ git init
$ echo "rvm use 1.9.2@rails3.1" > .rvmrc
A estrutura de diretório criada é igual a de uma aplicação rails comum com a diferença dos diretórios app/controllers, assets, helpers e views que ficam no namespace da aplicação uhoh:
create  
create  README.rdoc
create  Rakefile
create  uhoh.gemspec
create  MIT-LICENSE
create  .gitignore
create  Gemfile
create  app
create  app/controllers/uhoh/application_controller.rb
create  app/helpers/uhoh/application_helper.rb
create  app/models
create  app/views/layouts/application.html.erb
create  app/views/layouts/uhoh/application.html.erb
create  app/assets/images/uhoh
create  app/assets/images/uhoh/.gitkeep
create  config/routes.rb
create  lib/uhoh.rb
create  lib/tasks/uhoh_tasks.rake
create  lib/uhoh/engine.rb
create  app/assets/stylesheets/uhoh/application.css
create  app/assets/javascripts/uhoh/application.js
create  script
create  script/rails
create  test/test_helper.rb
create  test/uhoh_test.rb
append  Rakefile
create  test/integration/navigation_test.rb
vendor_app  test/dummy
run  bundle install
O arquivo de configuração principal está em /lib/uhoh/engine.rb e já possui uma
chamada a isolate_namespace, que torna a engine isolada da aplicação onde será montada.
module Uhoh  
  class Engine < Rails::Engine  
    isolate_namespace Uhoh  
  end  
end  

Engine de Noitificações 1

Criar um controller para a engine:
$ rails generate controller failures index
Criar uma rota padrao para a action do controller:
Uhoh::Engine.routes.draw do  
  root :to => "failures#index"  
end 
Criar um model para armazenar as mensagens de erro:
$ rails generate model failure message:text
As migrations podem ser executadas diretamente na engine
$ rake db:migrate
$ rails c
> Uhoh::Failure.create!(:message => 'Ohoh Failure!')
Mas quando incluidas em outra aplicação Rails elas precisam ser copiadas para as migrations da aplicação. Esta informação deve ser colocada no arquivo README para orientar o usuário da engine.
$ rake uhoh:install:migrations
Modificar o controller /app/controllers/uhoh/failures_controller.rb
module Uhoh  
  class FailuresController < ApplicationController  
    def index  
      @failures = Failure.all  
    end  
  end  
end 
Modificar a view /app/views/uhoh/failures/index.html.erb:
<h1>Failures</h1>  
<ul>  
  <% for failure in @failures %>  
  <li><%= failure.message %></li>  
  <% end %>  
</ul>  

Configurar um Initializer

Notifier que vai ficar escutando quando a aplicação lança uma exception. Criar um initializer em /uhoh/config/initializers/exception_handler.rb
ActiveSupport::Notifications.subscribe \  
  "process_action.action_controller" do \  
  |name, start, finish, id, payload|  
  if payload[:exception]  
    name, message = *payload[:exception]  
    Uhoh::Failure.create!(:message => message)  
  end  
end

Testar a Engine na aplicação Dummy

É possível testar a engine na aplicação ficticia de teste criada em test/dummy:
Informar para aplicação qual url será usada para referênciar a Engine no arquivo /test/dummy/config/routes.rb:
Rails.application.routes.draw do  
  mount Uhoh::Engine => "/uhoh"  
end
Criar um controle na aplicação fictícia para simular uma exception:
$ cd test/dummy
$ rails g controller simulate failure 
Lançar uma exception de teste:
class SimulateController < ApplicationController  
  def failure  
    raise "Simulating an exception"  
  end  
end

Testado tudo numa nova aplicação

Criar a nova aplicação que vai utilizar a engine a partir do path
$ rails new uhoh-parent
$ vi uhoh-pai/Gemfile
#=>incluir esta linha utilizar a engine criada localmente
gem 'uhoh',  :path => '../uhoh/'
Ou criar uma gem e instalar no sistema. Editar o arquivo de propriedades uhoh.gemspec e contruir a gem
$ gem build uhoh.gemspec
Vai gerar o arquivo uhoh-0.0.1.gem que pode ser colocado num repositório ou instalado direto no sistema
$ gem install uhoh
Verificar se a gem foi instalada, a partir da aplicação pai abrir a engine
$ export BUNDLER_EDITOR=gmate
$ bundle open uhoh
Instalar as migrations da engine na aplicação
$ bundle exec rake uhoh:install:migrations
$ bundle exec rake db:migrate
$ rails s
Acessar http://0.0.0.0:3000/uhoh

Referências:
1 http://railscasts.com/episodes/277-mountable-engines
http://www.builtfromsource.com/2010/12/13/mountable-engines-in-rails-3-1-beta-getting-started/
http://railscasts.com/episodes/249-notifications-in-rails-3

sexta-feira, 19 de agosto de 2011

Rails 3.1 + Ubuntu

Criar um novo ambiente para as gems do Rails 3.1:
$ rvm ruby-1.9.2@rails3.1 --create --default
Atualizar o rake 0.8.7 para 0.9.2:
$ gem update rake
$ rake --version
Instalar a última versão do Rails:
$ gem install rails --pre --no-ri --no-rdoc
$ rails -v
Nova aplicação de teste:
$ rails new testeapp
$ cd testeapp
Configurar o gemset que o projeto vai utlizar:
$ echo 'rvm 1.9.2@rails3.1' > .rvmrc
Adicionar um motor javascript ao Gemfile (necessário no Ubuntu)
$ vi Gemfile
  gem 'therubyracer', '>= 0.8.2'
Testar se tudo funciona:
$ bundle exec rake -T
Gems que pode auxiliar a criar aplicações Rails 3.1:
$ gem install i18n thor bundler --no-ri --no-rdoc
$ gem install rails_apps_composer --no-ri --no-rdoc
A gem rails_app_composer ajuda a criar novas aplicações rails:
$ rails_apps_composer list
$ rails_apps_composer new APP_NAME -r jquery haml rspec cucumber devise


Referencias:
http://railsapps.github.com/installing-rails-3-1.html
https://github.com/sstephenson/execjs
https://github.com/RailsApps/rails_apps_composer

quarta-feira, 17 de agosto de 2011

Django + Virtualenv + Pip + Ubuntu

Instalar os pacotes necessários:
$ sudo apt-get install python-setuptools python-dev build-essential
Instalar o Pip:
$ sudo easy_install -U pip
$ pip help
$ pip zip --list
Instalar a Virtualenv:
$ sudo pip install -U virtualenv
Criar um novo ambiente virtual:
$ mkdir -p ~/.virtualenvs
$ cd ~/.virtualenvs
$ virtualenv --no-site-packages --distribute ~/.virtualenvs/default
Instalar Yolk (ferramenta para listar pacotes) no novo ambiente virtual default criado:
$ pip install -E ~/.virtualenvs/default yolk
Ativar o ambiente para uso:
$ source ~/.virtualenvs/default/bin/activate
$ yolk -l
Para desativar o ambiente:
$ deactivate
$ yolk -l
Instalar o Django no ambiente
$ pip install -E ~/.virtualenvs/default Django
Criar um arquivo com que especifica as versão utilizadas:
$ pip freeze -E ~/.virtualenvs/default &gt; requirements.txt
É possivel usar este arquivo para instalar os mesmos pacotes:
$ pip install -E ~/.virtualenvs/default -r ~/.virtualenvs/default/requirements.txt
Instalar o console IPhyton:
$ pip install -E ~/.virtualenvs/default ipython
Ativar o suporte ao tab-complete dos comandos do pip:
$ pip completion --bash &gt;&gt; ~/.bash_completion
$ source ~/.bashrc
$ pip search "mysql"
Testar se todo o ambiente está funcionando:
$ ipython =&gt; CTRL+D para sair do console
$ cd ~/projetos-python
$ django-admin.py startproject demoapp
$ python manage.py runserver 8000  #=&gt; acessar http://127.0.0.1:8000/


Referências:
http://tumblr.intranation.com/post/766290325/python-virtualenv-quickstart-django
http://pypi.python.org/pypi/virtualenv
http://pypi.python.org/pypi/yolk
http://alexandrebm.com/pip-instalador-de-pacotes-no-python
http://www.pip-installer.org/en/latest/#using-pip-with-virtualenv

quarta-feira, 10 de agosto de 2011

Deploy com Capistrano

Configurar a variavel de ambiente do servidor
$ sudo nano /etc/environment
#inserir esta linha
export RAILS_ENV=production
Instalar a gem Capistrano
$ gem install capistrano --no-ri --no-rdoc
Criar uma nova aplicação Rails, versionar e adicionar o repositório remoto.
$ rails new app.demo
$ cd app.demo 
$ bundle install #=> é necessário criar o Gemfile.look
$ git init
$ git add .
$ git commit -am 'Initial commit'
$ git remote add origin git@pavilion:app.demo
$ git push origin master
Criar os arquivos do Capistrano
$ capify .
$ git status # -> para mostrar os diretórios incluidos
Substituir o conteúdo do arquivo que o comando anterior criou em config/deploy.rb
Configurar o deploy na aplicação
$ git add .
$ git commit -am 'Initial commit'
$ git push
Fazer o deploy da aplicação
$ cap deploy:setup
$ cap deploy  
$ cap deploy:migrations
Configurar a página de manutenção (é possível customizar o layout da pagina maintenance.htm)
$ sudo a2enmod rewrite #=> habilita o modulo de reescrita de url
$ cap deploy:web:disable \
      REASON="Atualizações de Segurança" \
      UNTIL="21h de hoje"
$ cap deploy:web:enable

Referências:
http://beginrescueend.com/integration/capistrano
http://gembundler.com/deploying.html
http://blog.josephholsten.com/2010/09/deploying-with-bundler-and-capistrano/
http://andkrup.wordpress.com/2011/05/10/ubuntu-10-10-apache2-passenger-rvm-capistrano-and-git-the-whole-shebang/
http://shiftcommathree.com/articles/make-your-rails-maintenance-page-respond-with-a-503


sábado, 6 de agosto de 2011

Configurar um repositório Git remoto no Ubuntu

Criar um novo usuário específico para o gerenciar os repositórios git's remoto
$ sudo adduser git
$ su git

Copiar a chave de usuário da máquina cliente para authorized_keys no servidor, para permitir acesso ao repositório.
$ ssh-copy-id -i ~/.ssh/id_rsa.pub git@pavilion

Criar um diretório para armazenar o repositório no diretório home do usuário git criado e iniciar um novo repositório.
$ mkdir ~/app.demo 
$ cd ~/app.demo
$ git init --bare

Adicionar o repositório remoto ao repositório do projeto na maquina cliente.
$ rails new app.demo
$ cd app.demo 
$ git init
$ git remote add origin git@pavilion:app.demo
$ git add .
$ git commit -am 'Initial commit'
$ git push origin master

Também é possível outros desenvolvedores clonarem o repositório remoto.
$ git clone git@pavilion:app.demo
$ cd app.demo

Testar e sincronzar as alterações com o repositório remoto.
$ touch README
$ git add .
$ git commit -m 'initial commit'
$ git push origin master

Comandos úteis

É possível desfazer alterações nos arquivos.
$ touch README
$ git revert HEAD #=> retorna versão anterior para arquivos já comitados
$ git reset --hard #=> retorna versão anterior para arquivos modificados e ainda não comitados


Referências:
http://valeriofarias.com/gitparadesigners.htm

Instalar Passenger + Apache + RVM + Ubuntu

Criar um wraper para a versão do ruby informada.  Configura as variáveis de ambientes corretas para a aplicação
$ rvm 1.9.2 --passenger  # ou rvm wrapper 1.9.2@rails3 passenger
O instalador do Passenger vai guiar e mostrar os comandos necessários para instalar as dependências.
$ sudo gem install passenger --no-ri --no-rdoc
$ rvmsudo passenger-install-apache2-module


Configurar o módulo do Passenger

Configurar um novo módulo para o Passenger no Apache.
$ sudo nano /etc/apache2/mods-available/passenger.load
#inserir a primeira linha da saída da instalação
LoadModule passenger_module /home/deployer/.rvm/gems/ruby-1.9.2-p290@rails3/gems/passenger-3.0.8/ext/apache2/mod_passenger.so

$ sudo nano /etc/apache2/mods-available/passenger.conf
#inserir as 2 últimas linhas de config
PassengerRoot /home/deployer/.rvm/gems/ruby-1.9.2-p290@rails3/gems/passenger-3.0.8
PassengerRuby /home/deployer/.rvm/wrappers/ruby-1.9.2-p290@rails3/ruby
Habilitar o novo módulo e reniciar o Apache.
$ sudo a2enmod passenger
$ sudo /etc/init.d/apache2 reload


Configurar o Host-Virtual

Dar permissões para o usuário deployer na pasta onde ficarão as aplicações e criar a estrutura de diretórios básica.
$ sudo chown deployer:deployer /var/www -R
$ cd /var/www
$ mkdir app.demo.org
$ cd app.demo.org; mkdir public; mkdir tmp
Criar um script com uma pagina simples para testar o ambiente.
$ nano /var/www/app.demo.org/config.ru
# inluir o conteúdo
app = proc do |env|
  [200, { "Content-Type" => "text/html" }, ["hello, world"]]
end
run app
Criar o arquivo de configuração do novo site no Apache.
$ sudo nano /etc/apache2/sites-available/app.demo.org
<VirtualHost *:80>
    ServerName app.demo.org
    DocumentRoot /var/www/app.demo.org/public # <-- be sure to point to 'public'!
    RailsEnv production
    
    <Directory /var/www/app.demo.org/public>
        Options Indexes FollowSymLinks -MultiViews  # <-- MultiViews must be turned off
        AllowOverride all                           # <-- relax Apache security settings
        Order allow,deny
        Allow from all       
    </Directory>
</VirtualHost>
Habilitar o novo site.
$ sudo a2ensite app.demo.org
$ sudo /etc/init.d/apache2 restart
Configurar o redirecionamento no arquivo de hosts.
$ sudo vi hosts
# inserir a referência
127.0.0.1 app.demo.org
Acessar o domínio do host para verificar se tudo funciona
$ lynx app.demo.org

Referências:

https://rvm.beginrescueend.com/integration/passenger
http://blog.phusion.nl/2010/09/21/phusion-passenger-running-multiple-ruby-versions/

sexta-feira, 5 de agosto de 2011

Configurar o Gmate

Adicionar o projeto na lista de repositorios e instalar o pacote
$ sudo add-apt-repository ppa:ubuntu-on-rails/ppa
$ sudo apt-get update
$ sudo apt-get install gedit-gmate
Instalar a fonte monaco
$ cd ~/.fonts
$ wget http://www.gringod.com/wp-upload/software/Fonts/Monaco_Linux.ttf
$ sudo fc-cache -f -v
Instalar o mesmo tema do RailsCast
$ wget http://github.com/mig/gedit-themes/tarball/master
Verificar lista dos plugins disponíveis no github do projeto em https://github.com/gmate/gmate

Instalar RVM + Rails no Ubuntu 11.04

Instalar os pacotes necessários.
$ sudo apt-get update
$ sudo apt-get install build-essential git-core curl

Instalar a RVM e seguir todas as instruções do output do comando.
$ bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

Fazer o reload do prompt.
$ source ~/.bashrc # reload das configuracoes

Se tudo estiver correto a saída do camando abaixo deve ser: "rvm is a function".
$ type rvm | head -n1

Editar ou criar o arquivo ~/.bash_completion para habilitar o autocomplete do rvm.
$ vi ~/.bash_completion

# inserir estas linhas
if [[ -s ~/.rvm/scripts/rvm ]]
then
    source ~/.rvm/scripts/rvm
    source ~/.rvm/scripts/completion
    rvm reload
fi

Criar o arquivo  ~/.bash_prompt e incluir o conteúdo do dotfile do link do @danielvlopes (https://raw.github.com/danielvlopes/dotfiles/master/bash/config) para para apresentar no prompt a versão do ruby e o branch do git que está selecionado.
$ vi ~/.bashrc

# incluir estas linhas
if [ -f ~/.bash_prompt ]; then
    . ~/.bash_prompt
fi

Verificar os pacotes faltantes. Este comando mostra na saída do console o comando que deve ser copiado e executado no terminal.
$ rvm notes

Verificar os rubys disponíveis e instalar os necessários.
$ rvm list known

# intalar o ruby
$ rvm install 1.9.2
$ rvm gemset create rails3
$ rvm use 1.9.2@rails3 --default

Instalar o rails.
$ gem install bundler rails --no-rdoc --no-ri
$ gem list
$ ruby -v
$ rails -v