tinyci 0.1.0

data/lib/tinyci/cli.rb

@@ -0,0 +1,104 @@
+require 'tinyci/version'
+require 'tinyci/scheduler'
+require 'tinyci/installer'
+require 'tinyci/git_utils'
+require 'optparse'
+
+module TinyCI
+  # Defines the CLI interface. Uses OptionParser.
+  class CLI
+    extend GitUtils
+    
+    LOGO = File.read(File.expand_path('logo.txt', __dir__))
+    
+    def self.parse!(argv = ARGV)
+      opts = {}
+      
+      global = OptionParser.new do |o|
+        o.banner = ''
+        o.on("-q", "--[no-]quiet", "surpress output") {|q| opts[:quiet] = q}
+        o.on("-D <DIR>", "--dir <DIR>", "specify repository location") {|d| opts[:dir] = d}
+      end
+      
+      subcommands = { 
+        'run' => OptionParser.new do |o|
+          o.banner = "#{LOGO % TinyCI::VERSION}\nGlobal options:\n  #{global.help.slice(3..-1)}\nrun options:"
+          o.on("-c <SHA>", "--commit <SHA>", "run against a specific commit") {|c| opts[:commit] = c}
+          o.on("-a", "--all", "run against all commits which have not been run against before") {|a| opts[:all] = a}
+        end,
+        'install' => OptionParser.new do |o|
+          o.banner = "Usage: install [options]"
+          o.on("-q", "--[no-]quiet", "quietly run") {|v| opts[:quiet] = v}
+        end
+      }
+      
+          banner = <<TXT
+#{LOGO % TinyCI::VERSION}
+Global options:
+    #{global.help.strip}
+
+Available commands:
+    run      build and test the repo
+    install  install the git hook into the current repository
+    version  print the TinyCI version number
+TXT
+      if argv[0] == '--help'
+        puts banner
+        return false
+      end
+      
+      global.order!(argv)
+      command = argv.shift
+      
+      if command.nil? || subcommands[command].nil?
+        puts banner
+        return false
+      end
+      
+      subcommands[command].order!(argv)
+      
+      opts[:dir] ||= begin
+        repo_root
+      rescue TinyCI::Subprocesses::SubprocessError => e
+        if e.message == '`git rev-parse --is-inside-git-dir` failed with code 32768'
+          exit 1
+        else
+          raise e
+        end
+      end
+      
+      send "do_#{command}", opts
+    end
+    
+    def self.do_run(opts)
+      if PidFile.running?
+        puts 'TinyCI is already running!' unless opts[:quiet]
+        return false
+      end
+      
+      opts.delete(:commit) if opts[:all]
+      
+      if !opts[:commit] && !opts[:all]
+        puts "You must pass either --commit or --all, or try --help" unless opts[:quiet]
+        return false
+      end
+            
+      logger = MultiLogger.new(quiet: opts[:quiet])
+      result = Scheduler.new(commit: opts[:commit], logger: logger, working_dir: opts[:dir]).run!
+      
+      result
+    end
+    
+    def self.do_install(opts)
+      logger = MultiLogger.new(quiet: opts[:quiet])
+    
+      TinyCI::Installer.new(logger: logger, working_dir: opts[:dir]).write!
+    end
+    
+    def do_version(opts)
+      puts TinyCI::VERSION
+      
+      true
+    end
+  end
+end

data/lib/tinyci/config.rb

