buildbox 0.0.4 → 0.1

data/lib/buildbox/client.rb

@@ -1,86 +0,0 @@
-module Buildbox
-  class Client
-    def initialize(options)
-      @options  = options
-      @interval = 5
-    end
-
-    def start
-      exit_if_already_running
-
-      Buildbox.logger.info "Starting client..."
-
-      register_client
-
-      begin
-        daemonize if @options[:daemon]
-        pid_file.save
-
-        loop do
-          reload_configuration
-          Buildbox::Worker.new.process
-          wait_for_interval
-        end
-      rescue => e
-        Buildbox.logger.error "#{e.class.name}: #{e.message}"
-        e.backtrace.each { |line| Buildbox.logger.error line }
-
-        api.crash(e)
-      ensure
-        pid_file.delete
-      end
-    end
-
-    def stop
-      Buildbox.logger.info "Stopping client..."
-
-      Process.kill(:KILL, pid_file.delete)
-    end
-
-    private
-
-    def daemonize
-      if @options[:daemon]
-        Process.daemon
-
-        Buildbox.logger = Logger.new(Buildbox.root_path.join("buildbox.log"))
-      end
-    end
-
-    def register_client
-      worker_uuid = Buildbox.configuration.worker_uuid
-      response    = api.register(:uuid => worker_uuid, :hostname => `hostname`.chomp)
-
-      Buildbox.configuration.update :worker_uuid, response.payload[:uuid]
-    end
-
-    def reload_configuration
-      Buildbox.configuration.reload
-    end
-
-    def wait_for_interval
-      Buildbox.logger.debug "Sleeping for #{@interval} seconds"
-
-      sleep(@interval)
-    end
-
-    def exit_if_already_running
-      if pid_file.exist?
-        Buildbox.logger.error "Process (#{pid_file.pid} - #{pid_file.path}) is already running."
-
-        exit 1
-      end
-    end
-
-    def worker
-    end
-
-    def api
-      @api ||= Buildbox::API.new(:api_key => Buildbox.configuration.api_key)
-    end
-
-    def pid_file
-      @pid_file ||= Buildbox::PidFile.new
-    end
-  end
-end

data/lib/buildbox/observer.rb

@@ -1,59 +0,0 @@
-module Buildbox
-  class Observer
-    INTERVAL = 3 # feels like a good number
-
-    def initialize(api, build_uuid)
-      @api        = api
-      @build_uuid = build_uuid
-
-      @queue    = Queue.new
-      @results  = {}
-      @threads  = {}
-    end
-
-    def started(result)
-      @results[result.uuid] = result
-
-      update(result.uuid)
-    end
-
-    def chunk(result)
-      update_on_interval(result.uuid)
-    end
-
-    def finished(result)
-      # kill off the interval updater
-      thread = @threads[result.uuid]
-      thread.kill if thread && thread.alive?
-
-      update(result.uuid)
-    end
-
-    private
-
-    # every INTERVAL seconds, read from the result and update the server with the output.
-    # if we don't do updates every INTERVAL like this, then we end up spamming the server
-    # with every chunk we get from the command runner (which ends up being every line), and in the case
-    # of a bundle install for example, it may have 100 lines, we end up doing 100 updates to the server.
-    def update_on_interval(uuid)
-      return if @threads[uuid]
-
-      @threads[uuid] = Thread.new do
-        loop do
-          update(uuid)
-          sleep INTERVAL
-        end
-      end
-
-      @threads[uuid].abort_on_exception = true
-    end
-
-    def update(uuid)
-      result       = @results[uuid]
-      json         = result.as_json
-      json[:state] = json.delete(:finished) ? 'finished' : 'started'
-
-      @api.update_build_result_async(@build_uuid, json.delete(:uuid), json)
-    end
-  end
-end

data/lib/buildbox/pid_file.rb

@@ -1,25 +0,0 @@
-module Buildbox
-  class PidFile
-    def exist?
-      File.exist?(path)
-    end
-
-    def path
-      Buildbox.root_path.join("buildbox.pid")
-    end
-
-    def pid
-      File.readlines(path).first.to_i
-    end
-
-    def save
-      File.open(path, 'w+') { |file| file.write(Process.pid.to_s) }
-    end
-
-    def delete
-      value = pid
-      File.delete(path)
-      value
-    end
-  end
-end

