tinyci 0.4 → 0.5.1

data/lib/tinyci/cli.rb

@@ -1,118 +1,199 @@
+# frozen_string_literal: true
+
 require 'tinyci/version'
 require 'tinyci/scheduler'
 require 'tinyci/installer'
 require 'tinyci/compactor'
+require 'tinyci/log_viewer'
 require 'tinyci/git_utils'
+require 'tinyci/cli_ssh_delegator'
 require 'optparse'
 require 'pidfile'
 
 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|
+    include GitUtils
+
+    LOGO = File.read(File.expand_path('logo.txt', __dir__)).freeze
+    HIDDEN_OPTIONS = %w[
+      running-remotely
+    ].freeze
+
+    def initialize(argv = ARGV)
+      @argv = argv
+      @opts = {}
+    end
+
+    def parse!
+      if @argv[0] == '--help'
+        puts banner
+        return false
+      end
+
+      unless subcommand
+        puts banner
+        return false
+      end
+
+      global_parser.order!(global_args)
+      subcommand_parsers[subcommand].order!(subcommand_args)
+
+      @opts[:working_dir] ||= working_dir
+
+      if @opts[:remote]
+        CLISSHDelegator.new(@argv, **@opts).run!
+      else
+        send "do_#{subcommand}", @opts
+      end
+    end
+
+    private
+
+    def working_dir
+      repo_root
+    rescue TinyCI::Subprocesses::SubprocessError => e
+      raise e unless e.message == '`git rev-parse --is-inside-git-dir` failed with code 32768'
+
+      exit 1
+    end
+
+    def global_parser
+      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}
+        o.on('-q', '--[no-]quiet', 'surpress output') { |q| @opts[:quiet] = q }
+        o.on('--running-remotely') { |_rr| @opts[:running_remotely] = true }
+        o.on('-D=DIR', '--dir=DIR', 'specify repository location') { |d| @opts[:working_dir] = d }
+        o.on('-r [REMOTE]', '--remote [REMOTE]',
+             'specify remote') { |r| @opts[:remote] = r.nil? ? true : r }
       end
-      
-      subcommands = { 
+    end
+
+    def global_help
+      global_parser.help.split("\n").reject do |help_line|
+        HIDDEN_OPTIONS.any? { |o| help_line =~ Regexp.new(o) }
+      end.join("\n").strip
+    end
+
+    def subcommand_banner(subcommand_name)
+      "#{LOGO % TinyCI::VERSION}\nGlobal options:\n  #{global_help}\n\n#{subcommand_name} options:"
+    end
+
+    def subcommand_parsers
+      {
         '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}
+          o.banner = subcommand_banner('run')
+          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}
+          o.banner = subcommand_banner('install')
+          o.on('-a', '--[no-]absolute-path',
+               'install hook with absolute path to specific tinyci version (not recommended)') { |v| @opts[:absolute_path] = v }
         end,
         'compact' => OptionParser.new do |o|
-          o.banner = "Usage: compact [options]"
-          o.on("-n", "--num-builds-to-leave <NUM>", "number of builds to leave in place, starting from the most recent") {|n| opts[:num_builds_to_leave] = n}
-          o.on("-b", "--builds-to-leave <BUILDS>", "specific build directories to leave in place, comma-separated") {|b| opts[:builds_to_leave] = b.split(',')}
-          o.on("-q", "--[no-]quiet", "quietly run") {|v| opts[:quiet] = v}
+          o.banner = subcommand_banner('compact')
+          o.on('-n', '--num-builds-to-leave <NUM>',
+               'number of builds to leave in place, starting from the most recent') { |n| @opts[:num_builds_to_leave] = n }
+          o.on('-b', '--builds-to-leave <BUILDS>',
+               'specific build directories to leave in place, comma-separated') { |b| @opts[:builds_to_leave] = b.split(',') }
+        end,
+        'log' => OptionParser.new do |o|
+          o.banner = subcommand_banner('log')
+          o.on('-f', '--follow', 'follow the logfile') { |f| @opts[:follow] = f }
+          o.on('-n <NUM>', '--num-lines <NUM>',
+               'number of lines to print') { |n| @opts[:num_lines] = n.to_i }
+          o.on('-c <SHA>', '--commit <SHA>',
+               'run against a specific commit') { |c| @opts[:commit] = c }
         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
-    compact  compress old build artifacts
-    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)
+
+    def banner
+      <<~TXT
+        #{LOGO % TinyCI::VERSION}
+        Global options:
+            #{global_help}
+
+        Available commands:
+            run      build and test the repo
+            install  install the git hook into the current repository
+            compact  compress old build artifacts
+            log      print logfiles
+            version  print the TinyCI version number
+      TXT
+    end
+
+    def subcommand_index
+      @argv.index { |arg| subcommand_parsers.keys.include? arg }
+    end
+
+    def subcommand
+      return nil unless subcommand_index
+
+      @argv[subcommand_index]
+    end
+
+    def global_args
+      @argv[0..subcommand_index - 1]
+    end
+
+    def subcommand_args
+      @argv[subcommand_index + 1..-1]
+    end
+
+    def 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]
+        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 = Scheduler.new(commit: opts[:commit], logger: logger,
+                             working_dir: opts[:working_dir]).run!
+
       result
     end
