hercules 0.1.1

data/lib/hercules.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+
+require File.dirname(__FILE__) + '/http_handler'
+require File.dirname(__FILE__) + '/config'
+
+module Hercules
+  class Hercules
+    attr_reader :options
+
+    def initialize(arguments, stdin)
+      @arguments = arguments
+      @stdin = stdin
+
+      # Set default options
+      @options = OpenStruct.new
+      @options.config_file = 'config.yml'
+      @options.verbose = false
+      @options.log_file = nil
+      @options.pid_file = 'hercules.pid'
+      @options.foreground = false
+
+      @config = nil
+      @pid_file = nil
+      @log = nil
+    end
+
+    def run
+      parse_options
+      set_logger
+      read_config
+      be_verbose if @options.verbose
+
+      # if -f is not present we fork into the background and write hercules.pid
+      @options.foreground ? process_command : daemonize
+      @log.close  
+    end
+
+
+    protected
+    def exit_gracefully
+      remove_pid
+      @log.info "Terminating hercules..." 
+      @log.close unless @log.nil? rescue nil
+      exit 0
+    end
+
+    def remove_pid
+      if !@pid_file.nil? and File.exist? @pid_file
+        @log.info "Removing pid file #{@pid_file}..." 
+        File.unlink @pid_file
+      end
+    end
+
+    def reload_config    
+      begin
+        @log.info "Reloading config file #{@options.config_file}..." 
+        @config.reload
+        @log.info "Configuration updated." 
+      rescue Exception => e      
+        @log.error "Error reading config file #{@options.config_file}: #{e.inspect}"
+      end
+    end
+
+    def read_config    
+      begin
+        @config = ::Hercules::Config.new(@options.config_file)
+      rescue Exception => e      
+        @log.fatal "Error reading config file #{@options.config_file}: #{e.inspect}"
+        exit -1
+      end
+    end
+
+    def set_logger
+      require 'logger'
+      if @options.log_file.nil?
+        @log = Logger.new(STDERR)
+      else
+        @log = Logger.new(@options.log_file, 'daily')
+      end
+      @log.level = Logger::INFO
+    end
+
+    def daemonize
+      begin
+        @pid_file = @options.pid_file 
+        pid = fork do
+          process_command
+        end
+        File.open(@pid_file, 'w+'){|f| f.write pid.to_s }
+        Process.detach(pid)
+      rescue Exception => e
+        @log.fatal "Error while daemonizing: #{e.inspect}"
+        exit
+      end
+    end
+
+    def parse_options
+      opts = OptionParser.new 
+      opts.on('-v', '--version')            { puts "hercules version #{VERSION}" ; exit 0 }
+      opts.on('-h', '--help')               { puts opts; exit 0  }
+      opts.on('-V', '--verbose')            { @options.verbose = true }  
+      opts.on('-f', '--foreground')         { @options.foreground = true }
+      opts.on('-l', '--log log_file')       { |log_file| @options.log_file = log_file }
+      opts.on('-p', '--pid pid_file')       { |pid_file| @options.pid_file = pid_file }
+      opts.on('-c', '--conf config_file')   { |conf| @options.config_file = conf }
+
+      opts.parse!(@arguments)
+    end
+
+    def startup_checkouts
+      @config.branches.each do |project,branches|
+        branches.each do |branch|
+          if @config[project][branch]['checkout_on_startup']
+            @log.info "Starting checkout of #{branch} in project #{project}..."
+            begin
+              Deployer.new(@log, @config[project], branch).deploy
+            rescue Exception => e
+              @log.error "Error in startup checkout of branch #{branch}: #{e.message}\nBacktrace:#{e.backtrace}"
+            end
+          end
+        end
+      end
+    end
+
+    def process_command
+      EventMachine::run do
+        Signal.trap("TERM"){ exit_gracefully }
+        Signal.trap("HUP"){ reload_config }
+        startup_checkouts
+        EventMachine.epoll
+        host = @config.host
+        port = @config.port
+        EventMachine::start_server(host, port, HttpHandler, {:log => @log, :config => @config})
+        @log.info "Listening on #{host}:#{port}..."
+      end
+    end
+
+    def parse_options
+      opts = OptionParser.new 
+      opts.on('-v', '--version')            { puts "Hercules version #{VERSION}" ; exit 0 }
+      opts.on('-h', '--help')               { puts opts; exit 0  }
+      opts.on('-V', '--verbose')            { @options.verbose = true }  
+      opts.on('-f', '--foreground')         { @options.foreground = true }
+      opts.on('-l', '--log log_file')       { |log_file| @options.log_file = log_file }
+      opts.on('-p', '--pid pid_file')       { |pid_file| @options.pid_file = pid_file }
+      opts.on('-c', '--conf config_file')   { |conf| @options.config_file = conf }
+      opts.parse!(@arguments)
+    end
+
+    def be_verbose
+      @log.info "Start at #{DateTime.now}"
+      @log.info "Options:\n"
+      @options.marshal_dump.each do |name, val|        
+        @log.info "  #{name} = #{val}"
+      end
+      @log.level = Logger::DEBUG
+    end
+  end
+end

