yad 0.0.4

data/lib/ext/string.rb

@@ -0,0 +1,6 @@
+class String
+  # Turns a lower_case_underscored_name into an UpperCaseCamelCaseName
+  def classify
+    self.gsub("_", " ").gsub(/\b('?[a-z])/) { $1.capitalize }.gsub(" ", "")
+  end
+end

data/lib/yad.rb

@@ -0,0 +1,46 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'rake'
+require 'open4'
+require 'yaml'
+
+require "ext/rake/remote_task"
+require "ext/rake"
+require "ext/string"
+
+require "yad/core"
+Yad::Core.define_tasks
+
+require "yad/web/apache"
+
+require "yad/maintenance/shared_system"
+
+require "yad/app/passenger"
+
+require "yad/framework/rails"
+
+require "yad/db/rails"
+
+require "yad/scm/git"
+
+module Yad
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  
+  VERSION = if File.exist?(File.join(PATH, 'VERSION.yml'))
+              config = YAML.load_file(File.join(PATH, 'VERSION.yml'))
+              "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+            else
+              "0.0.0"
+            end
+  # :startdoc:
+
+  # Returns the version string for the library.
+  def self.version
+    VERSION
+  end
+  
+end

data/lib/yad/app/passenger.rb

@@ -0,0 +1,28 @@
+module Yad
+  module App
+    class Passenger
+      def self.build_start_command(release_directory)
+        "touch #{release_directory}/tmp/restart.txt"
+      end
+      
+       def self.define_tasks
+         return if @tasks_already_defined
+         @tasks_already_defined = true
+         namespace :yad do
+           namespace :app do
+
+             desc "Starts the application server"
+             remote_task :start, :roles => :app do
+               cmd = Yad::App::Passenger.build_start_command(current_path)
+               run(cmd)
+               puts("Passenger app restarted on #{target_host}")
+             end
+
+           end
+         end
+       end
+       
+    end # class Passenger
+    
+  end # module App
+end # module Yad

data/lib/yad/core.rb

@@ -0,0 +1,199 @@
+module Yad
+  class Core
+    def self.build_setup_command(deployment_directory, options = {})
+      default_options = { :umask => '02',
+        :shared_subdirectories => [] }
+      
+      options = default_options.merge(options)
+      dirs = [File.join(deployment_directory, "releases"),
+              File.join(deployment_directory, "scm"),
+              File.join(deployment_directory, "shared"),
+              File.join(deployment_directory, "shared", "config")
+             ]
+      options[:shared_subdirectories].each do |subdirectory|
+        dirs << File.join(deployment_directory, "shared", subdirectory) unless subdirectory == 'config'
+      end
+      "umask #{options[:umask]} && mkdir -p #{dirs.join(' ')}"
+    end
+
+    def self.build_update_source_code_command(checkout_command, export_command, new_release_directory)
+      [checkout_command,
+       export_command,
+       "chmod -R g+w #{new_release_directory}"
+      ].join(" && ")
+    end
+    
+    def self.build_remove_directory_command(directory_to_remove)
+      "rm -rf #{directory_to_remove}"
+    end
+
+    def self.build_files_array(delimited_file_names)
+      return [] unless delimited_file_names
+      files = delimited_file_names.split(",").map { |f| f.strip }.flatten
+      files = files.reject { |f| File.directory?(f) || File.basename(f)[0] == ?. }
+      files
+    end
+
+    def self.build_update_symlink_command(current_release_symlink, new_release_directory)
+      "rm -f #{current_release_symlink} && ln -s #{new_release_directory} #{current_release_symlink}"
+    end
+    
+    def self.build_revision_log_command(timestamp, inline_revision_identifier_command, new_release_directory, deployment_directory)
+      "echo #{timestamp} $USER #{inline_revision_identifier_command} #{File.basename(new_release_directory)} >> #{deployment_directory}/revisions.log"
+    end
+
+    def self.build_cleanup_command(max_release_count, releases_directory, all_releases)
+      if all_releases.length <= max_release_count
+        "echo keeping all releases"
+      else
+        releases_to_remove = (all_releases - all_releases.last(max_release_count)).map { |release| File.join(releases_directory, release) }.join(" ")
+        "rm -rf #{releases_to_remove}"
+      end
+    end
+
+    def self.build_rollback_command(current_release_symlink, previous_release_directory, latest_release_directory)
+      if previous_release_directory.nil? || previous_release_directory == latest_release_directory || latest_release_directory.nil?
+        "echo no previous release for rollback"
+      else
+        "rm -f #{current_release_symlink}; ln -s #{previous_release_directory} #{current_release_symlink} && rm -rf #{latest_release_directory}"
+      end
+    end
+    
+    def self.define_tasks
+      return if @tasks_already_defined
+      @tasks_already_defined = true
+      namespace :yad do
+        
+        desc "Prepares one or more servers for deployment"
+        remote_task :setup do
+          Rake::Task['yad:core:setup_deployment'].invoke
+          Rake::Task.invoke_if_defined('yad:framework:setup', :framework)
+        end
+        
+        desc "Copies files to the shared/config directory using FILES=a,b,c (e.g. rake vlad:upload_config_files FILES=config/database.yml,config/maintenance.html)"
+        remote_task :upload_config_files do
+          files = Yad::Core.build_files_array(ENV["FILES"])
+          if files.empty?
+            puts("Please specify at least one file to upload (via the FILES environment variable)")
+          else
+            files.each do |file|
+              rsync(file, "#{target_host}:#{File.join(shared_config_path, File.basename(file))}")
+            end
+            puts("uploaded #{files.inspect} to #{target_host}")
+          end
+        end
+        
+        desc "Creates the database for the application"
+        remote_task :create_db, :roles => :app do
+          Rake::Task.invoke_if_defined('yad:db:create', :db, "Please specify the database delegate via the :db variable")
+        end
+        
+        desc "Updates the application servers to the latest version"
+        remote_task :update, :roles => :app do
+          Rake::Task.invoke_if_defined('yad:scm:update', :scm)
+          Rake::Task.invoke_if_defined('yad:framework:update', :framework)
+          Rake::Task['yad:core:update_symlink'].invoke
+        end
+
+        desc "Runs migrations for the database for the application"
+        remote_task :migrate_db, :roles => :app do
+          Rake::Task.invoke_if_defined('yad:db:migrate', :db, "Please specify the database delegate via the :db variable")
+        end
+        
+        desc "Starts the application server"
+        remote_task :start_app, :roles => :app do
+          Rake::Task.invoke_if_defined('yad:app:start', :app, "Please specify the app delegate via the :app variable")
+        end
+        
+        desc "Starts the web server"
+        remote_task :start_web, :roles => :web do
+          Rake::Task.invoke_if_defined('yad:web:start', :web, "Please specify the web delegate via the :web variable")
+        end
+        
+        "Stops the web server"
+        remote_task :stop_web, :roles => :web do
+          Rake::Task.invoke_if_defined('yad:web:stop', :web, "Please specify the web delegate via the :web variable")
+        end
+        
+        desc "Stops the application server"
+        remote_task :stop_app, :roles => :app do
+          Rake::Task.invoke_if_defined('yad:app:stop', :app, "Please specify the app delegate via the :app variable")
+        end
+        
+        desc "Turns on the maintenance page for the application"
+        remote_task :turn_on_maintenance, :roles => :web do
+          Rake::Task.invoke_if_defined('yad:maintenance:turn_on', :maintenance, "Please specify the maintenance delegate via the :maintenance variable")
+        end
+        
+        desc "Turns off the maintenance page for the application"
+        remote_task :turn_off_maintenance, :roles => :web do
+          Rake::Task.invoke_if_defined('yad:maintenance:turn_off', :maintenance, "Please specify the maintenance delegate via the :maintenance variable")
+        end
+        
+        desc "Rolls back to the previous release, but DOES NOT restart the application"
+        remote_task :rollback do
+          cmd = Yad::Core.build_rollback_command(current_path, previous_release, latest_release)
+          if cmd.length == 0
+            puts("could not rollback the code because there is no previous release")
+          else
+            run(cmd)
+            puts("rolled back to #{File.basename(previous_release)} on #{target_host}")
+          end
+        end
+        
+        desc "Cleans up old releases"
+        remote_task :cleanup do
+          cmd = Yad::Core.build_cleanup_command(keep_releases, releases_path, releases)
+          run(cmd)
+          puts("old releases cleaned up on #{target_host}")
+        end
+
+        remote_task :invoke do
+          # TODO:
+        end
+        
+        namespace :core do
+
+          remote_task :setup_deployment, :roles => :app do
+            options = Rake::RemoteTask.get_options_hash(:umask, :shared_subdirectories)
+            cmd = Yad::Core.build_setup_command(deploy_to, options)
+            run(cmd)
+            puts("Yad set up on #{target_host}")
+          end
+
+          remote_task :update_symlink, :roles => :app do
+            begin
+              symlinked = false
+              cmd = Yad::Core.build_update_symlink_command(current_path, release_path)
+              run(cmd)
+              puts("'current' symlink updated on #{target_host}")
+              symlinked = true
+              scm_value = Rake::RemoteTask.fetch(:scm, false)
+              if scm_value
+                scm_class = eval("Yad::Scm::#{scm_value.to_s.classify}")
+                options = Rake::RemoteTask.get_options_hash(:revision)
+                inline_command = scm_class.build_inline_revision_identifier_command(scm_path, options)
+              else
+                inline_command = 'none'
+              end
+              cmd = Yad::Core.build_revision_log_command(Time.now.utc.strftime("%Y%m%d%H%M.%S"), inline_command, release_path, deploy_to)
+              run(cmd)
+            rescue => e
+              if releases.length > 1 && symlinked then
+                cmd = Yad::Core.build_update_symlink_command(current_path, previous_release)
+                run(cmd)
+              end
+              cmd = Yad::Core.build_remove_directory_command(release_path)
+              run(cmd)
+              raise e
+            end
+          end
+          
+        end
+
+      end
+    end
+    
+  end # class Core
+  
+end # module Yad

data/lib/yad/db/rails.rb

@@ -0,0 +1,62 @@
+module Yad
+  module Db
+    class Rails
+      def self.build_create_db_command(release_directory, options = {})
+        default_options = { :app_env  => 'production',
+          :rake_cmd => 'rake'
+        }
+        options = default_options.merge(options)
+        "cd #{release_directory}; #{options[:rake_cmd]} RAILS_ENV=#{options[:app_env]} db:create"
+      end
+
+      def self.build_migrate_db_command(release_directory, options = {})
+        default_options = { :app_env      => 'production',
+          :rake_cmd     => 'rake',
+          :migrate_args => '',
+        }
+        options = default_options.merge(options)
+        "cd #{release_directory}; #{options[:rake_cmd]} RAILS_ENV=#{options[:app_env]} db:migrate #{options[:migrate_args]}"
+      end
+
+      def self.define_tasks
+        return if @tasks_already_defined
+        @tasks_already_defined = true
+        namespace :yad do
+          namespace :db do
+
+            desc "Creates the database for the application"
+            remote_task :create, :roles => :app do
+              break unless target_host == Rake::RemoteTask.hosts_for(:app).first
+              options = Rake::RemoteTask.get_options_hash(:app_env, :rake_cmd)
+              cmd = Yad::Db::Rails.build_create_db_command(current_path, options)
+              run(cmd)
+              puts("database created")
+            end
+            
+            desc "Runs migrations on the database"
+            remote_task :migrate, :roles => :app do
+              break unless target_host == Rake::RemoteTask.hosts_for(:app).first
+              options = Rake::RemoteTask.get_options_hash(:app_env, :rake_cmd, :migrate_args)
+              target = Rake::RemoteTask.fetch(:migrate_target, false)
+              if target
+                target_directory = case target.to_sym
+                                   when :current then current_path
+                                   when :latest  then latest_release
+                                   else raise ArgumentError, "unknown migration target #{target.inspect}"
+                                   end
+              else
+                target_directory = latest_release
+              end
+              cmd = Yad::Db::Rails.build_migrate_db_command(target_directory, options)
+              run(cmd)
+              puts("database migrations completed")
+            end
+            
+          end
+        end
+      end
+      
+    end # class Rails
+    
+  end # module Db
+end # module Yad

data/lib/yad/framework/rails.rb

@@ -0,0 +1,64 @@
+module Yad
+  module Framework
+    class Rails
+      def self.build_setup_command(shared_directory, options = {})
+        default_options = { :umask => '02' }
+        options = default_options.merge(options)
+        dirs = [File.join(shared_directory, "log"),
+                File.join(shared_directory, "pids"),
+                File.join(shared_directory, "system")
+               ]
+        "umask #{options[:umask]} && mkdir -p #{dirs.join(' ')}"
+      end
+
+      def self.build_update_command(new_release_directory, shared_directory, options = {})
+        default_options = { :app_env                        => 'production',
+          :framework_update_db_config_via => 'none' }
+        options = default_options.merge(options)
+        commands = ["rm -rf #{new_release_directory}/log #{new_release_directory}/public/system #{new_release_directory}/tmp/pids",
+                    "mkdir -p #{new_release_directory}/tmp",
+                    "ln -s #{shared_directory}/log #{new_release_directory}/log",
+                    "ln -s #{shared_directory}/pids #{new_release_directory}/tmp/pids",
+                    "ln -s #{shared_directory}/system #{new_release_directory}/public/system"
+                   ]
+        
+        case options[:framework_update_db_config_via].to_sym
+        when :copy
+          commands << "cp -f #{new_release_directory}/config/database_#{options[:app_env]}.yml #{new_release_directory}/config/database.yml"  
+        when :symlink
+          commands << "ln -nfs #{shared_directory}/config/database.yml #{new_release_directory}/config/database.yml"
+        end
+        
+        commands.join(" && ")
+      end
+      
+       def self.define_tasks
+         return if @tasks_already_defined
+         @tasks_already_defined = true
+         namespace :yad do
+           namespace :framework do
+
+             desc "Performs additional setup needed for the framework"
+             remote_task :setup, :roles => :app do
+               options = Rake::RemoteTask.get_options_hash(:umask)
+               cmd = Yad::Framework::Rails.build_setup_command(shared_path, options)
+               run(cmd)
+               puts("Rails set up on #{target_host}")
+             end
+             
+             desc "Updates the framework configuration and working directories after a new release has been exported"
+             remote_task :update, :roles => :app do
+               options = Rake::RemoteTask.get_options_hash(:app_env, :framework_update_db_config_via)
+               cmd = Yad::Framework::Rails.build_update_command(release_path, shared_path, options)
+               run(cmd)
+               puts("Rails shared paths and files updated on #{target_host}")
+             end
+             
+           end
+         end
+       end
+       
+    end # class Rails
+    
+  end # module Framework
+end # module Yad

data/lib/yad/maintenance/shared_system.rb

@@ -0,0 +1,39 @@
+module Yad
+  module Maintenance
+    class SharedSystem
+      def self.build_turn_on_command(shared_directory, options = {})
+        "cp -f #{shared_directory}/config/maintenance.html #{shared_directory}/system/"
+      end
+      
+      def self.build_turn_off_command(shared_directory, options = {})
+        "rm -f #{shared_directory}/system/maintenance.html"
+      end
+      
+      def self.define_tasks
+        return if @tasks_already_defined
+        @tasks_already_defined = true
+        namespace :yad do
+          namespace :maintenance do
+            
+            desc "Turns on the maintenance page for the application"
+            remote_task :turn_on, :roles => :web do
+              cmd = Yad::Maintenance::SharedSystem.build_turn_on_command(shared_path)
+              run(cmd)
+              puts("maintenance page turned on for #{target_host}")
+            end
+
+             desc "Turns off the maintenance page for the application"
+            remote_task :turn_off, :roles => :web do
+              cmd = Yad::Maintenance::SharedSystem.build_turn_off_command(shared_path)
+              run(cmd)
+              puts("maintenance page turned off for #{target_host}")
+            end
+            
+          end
+        end
+      end
+
+    end # class Rails
+    
+  end # module Maintenance
+end # module Yad