vito 0.0.4 → 0.0.5

data/lib/vito/dsl/server.rb

@@ -1,7 +1,7 @@
 module Vito
   module Dsl
     class Server
-      def initialize(args = nil)
+      def initialize(args = [])
         @args = args
       end
 
@@ -9,8 +9,8 @@ module Vito
         @connection ||= Vito::Connection.new(type, options)
       end
 
-      def install(name, options = {})
-        Vito::Dsl::Installation.new(name, options, @connection).install
+      def install(name, options = {}, &block)
+        Vito::Dsl::Installation.new(name, options, @connection).install(&block)
       end
     end
   end

data/lib/vito/dsl_file.rb

@@ -1,24 +1,30 @@
 module Vito
   class DslFile
-    def initialize(argv = nil)
-      @argv = argv
+    def initialize(command_line = nil)
+      @command_line = command_line
     end
 
-    def run(code_string = nil, &block)
+    def run(string = nil, &block)
       if block_given?
         instance_eval(&block)
       else
-        instance_eval(code_string)
+        string ||= vito_file
+        instance_eval(string)
       end
     end
 
     private
 
-    attr_reader :options
+    attr_reader :command_line
 
     # called by the vito.rb file
     def server(*args, &block)
       Vito::Dsl::Server.new(args).instance_eval(&block)
     end
+
+    def vito_file
+      file = command_line.options.file || "vito.rb"
+      File.open(file).read
+    end
   end
 end

data/lib/vito/operating_systems/ubuntu_10.rb

@@ -8,6 +8,10 @@ module Vito
         @connection = connection
       end
 
+      def service(service, command)
+        @connection.run("sudo /etc/init.d/#{service} #{command}")
+      end
+
       def is?(name, version = nil)
         version = VERSION unless version
         name == NAME && version.to_s == VERSION

data/lib/vito/output.rb

@@ -12,7 +12,9 @@ module Vito
 
     def result
       if success?
-        @result ||= @stdout.read
+        @result ||= @stdout
+          .read
+          .gsub(/(\n|\s){1,}\Z/, "")
       else
         @result ||= @stderr.read
       end

data/lib/vito/recipe.rb

@@ -5,10 +5,35 @@ module Vito
     def initialize(options, connection)
       @options = options
       @connection = connection
+      @with = {}
     end
 
-    def run
-      raise "#{self.class.name} recipe needs to define a #run method"
+    def method_missing(name, args = {})
+      if with?(name.to_sym)
+        @with[name.to_sym]
+      else
+        raise "#{self.class.name} recipe needs to define a ##{name} method"
+      end
+    end
+
+    def with(name, args = {})
+      @with[name.to_sym] = args
+    end
+
+    def with?(name)
+      @with.keys.include?(name.to_sym)
+    end
+
+    def install
+      raise "#{self.class.name} recipe needs to define a #install method"
+    end
+
+    def remove
+      raise "#{self.class.name} recipe needs to define a #remove method"
+    end
+
+    def update
+      raise "#{self.class.name} recipe needs to define a #update method"
     end
 
     def depends_on_recipe(recipe, options = {})
@@ -34,9 +59,9 @@ module Vito
       @os ||= Vito::OperatingSystem.new(@connection).os
     end
 
-    def install_os_dependencies
+    def install_os_dependencies(os_dependencies = nil)
       os.update_packages
-      os.install_dependencies(os_dependencies) if self.respond_to?(:os_dependencies)
+      os.install_dependencies(os_dependencies) if os_dependencies
     end
   end
 end

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