data/lib/http_handler.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require 'rubygems'
+require 'eventmachine'
+require 'evma_httpserver'
+require 'json'
+require File.dirname(__FILE__) + '/request_handler'
+
+module Hercules
+  class HttpHandler < EventMachine::Connection
+    include EventMachine::HttpServer
+
+    def initialize *args
+      @config = args[0][:config]
+      @log = args[0][:log]
+    end
+
+    def process_http_request
+      begin
+        @config.reload
+        resp = EventMachine::DelegatedHttpResponse.new( self )
+        req = RequestHandler.new({:config => @config, :log => @log, :method => @http_request_method, :path => @http_path_info, :query => @http_query_string, :body => @http_post_content})
+        return send(resp, req.status, req.message)
+      rescue Exception => e
+        send(resp, 500, "Error while processing HTTP request: #{e.inspect} \nREQUEST: #{@http_request_method} #{@http_path_info}?#{@http_query_string}\n#{@http_post_content}")
+        @log.error "Backtrace: #{e.backtrace}"
+      end
+    end
+
+    def send resp, status, message
+      if status == 500
+        @log.error "#{status}: #{message}"
+      else
+        @log.info "#{status}: #{message}"
+      end
+      resp.status = status
+      resp.content = message
+      resp.send_response
+    end
+  end
+end

data/lib/request_handler.rb

