vito 0.0.4 → 0.0.5

data/lib/vito/recipes/postgres/install.rb

@@ -0,0 +1,106 @@
+module Vito
+  module Recipes
+    module Postgres
+      class Install < Vito::Recipe
+        def install
+          if installed?
+            Vito::Log.write "Postgres already installed."
+          else
+            Vito::Log.write "Installing Postgres"
+            install_os_dependencies
+            install_postgres
+          end
+        end
+
+        private
+
+        def postgres_installed?
+          @memo ||= query("psql --version").success?
+        end
+
+        def user_exists?
+          query("sudo su - postgres -c \"psql -tAc \\\\\"SELECT 1 FROM pg_roles WHERE rolname='#{username}'\\\\\" | grep -q 1 || echo 'hey'\"").result == ""
+        end
+
+        def utf_template?
+          query("sudo su - postgres -c \"psql -d template1 -c \\\\\"SHOW SERVER_ENCODING;\\\\\" | grep -q UTF || echo 'hey'\"").result == ""
+        end
+
+        def installed?
+          # Only verifies Postgres configuration if it's installed
+          if postgres_installed?
+            Vito::Log.write "User doesn't exist. I will create one." unless user_exists?
+            Vito::Log.write "template1 database's encoding should be UTF-8. I'll adjust this." unless utf_template?
+          end
+
+          postgres_installed? &&
+            user_exists? &&
+            utf_template?
+        end
+
+        def username
+          @options.fetch(:username, 'vitouser')
+        end
+
+        def password
+          @options.fetch(:password, '123456')
+        end
+
+        def install_postgres
+          string = []
+          run_command "sudo apt-get install -y postgresql-9.1 libpq-dev"
+
+          # Create user only if it doesn't exist yet
+          unless user_exists?
+            string << "sudo su - postgres -c \"createuser -d -r -s #{username}\""
+          end
+
+          run_command(string.join(" && ")) unless string.empty?
+          convert_template1_to_utf8 unless utf_template?
+          string = []
+
+          if os.is?(:ubuntu, "10")
+            string << "sudo /etc/init.d/postgresql restart"
+          else
+            string << "sudo service postgresql restart"
+          end
+          run_command "sudo su - postgres -c \"psql -d template1 -c \\\\\"alter user #{username} with password '#{password}'\\\\\";\""
+
+          run_command(string.join(" && "))
+        end
+
+        def install_os_dependencies
+          return if postgres_installed?
+          Vito::Log.write "Installing some OS dependencies first"
+          if os.is?(:ubuntu, "10")
+            run_command("sudo apt-get remove -y postgresql")
+            run_command("sudo apt-get autoremove -y")
+            run_command("sudo apt-get install -y python-software-properties")
+            run_command("sudo add-apt-repository ppa:pitti/postgresql && sudo apt-get update")
+          end
+
+          super(os_dependencies)
+        end
+
+        def os_dependencies
+          %w(libpq-dev postgresql-contrib)
+        end
+
+        def convert_template1_to_utf8
+          # In some cases, the OS locale won't be compatible with UTF-8. When
+          # creating a database, Rails will try to use Postgres' template1 with
+          # UTF-8.
+          #
+          # Here, we delete template1, then login in template0 to recreate
+          # template1 with UTF-8 encoding.
+          run_command "sudo su - postgres -c \"psql -d template1 -c \\\\\"UPDATE pg_database SET datallowconn = TRUE where datname = 'template0';\\\\\"\""
+          run_command "sudo su - postgres -c \"psql -d template0 -c \\\\\"UPDATE pg_database SET datistemplate = FALSE where datname = 'template1'; \\\\\"\""
+          run_command "sudo su - postgres -c \"psql -d template0 -c \\\\\"drop database template1; \\\\\"\""
+          run_command "sudo su - postgres -c \"psql -d template0 -c \\\\\"create database template1 with template = template0 encoding = 'UNICODE'  LC_CTYPE = 'en_US.UTF-8' LC_COLLATE = 'C'; \\\\\"\""
+          run_command "sudo su - postgres -c \"psql -d template0 -c \\\\\" UPDATE pg_database SET datistemplate = TRUE where datname = 'template1'; \\\\\"\""
+          run_command "sudo su - postgres -c \"psql -d template1 -c \\\\\" UPDATE pg_database SET datallowconn = FALSE where datname = 'template0'; \\\\\"\""
+        end
+      end
+    end
+  end
+end