@@ -0,0 +1,155 @@
+module Vito
+  module Recipes
+    module Apache
+      class Install < Vito::Recipe
+        APACHE_HOMEDIR = "/etc/apache2"
+
+        def initialize(options, connection)
+          @vhosts = {}
+          super
+        end
+
+        def install
+          if installed?
+            Vito::Log.write "Apache2 already installed."
+          else
+            Vito::Log.write "Installing Apache2"
+            install_apache
+          end
+        end
+
+        # Used in the Apache block
+        def vhosts(options = {})
+          @vhosts[:rails_env]  = options[:rails_env]  || "production"
+          @vhosts[:servername] = options[:servername] || "www.example.com"
+
+          @vhosts[:ports] = options[:ports] || [80]
+          @vhosts[:ports] << 443 if Array(options[:with]).include?(:ssl)
+
+          @vhosts[:path] = options[:path]
+
+          raise InvalidApacheVhosts, "VHosts' app path not specified" unless @vhosts[:path]
+          raise InvalidApacheVhosts, "VHosts' app port not specified" unless @vhosts[:ports]
+        end
+
+        private
+
+        def installed?
+          false
+        end
+
+        def install_apache
+
+          # OS dependency
+          #
+          install_os_dependencies(os_dependencies)
+
+          # Install Apache
+          #
+          run_command "sudo apt-get install -y apache2 apache2-mpm-prefork apache2-prefork-dev"
+
+          # Install passenger
+          if with?(:passenger)
+            depends_on_recipe(:passenger, {server: :apache}.merge(passenger))
+          end
+
+          # CONFIGURES APACHE
+          #
+          # VHOSTS
+          #
+          unless @vhosts.empty?
+            Vito::Log.write("Setting up Apache's VHosts")
+
+            #
+            # For VHosts, create a file in /etc/apache2/sites-available/vito_site
+            #
+            # TODO: we shouldn't use Rails unless Passenger is specified
+            vhosts_template_file = if rails?
+                                     "vito_rails_site"
+                                   else
+                                     "vito_site"
+                                   end
+            created_vhosts = []
+
+            @vhosts[:ports].each do |port|
+              vhosts_file = "#{vhosts_template_file}_#{port}"
+
+              if site_already_enabled?(vhosts_file)
+                Vito::Log.write("#{vhosts_file} Apache site already defined.")
+                next
+              end
+              # Disable the old 000-default site
+              #
+              run_command "sudo a2dissite 000-default"
+
+
+              # Downloads template file
+              command = []
+              command << "cd #{APACHE_HOMEDIR}/sites-available/"
+              command << "sudo curl https://raw.github.com/kurko/vito/master/templates/apache2/#{vhosts_template_file} -O"
+              command << "sudo mv #{vhosts_template_file} #{vhosts_file}"
+              run_command command.join(" && ")
+
+              path = @vhosts[:path].gsub(/\//, '\/')
+              command = []
+              command << "cd #{APACHE_HOMEDIR}/sites-available/"
+              command << "sudo sed -i 's/{{VITO_PORT}}/#{port.to_i}/' #{vhosts_file}"
+              command << "sudo sed -i 's/{{VITO_SERVERNAME}}/#{@vhosts[:servername].gsub(/\//, "\/")}/' #{vhosts_file}"
+
+
+              # Rails specific
+              command << "sudo sed -i 's/{{VITO_RAILS_PUBLIC_PATH}}/#{path}/g' #{vhosts_file}"
+              command << "sudo sed -i 's/{{VITO_RAILS_ENV}}/#{@vhosts[:rails_env].gsub(/\//, "\/")}/' #{vhosts_file}"
+
+              # non-Rails
+              command << "sudo sed -i 's/{{VITO_SITE_PATH}}/#{path}/g' #{vhosts_file}"
+
+              run_command command.join(" && ")
+
+              created_vhosts << vhosts_file
+            end
+
+            # Replace the paths with whatever is passed in the vito.rb. Then create
+            # the path. Let's say it's /var/projects/, run:
+            #
+            # Considering the user 'deploy' and the group 'admin'
+            #
+            run_command "[ -d #{@vhosts[:path]} ] || sudo mkdir -p #{@vhosts[:path]}"
+            run_command "sudo chown \\$USER:admin #{@vhosts[:path]}"
+
+            Vito::Log.write("Activating Apache's VHosts")
+
+            command = []
+            created_vhosts.each do |file|
+              command << "sudo a2ensite #{file}"
+            end
+
+            if command.empty?
+              Vito::Log.write("*** No files to activate? ***")
+            else
+              run_command(command.join(" && "))
+            end
+          end
+
+          # Then restart apache
+          #
+          os.service(:apache2, :restart)
+
+        end
+
+        def os_dependencies
+          %w(libcurl4-openssl-dev curl)
+        end
+
+        def rails?
+          with?(:passenger)
+        end
+
+        def site_already_enabled?(site)
+          # TODO: apachectl is Ubuntu specific
+          query("sudo apachectl -S|grep site").result.match(/#{site}/)
+        end
+      end
+    end
+  end
+end

data/lib/vito/recipes/apache/service.rb

@@ -0,0 +1,20 @@
+module Vito
+  module Recipes
+    module Apache
+      class Service
+        def initialize(recipe)
+          @recipe = recipe
+        end
+
+        def restart
+
+
+        end
+
+        private
+
+        attr_reader :recipe
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Vito
+  module Recipes
+    module Git
+      class Install < Vito::Recipe
+        def install
+          if git_installed?
+            Vito::Log.write "Git is already installed."
+          else
+            Vito::Log.write "Installing Git's OS dependencies"
+            install_os_dependencies(os_dependencies)
+            Vito::Log.write "Installing Git itself"
+            install_git
+          end
+        end
+
+        private
+
+        def git_installed?
+          query("git --version").success?
+        end
+
+        def install_git
+          string = []
+          string << "sudo apt-get install -y git-core"
+          string << "git --version"
+          run_command(string.join(" && "))
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Vito
+  module Recipes
+    module Passenger
+      class Install < Vito::Recipe
+        class InvalidApacheVhosts < StandardError; end
+
+        def install
+          if installed?
+            Vito::Log.write "Passenger already installed."
+          else
+            Vito::Log.write "Installing Passenger"
+            depends_on_recipe(:ruby, dependent: "Passenger")
+
+            if @options[:server] == :apache
+              install_passenger_with_apache2
+            end
+          end
+        end
+
+        private
+
+        def installed?
+          # TODO: apachectl is Ubuntu specific
+          query("sudo apachectl -M|grep passenger").result.match(/passenger_module/)
+        end
+
+        def install_passenger_with_apache2
+
+          run_command "gem install passenger && rbenv rehash"
+          run_command "passenger-install-apache2-module --auto"
+
+          paths = Paths.new(self)
+          mod_passenger   = "LoadModule passenger_module #{paths.mod_passenger(:apache)}"
+          passenger_path  = "PassengerRoot #{paths.passenger_path}"
+
+          ruby_paths      = Vito::Recipes::Ruby::Paths.new(self)
+          ruby_path       = "PassengerDefaultRuby #{ruby_paths.ruby_path}"
+
+          # Creates /etc/apache2/mods-available/passenger.load
+          #
+          passenger_load_file = "/etc/apache2/mods-available/passenger.load"
+
+          query "sudo rm #{passenger_load_file}"
+          command = ["sudo touch #{passenger_load_file}"]
+          command << "sudo echo #{mod_passenger} " + \
+                     "| cat - #{passenger_load_file} > ~/vitotemp"
+          command << "sudo mv ~/vitotemp #{passenger_load_file}"
+
+          run_command command.join(" && ")
+
+          query "rm ~/vitofile"
+
+          # Creates /etc/apache2/mods-available/passenger.conf
+          #
+          passenger_conf_file = "/etc/apache2/mods-available/passenger.conf"
+
+          query "sudo rm #{passenger_conf_file}"
+          command = ["sudo touch #{passenger_conf_file}"]
+          command << "sudo echo #{passenger_path} " + \
+                     "| cat - #{passenger_conf_file} > ~/vitotemp"
+          command << "sudo mv ~/vitotemp #{passenger_conf_file}"
+          command << "sudo echo #{ruby_path} " + \
+                     "| cat - #{passenger_conf_file} > ~/vitotemp"
+          command << "sudo mv ~/vitotemp #{passenger_conf_file}"
+
+          run_command command.join(" && ")
+
+          query "rm ~/vitofile"
+
+          # Then active the module
+          #
+          run_command "sudo a2enmod passenger"
+          os.service(:apache2, :restart)
+
+        end
+
+        def os_dependencies
+          %w(build-essential libcurl4-openssl-dev curl)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Vito
+  module Recipes
+    module Passenger
+      class Paths
+        def initialize(recipe)
+          @recipe = recipe
+        end
+
+        def passenger_path
+          @passenger_path ||= recipe.query("gem contents passenger|grep gemspec")
+            .result
+            .gsub(/\n/, "")
+            .gsub(/\/passenger\.gemspec/, "")
+        end
+
+        def mod_passenger(server = :apache)
+          server = "apache2" if server == :apache
+          "#{passenger_path}/buildout/#{server}/mod_passenger.so"
+        end
+
+        private
+
+        attr_reader :recipe
+      end
+    end
+  end
+end