@@ -0,0 +1,142 @@
+# coding: utf-8
+require 'json'
+require 'uri'
+require File.dirname(__FILE__) + '/deployer'
+
+module Hercules
+  # Class that knows how to handle deploy requests.
+  # This implementation will just parse a JSON as defined by github http hooks.
+  # In order to use other hook formats this class should be reimplemented.
+  class RequestHandler
+    # We must pass the request data (method, path, query and body).
+    # * options is a hash containing all the request data described above plus the logger and the config hash.
+    def initialize(options)
+      @method = options[:method]
+      @body = options[:body]
+      @log = options[:log]
+      @path = options[:path]
+      @config = options[:config]
+    end
+
+    # Returns the message generated as response for the request passed in the initializer.
+    # We also store the message for further queries.
+    def message
+      @result ||= process_request
+      @result[:message]
+    end
+
+    # Returns the status generated as response for the request passed in the initializer.
+    # We also store the status for further queries.
+    def status
+      @result ||= process_request
+      @result[:status]
+    end
+
+    # Returns the repository name that fired the request.
+    def repository_name
+      return payload['repository']['name'] if @method == "POST"
+      return @path.split('/')[1] if @method == "GET"
+    end
+
+    # Returns the security token that fired the request.
+    def request_token 
+      @path.split('/')[2]
+    end
+
+    # Returns true whenever the request made was a HDI request
+    def request_hdi?
+      @path.split('/')[3] == 'hdi' and @method == "GET"
+    end
+
+    # Returns the assembled HDI
+    def hdi
+      response = ""
+      css = ""
+      File.open(File.dirname(__FILE__) + "/../hdi/site/index.html", 'r'){|f| response = f.read }
+      File.open(File.dirname(__FILE__) + "/../hdi/site/stylesheets/style.css", 'r'){|f| css = f.read }
+      response.gsub(/<link href="stylesheets\/style.css" media="all" rel="stylesheet" type="text\/css">/, "<style>#{css}</style>").gsub(/##REQUEST_ADDRESS##/, @path.gsub(/\/hdi/, ""))
+    end
+
+    # Returns the url of the repository that fired the request.
+    def repository_url
+      payload['repository']['url']
+    end
+
+    # Returns the branch of the repository that fired the request.
+    def branch
+      payload['ref'].split('/').pop
+    end
+
+    private
+    def process_request
+      @method == "GET" ? process_get : process_post
+    end
+
+    def project_json
+      response = {}
+      @config.branches[repository_name].each do |k|
+        deployed = File.exist?("#{@config[repository_name]['target_directory']}/branches/#{k}")
+        response[k] = {:deployed => deployed}
+        if deployed
+          checkouts = []
+          Dir.glob("#{@config[repository_name]['target_directory']}/checkouts/#{k}/*").sort{|a,b| File.new(a).ctime.strftime("%Y%m%d%H%M%S") <=> File.new(b).ctime.strftime("%Y%m%d%H%M%S") }.reverse_each do |path|
+            output = ""
+            checkout = path.split('/').pop
+            begin
+              File.open("#{@config[repository_name]['target_directory']}/logs/#{k}/#{checkout}.log"){|f| output = f.read }
+              checkouts.push({:sha1 => checkout, :timestamp => File.mtime(path).strftime("%Y-%m-%d %H:%M:%S"), :output => output})
+            rescue Errno::ENOENT => e
+              checkouts.push({:sha1 => checkout, :timestamp => File.mtime(path).strftime("%Y-%m-%d %H:%M:%S")})
+            end
+          end
+          response[k][:checkouts] = checkouts
+        end
+      end
+      response.to_json
+    end
+
+    def process_get
+      return {:status => 402, :message => "Repository not found"} if @config[repository_name].nil?
+      return {:status => 403, :message => "Invalid token"} unless @config[repository_name]['token'] == request_token
+      return {:status => 200, :message => hdi } if request_hdi?
+
+      # Otherwise we must return the json with project data
+      {:status => 200, :message => project_json }
+    end
+
+    def process_post
+      return {:status => 404, :message => "POST content is null"} if @body.nil? 
+      return {:status => 404, :message => "Repository #{repository_name} not found in config"} unless @config.include? repository_name
+      return {:status => 404, :message => "Branch #{branch} not found in config"} unless @config[repository_name].include? branch
+      return {:status => 403, :message => "Invalid token"} unless @config[repository_name]['token'] == request_token
+      deploy
+    end
+
+    # Call the Deployer class to do the deploy magic.
+    # To implement a diferent SCM we will need to rewrite the Deployer and this method.
+    def deploy
+      d = Deployer.new(@log, @config[repository_name], branch)
+      begin
+        d.deploy
+        return {:status => 200, :message => "ok"}
+      rescue Exception => e
+        @log.error "Backtrace: #{e.backtrace}"
+        return {:status => 500, :message => "Error while deploying branch #{branch}: #{e.inspect}"}
+      end
+    end
+
+    # Parses the request body (only for POST)
+    # Here is the github specific code.
+    def parse_body
+      post = URI.unescape(@body)
+      @log.debug "Received POST: #{post}"
+      JSON.parse(post.gsub(/^payload=/, ""))
+    end
+
+    # Here we call the body parser and store the result for further queries.
+    def payload
+      @payload ||= parse_body
+    end
+
+  end
+end

data/tests/command_runner_test.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+require 'lib/command_runner'
+require 'logger'
+require 'test/unit'
+
+class CommandRunnerTest < Test::Unit::TestCase
+  def setup
+    @log = Logger.new(STDERR)
+    @log.level = Logger::ERROR
+    @cmd = Hercules::CommandRunner.new @log
+  end
+
+  def test_command_output
+    assert_equal 'test', @cmd.run("echo test").output
+  end
+
+  def test_command_log
+    @cmd.run("echo test1")
+    @cmd.run("echo test2")
+    @cmd.run("echo test3")
+    assert_equal "test1\ntest2\ntest3\n", @cmd.output
+  end
+
+  def test_command_log_store
+    @cmd.run("echo test1")
+    @cmd.run("echo test2")
+    @cmd.run("echo test3")
+    file = "/tmp/output.#{Time.now.strftime "%Y%m%d%H%M%S"}.log"
+    @cmd.store_output file
+    File.open(file, 'r') do |f|
+      assert_equal "test1\ntest2\ntest3\n", f.read
+    end
+  end
+end
+

data/tests/config_test.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+require 'lib/config.rb'
+require 'test/unit'
+
+class ConfigTest < Test::Unit::TestCase
+  def test_basic_methods_with_default_fixture
+    config = Hercules::Config.new 'tests/fixtures/config.yml'
+    assert_equal YAML.load_file('tests/fixtures/config.yml'), config.projects
+    assert_equal ['target_directory', 'repository', 'token'], Hercules::Config.project_attributes
+    assert_equal ['checkout_on_startup', 'checkouts_to_keep'], Hercules::Config.branch_attributes
+    assert_equal ['master', 'test'], config.branches['test_project']
+  end
+
+  def test_config_attr_reader
+    config = Hercules::Config.new 'tests/fixtures/config.yml'
+    yml = YAML.load_file('tests/fixtures/config.yml')
+    config.each do |k,v|
+      assert_equal config[k], yml[k]
+    end
+  end
+
+  def test_config_validation
+    [ 'tests/fixtures/config_empty.yml', 'tests/fixtures/config_empty_branches.yml', 'tests/fixtures/config_empty_projects.yml', 'tests/fixtures/config_partial_1.yml', 'tests/fixtures/config_partial_2.yml', 'tests/fixtures/config_partial_3.yml'].each do |p|
+      assert_invalid_config(p) 
+    end
+  end
+
+  def test_config_with_global_attributes
+    config = Hercules::Config.new 'tests/fixtures/config_global.yml'
+    assert_equal "127.0.0.1", config.host
+    assert_equal 8081, config.port
+  end
+
+  def assert_invalid_config path
+    assert_raise(Hercules::InvalidConfig) do
+      config = Hercules::Config.new(path)
+    end
+  end
+end

data/tests/fixtures/Gemfile

@@ -0,0 +1 @@
+source :gemcutter

data/tests/fixtures/Gemfile.lock

@@ -0,0 +1,8 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES

data/tests/fixtures/Gemfile.with_git_gem

@@ -0,0 +1,2 @@
+source :gemcutter
+gem "git"