-    
-    def self.do_install(opts)
+
+    def do_install(opts)
       logger = MultiLogger.new(quiet: opts[:quiet])
-    
-      TinyCI::Installer.new(logger: logger, working_dir: opts[:dir]).install!
+
+      TinyCI::Installer.new(logger: logger, working_dir: opts[:working_dir],
+                            absolute_path: opts[:absolute_path]).install!
     end
-    
-    def self.do_compact(opts)
+
+    def do_compact(opts)
       logger = MultiLogger.new(quiet: opts[:quiet])
-      
-      TinyCI::Compactor.new(logger: logger, working_dir: opts[:dir], num_builds_to_leave: opts[:num_builds_to_leave], builds_to_leave: opts[:builds_to_leave]).compact!
+
+      TinyCI::Compactor.new(
+        logger: logger,
+        working_dir: opts[:working_dir],
+        num_builds_to_leave: opts[:num_builds_to_leave],
+        builds_to_leave: opts[:builds_to_leave]
+      ).compact!
     end
-    
-    def do_version(opts)
+
+    def do_log(opts)
+      TinyCI::LogViewer.new(
+        working_dir: opts[:working_dir],
+        commit: opts[:commit],
+        follow: opts[:follow],
+        num_lines: opts[:num_lines]
+      ).view!
+    end
+
+    def do_version(_opts)
       puts TinyCI::VERSION
-      
+
       true
     end
   end

