tinyci 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7a0de56d2686e1af8a2960bdfb0b8ac3eba240ed
+  data.tar.gz: f1529cf28f2e9a10fb36bda7085cf465935ee59a
+SHA512:
+  metadata.gz: 42639f2ca97b82a9ad3fc43cc6e35cfc8052659f6aaef73ebaabed6342bb12f66b64060f3856c19d785af15c8ba7ac0fe93365943ff17fc65b42b849e32c305e
+  data.tar.gz: 9406072d6fae373d7cbfb933e4c8856e57d0f41d93a3e753b9bb773e85a708a9405ba9029c889962e02d275b99645aac7b0b7cb4c41486dd72fefccc1d622400

data/.gitignore

@@ -0,0 +1,7 @@
+doc
+.yardoc
+spec/support/repos/*
+!*.git.tar.gz
+spec/examples.txt
+tmp
+pkg

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--order random

data/.ruby-version

@@ -0,0 +1 @@
+2.4.2

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+gem 'pry-byebug'
+# gem 'byebug'
+# gem 'pry-doc'
+gem 'pry'
+gem 'guard-rspec'
+gem 'fuubar'
+gem 'rspec-nc'
+gem 'terminal-notifier', '1.7.1'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,97 @@
+PATH
+  remote: .
+  specs:
+    tinyci (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.8.0)
+    barrier (1.0.2)
+    byebug (9.1.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    ffi (1.9.18)
+    formatador (0.2.5)
+    fuubar (2.2.0)
+      rspec-core (~> 3.0)
+      ruby-progressbar (~> 1.4)
+    guard (2.14.1)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.12)
+    method_source (0.9.0)
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.11.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.5.0)
+      byebug (~> 9.1)
+      pry (~> 0.10)
+    rake (12.1.0)
+    rb-fsevent (0.10.2)
+    rb-inotify (0.9.10)
+      ffi (>= 0.5.0, < 2)
+    redcarpet (3.4.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-nc (0.3.0)
+      rspec (>= 3)
+      terminal-notifier (>= 1.4)
+    rspec-support (3.6.0)
+    ruby-progressbar (1.8.1)
+    ruby_dep (1.5.0)
+    shellany (0.0.1)
+    terminal-notifier (1.7.1)
+    thor (0.20.0)
+    yard (0.9.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  barrier
+  bundler (~> 1.14)
+  fuubar
+  guard-rspec
+  pry
+  pry-byebug
+  rake
+  redcarpet
+  rspec
+  rspec-nc
+  terminal-notifier (= 1.7.1)
+  tinyci!
+  yard
+
+BUNDLED WITH
+   1.16.0.pre.3

data/Guardfile

@@ -0,0 +1,7 @@
+interactor :off
+
+guard :rspec, cmd: "bundle exec rspec", all_after_pass: true, all_on_start: true do
+  watch(%r{^lib\/tinyci\/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{spec\/support\/.+})       { "spec" }
+  watch(%r{^spec\/.+_spec\.rb$})
+end

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2018 Jonathan Davies
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,211 @@
+     _____ _               _____  _____
+    /__   (_)_ __  _   _  / ___/ /_  _/
+       | || | '_ \| | | |/ /     / /
+       | || | | | | |_| / /___/\/ /_  
+       |_||_|_| |_|\__, \____/\____/
+                   |___/
+
+TinyCI
+======
+
+A minimal Continuous Integration system, written in ruby, powered by git. MIT licensed.
+
+### Motivation
+
+Existing CI solutions like [Travis](https://travis-ci.org) and [Jenkins](https://jenkins.io) run as daemons requiring large amounts of RAM, typically in their own virtual machines. A more lightweight system was desired, for use with small scale personal projects.
+
+### Architecture
+
+#### Requirements
+
+TinyCI is written in ruby 2. It is not known exactly how recent a version of git is required, however development and testing was carried out against 2.7.4, the version packaged for ubuntu 16.04.
+
+It does not have a heavy dependency on ruby 2, mainly making use of convenient syntactic features. Porting to ruby 1.9 would be very simple.
+
+#### Stages
+
+TinyCI is executed via git `post-update` hooks. When a new commit is pushed, the following steps are executed:
+
+1. Clean  
+    The [export path](#Export_Path) is removed
+2. Export  
+    A clean copy of the commit is placed at the [export path](#Export_Path). Clean in this context means without any .git directory or similar.
+3. Build  
+    The project's build command is executed
+4. Test  
+    The project's test command is executed
+
+Finally the result is stored in git using the [git-notes](https://git-scm.com/docs/git-notes) feature. This is how TinyCI determines which commits to run against.
+
+#### Eligible Commits
+
+When TinyCI is executed, it runs against all eligible commits, from oldest to newest. At the present time, all commits without any `tinyci-result` git-notes object attached are eligible. This means that the first time TinyCI executes, it will run against every commit in the repository's history. 
+
+While this is obviously suboptimal, note that if no configuration file is found, the exported copy of the commit is deleted and TinyCI moves on to the next commit, so this will not create a huge number of extraneous exports. It would be desirable to check for the presence of the config file before exporting the entire commit with a call to `git-cat-file`, see the [TODO section](#Limitations_TODO) below.
+
+#### Executor Classes
+
+Building and Testing are done by subclasses of {TinyCI::Executor}. An instance of each is created for every commit TinyCI runs against. This enables "pluggable backends" for TinyCI. At present there is only the `ScriptBuilder` and `ScriptTester`, which just run a command specified in the config file.
+
+#### Export Path
+
+The export path is the location where exported copies of commits are placed. Currently it is hardcoded as a directory called `builds` under the repo root, or under the the `.git` directory in the case of a non-bare repository.
+
+#### Configuration
+
+TinyCI is configured with a YAML file named `.tinyci.yml` in the root directory of the repo. There are two sections, one for the builder and one for the tester. Each has a `class` key which specifies the {TinyCI::Executor} subclass to be used, and a `config` key which contains specific configuration for that executor. This `config` object can contain anything, it is passed wholesale to the executor object. For an example, see below, or see the example project.
+
+#### Execution Model
+
+TinyCI uses a pidfile to guarantee only a single executing process at a time. This ensures that multiple team members committing to a repository concurrently, or rapid commits in succession by a single user do not result in multiple concurrent executions of the test suite.
+
+Because TinyCI checks anew for eligible git objects to run against after each iteration of its main loop, and runs until no more are found, in the event of multiple commits being pushed concurrently, or further commits being pushed while an initial commit is still being built and tested, the first TinyCI instance will eventually execute against all commits.
+
+It is of course possible that commits might be pushed consistently faster than they can be tested, resulting in a never-to-be-cleared backlog; if this is the case the a more substantial CI solution is probably advisable for your project.
+
+If you look in the source code you will also find `RktBuilder` and `RktTester`, these were experimental attempts to integrate the Rkt container runtime. They are not recommended for use but are left for users to examine.
+
+#### Logging/Output
+
+TinyCI is executed in a `post-update` git hook. As such, the output is shown to the user as part of the local call to `git push`. Once the TinyCI hook is running, the local git process can be freely killed if the user does not wish to watch the output - this will not affect the remote execution of TinyCI.
+
+As well as logging to stdout, the TinyCI process writes a `tinyci.log` file in each exported directory.
+
+#### Limitations/TODO
+
+* TinyCI currently has no support for running a script on success or failure of the test script. This feature would allow for notifications to be sent, eg. slack bots, email, etc. It would also enable TinyCI to act as part of an automated deployment system.
+
+* As mentioned above, when TinyCI is executed against a commit without a configuration file, it exports the whole directory, finds the config file to be missing, then deletes the export. As such, when TinyCI installed against an existing project with many commits, this process will happen for every commit, wasting a lot of time and churning the disk.  
+Instead, it would be preferable to check for the config file before doing the export, with a call to `git-cat-file`. An additional way to handle this would be to prevent the processing of commits created prior to the installation of TinyCI, perhaps by marking them with git-notes at install time, or by checking the creation date of the hook file.
+ 
+* Presently, if a user kills their local git process while TinyCI is running, it will continue to execute on the server. If they then push another commit, the original TinyCI process will go on to test the second commit as well, as expected. However, the output from the second git push will simply consist of an error message describing the behavior.  
+Instead, this second TinyCI execution should begin tailing the output of the first process, perhaps gaining direct access to it's stdout stream.
+
+* It would be desirable to add a command to the TinyCI binary to SSH into the remote server and tail the the log output of a currently running TinyCI process, enabling functionality similar to that described in above, but without making a new commit.
+
+* The exported copies of each build are left on the disk forever. This will obviously eat disk space. One could handle deleting/compressing them with a cronjob, however it would be desirable to integrate this functionality into TinyCI and to automate it.
+
+* More configuration options should be added, eg. specification of the export path.
+
+* In general, more local functionality for the TinyCI binary would be desirable, some way to retrieve the results of tests and query them from the local clone for example, or some way to show them in `git log` output.
+
+### Usage
+
+#### Instructions
+
+First, add a configuration file to your project:
+
+    cat <<EOF > .tinyci.yml
+    builder:
+      class: ScriptBuilder
+      config:
+        command: build.sh
+    tester:
+      class: ScriptTester
+      config:
+        command: test.sh
+    EOF
+
+This config assumes you have files called `build.sh` and `test.sh` in the root of your project that execute the appropriate commands.
+
+TinyCI is distributed as a ruby gem. Install it like so:
+
+    gem install tinyci
+    
+The gem should be installed on the remote server where you want the tests to execute. On that server, install TinyCI into your repository with the install command:
+
+    tinyci install
+    
+Now, commit the configuration file and push it to your remote repository. As discussed above, this will currently result in a large amount of output as every previous commit is exported, found to be missing a config file and then the export deleted. Eventually you will see your build and test scripts executed.
+
+#### Example Project
+
+Here we will demonstrate cloning the [tinyci-example](https://github.com/JonnieCache/tinyci-example) project, creating a bare clone of it to simulate our server where the tests will run, and pushing a commit to see TinyCI in action.
+
+The example project has very simple build and test scripts written in bash.
+
+First, create a directory to store both clones:
+
+    $ mkdir tinyci-test
+    $ cd tinyci-test
+
+Clone the example project from github:
+
+    $ git clone https://github.com/JonnieCache/tinyci-example.git
+    
+    Cloning into 'tinyci-example'...
+    remote: Counting objects: 8, done.
+    remote: Compressing objects: 100% (6/6), done.
+    remote: Total 8 (delta 0), reused 8 (delta 0), pack-reused 0
+    Unpacking objects: 100% (8/8), done.
+    
+Clone it again into a bare repository:
+
+    $ git clone --bare tinyci-example tinyci-example-bare
+    
+    Cloning into bare repository 'tinyci-example-bare'...
+    done.
+    
+Install tinyci:
+
+    $ gem install tinyci
+    
+Install the tinyci hook into our bare clone:
+
+    $ cd tinyci-example-bare
+    $ tinyci install
+    
+    [09:48:42] tinyci post-update hook installed sucessfully
+    
+Go into our initial clone and make a change:
+
+    $ cd ../tinyci-example
+    $ echo "foo" > bar
+    $ git add bar
+    $ git commit -m 'foobar'
+    
+    [master cebb4ec] foobar
+     1 file changed, 1 insertion(+)
+     create mode 100644 bar
+    
+Add our bare repo as a remote:
+
+    $ git remote add test ../tinyci-example-bare
+    
+Push the commit and watch tinyci in action:
+
+    $ git push test master
+    
+    Counting objects: 3, done.
+    Delta compression using up to 4 threads.
+    Compressing objects: 100% (2/2), done.
+    Writing objects: 100% (3/3), 268 bytes | 0 bytes/s, done.
+    Total 3 (delta 1), reused 0 (delta 0)
+    remote: [09:49:53] Commit: 22c36d0c1213361d06b385d2b55648985347e1f4
+    remote: [09:49:53] Cleaning...
+    remote: [09:49:53] Exporting...
+    remote: [09:49:53] Building...
+    remote: [09:49:53] Testing...
+    remote: [09:49:53] foo bar
+    remote: [09:49:53] Finished 22c36d0c1213361d06b385d2b55648985347e1f4
+    remote: [09:49:53] Commit: cebb4ec18b89f093c7cdeb909c2c340708052575
+    remote: [09:49:53] Cleaning...
+    remote: [09:49:53] Exporting...
+    remote: [09:49:53] Building...
+    remote: [09:49:53] Testing...
+    remote: [09:49:53] foo bar
+    remote: [09:49:53] Finished cebb4ec18b89f093c7cdeb909c2c340708052575
+    To ../tinyci-example-bare
+       22c36d0..cebb4ec  master -> master
+    
+Here we are seeing TinyCI testing both the initial commit that is present in the github repo, an then the new commit that we just made. Breaking the test to see the failure output is left as an exercise for the reader.
+    
+### Contributing
+
+Make an issue, send a pull request, you know the drill. Have a look at the [TODO section](#Limitations_TODO) for some ideas.
+
+TinyCI has a suite of RSpec tests, please use them.
+
+### Copyright
+
+Copyright (c) 2018 Jonathan Davies. See [LICENSE](LICENSE) for details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/tinyci

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'tinyci/cli'
+
+result = TinyCI::CLI.parse!
+
+exit result ? 1 : 0

data/lib/pidfile.rb

@@ -0,0 +1,150 @@
+class PidFile
+  attr_reader :pidfile, :piddir, :pidpath
+
+  class DuplicateProcessError < RuntimeError; end
+
+  VERSION = '0.3.0'
+
+  DEFAULT_OPTIONS = {
+    :pidfile => File.basename($0, File.extname($0)) + ".pid",
+    :piddir => '/var/run',
+  }
+
+  def initialize(*args)
+    opts = {}
+
+    #----- set options -----#
+    case
+    when args.length == 0 then
+    when args.length == 1 && args[0].class == Hash then
+      arg = args.shift
+
+      if arg.class == Hash
+        opts = arg
+      end
+    else
+      raise ArgumentError, "new() expects hash or hashref as argument"
+    end
+
+    opts = DEFAULT_OPTIONS.merge opts
+
+    @piddir     = opts[:piddir]
+    @pidfile    = opts[:pidfile]
+    @pidpath    = File.join(@piddir, @pidfile)
+    @fh         = nil
+
+    #----- Does the pidfile or pid exist? -----#
+    if self.pidfile_exists?
+      if self.class.running?(@pidpath)
+        raise DuplicateProcessError, "TinyCI is already running, process #{self.class.pid} will test your commit, don't worry!"
+        
+        exit! # exit without removing the existing pidfile
+      end
+
+      self.release
+    end
+
+    #----- create the pidfile -----#
+    create_pidfile
+
+    at_exit { release }
+  end
+
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+  # Instance Methods
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+
+  # Returns the PID, if any, of the instantiating process
+  def pid
+    return @pid unless @pid.nil?
+
+    if self.pidfile_exists?
+      @pid = open(self.pidpath, 'r').read.to_i
+    else
+      @pid = nil
+    end
+  end
+
+  # Boolean stating whether this process is alive and running
+  def alive?
+    return false unless self.pid && (self.pid == Process.pid)
+
+    self.class.process_exists?(self.pid)
+  end
+
+  # does the pidfile exist?
+  def pidfile_exists?
+    self.class.pidfile_exists?(pidpath)
+  end
+
+  # unlock and remove the pidfile. Sets pid to nil
+  def release
+    unless @fh.nil?
+      @fh.flock(File::LOCK_UN)
+      remove_pidfile
+    end
+    @pid = nil
+  end
+
+  # returns the modification time of the pidfile
+  def locktime
+    File.mtime(self.pidpath)
+  end
+
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+  # Class Methods
+  #-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#
+
+  # Returns the PID, if any, of the instantiating process
+  def self.pid(path=nil)
+    if pidfile_exists?(path)
+      open(path, 'r').read.to_i
+    end
+  end
+
+  # class method for determining the existence of pidfile
+  def self.pidfile_exists?(path=nil)
+    path ||= File.join(DEFAULT_OPTIONS[:piddir], DEFAULT_OPTIONS[:pidfile])
+
+    File.exist?(path)
+  end
+
+  # boolean stating whether the calling program is already running
+  def self.running?(path=nil)
+    calling_pid = nil
+    path ||= File.join(DEFAULT_OPTIONS[:piddir], DEFAULT_OPTIONS[:pidfile])
+
+    if pidfile_exists?(path)
+      calling_pid = pid(path)
+    end
+
+    process_exists?(calling_pid)
+  end
+
+private
+
+  # Writes the process ID to the pidfile and defines @pid as such
+  def create_pidfile
+    # Once the filehandle is created, we don't release until the process dies.
+    @fh = open(self.pidpath, "w")
+    @fh.flock(File::LOCK_EX | File::LOCK_NB) || raise
+    @pid = Process.pid
+    @fh.puts @pid
+    @fh.flush
+    @fh.rewind
+  end
+
+  # removes the pidfile.
+  def remove_pidfile
+    File.unlink(self.pidpath) if self.pidfile_exists?
+  end
+
+  def self.process_exists?(process_id)
+    begin
+      Process.kill(0, process_id)
+      true
+    rescue Errno::ESRCH, TypeError # "PID is NOT running or is zombied
+      false
+    end
+  end
+end

data/lib/tinyci/builders/rkt_builder.rb

@@ -0,0 +1,31 @@
+require 'tinyci/executor'
+
+module TinyCI
+  module Builders
+    class RktBuilder < TinyCI::Executor
+      def build
+        cmd = [
+          'sudo',
+          'rkt',
+          'run',
+          '--net=host',
+          '--insecure-options=image',
+          '--volume',
+          "src,kind=host,source=#{@config[:target]}/src,readOnly=false",
+          '--mount',
+          "volume=src,target=#{@config[:src_path]}",
+          @config[:image],
+          '--working-dir',
+          @config[:src_path],
+          '--exec',
+          @config[:command]
+        ]
+        
+        log_info "RKT build command: #{cmd.join(' ')}"
+        
+        execute_stream(*cmd, label: 'build')
+      end
+      
+    end
+  end
+end

data/lib/tinyci/builders/script_builder.rb

@@ -0,0 +1,18 @@
+require 'tinyci/executor'
+
+module TinyCI
+  module Builders
+    class ScriptBuilder < TinyCI::Executor
+      def build
+        execute_stream(script_location, label: 'build', pwd: @config[:target])
+      end
+      
+      private
+      
+      def script_location
+        File.join @config[:target], @config[:command]
+      end
+      
+    end
+  end
+end

data/lib/tinyci/builders/test_builder.rb

@@ -0,0 +1,11 @@
+require 'tinyci/executor'
+
+module TinyCI
+  module Builders
+    class TestBuilder < TinyCI::Executor      
+      def build
+        raise 'Simulated build failed' if @config[:result] == false
+      end
+    end
+  end
+end