data/lib/vito/recipes/rbenv/install.rb

@@ -0,0 +1,54 @@
+module Vito
+  module Recipes
+    module Rbenv
+      class Install < Vito::Recipe
+        def install
+          if rbenv_installed?
+            Vito::Log.write "Rbenv already installed."
+          else
+            Vito::Log.write "Installing Rbenv"
+            depends_on_recipe(:git)
+            install_rbenv
+          end
+
+          install_ruby_build
+        end
+
+        private
+
+        def rbenv_installed?
+          string = []
+          string << "cd ~/"
+          string << "rbenv commands"
+          query(string.join(" && ")).success?
+        end
+
+        def install_rbenv
+          puts "Installing Rbenv..."
+          string = []
+          # TODO verify if this folder already exists
+          run_command "git clone git://github.com/sstephenson/rbenv.git ~/.rbenv"
+
+          # TODO verify if .bashrc already have these lines
+          string = []
+          string << "echo 'eval \"$(rbenv init -)\"' | cat - ~/.bashrc > ~/vitotemp && mv ~/vitotemp ~/.bashrc"
+          string << "echo 'export PATH=\"\\$HOME/.rbenv/bin:\\$PATH\"' | cat - ~/.bashrc > vitotemp && mv vitotemp ~/.bashrc"
+
+          run_command string.join(" && ")
+
+          query("rm ~/vitotemp")
+        end
+
+        def install_ruby_build
+          if query("[ -d ~/.rbenv/plugins/ruby-build ] && echo 1").result != "1"
+            puts "Installing ruby-build embedded into rbenv..."
+            string = []
+            # TODO verify if this dir already exists
+            string << "git clone https://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build"
+            run_command string.join(" && ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vito/recipes/ruby/install.rb

@@ -0,0 +1,57 @@
+module Vito
+  module Recipes
+    module Ruby
+      class Install < Vito::Recipe
+        def install
+          if ruby_exists?
+            Vito::Log.write "Ruby version #{version} is already installed."
+          else
+            Vito::Log.write "Installing Ruby"
+            install_os_dependencies(os_dependencies)
+            depends_on_recipe(:rbenv)
+            install_ruby
+          end
+        end
+
+        def install_ruby
+          version_to_install = version
+          if version_to_install.nil?
+            version_to_install = "2.0.0-p247"
+            Vito::Log.write "No Ruby version specified, installing #{version_to_install}."
+          end
+          string = []
+          string << "rbenv install #{version_to_install}"
+          string << "rbenv global #{version_to_install}"
+          string << "rbenv rehash"
+          string << "gem install bundler"
+          run_command string.join(" && ")
+        end
+
+        private
+
+        def ruby_exists?
+          if version.nil?
+            if @options[:dependent]
+              Vito::Log.write "#{@options[:dependent]} requires Ruby, but didn't specify a version."
+            else
+              Vito::Log.write "No Ruby version specified. Checking for any version instead."
+            end
+          end
+          program_version("ruby -v").matches?(version)
+        end
+
+        def os_dependencies
+          %w(build-essential openssl libreadline6
+             libreadline6-dev zlib1g zlib1g-dev libssl-dev
+             libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3
+             libxml2-dev libxslt1-dev autoconf libc6-dev
+             libncurses5-dev)
+        end
+
+        def version
+          @options[:version]
+        end
+      end
+    end
+  end
+end

data/lib/vito/recipes/ruby/paths.rb

@@ -0,0 +1,19 @@
+module Vito
+  module Recipes
+    module Ruby
+      class Paths
+        def initialize(recipe)
+          @recipe = recipe
+        end
+
+        def ruby_path
+          @path ||= recipe.query("rbenv which ruby").result.gsub(/\n/, "")
+        end
+
+        private
+
+        attr_reader :recipe
+      end
+    end
+  end
+end

data/lib/vito/tasks/vagrant_bootstrap.rb

@@ -0,0 +1,49 @@
+module Vito
+  module Tasks
+    class VagrantBootstrap
+      def initialize(os_name)
+        @os_name = os_name
+      end
+
+      def install
+        puts "=> Initializing #{os_name} box called #{os_name}_test_box into: #{box_location(os_name)}"
+        pwd = Dir.pwd
+        Dir.chdir("spec/vagrant_boxes/#{os_name}")
+
+        puts "Attempting to download and prepare the box..."
+        system "vagrant up && vagrant halt"
+        puts "Attempting to take snapshot of clean box..."
+
+        install_snapshot_plugin
+        system "vagrant snapshot take #{snapshot_name}" unless snapshot_exist?
+
+        puts "Done.\n"
+        Dir.chdir(pwd)
+      end
+
+      private
+
+      attr_reader :os_name
+
+      def install_snapshot_plugin
+        snapshot_plugin_name = "vagrant-vbox-snapshot"
+        unless system("vagrant plugin list|grep #{snapshot_plugin_name} &> /dev/null && echo 1")
+          system("vagrant plugin install vagrant-vbox-snapshot")
+        end
+      end
+
+      def snapshot_exist?
+        `vagrant snapshot list|grep #{snapshot_name} &> /dev/null && echo 1`
+        $?.success?
+      end
+
+      def snapshot_name
+        "#{os_name}_initial_box"
+      end
+
+      def box_location(os)
+        "spec/vagrant_boxes/#{os}"
+      end
+    end
+  end
+end

data/lib/vito/tests/vagrant_test_box.rb

@@ -0,0 +1,44 @@
+module Vito
+  module Tests
+    class VagrantTestBox
+      BOXES_PATH = "spec/vagrant_boxes/"
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_s
+      end
+
+      def ssh_port
+        grep_result = `grep "network :forwarded_port, guest: 22, host" #{vagrantfile_path}`
+        grep_result.match(/host: ([0-9]{4})/)[1]
+      end
+
+      def path
+        "#{BOXES_PATH}#{name}"
+      end
+
+      def initial_snapshot_name
+        "#{name}_initial_box"
+      end
+
+      def self.boxes(*boxes)
+        vagrant_boxes = []
+        if boxes.size > 0
+          vagrant_boxes = boxes
+        else
+          Dir["#{BOXES_PATH}*"].each do |box|
+            vagrant_boxes << File.basename(box) if File.directory?(box)
+          end
+        end
+        vagrant_boxes.map { |box| new(box) }
+      end
+
+      private
+
+      def vagrantfile_path
+        "#{path}/Vagrantfile"
+      end
+    end
+  end
+end

data/lib/vito/utils/program_version.rb

@@ -6,8 +6,8 @@ module Vito
         @connection = connection
       end
 
-      def matches?(version)
-        version = version.gsub(/-/, "(.*){,1}")
+      def matches?(version = nil)
+        version = version.to_s.gsub(/-/, "(.*){,1}")
         if output.success?
           return output.result =~ /#{version}/
         end

data/lib/vito/version.rb

@@ -1,3 +1,3 @@
 module Vito
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/acceptance/recipes/apache_acceptance_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe "Apache recipe" do
+  Vito::Tests::VagrantTestBox.boxes(:ubuntu10, :ubuntu12).each do |box|
+    it "tests on #{box.name}" do
+      setup_vagrant(box)
+
+      assert_installation(box, "git --version").should be_false
+
+      Vito::DslFile.new.run do
+        server do
+          connection :ssh, command: "ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p#{box.ssh_port}", verbose: true
+          install :apache do
+            with :passenger
+            vhosts with: :ssl, path: "/var/projects/someapp/current/public"
+          end
+        end
+      end
+
+      assert_installation(box, "git --version").should be_true
+      assert_installation(box, "gem list|grep passenger").should be_true
+      assert_installation(box, "apache2 -v").should be_true
+    end
+  end
+end

data/spec/acceptance/recipes/git_acceptance_spec.rb

@@ -1,20 +1,20 @@
 require "spec_helper"
 
 describe "Git recipe" do
-  before do
-    setup_vagrant
-  end
+  Vito::Tests::VagrantTestBox.boxes(:ubuntu10, :ubuntu12).each do |box|
+    it "tests on #{box.name}" do
+      setup_vagrant(box)
 
-  it "installs Git" do
-    assert_installation("git --version").should be_false
+      assert_installation(box, "git --version").should be_false
 
-    Vito::DslFile.new.run do
-      server do
-        connection :ssh, command: 'ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p2222', silent: true
-        install :git
+      Vito::DslFile.new.run do
+        server do
+          connection :ssh, command: "ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p#{box.ssh_port}", verbose: true
+          install :git
+        end
       end
-    end
 
-    assert_installation("git --version").should be_true
+      assert_installation(box, "git --version").should be_true
+    end
   end
 end

data/spec/acceptance/recipes/postgres_acceptance_spec.rb

@@ -1,20 +1,20 @@
 require "spec_helper"
 
 describe "Postgres recipe" do
-  before do
-    setup_vagrant
-  end
+  Vito::Tests::VagrantTestBox.boxes(:ubuntu10, :ubuntu12).each do |box|
+    it "tests on #{box.name}" do
+      setup_vagrant(box)
 
-  it "installs Postgres" do
-    assert_installation("psql --version").should be_false
+      assert_installation(box, "psql --version").should be_false
 
-    Vito::DslFile.new.run do
-      server do
-        connection :ssh, command: 'ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p2222', silent: true
-        install :postgres
+      Vito::DslFile.new.run do
+        server do
+          connection :ssh, command: "ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p#{box.ssh_port}", verbose: true
+          install :postgres, username: 'sebasoga', password: 'kicks_ass'
+        end
       end
-    end
 
-    assert_installation("psql --version").should be_true
+      assert_installation(box, "psql --version").should be_true
+    end
   end
 end

data/spec/acceptance/recipes/rbenv_acceptance_spec.rb

@@ -1,22 +1,22 @@
 require "spec_helper"
 
 describe "Rbenv recipe" do
-  before do
-    setup_vagrant
-  end
+  Vito::Tests::VagrantTestBox.boxes(:ubuntu10, :ubuntu12).each do |box|
+    it "tests on #{box.name}" do
+      setup_vagrant(box)
 
-  it "installs Git and then Rbenv" do
-    assert_installation("git --version").should be_false
-    assert_installation("rbenv --version").should be_false
+      assert_installation(box, "git --version").should be_false
+      assert_installation(box, "rbenv --version").should be_false
 
-    Vito::DslFile.new.run do
-      server do
-        connection :ssh, command: 'ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p2222', silent: true
-        install :rbenv
+      Vito::DslFile.new.run do
+        server do
+          connection :ssh, command: "ssh -i ~/.vagrant.d/insecure_private_key vagrant@localhost -p#{box.ssh_port}", verbose: true
+          install :rbenv
+        end
       end
-    end
 
-    assert_installation("git --version").should be_true
-    assert_installation("rbenv --version").should be_true
+      assert_installation(box, "git --version").should be_true
+      assert_installation(box, "rbenv --version").should be_true
+    end
   end
 end