data/lib/tinyci/cli_ssh_delegator.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'tinyci/git_utils'
+require 'net/ssh'
+
+module TinyCI
+  # Wrapper that takes calls to {CLI} from the command line and executes them remotely via ssh, on
+  # the server hosting the remote tinyci is installed to. The main purpose is to allow convenient
+  # execution of `tinyci log` on the remote server.
+  class CLISSHDelegator
+    include GitUtils
+
+    #
+    # Constructor
+    #
+    # @param [Array<String>] argv The original arguments passed into {CLI}
+    # @param [String] working_dir The (local) directory from which to run.
+    # @param [String, Boolean] remote Which remote to ssh into. If this is set to `true` then use
+    # the upstream remote for the current branch
+    # @param [<Type>] **opts <description>
+    #
+    def initialize(argv, working_dir:, remote:, **opts)
+      @argv = argv
+      @working_dir = working_dir
+
+      # Handle `remote: true` case where `--remote` switch is passed on its own without specifying a
+      # remote name. The fact of this case must be stored so that the arguments to the remote
+      # execution can be properly constructed.
+      if remote == true
+        @remote = current_tracking_remote
+        @derived_remote = true
+      else
+        @remote = remote
+        @derived_remote = false
+      end
+      @opts = opts
+    end
+
+    def run!
+      unless remote_exists?
+        warn "Remote `#{@remote}` not found"
+
+        return false
+      end
+
+      if github_remote?
+        msg = "`#{@remote}` is a github remote: #{remote_url}"
+        msg += "\nPerhaps you meant to run tinyci #{@argv.first} against a different one?"
+
+        warn msg
+        return false
+      end
+
+      unless ssh_remote?
+        msg = "`#{@remote}` does not appear to have an ssh remote: #{remote_url}"
+        msg += "\nPerhaps you meant to run tinyci #{@argv.first} against a different one?"
+
+        warn msg
+        return false
+      end
+
+      do_tunnel!(remote_url.host, remote_url.user, command)
+
+      true
+    end
+
+    def command
+      (['tinyci', '--running-remotely', '--dir', remote_url.path] + args).join ' '
+    end
+
+    #
+    # Build the argument list to execute at the remote end.
+    # Main concern here is removing the arguments which are specific to remote execution, ie.
+    # those relevant only to this class.
+    #
+    def args
+      args = @argv.clone
+
+      # since --dir always has an argument we can delete twice to get rid of the switch and the arg
+      index = args.index('--dir') || args.index('-D')
+      2.times { args.delete_at index } if index
+
+      # the --remote switch can live on its own
+      index = args.index('--remote') || args.index('-r')
+      if index
+        args.delete_at index
+        args.delete_at index unless @derived_remote
+      end
+
+      args
+    end
+
+    def do_tunnel!(host, user, cmd)
+      Net::SSH.start(host, user) do |ssh|
+        ssh.open_channel do |ch|
+          ch.exec cmd do |e_ch, success|
+            abort 'could not execute command' unless success
+            e_ch.on_data do |_ch, data|
+              print data
+            end
+            e_ch.on_extended_data do |_ch, _type, data|
+              warn data
+            end
+          end
+        end
+
+        ssh.loop
+      end
+    end
+  end
+end

data/lib/tinyci/compactor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'tinyci/git_utils'
 require 'zlib'
@@ -5,16 +7,16 @@ require 'rubygems/package'
 require 'find'
 
 module TinyCI
-  
   # Tool for compressing old builds into .tar.gz files
   class Compactor
     include GitUtils
     include Subprocesses
-    
+
     BLOCKSIZE_TO_READ = 1024 * 1000
-    
+
+    #
     # Constructor
-    # 
+    #
     # @param [String] working_dir The directory from which to run.
     # @param [Integer] num_builds_to_leave How many builds not to compact, starting from the newest
     # @param [String] builds_to_leave Comma-separated list of build directory names not to compact
@@ -23,77 +25,75 @@ module TinyCI
       @logger = logger
       @working_dir = working_dir || repo_root
       @num_builds_to_leave = (num_builds_to_leave || 1).to_i
-      @builds_to_leave = builds_to_leave || []
+      @builds_to_leave = (Array(builds_to_leave) || []).map(&:to_s)
     end
-    
+
     # Compress and delete the build directories
     def compact!
       unless inside_repository?
-        log_error "not currently in a git repository"
+        log_error 'not currently in a git repository'
         return false
       end
-      
+
       directories_to_compact.each do |dir|
         compress_directory dir
         FileUtils.rm_rf builds_dir(dir)
-        
+
         log_info "Compacted #{archive_path(dir)}"
       end
     end
-    
+
     private
-    
+
     # Build the list of directories to compact according to the options
     def directories_to_compact
       builds = Dir.entries builds_dir
-      builds.select! {|e| File.directory? builds_dir(e) }
-      builds.reject! {|e| %w{. ..}.include? e }
+      builds.select! { |e| File.directory? builds_dir(e) }
+      builds.reject! { |e| %w[. ..].include? e }
       builds.sort!
-      
-      builds = builds[0..-(@num_builds_to_leave+1)]
-      builds.reject! {|e| @builds_to_leave.include?(e) || @builds_to_leave.include?(builds_dir(e, 'export'))}
+
+      builds = builds[0..-(@num_builds_to_leave + 1)]
+      builds.reject! { |e| @builds_to_leave.include?(e) || @builds_to_leave.include?(builds_dir(e)) }
 
       builds
     end