@@ -0,0 +1,55 @@
+require 'tinyci/symbolize'
+require 'yaml'
+
+module TinyCI
+  # Represents the Configuration for a repo, parsed from the `.tinyci.yml` file in the repo root.
+  # Mainly a wrapper around a the hash object parsed from the yaml in the config file.
+  # The keys of the hash are recursively symbolized.
+  class Config
+    include Symbolize
+    
+    # Constructor
+    # 
+    # @param [String] working_dir The working directory in which to find the config file
+    # @param [String] config_path Override the path to the config file
+    # @param [String] config Override the config content
+    # 
+    # @raise [ConfigMissingError] if the config file is not found
+    def initialize(working_dir: '.', config_path: nil, config: nil)
+      @working_dir = working_dir
+      @config_pathname = config_path
+      @config_content = config
+      
+      raise ConfigMissingError, "config file #{config_pathname} not found" unless config_file_exists?
+    end
+    
+    # Address into the config object
+    # 
+    # @param [Symbol] key The key to address
+    def [](key)
+      config_content[key]
+    end
+    
+    # Return the raw hash representation
+    def to_hash
+      config_content
+    end
+    
+    private
+    
+    def config_file_exists?
+      File.exist? config_pathname
+    end
+    
+    def config_pathname
+      @config_pathname || File.expand_path('.tinyci.yml', @working_dir)
+    end
+    
+    def config_content
+      @config_content ||= symbolize(YAML.safe_load(File.read(config_pathname))).freeze
+    end
+  end
+    
+  # Error raised when the config file cannot be found
+  class ConfigMissingError < StandardError; end
+end

data/lib/tinyci/executor.rb

@@ -0,0 +1,21 @@
+require 'tinyci/subprocesses'
+require 'tinyci/logging'
+
+module TinyCI
+  # Parent class for Builder and Tester classes
+  # 
+  # @abstract
+  class Executor
+    include Subprocesses
+    include Logging
+    
+    # Returns a new instance of the executor.
+    # 
+    # @param config [Hash] Configuration hash, typically taken from relevant key in the {Config} object.
+    # @param logger [Logger] Logger object
+    def initialize(config, logger: nil)
+      @config = config
+      @logger = logger
+    end
+  end
+end

data/lib/tinyci/git_utils.rb

@@ -0,0 +1,68 @@
+require 'tinyci/subprocesses'
+
+module TinyCI
+  
+  # Methods for dealing with git repos.
+  module GitUtils
+    
+    # Returns the absolute path to the root of the current git directory
+    # 
+    # @return [String] the path
+    def repo_root
+      return git_directory_path if inside_bare_repo?
+      
+      if inside_git_directory?
+        File.expand_path('..', git_directory_path)
+      elsif inside_work_tree?
+        execute(git_cmd('rev-parse', '--show-toplevel'))
+      else
+        raise 'not in git directory or work tree!?'
+      end
+    end
+    
+    # Are we currently under a git repo?
+    def inside_git_directory?
+      execute(git_cmd('rev-parse', '--is-inside-git-dir')) == 'true'
+    end
+    
+    # Are we under a bare repo?
+    def inside_bare_repo?
+      execute(git_cmd('rev-parse', '--is-bare-repository')) == 'true'
+    end
+    
+    # Are we currently under a git work tree?
+    def inside_work_tree?
+      execute(git_cmd('rev-parse', '--is-inside-work-tree')) == 'true'
+    end
+    
+    # Are we currently under a repo in any sense?
+    def inside_repository?
+      execute(git_cmd('rev-parse', '--is-inside-work-tree', '--is-inside-git-dir')).split.any? {|s| s == 'true'}
+    end
+    
+    # Returns the absolute path to the .git directory
+    def git_directory_path
+      File.expand_path(execute(git_cmd('rev-parse', '--git-dir')), defined?(@working_dir) ? @working_dir : nil)
+    end
+    
+    # Execute a git command, passing the -C parameter if the current object has
+    # the working_directory instance var set
+    def git_cmd(*args)
+      cmd = ['git']
+      cmd += ['-C', @working_dir] if defined?(@working_dir) && !@working_dir.nil?
+      cmd += args
+      
+      cmd
+    end
+    
+    private
+    
+    def self.included(base)
+      base.include Subprocesses
+    end
+    
+    def self.extended(base)
+      base.extend Subprocesses
+    end
+  end
+end