data/lib/buildbox/response.rb

@@ -1,49 +0,0 @@
-module Buildbox
-  class Response
-    attr_reader :payload
-
-    def initialize(response)
-      @response = response
-
-      unless success?
-        raise "API Error: #{@response.code} #{@response.body}"
-      end
-
-      if json?
-        json = JSON.parse(@response.body)
-
-        if json.kind_of?(Array)
-          @payload = json.map { |item| symbolize_keys(item) }
-        else
-          @payload = symbolize_keys(json)
-        end
-      end
-    end
-
-    def success?
-      @response.code.to_i == 200
-    end
-
-    private
-
-    def json?
-      @response['content-type'] =~ /json/
-    end
-
-    def symbolize_keys(hash)
-      hash.inject({}) do |result, item|
-        key, value = item
-        new_key   = case key
-                    when String then key.to_sym
-                    else key
-                    end
-        new_value = case value
-                    when Hash then symbolize_keys(value)
-                    else value
-                    end
-        result[new_key] = new_value
-        result
-      end
-    end
-  end
-end

data/lib/buildbox/result.rb

@@ -1,36 +0,0 @@
-module Buildbox
-  class Result
-    require 'securerandom'
-
-    attr_reader :uuid, :command
-    attr_accessor :output, :finished, :exit_status
-
-    def initialize(command)
-      @uuid     = SecureRandom.uuid
-      @output   = ""
-      @finished = false
-      @command  = command
-    end
-
-    def finished?
-      finished
-    end
-
-    def success?
-      exit_status == 0
-    end
-
-    def as_json
-      { :uuid        => @uuid,
-        :command     => @command,
-        :output      => clean_output,
-        :exit_status => @exit_status }
-    end
-
-    private
-
-    def clean_output
-      Buildbox::UTF8.clean(@output).chomp
-    end
-  end
-end

data/spec/buildbox/buildbox/build_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-describe Buildbox::Build do
-  let(:build) { Buildbox::Build.new(:uuid => '1234', :repository => "git@github.com:keithpitt/ci-ruby.git", :commit => "67b15b704e0", :command => "rspec") }
-
-  describe "#start" do
-    let(:build_path) { double }
-    let(:root_path)  { double(:join => build_path) }
-    let(:command)    { double(:run => true, :run! => true) }
-
-    before do
-      Buildbox.stub(:root_path => root_path)
-      Buildbox::Command.stub(:new => command)
-    end
-
-    context "with a new checkout" do
-      before do
-        build_path.stub(:exist? => false, :mkpath => true)
-      end
-
-      it "creates a directory for the build" do
-        build_path.should_receive(:mkpath)
-
-        build.start
-      end
-
-      it "creates a folder for the build" do
-        root_path.should_receive(:join).with('git-github-com-keithpitt-ci-ruby-git')
-
-        build.start
-      end
-
-      it "clones the repo" do
-        command.should_receive(:run!).with(%{git clone "git@github.com:keithpitt/ci-ruby.git" .}).once
-
-        build.start
-      end
-    end
-
-    context "with an existing checkout" do
-      before do
-        build_path.stub(:exist? => true)
-      end
-
-      it "doesn't checkout the repo again" do
-        command.should_not_receive(:run!).with(%{git clone "git@github.com:keithpitt/ci-ruby.git" .})
-
-        build.start
-      end
-
-      it "cleans, fetches and checks out the commit" do
-        command.should_receive(:run!).with(%{git clean -fd}).ordered
-        command.should_receive(:run!).with(%{git fetch}).ordered
-        command.should_receive(:run!).with(%{git checkout -qf "67b15b704e0"}).ordered
-
-        build.start
-      end
-
-      it "runs the command" do
-        command.should_receive(:run).with(%{rspec})
-
-        build.start
-      end
-    end
-  end
-end

data/spec/buildbox/buildbox/configuration_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Buildbox::Configuration do
-  subject(:configuration) { Buildbox::Configuration.new }
-
-  it "has a default endpoint" do
-    configuration.endpoint.should =~ /buildbox/
-  end
-end

data/spec/buildbox/buildbox_spec.rb

@@ -1,4 +0,0 @@
-require 'spec_helper'
-
-describe Buildbox do
-end

data/spec/support/dotenv.rb

@@ -1,3 +0,0 @@
-require 'dotenv'
-
-Dotenv.load