-    
+
     # Get the location of the builds directory
     def builds_dir(*path_segments)
       File.join @working_dir, 'builds/', *path_segments
     end
-    
+
     # Build the path for a compressed archive
     def archive_path(dir)
-      File.join(builds_dir, dir+".tar.gz")
+      File.join(builds_dir, dir + '.tar.gz')
     end
-    
+
     # Create a .tar.gz file from a directory
     # Done in pure ruby to ensure portability
     def compress_directory(dir)
       File.open archive_path(dir), 'wb' do |oarchive_path|
         Zlib::GzipWriter.wrap oarchive_path do |gz|
           Gem::Package::TarWriter.new gz do |tar|
-            Find.find "#{builds_dir}/"+dir do |f|
-              relative_path = f.sub "#{builds_dir}/", ""
+            Find.find "#{builds_dir}/" + dir do |f|
+              relative_path = f.sub "#{builds_dir}/", ''
               mode = File.stat(f).mode
               size = File.stat(f).size
-              
+
               if File.directory? f
                 tar.mkdir relative_path, mode
               else
                 tar.add_file_simple relative_path, mode, size do |tio|
                   File.open f, 'rb' do |rio|
-                    while buffer = rio.read(BLOCKSIZE_TO_READ)
+                    while (buffer = rio.read(BLOCKSIZE_TO_READ))
                       tio.write buffer
                     end
                   end
                 end
               end
-              
             end
           end
         end
       end
-      
     end
   end
 end

data/lib/tinyci/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'tinyci/config_transformer'
 require 'tinyci/symbolize'
 require 'yaml'
@@ -6,60 +8,57 @@ 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.
-  # 
+  #
   # As it is loaded, the configuration file data is passed through the {TinyCI::ConfigTransformer}
   # class, which translates any definitions in the concise format into the more verbose format
   class Config
     include Symbolize
-    
+
+    attr_accessor :config_path
+
     # 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
+    def initialize(config_path, config: nil)
+      @config_path = config_path
       @config_content = config
-      
-      raise ConfigMissingError, "config file #{config_pathname} not found" unless config_file_exists?
+
+      raise ConfigMissingError, "config file #{config_path} 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
-    # 
+    #
     # @return [Hash] The configuration as a hash
     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)
+      File.exist? config_path
     end
-    
+
     def config_content
       @config_content ||= begin
-        config = YAML.safe_load(File.read(config_pathname))
+        config = YAML.safe_load(File.read(config_path))
         transformed_config = ConfigTransformer.new(config).transform!
         symbolize(transformed_config).freeze
       end
     end
   end
-    
+
   # Error raised when the config file cannot be found
   class ConfigMissingError < StandardError; end
 end

data/lib/tinyci/config_transformer.rb

@@ -1,61 +1,59 @@
+# frozen_string_literal: true
+
 module TinyCI
   # Transforms the configuration format from the condensed format to the
   # more verbose format accepted by the rest of the system
   class ConfigTransformer
-    
     # Constructor
-    # 
+    #
     # @param [Hash] input The configuration object, in the condensed format
     def initialize(input)
       @input = input
     end
-    
+
     # Transforms the config object
-    # 
+    #
     # @return [Hash] The config object in the verbose form
     def transform!
-      @input.inject({}) do |acc, (key, value)|
+      @input.each_with_object({}) do |(key, value), acc|
         method_name = "transform_#{key}"
-        
+
         if respond_to? method_name, true
-          
           acc.merge! send(method_name, value)
         else
           acc[key] = value
         end
-        
-        acc
       end
     end
-    
+
     private
-    
+
     def transform_build(value)
       {
         builder: {
-          :class => "ScriptBuilder",
+          class: 'ScriptBuilder',
           config: {
             command: value
           }
         }
       }
     end
-    
+
     def transform_test(value)
       {
         tester: {
-          :class => "ScriptTester",
+          class: 'ScriptTester',
           config: {
             command: value
           }
         }
       }
     end
-    
+
     def transform_hooks(value)
       {
         hooker: {
-          :class => "ScriptHooker",
+          class: 'ScriptHooker',
           config: value
         }
       }