data/lib/tinyci/installer.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+require 'tinyci/git_utils'
+
+module TinyCI
+  
+  # Responsible for writing the git hook file
+  class Installer
+    include GitUtils
+    
+    # Constructor
+    # 
+    # @param [String] working_dir The directory from which to run. Does not have to be the root of the repo
+    # @param [Logger] logger Logger object
+    def initialize(working_dir: nil, logger: nil)
+      @logger = logger
+      @working_dir = working_dir || repo_root
+    end
+    
+    # Write the hook to the relevant path and make it executable
+    def write!
+      unless inside_repository?
+        log_error "not currently in a git repository"
+        return false
+      end
+      
+      if hook_exists?
+        log_error "post-update hook already exists in this repository"
+        return false
+      end
+      
+      File.open(hook_path, 'a') {|f| f.write hook_content}
+      FileUtils.chmod('u+x', hook_path)
+      
+      log_info 'tinyci post-update hook installed successfully'
+    end
+    
+    private
+    
+    def hook_exists?
+      File.exist? hook_path
+    end
+    
+    def hook_path
+      File.expand_path('hooks/post-update', git_directory_path)
+    end
+    
+    def hook_content
+      <<-EOF
+#!/bin/sh
+
+tinyci run --all
+      EOF
+    end
+  end
+end

data/lib/tinyci/logging.rb

@@ -0,0 +1,16 @@
+require 'tinyci/multi_logger'
+
+module TinyCI
+  # Defines helper instance methods for logging to reduce code verbosity
+  module Logging
+    
+    %w(log debug info warn error fatal unknown).each do |m|
+      define_method("log_#{m}") do |*args|
+        return false unless defined?(@logger) && @logger.is_a?(MultiLogger)
+        
+        @logger.send(m, *args)
+      end
+    end  
+    
+  end
+end

data/lib/tinyci/logo.txt

@@ -0,0 +1,6 @@
+ _____ _               _____  _____
+/__   (_)_ __  _   _  / ___/ /_  _/
+   | || | '_ \| | | |/ /     / /
+   | || | | | | |_| / /___/\/ /_  
+   |_||_|_| |_|\__, \____/\____/  %s
+               |___/

data/lib/tinyci/multi_logger.rb

@@ -0,0 +1,49 @@
+require 'logger'
+
+module TinyCI
+  # This class allows logging to both `STDOUT` and to a file with a single call.
+  # @attr [Boolean] quiet Disables logging to STDOUT
+  class MultiLogger
+    FORMAT = Proc.new do |severity, datetime, progname, msg|
+      "[#{datetime.strftime "%T"}] #{msg}\n"
+    end
+    
+    attr_accessor :quiet
+    
+    # Constructor
+    # 
+    # @param [Boolean] quiet Disables logging to STDOUT
+    # @param [String] path Location to write logfile to
+    def initialize(quiet: false, path: nil)
+      @file_logger = nil
+      self.output_path = path
+      @quiet = quiet
+      
+      @stdout_logger = Logger.new($stdout)
+      @stdout_logger.formatter = FORMAT
+      @stdout_logger.level = Logger::INFO
+    end
+    
+    def targets
+      logs = []
+      logs << @file_logger if @file_logger
+      logs << @stdout_logger unless @quiet
+      
+      logs
+    end
+    
+    def output_path=(path)
+      if path
+        @file_logger = Logger.new(path)
+        @file_logger.formatter = FORMAT
+        @file_logger.level = Logger::INFO
+      end
+    end
+
+    %w(log debug info warn error fatal unknown).each do |m|
+      define_method(m) do |*args|
+        targets.each { |t| t.send(m, *args) }
+      end
+    end
+  end
+end

data/lib/tinyci/runner.rb

