hercules 0.1.1

data/hercules.gemspec

@@ -0,0 +1,120 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{hercules}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Diogo Biazus"]
+  s.date = %q{2010-10-14}
+  s.default_executable = %q{hercules}
+  s.description = %q{Very simple deployment tool. It was made to deploy rails applications using github, bundler.}
+  s.email = %q{diogob@gmail.com}
+  s.executables = ["hercules"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bin/hercules",
+     "hdi/README.md",
+     "hdi/config.rb",
+     "hdi/site/index.html",
+     "hdi/site/stylesheets/style.css",
+     "hdi/src/configuration.rb",
+     "hdi/src/layouts/application.haml",
+     "hdi/src/pages/_hdi.haml",
+     "hdi/src/pages/_header.haml",
+     "hdi/src/pages/_jquery.haml",
+     "hdi/src/pages/index.haml",
+     "hdi/src/stylesheets/style.sass",
+     "hercules.gemspec",
+     "lib/command_runner.rb",
+     "lib/config.rb",
+     "lib/deployer.rb",
+     "lib/git_handler.rb",
+     "lib/hercules.rb",
+     "lib/http_handler.rb",
+     "lib/request_handler.rb",
+     "tests/command_runner_test.rb",
+     "tests/config_test.rb",
+     "tests/fixtures/Gemfile",
+     "tests/fixtures/Gemfile.lock",
+     "tests/fixtures/Gemfile.with_git_gem",
+     "tests/fixtures/Gemfile.with_git_gem.lock",
+     "tests/fixtures/bogus_config.yml",
+     "tests/fixtures/bogus_deployer.rb",
+     "tests/fixtures/config.yml",
+     "tests/fixtures/config_empty.yml",
+     "tests/fixtures/config_empty_branches.yml",
+     "tests/fixtures/config_empty_projects.yml",
+     "tests/fixtures/config_global.yml",
+     "tests/fixtures/config_partial_1.yml",
+     "tests/fixtures/config_partial_2.yml",
+     "tests/fixtures/config_partial_3.yml",
+     "tests/fixtures/deployer_branch.rb",
+     "tests/fixtures/deployer_exception.rb",
+     "tests/fixtures/deployer_false.rb",
+     "tests/fixtures/deployer_path.rb",
+     "tests/fixtures/deployer_true.rb",
+     "tests/fixtures/deployer_undefined_variable.rb",
+     "tests/fixtures/startup_checkout_config.yml",
+     "tests/fixtures/startup_checkout_error_config.yml",
+     "tests/git_handler_test.rb",
+     "tests/git_setup.rb",
+     "tests/hercules_test.rb",
+     "tests/http_handler_test.rb",
+     "tests/request_handler_test.rb",
+     "tests/startup.rb"
+  ]
+  s.homepage = %q{http://github.com/diogob/hercules}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Simple deploy solution for ruby applications (using github+bundler).}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, ["= 0.12.10"])
+      s.add_runtime_dependency(%q<eventmachine_httpserver>, ["= 0.2.0"])
+      s.add_runtime_dependency(%q<git>, ["= 1.2.5"])
+      s.add_runtime_dependency(%q<json>, ["= 1.4.6"])
+      s.add_runtime_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<haml>, ["= 3.0.18"])
+      s.add_development_dependency(%q<compass>, ["= 0.10.5"])
+      s.add_development_dependency(%q<staticmatic>, ["= 0.10.8"])
+    else
+      s.add_dependency(%q<eventmachine>, ["= 0.12.10"])
+      s.add_dependency(%q<eventmachine_httpserver>, ["= 0.2.0"])
+      s.add_dependency(%q<git>, ["= 1.2.5"])
+      s.add_dependency(%q<json>, ["= 1.4.6"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<haml>, ["= 3.0.18"])
+      s.add_dependency(%q<compass>, ["= 0.10.5"])
+      s.add_dependency(%q<staticmatic>, ["= 0.10.8"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, ["= 0.12.10"])
+    s.add_dependency(%q<eventmachine_httpserver>, ["= 0.2.0"])
+    s.add_dependency(%q<git>, ["= 1.2.5"])
+    s.add_dependency(%q<json>, ["= 1.4.6"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<haml>, ["= 3.0.18"])
+    s.add_dependency(%q<compass>, ["= 0.10.5"])
+    s.add_dependency(%q<staticmatic>, ["= 0.10.8"])
+  end
+end
+

data/lib/command_runner.rb

@@ -0,0 +1,73 @@
+module Hercules
+  # Class to run the shell commands and store their output.
+  # Yes, this class was kindly provided by Integrity.
+  # A very nice CI solution built with ruby: http://github.com/integrity/integrity
+  # I've made some modifications to store all the commands ran in an output log.
+  class CommandRunner
+    attr_reader :output
+
+    class Error < StandardError # :nodoc:
+    end
+
+    Result = Struct.new(:success, :output)
+
+    # We need to inform the logger object to initialize a CommandRunner
+    def initialize(logger)
+      @logger = logger
+      @output = ""
+    end
+
+    # This method will store the output of every command ran by this
+    # instance on a file.
+    # * path is the file path where we want to store the log.
+    def store_output path
+      File.open(path, 'a+'){|f| f.write @output }
+    end
+
+    # Change the working directory.
+    # * dir is the new working directory.
+    def cd(dir)
+      @dir = dir
+      self
+    end
+
+    # Run a command using IO.popen, append output to @output
+    # * command is the string containing the shell command that will be run.
+    def run(command)
+      cmd = normalize(command)
+
+      @logger.debug(cmd)
+
+      output = ""
+      IO.popen(cmd, "r") { |io| output = io.read }
+
+      @output += output
+      Result.new($?.success?, output.chomp)
+    end
+
+    # Run a command using IO.popen, append output to @output
+    # But we raise an error in case the command is not successful.
+    # * command is the string containing the shell command that will be run.
+    def run!(command)
+      result = run(command)
+
+      unless result.success
+        @logger.error(result.output.inspect)
+        raise Error, "Failed to run '#{command}'"
+      end
+      @logger.debug(result.output.inspect)
+
+      result
+    end
+
+    # We change the working directory befor executing anything.
+    # * cmd is the command to be executed.
+    def normalize(cmd)
+      if @dir
+        "(cd #{@dir} && #{cmd} 2>&1)"
+      else
+        "(#{cmd} 2>&1)"
+      end
+    end
+  end
+end

data/lib/config.rb

@@ -0,0 +1,82 @@
+# coding: utf-8
+require 'yaml'
+
+module Hercules
+  class InvalidConfig < Exception; end
+  class Config
+    def initialize(path)
+      @config = nil
+      @path = path
+      reload
+      validate
+    end
+
+    def reload
+      @config = YAML.load_file(@path)
+    end
+
+    def [](k)
+      @config[k]
+    end
+
+    def each
+      @config.each do |k,v|
+        yield(k,v)
+      end
+    end
+
+    def include?(k)
+      @config.include?(k)
+    end
+
+    def host
+      @config['host'] || "0.0.0.0"
+    end
+
+    def port
+      @config['port'] || 8080
+    end
+
+    def projects
+      p = {}
+      @config.each do |k,v| 
+        p[k] = v unless self.class.global_attributes.include?(k)
+      end
+      p
+    end
+
+    def self.global_attributes
+      ['host', 'port']
+    end
+
+    def self.project_attributes
+      ['target_directory', 'repository', 'token']
+    end
+
+    def self.branch_attributes
+      ['checkout_on_startup', 'checkouts_to_keep']
+    end
+
+    def branches
+      r = {}
+      projects.each do |k,v|
+        r[k] = v.keys.find_all{|e| e unless self.class.project_attributes.include?(e)}
+      end
+      r
+    end
+
+    private
+    def validate
+      # We need to test projects.empty? to cover cases where the config has only global attributes set.
+      raise InvalidConfig.new("Empty config file.") if @config.nil? or projects.empty?
+      projects.each do |k,v|
+        raise InvalidConfig.new("Config file error. #{k} expects a hash of options but got #{v}") unless v.is_a?(Hash)
+        # Every project attribute is mandatory
+        raise InvalidConfig.new("Config file lacks some project attribute, every project must have #{self.class.project_attributes.inspect}") unless !v.nil? and self.class.project_attributes & v.keys == self.class.project_attributes
+        branches[k].each do |branch|
+          raise InvalidConfig.new("Branch #{branch} in project #{k} lacks some branch attribute, every branch must have #{self.class.branch_attributes.inspect}") unless !@config[k][branch].nil? and self.class.branch_attributes & @config[k][branch].keys == self.class.branch_attributes
+        end
+      end
+    end
+  end
+end

data/lib/deployer.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+require File.dirname(__FILE__) + '/git_handler'
+require File.dirname(__FILE__) + '/command_runner'
+require 'bundler'
+
+module Hercules
+  # The Deployer is responsible for clonning the repository,
+  # copying the code, and calling the deploy triggers.
+  class Deployer
+    # * logger is the object of Logger class that will log the deploy actions.
+    # * config is the hash configuration of the project we want to deploy. 
+    # Will be a subtree of the configuration YAML
+    # * branch is the name of the branch we are deploying.
+    def initialize(logger, config, branch)
+      @log = logger
+      @config = config
+      @branch = branch
+      @cmd = CommandRunner.new(@log)
+      @trigger_class = nil
+    end
+
+
+    # This method will do the deploy: git clone, run bundle install and call the triggers callbacks.
+    def deploy
+      git = GitHandler.new @config
+      git.deploy_branch(@branch) do |dir, branch|
+        Bundler.with_clean_env do
+          @cmd.cd(dir)
+          bundle_path = "#{dir}/../../../bundles/#{@branch}"
+          FileUtils.mkdir_p(bundle_path)
+          FileUtils.mkdir_p("#{dir}/vendor")
+          FileUtils.ln_s(bundle_path, "#{dir}/vendor/bundle", :force => true)
+          @cmd.run!("bundle install --deployment")
+          @trigger_class = look_for_triggers(dir)
+          before_trigger(dir) if has_before_trigger?
+        end
+      end
+      @log.warn "Branch #{@branch} deployed"
+      dir = "#{git.branches_path}/#{@branch}"
+      Bundler.with_clean_env do
+        after_trigger(dir) if has_after_trigger?
+      end
+    ensure
+      # Now we must store the deploy output
+      output_dir = "#{@config['target_directory']}/logs/#{@branch}/"
+      FileUtils.mkdir_p output_dir
+      @cmd.store_output "#{output_dir}/#{git.last_commit}.log"
+    end
+
+    private
+    # This method will execute the before trigger
+    # * dir is the working directory for trigger execution.
+    def before_trigger(dir)
+      @log.debug "Executing before_trigger"
+      Dir.chdir(dir) do
+        raise "before_deploy returned false." unless @trigger_class.before_deploy({:path => dir, :branch => @branch, :shell => @cmd})
+      end
+    end
+
+    # This method will execute the after trigger
+    # * dir is the working directory for trigger execution.
+    def after_trigger(dir)
+      @log.debug "Executing after_trigger"
+      Dir.chdir(dir) do
+        @trigger_class.after_deploy({:path => dir, :branch => @branch, :shell => @cmd})
+      end
+      @log.info "After deploy script executed"
+    end
+
+    # Check if the project has a before trigger
+    def has_before_trigger?; (!@trigger_class.nil? and @trigger_class.methods.include?("before_deploy"))  ;end
+    # Check if the project has an after trigger
+    def has_after_trigger?;  (!@trigger_class.nil? and @trigger_class.methods.include?("after_deploy"))  ;end
+
+    # Look for triggers in <dir>/lib/hercules_triggers.rb
+    # The triggers should be inside a Hercules module in the Triggers class.
+    # * dir is the root dir where we will look for the triggers.
+    def look_for_triggers(dir)
+      if File.exists? "#{dir}/lib/hercules_triggers.rb"
+        require "#{dir}/lib/hercules_triggers.rb"
+        begin
+          @log.info "Looking for trigger in #{dir}/lib/hercules_triggers.rb"
+          return ::Hercules::Triggers
+        rescue NameError => e
+          # We have to allow the use of a lib/hercules_triggers.rb unrelated to Hercules
+          if e.message =~ /uninitialized constant .*Hercules.*/
+            @log.warn "File lib/deployer.rb without Hercules::Triggers: #{e.inspect}"
+            return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/git_handler.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+require 'git'
+
+module Hercules
+  # Class that handles the git operations.
+  class GitHandler
+    attr_reader :last_commit
+    # We pass an options hash that should contain: 
+    #   {
+    #   'target_directory' => '/home/hercules/hercules.com', 
+    #   'repository' => 'git://github.com/diogob/hercules.git',
+    #   'master' => { 'checkouts_to_keep' => 2 },
+    #   }
+    def initialize(options)
+      @options = options
+      @last_commit = nil
+    end
+
+    # Will export the branch to @options['target_directory']/checkouts/
+    # And link it in @options['target_directory']/branches/
+    # It uses the commit's sha1 as directory name.
+    # * branch is the branch to be deployed, defaults to master.
+    def export_branch(branch = 'master')
+      tmp_dir = "#{@options['target_directory']}/checkouts/#{branch}/.tmp_#{Time.now.strftime("%Y%m%d%H%M%S")}"
+      begin
+        repo = Git.clone(@options['repository'], tmp_dir, {:depth => 1})
+        repo.checkout("origin/#{branch}")
+      rescue Exception => e
+        FileUtils.rm_rf repo.dir.to_s unless repo.nil?
+        raise "Error while cloning #{@options['repository']}: #{e}"
+      end
+      @last_commit = repo.gcommit('HEAD').sha
+      commit_dir = "#{@options['target_directory']}/checkouts/#{branch}/#{@last_commit}"
+      Dir.chdir(repo.dir.to_s) { FileUtils.rm_r '.git' }
+      FileUtils.mv repo.dir.to_s, commit_dir
+      commit_dir
+    end
+
+    # Returns the path to branches' link directory.
+    def branches_path
+      "#{@options['target_directory']}/branches"
+    end
+
+    # Creates and then returns the path to branches' link directory.
+    def create_branches_dir
+      FileUtils.mkdir_p branches_path
+      branches_path
+    end
+
+    # Deploys the branch.
+    # This means it exports it and removes old checkouts upon a successful completion.
+    # It also creates the links' directory and links the checkout.
+    # * branch is the branch name to be deployed. Defaults to master.
+    def deploy_branch(branch = 'master')
+      checkout = export_branch(branch)
+      #@todo here we must call the before deploy script
+      yield(checkout, branch) if block_given?
+      remove_old_checkouts branch
+      FileUtils.rm_f("#{create_branches_dir}/#{branch}")
+      FileUtils.ln_sf(checkout, "#{branches_path}/#{branch}")
+      self
+    end
+
+    private
+    def remove_old_checkouts(branch) # :nodoc:
+      max = @options[branch]['checkouts_to_keep']
+      dir = "#{@options['target_directory']}/checkouts/#{branch}"
+      if (Dir.glob("#{dir}/*").size) > max
+        # Here we must delete the oldest checkout
+        checkout_to_delete = Dir.glob("#{dir}/*").sort{|a,b| File.new(a).mtime.strftime("%Y%m%d%H%M%S") <=> File.new(b).mtime.strftime("%Y%m%d%H%M%S") }.shift
+        FileUtils.rm_r "#{checkout_to_delete}"
+        # Remove log file if it exists
+        # To achieve consistency we must remove the log when and only when we remove the checkout
+        FileUtils.rm_f "#{@options['target_directory']}/logs/#{checkout_to_delete.split('/').pop}.log"
+      end
+    end
+  end
+end