konstant 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: effe897e9f439446faa514383ab12669c1c876e3
+  data.tar.gz: 0098fb81a4dd80eb3f3963f7b2074015e2967bb2
+SHA512:
+  metadata.gz: 19a2645f44d5428c8145eb804358ca4c09aff2ee08be8bd730f7a5fa8e95eb2187fb27fd41fb1e2972952a0b34c02ad4d02c16c00928e5f1184273eebeac41ce
+  data.tar.gz: aa4fc7a3adbaea16385bfa6b6acfffea7a472b265c64ab024ecf876c750e0dd35690def33c31ab3cc3084e8fa7f81b909b5a4ba46760397e2f73597073631a34

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+projects
+konstant.js

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--backtrace

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p481

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in konstant.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Moritz Schepp (moritz.schepp@gmail.com)
+
+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,125 @@
+# Konstant
+
+A simple continuous integration server with a web UI, that allows
+you to implement a continuous delivery setup.
+
+Konstant is built with ruby and comes as a ruby gem.
+
+## Installation
+
+Just install the gem like this
+
+    $ gem install konstant
+
+This will provide the `konstant` executable.
+
+## Usage
+
+### Setting up the data directory
+
+    $ mkdir ci
+    $ cd ci
+    $ konstant init
+
+This will create an empty projects folder and a sample konstant.js config
+file within `ci`. The config file contains reasonable defaults for you to get
+started with.
+
+
+### Running the server
+
+The konstant server can be instructed to provide the web UI, the actual build
+scheduler or both. The server has to be run from within the directory containing
+`konstant.js`
+
+    $ cd ci
+    $ konstant run -w # provide the web UI (default http://0.0.0.0:9105)
+    $ konstant run -s # provide the CI scheduler
+    $ konstant run -w -s # provide both
+
+run `konstant --help` for some additional options.
+
+
+### Adding projects
+
+Adding projects is done by adding subdirectories under the `ci/projects` folder.
+Bash scripts within those subdirectories define how a project is to be built,
+deployed and cleaned up. A generator is provided to quickly create new projects:
+
+    $ cd ci
+    $ konstant generate project my_app
+
+this will create `ci/projects/my_app` including some sample bash scripts. Modify
+them according to your build scenario.
+
+
+### The scripts
+
+A build is a sequence of jobs:
+
+* `build` is always run
+* `deploy` is only run if `build` succeeded
+* `cleanup` is always run
+
+Those jobs are represented by bash scripts within each project directory. Only
+the `build` script is required, the other jobs are simply not executed
+if the files are missing.
+
+The scripts are required to have the executable bit set. Apart from that, it is
+recommended to have each script start with `#!/bin/bash -e` so that any
+failed command within the script will prevent the execution of any remaining 
+commands.
+
+When a project is built, the above jobs are executed while status, stdout and
+stderr are recorded within the directory for that build. Build directories are
+kept under `ci/projects/my_app/builds` and are named according to the timestamp
+when the build was requested.
+
+
+### Triggering builds
+
+Once the CI scheduler is up and running, building can be triggered in three
+ways:
+
+* click a button on the web UI
+* create the file `ci/projects/my_app/run.txt`
+* make an http request to `/projects/my_app/build` (any http verb works)
+
+You might find the last two ways useful to automate builds after git pushes.
+
+
+### Sample project
+
+For example, to test the
+`carrierwave_backgrounder` ruby gem, you could
+
+    $ cd ci/projects/carrierwave_backgrounder
+    $ git clone https://github.com/lardawge/carrierwave_backgrounder.git src
+
+And insert the following code into `ci/projects/carrierwave_backgrounder/build`
+
+```bash
+#!/bin/bash -e
+
+cd $KONSTANT_PROJECT_ROOT/src
+git pull
+
+bundle install --path=$KONSTANT_PROJECT_ROOT/bundle --quiet
+
+bundle exec rspec --format progress
+```
+
+Since we don't want to deploy anything after successful builds and there is
+nothing to cleanup, you might want to
+
+    $ cd ci/projects/carrierwave_backgrounder/
+    $ rm deploy cleanup
+
+
+## Contributing
+
+1. Fork it ( https://github.com/coneda/konstant/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/bin/konstant

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'konstant'
+
+unless Konstant.env == "production"
+  require "debugger"
+end
+
+cli = Konstant::Cli.new
+cli.parse_options
+command = cli.cli_arguments.first
+
+[:INT, :TERM].each do |sig|
+  trap sig do
+    Konstant.shutdown_handlers.each do |sh|
+      sh.call
+    end
+  end
+end
+
+command = "version" if cli.config[:version]
+Konstant.configure "data_dir" => File.expand_path(".")
+
+case command
+  when "version"
+    puts Konstant::VERSION
+  when "run"
+    Konstant.configure "./konstant.js"
+
+    require "puma"
+    require "rack/handler/puma"
+
+    threads = []
+
+    if cli.config[:web]
+      threads << Thread.new do
+        options = {
+          :Host => cli.config[:host],
+          :Port => cli.config[:port]
+        }
+
+        app = Konstant::Web
+        static = Rack::Static.new(app,
+          :urls => ["/assets"],
+          :root => "#{Konstant.root}/public",
+          :index => "index.html"
+        )
+
+        Rack::Handler::Puma.run static, options do |server|
+          Konstant.shutdown_handlers << Proc.new do
+            server.stop
+          end
+        end
+      end
+      sleep 2
+      puts "Web server started"
+    end
+
+    if cli.config[:scheduler]
+      threads << Thread.new do
+        Konstant::Scheduler.new.run
+      end
+      puts "Build scheduler started"
+    end
+
+    threads.map{|t| t.join}
+  when "config"
+    Konstant.configure "./konstant.js"
+    p Konstant.config
+  when "init"
+    system "cp -a #{Konstant.root}/data/templates/data_dir/* ."
+  when "generate"
+    item = cli.cli_arguments[1]
+
+    case item
+      when "project"
+        project_id = cli.cli_arguments[2]
+        Konstant.configure "./konstant.js"
+        system "cp -a #{Konstant.root}/data/templates/project #{Konstant.config['data_dir']}/projects/#{project_id}"
+      else
+        puts "Generator doesn't exist: '#{item}'"
+    end
+  else
+    raise "unknown command '#{command}'"
+end

data/data/templates/data_dir/konstant.js

@@ -0,0 +1,16 @@
+{
+  /* the amount of builds to keep for each project */
+  "builds_to_keep": 50,
+
+  /* the interval to check for new projects */
+  "new_projects_interval": 5,
+
+  /* the interval to check if a project has to be rebuilt */
+  "build_check_interval": 1,
+
+  /* the sender address for mail notifications */
+  "mail_sender": "admin@example.com",
+
+  /* a list of recipients for notifications on failures and recoveries */
+  "notify": []
+}

data/data/templates/project/build

@@ -0,0 +1,8 @@
+#!/bin/bash -e
+
+# Some output (stdout)
+echo "Building in project dir $KONSTANT_PROJECT_ROOT ..."
+echo "The build timestamp is $KONSTANT_TIMESTAMP"
+
+# Exit with positive status code (build succeeded)
+# exit 0

data/data/templates/project/cleanup

@@ -0,0 +1,5 @@
+#!/bin/bash -e
+
+# Add code to cleanup the build directory after each build. This happens in
+# case of success and failure alike.
+echo "Cleaning up ..."

data/data/templates/project/deploy

@@ -0,0 +1,4 @@
+#!/bin/bash -e
+
+# Add code to deploy this project to production after a successful build
+echo "Deploying ..."

data/konstant.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'konstant/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "konstant"
+  spec.version       = Konstant::VERSION
+  spec.authors       = ["Moritz Schepp"]
+  spec.email         = ["moritz.schepp@gmail.com"]
+  spec.summary       = "Continous delivery made easy."
+  spec.homepage      = "https://github.com/coneda/konstant"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "debugger"
+
+  spec.add_dependency "json"
+  spec.add_dependency "puma"
+  spec.add_dependency "mixlib-cli"
+  spec.add_dependency "mail"
+end

data/lib/konstant/build.rb

@@ -0,0 +1,86 @@
+class Konstant::Build
+
+  def initialize(project, timestamp)
+    @project = project
+    @timestamp = timestamp
+  end
+
+  attr_reader :project, :timestamp
+
+  def create
+    system "mkdir -p #{path}"
+  end
+
+  def destroy
+    system "rm -rf #{path}"
+  end
+
+  def human
+    Time.parse(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+  end
+
+  def ok?(task = 'build')
+    status(task) == nil ? nil : (status(task) == 0)
+  end
+
+  def failure?
+    !ok?
+  end
+
+  def path
+    "#{project.path}/builds/#{timestamp}"
+  end
+
+  def status(task = 'build')
+    File.read("#{path}/#{task}.status").strip.to_i
+  rescue Errno::ENOENT => e
+    nil
+  end
+
+  def stdout(task = 'build')
+    File.read "#{path}/#{task}.stdout"
+  rescue Errno::ENOENT => e
+    nil
+  end
+
+  def stderr(task = 'build')
+    File.read "#{path}/#{task}.stderr"
+  rescue Errno::ENOENT => e
+    nil
+  end
+
+  def previous
+    timestamps = project.build_timestamps
+    index = timestamps.index(timestamp)
+    if index <= timestamps.size - 1
+      project.builds[index + 1]
+    end
+  end
+
+  def as_json(*)
+    return {
+      "project_id" => project.id,
+      "timestamp" => timestamp,
+      "human" => human,
+      "stdout" => stdout,
+      "stderr" => stderr,
+      "status" => status,
+      "ok" => ok?,
+      "deploy" => {
+        "stdout" => stdout('deploy'),
+        "stderr" => stderr('deploy'),
+        "status" => status('deploy')
+      },
+      "cleanup" => {
+        "stdout" => stdout('cleanup'),
+        "stderr" => stderr('cleanup'),
+        "status" => status('cleanup')
+      }
+    }
+  end
+
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+
+end

data/lib/konstant/builder.rb

@@ -0,0 +1,108 @@
+class Konstant::Builder
+
+  def initialize(project)
+    @project = project
+    @timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+    @new_build = Konstant::Build.new project, timestamp
+  end
+
+  attr_reader :project, :timestamp, :new_build
+
+  def run
+    Konstant.logger.info "building project '#{project.id}'"
+
+    if build
+      if previous_build_failed?
+        Konstant.logger.info "project '#{project.id}' recovered"
+        notify :recovery
+      else
+        Konstant.logger.info "project '#{project.id}' built successfully"
+      end
+
+      Konstant.logger.info "deploying project '#{project.id}'"
+      unless deploy
+        notify :deploy_failed
+      end
+      Konstant.logger.info "project '#{project.id}' deployed"
+    else  
+      Konstant.logger.info "project '#{project.id}' failed to build"
+      notify :failure
+    end
+
+    Konstant.logger.info "cleaning up project '#{project.id}'"
+    unless cleanup
+      notify :cleanup_failed
+    end
+    Konstant.logger.info "project '#{project.id}' cleaned up"
+
+    symlink
+    Konstant.logger.info "finished building project '#{project.id}'"
+
+    cleanup_old_builds
+  end
+
+  def build
+    Konstant::Runner.new(new_build, "build").run
+  end
+
+  def deploy
+    Konstant::Runner.new(new_build, "deploy").run
+  end
+
+  def cleanup
+    Konstant::Runner.new(new_build, "cleanup").run
+  end
+
+  def cleanup_old_builds
+    builds = project.builds
+    limit = Konstant.config["builds_to_keep"]
+
+    if builds.size > limit
+      Konstant.logger.info "removing #{builds.size - limit} build(s) from project '#{project.id}'"
+      builds[limit..-1].each do |build|
+        build.destroy
+      end
+    end
+  end
+
+  def symlink
+    system "ln -sfn #{new_build.path} #{project.path}/current"
+  end
+
+  def notify(message)
+    unless Konstant.config["notify"].empty?
+      Mail.deliver do
+        from Konstant.config["mail_sender"]
+        to Konstant.config["notify"]
+
+        case message
+          when :failure
+            subject "Konstant: Project failed: #{project.id}"
+          when :recovery
+            subject "Konstant: Project recovered: #{project.id}"
+          when :cleanup_failed
+            subject "Konstant: Project could not be cleaned up: #{project.id}"
+          when :deploy_failed
+            subject "Konstant: Project could not be deployed: #{project.id}"
+        end
+      end
+    end
+  end
+
+  def build_status
+    new_build.status
+  end
+
+  def build_stdout
+    new_build.stdout
+  end
+
+  def build_stderr
+    new_build.stderr
+  end
+
+  def previous_build_failed?
+    new_build.previous ? new_build.previous.failure? : false
+  end
+
+end

data/lib/konstant/cli.rb

@@ -0,0 +1,37 @@
+require "mixlib/cli"
+
+class Konstant::Cli
+
+  include Mixlib::CLI
+
+  option(:web,
+    :short => "-w",
+    :long => "--web",
+    :default => false
+  )
+
+  option(:scheduler,
+    :short => "-s",
+    :long => "--scheduler",
+    :default => false
+  )
+
+  option(:host,
+    :short => "-h HOST",
+    :long => "--host HOST",
+    :default => "0.0.0.0"
+  )
+
+  option(:port,
+    :short => "-p PORT",
+    :long => "--port PORT",
+    :default => "9105"
+  )
+
+  option(:version,
+    :short => "-v",
+    :long => "--version",
+    :default => false
+  )
+
+end

data/lib/konstant/project.rb

@@ -0,0 +1,75 @@
+class Konstant::Project
+
+  def initialize(id)
+    @id = id
+  end
+
+  attr_reader :id
+
+  def self.all
+    Dir["#{Konstant.config['data_dir']}/projects/*"].map do |path|
+      new path.split('/').last
+    end
+  end
+
+  def build!
+    system "touch #{path}/run.txt"
+  end
+
+  def building?
+    File.exists? "#{path}/running.txt"
+  end
+
+  def path
+    "#{Konstant.config['data_dir']}/projects/#{id}"
+  end
+
+  def build_timestamps
+    Dir["#{path}/builds/*"].map do |path|
+      path.split('/').last
+    end.sort.reverse
+  end
+
+  def builds
+    build_timestamps.map do |ts|
+      Konstant::Build.new self, ts
+    end
+  end
+
+  def last_build
+    if ts = build_timestamps.first
+      Konstant::Build.new self, ts
+    end
+  end
+
+  def ok?(task = 'build')
+    last_build && last_build.ok?(task)
+  end
+
+  def status(task = 'build')
+    last_build ? last_build.status(task) : nil
+  end
+
+  def stdout(task = 'build')
+    last_build ? last_build.stdout(task) : nil
+  end
+
+  def stderr(task = 'build')
+    last_build ? last_build.stderr(task) : nil
+  end
+
+  def as_json(*)
+    return {
+      "id" => id,
+      "ok" => ok?,
+      "deploy_ok" => ok?('deploy'),
+      "cleanup_ok" => ok?('cleanup'),
+      "building" => building?
+    }
+  end
+
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+  
+end