@@ -0,0 +1,154 @@
+require 'tinyci/subprocesses'
+require 'tinyci/git_utils'
+require 'tinyci/logging'
+require 'tinyci/config'
+
+require 'tinyci/builders/test_builder'
+require 'tinyci/testers/test_tester'
+
+require 'tinyci/builders/rkt_builder'
+require 'tinyci/testers/rkt_tester'
+
+require 'tinyci/builders/script_builder'
+require 'tinyci/testers/script_tester'
+
+require 'fileutils'
+
+module TinyCI
+  # Responsible for managing the running of TinyCI against a single git object.
+  # 
+  # @attr builder [TinyCI::Executor] Returns the Builder object. Used solely for testing at this time.
+  # @attr tester [TinyCI::Executor] Returns the Tester object. Used solely for testing at this time.
+  class Runner
+    include Subprocesses
+    include GitUtils
+    include Logging
+    
+    attr_accessor :builder, :tester
+    
+    # Constructor, allows injection of generic configuration params.
+    # 
+    # @param working_dir [String] The working directory to execute against.
+    # @param commit [String] SHA1 of git object to run against
+    # @param logger [Logger] Logger object
+    # @param time [Time] Override time of object creation. Used solely for testing at this time.
+    # @param config [Hash] Override TinyCI config object, normally loaded from `.tinyci` file. Used solely for testing at this time.
+    def initialize(working_dir: '.', commit:, time: nil, logger: nil, config: nil)
+      @working_dir = working_dir
+      @logger = logger
+      @config = config
+      @commit = commit
+      @time = time || commit_time
+    end
+    
+    # Runs the TinyCI system against the single git object referenced in `@commit`.
+    # 
+    # @return [Boolean] `true` if the commit was built and tested successfully, `false` otherwise
+    def run!
+      begin
+        ensure_path target_path
+        setup_log
+        
+        log_info "Commit: #{@commit}"
+        
+        log_info "Cleaning..."
+        clean
+        
+        log_info "Exporting..."
+        ensure_path export_path
+        export
+        
+        begin
+          load_config
+        rescue ConfigMissingError => e
+          log_error e.message
+          log_error 'Removing export...'
+          clean
+          
+          return false
+        end
+        @builder ||= instantiate_builder
+        @tester  ||= instantiate_tester
+        
+        log_info "Building..."
+        @builder.build
+        
+        log_info "Testing..."
+        @tester.test
+        
+        log_info "Finished #{@commit}"
+      rescue => e
+          raise e if ENV['TINYCI_ENV'] == 'test'
+          
+          log_error e
+          log_error e.backtrace
+        return false
+      ensure
+
+      end
+      
+      true
+    end
+    
+    private
+    
+    # Creates log file if it doesnt exist
+    def setup_log
+      return unless @logger.is_a? MultiLogger
+      FileUtils.touch logfile_path
+      @logger.output_path = logfile_path
+    end
+    
+    def logfile_path
+      File.join(target_path, 'tinyci.log')
+    end
+    
+    # Instantiate the Builder object according to the class named in the config
+    def instantiate_builder
+      klass = TinyCI::Builders.const_get(@config[:builder][:class])
+      klass.new(@config[:builder][:config].merge(target: export_path), logger: @logger)
+    end
+    
+    # Instantiate the Tester object according to the class named in the config
+    def instantiate_tester
+      klass = TinyCI::Testers.const_get(@config[:tester][:class])
+      klass.new(@config[:tester][:config].merge(target: export_path), logger: @logger)
+    end
+    
+    # Instantiate the {Config} object from the `.tinyci.yml` file in the exported directory
+    def load_config
+      @config ||= Config.new(working_dir: export_path)
+    end
+
+    # Parse the commit time from git
+    def commit_time
+      Time.at execute(git_cmd('show', '-s', '--format=%ct', @commit)).to_i
+    end
+
+    # Build the absolute target path
+    def target_path
+      File.absolute_path("#{@working_dir}/builds/#{@time.to_i}_#{@commit}/")
+    end
+    
+    # Build the export path
+    def export_path
+      File.join(target_path, 'export')
+    end
+
+    def ensure_path(path)
+      execute 'mkdir', '-p', path
+    end
+    
+    def clean
+      FileUtils.rm_rf export_path
+    end
+
+    # Export a clean copy of the repo at the given commit, without a .git directory etc.
+    # This implementation is slightly hacky but its the cleanest way to do it in the absence of
+    # a `git export` subcommand.
+    # see https://stackoverflow.com/a/163769
+    def export
+      execute_pipe git_cmd('archive', '--format=tar', @commit), ['tar', '-C', export_path, '-xf', '-']
+    end
+  end
+end

data/lib/tinyci/scheduler.rb

@@ -0,0 +1,105 @@
+require 'tinyci/runner'
+require 'tinyci/subprocesses'
+require 'tinyci/git_utils'
+require 'pidfile'
+
+module TinyCI
+  # Manages the execution of test jobs. Responsible for deciding which
+  # commits need to be built and tested. Also manages the pidfile. This
+  # is the main entrypoint for TinyCI.
+  # 
+  # @attr_reader [String] working_dir The working directory to execute against
+  class Scheduler
+    include Subprocesses
+    include Logging
+    include GitUtils
+    
+    attr_reader :working_dir
+    
+    # Constructor, allows injection of configuration and custom {Runner} class.
+    # Config params are passed to {Runner} instances.
+    # 
+    # @param working_dir [String] The working directory to execute against
+    # @param logger [Logger] Logger object
+    # @param commit [String] specific git object to run against
+    # @param runner_class [TinyCI::Runner] Injection of {Runner} dependency
+    def initialize(
+        working_dir: nil,
+        logger: nil,
+        commit: nil,
+        runner_class: Runner
+      )
+    
+      @working_dir = working_dir || repo_root
+      @logger = logger
+      @runner_class = runner_class
+      @commit = commit
+    end
+    
+    # Runs the TinyCI system against the relevant commits. Also sets up the pidfile.
+    # 
+    # @return [Boolean] `true` if all commits built and tested successfully, `false` otherwise
+    def run!
+      pid = PidFile.new(pidfile: 'tinyci.pid', piddir: @working_dir)
+      
+      result = if @commit
+        run_commit @commit
+      else
+        run_all_commits
+      end
+      
+      pid.release
+      
+      result
+    end
+    
+    private
+    
+    # Git objects to be executed against, all those without a tinyci tag
+    # 
+    # @return [Array<String>] the sha1 hashes in reverse order of creation time
+    def get_commits
+      log = execute(git_cmd('log', '--notes=tinyci*', '--format=%H %ct %N§§§', '--reverse'))
+      
+      lines = log.split("§§§")
+      lines.map do |line|
+        parts = line.split(' ')
+        {
+          sha: parts[0],
+          time: parts[1],
+          result: parts[2]
+        }
+      end.select {|c| c[:result].nil?}
+    end
+    
+    # Instantiates {Runner} for a given git object, runs it, and stores the result
+    def run_commit(commit)
+      result = @runner_class.new(
+        working_dir: @working_dir,                           
+        commit: commit[:sha],
+        time: commit[:time],
+        logger: @logger
+      ).run!
+      
+      set_result(commit, result)
+    end
+    
+    # Repeatedly gets the list of eligable commits and runs TinyCI against them until there are no more remaining
+    def run_all_commits
+      commits = get_commits
+      
+      until commits.empty? do
+        commits.each {|c| run_commit(c)}
+        
+        commits = get_commits
+      end
+    end
+    
+    # Stores the result in a git note
+    def set_result(commit, result)
+      result_message = result ? 'success' : 'failure'
+      
+      execute git_cmd('notes', '--ref', 'tinyci-result', 'add', '-m', result_message, commit[:sha])
+    end
+  end
+end