buildbox 0.0.4 → 0.1

data/lib/buildbox/cli.rb

@@ -0,0 +1,92 @@
+require 'optparse'
+
+module Buildbox
+  class CLI
+    attr_reader :argv
+
+    def initialize(argv)
+      @argv     = argv
+      @commands = {}
+      @options  = {}
+
+      @commands['worker:start'] = OptionParser.new do |opts|
+        opts.banner = "Usage: buildbox worker:start"
+
+        opts.on("--help", "You're looking at it.") do
+          puts @commands['worker:start']
+          exit
+        end
+      end
+
+      @commands['worker:setup'] = OptionParser.new do |opts|
+        opts.banner = "Usage: buildbox worker:setup [token]"
+
+        opts.on("--help", "You're looking at it.") do
+          puts @commands['worker:setup']
+          exit
+        end
+      end
+
+      @commands['version'] = OptionParser.new do |opts|
+        opts.banner = "Usage: buildbox version"
+      end
+    end
+
+    def parse
+      global.order!
+
+      command = @argv.shift
+
+      if command
+        if @commands.has_key?(command)
+          @commands[command].parse!
+        else
+          puts "`#{command}` is an unknown command"
+          exit 1
+        end
+
+        if command == "version"
+          puts Buildbox::VERSION
+          exit
+        end
+
+        if command == "worker:start"
+          Buildbox::Worker.new(Buildbox.config.worker_access_token).start
+        elsif command == "worker:setup"
+          if @argv.length == 0
+            puts "No token provided"
+            exit 1
+          end
+
+          access_token = @argv.first
+          Buildbox.config.update(:worker_access_token => access_token)
+
+          puts "Successfully added worker access token"
+          puts "You can now start the worker with `buildbox worker:start`"
+        end
+      else
+        puts global.help
+      end
+    end
+
+    private
+
+    def global
+      @global ||= OptionParser.new do |opts|
+        opts.version = Buildbox::VERSION
+        opts.banner  = 'Usage: buildbox COMMAND [command-specific-actions]'
+
+        opts.separator help
+      end
+    end
+
+    def help
+<<HELP
+
+  worker   #  worker management (setup, server)
+  version  #  display version
+
+HELP
+    end
+  end
+end

data/lib/buildbox/command.rb

@@ -1,46 +1,40 @@
+require 'pty'
+
 module Buildbox
   class Command
-    require 'pty'
-
-    class Error < StandardError; end
+    class Result < Struct.new(:output, :exit_status)
+    end
 
-    def initialize(path = nil, read_interval = nil)
-      @path          = path || "."
-      @read_interval = read_interval || 5
+    def self.run(command, options = {}, &block)
+      new(command, options).run(&block)
     end
 
-    def run(command)
-      Buildbox.logger.debug(command)
+    def initialize(command, options = {})
+      @command       = command
+      @directory     = options[:directory] || "."
+      @read_interval = options[:read_interval] || 5
+    end
 
+    def run(&block)
+      output = ""
       read_io, write_io, pid = nil
-      result = Buildbox::Result.new(command)
-
-      # hack: this is so the observer class can raise a started event.
-      # instead of having a block passed to this command, we should implement
-      # a proper command observer
-      yield result
-
-      begin
-        dir = File.expand_path(@path)
 
-        # spawn the process in a pseudo terminal so colors out outputted
-        read_io, write_io, pid = PTY.spawn("cd #{dir} && #{command}")
-      rescue Errno::ENOENT => e
-        return Buildbox::Result.new(false, e.message)
-      end
+      # spawn the process in a pseudo terminal so colors out outputted
+      read_io, write_io, pid = PTY.spawn("cd #{expanded_directory} && #{@command}")
 
+      # we don't need to write to the spawned io
       write_io.close
 
       loop do
-        fds, = IO.select([read_io], nil, nil, @read_interval)
+        fds, = IO.select([read_io], nil, nil, read_interval)
         if fds
           # should have some data to read
           begin
-            chunk = read_io.read_nonblock(10240)
-            if block_given?
-              yield result, chunk
-            end
-            result.output += chunk
+            chunk         = read_io.read_nonblock(10240)
+            cleaned_chunk = UTF8.clean(chunk)
+
+            output << chunk
+            yield cleaned_chunk if block_given?
           rescue Errno::EAGAIN, Errno::EWOULDBLOCK
             # do select again
           rescue EOFError, Errno::EIO # EOFError from OSX, EIO is raised by ubuntu
@@ -50,24 +44,24 @@ module Buildbox
         # if fds are empty, timeout expired - run another iteration
       end
 
+      # we're done reading, yay!
       read_io.close
-      Process.waitpid(pid)
 
-      # output may be invalid UTF-8, as it is produced by the build command.
-      result.finished    = true
-      result.exit_status = $?.exitstatus
+      # just wait until its finally finished closing
+      Process.waitpid(pid)
 
-      result
+      # the final result!
+      Result.new(output.chomp, $?.exitstatus)
     end
 
-    def run!(command)
-      result = run(command)
+    private
 
-      unless result.success?
-        raise Error, "Failed to run '#{command}': #{result.output}"
-      end
+    def expanded_directory
+      File.expand_path(@directory)
+    end
 
-      result
+    def read_interval
+      @read_interval
     end
   end
 end

data/lib/buildbox/configuration.rb

@@ -1,61 +1,37 @@
-module Buildbox
-  class Configuration
-    def self.load(*args)
-      new(*args).tap &:reload
-    end
-
-    require 'json'
+require 'rubygems'
+require 'hashie/dash'
+require 'json'
 
-    attr_accessor :worker_uuid
-    attr_accessor :api_key
-    attr_accessor :endpoint
-    attr_accessor :use_ssl
-    attr_accessor :api_version
-
-    def initialize
-      @use_ssl       = true
-      @endpoint      = 'api.buildbox.io'
-      @api_version   = 1
-    end
+module Buildbox
+  class Configuration < Hashie::Dash
+    property :worker_access_token, :default => nil
+    property :api_endpoint,        :default => "http://api.buildbox.dev/v1"
 
-    def update(key, value)
-      self.public_send("#{key}=", value)
+    def update(attributes)
+      attributes.each_pair { |key, value| self[key] = value }
       save
     end
 
     def save
-      File.open(path, 'w+') do |file|
-        file.write(to_json)
-      end
-      Buildbox.logger.debug "Configuration saved to `#{path}`"
+      File.open(path, 'w+') { |file| file.write(pretty_json) }
     end
 
     def reload
-      json = if path.exist?
-               read
-             else
-               save && read
-             end
-
-      json.each_pair do |key, value|
-        self.public_send("#{key}=", value)
+      if path.exist?
+        read_and_load
+      else
+        save && read_and_load
       end
     end
 
     private
 
-    def to_json
-      JSON.pretty_generate(:endpoint    => endpoint,
-                           :use_ssl     => use_ssl,
-                           :api_version => api_version,
-                           :api_key     => api_key,
-                           :worker_uuid => worker_uuid)
+    def pretty_json
+      JSON.pretty_generate(self)
     end
 
-    def read
-      Buildbox.logger.debug "Reading configuration `#{path}`"
-
-      JSON.parse(path.read)
+    def read_and_load
+      merge! JSON.parse(path.read)
     end
 
     def path

data/lib/buildbox/environment.rb

@@ -0,0 +1,17 @@
+module Buildbox
+  class Environment
+    def initialize(environment)
+      @environment = environment
+    end
+
+    def any?
+      @environment && @environment.keys.length > 0
+    end
+
+    def to_s
+      @environment.to_a.map do |key, value|
+        %{#{key}=#{value.inspect}}
+      end.join(" ")
+    end
+  end
+end

data/lib/buildbox/monitor.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'celluloid'
+
+module Buildbox
+  class Monitor
+    include Celluloid
+
+    def initialize(build, api)
+      @build = build
+      @api   = api
+    end
+
+    def monitor
+      loop do
+        @api.update_build(@build) if @build.started?
+
+        if @build.finished?
+          break
+        else
+          sleep 1
+        end
+      end
+    end
+  end
+end

data/lib/buildbox/runner.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'celluloid'
+require 'tempfile'
+require 'fileutils'
+
+module Buildbox
+  class Runner
+    include Celluloid
+    include Celluloid::Logger
+
+    attr_reader :build
+
+    def initialize(build)
+      @build = build
+    end
+
+    def start
+      info "Starting to build #{namespace}/#{@build.number} starting..."
+      info "Running command: #{command}"
+
+      FileUtils.mkdir_p(directory_path)
+      File.open(script_path, 'w+') { |file| file.write(@build.script) }
+
+      build.output = ""
+      result = Command.run(command, :directory => directory_path) do |chunk|
+        build.output << chunk
+      end
+
+      build.output      = result.output
+      build.exit_status = result.exit_status
+
+      info "#{namespace}/#{@build.number} finished"
+    end
+
+    private
+
+    def command
+      export = environment.any? ? "export #{environment};" : ""
+
+      "#{export} chmod +x #{script_path} && #{script_path}"
+    end
+
+    def directory_path
+      @directory_path ||= Buildbox.root_path.join(namespace)
+    end
+
+    def script_path
+      @script_path ||= Tempfile.new("buildbox-#{namespace.gsub(/\//, '-')}-#{@build.number}").path
+    end
+
+    def namespace
+      "#{@build.project.team.name}/#{@build.project.name}"
+    end
+
+    def environment
+      @environment ||= Environment.new(@build.env)
+    end
+  end
+end

data/lib/buildbox/version.rb

@@ -1,3 +1,3 @@
 module Buildbox
-  VERSION = "0.0.4"
+  VERSION = "0.1"
 end

data/lib/buildbox/worker.rb

@@ -1,21 +1,37 @@
 module Buildbox
   class Worker
-    def process
-      if scheduled = api.builds.payload.first
-        start Build.new(scheduled)
+    def initialize(access_token)
+      @access_token = access_token
+    end
+
+    def start
+      loop do
+        projects.each do |project|
+          running_builds = api.scheduled_builds(project).map do |build|
+            Monitor.new(build, api).async.monitor
+            Runner.new(build).future(:start)
+          end
+
+          # wait for all the running builds to finish
+          running_builds.map(&:value)
+
+          sleep 5
+        end
       end
     end
 
     private
 
-    def start(build)
-      api.update_build_state(build.uuid, 'started')
-      build.start Buildbox::Observer.new(api, build.uuid)
-      api.update_build_state_async(build.uuid, 'finished')
+    def api
+      @api ||= Buildbox::API.new
     end
 
-    def api
-      @api ||= Buildbox::API.new(:api_key => Buildbox.configuration.api_key)
+    def projects
+      api.worker(:access_token => @access_token, :hostname => hostname).projects
+    end
+
+    def hostname
+      `hostname`.chomp
     end
   end
 end

data/spec/buildbox/buildbox/command_spec.rb

@@ -1,34 +1,34 @@
+# encoding: UTF-8
+
 require "spec_helper"
 
 describe Buildbox::Command do
-  let(:command) { Buildbox::Command.new }
-
   describe "#run" do
     it "successfully runs and returns the output from a simple comment" do
-      result = command.run('echo hello world')
+      result = Buildbox::Command.run('echo hello world')
 
-      result.should be_success
-      result.output.should == 'hello world'
+      result.exit_status.should == 0
+      result.output.should == "hello world"
     end
 
     it "redirects stdout to stderr" do
-      result = command.run('echo hello world 1>&2')
+      result = Buildbox::Command.run('echo hello world 1>&2')
 
-      result.should be_success
-      result.output.should == 'hello world'
+      result.exit_status.should == 0
+      result.output.should == "hello world"
     end
 
     it "handles commands that fail and returns the correct status" do
-      result = command.run('(exit 1)')
+      result = Buildbox::Command.run('(exit 1)')
 
-      result.should_not be_success
+      result.exit_status.should_not == 0
       result.output.should == ''
     end
 
     it "handles running malformed commands" do
-      result = command.run('if (')
+      result = Buildbox::Command.run('if (')
 
-      result.should_not be_success
+      result.exit_status.should_not == 0
       # bash 3.2.48 prints "syntax error" in lowercase.
       # freebsd 9.1 /bin/sh prints "Syntax error" with capital S.
       # zsh 5.0.2 prints "parse error" which we do not handle.
@@ -39,36 +39,40 @@ describe Buildbox::Command do
 
     it "can collect output in chunks" do
       chunked_output = ''
-      result = command.run('echo hello world') do |result, chunk|
-        chunked_output += chunk
+      result = Buildbox::Command.run('echo hello world') do |chunk|
+        unless chunk.nil?
+          chunked_output += chunk
+        end
       end
 
-      result.should be_success
-      result.output.should == 'hello world'
+      result.exit_status.should == 0
+      result.output.should == "hello world"
       chunked_output.should == "hello world\r\n"
     end
 
     it "can collect chunks at paticular intervals" do
-      command = Buildbox::Command.new(nil, 0.1)
+      command = Buildbox::Command.new(nil, :read_interval => 0.1)
 
       chunked_output = ''
-      result = command.run('sleep 0.5; echo hello world') do |result, chunk|
-        chunked_output += chunk
+      result = Buildbox::Command.run('sleep 0.5; echo hello world') do |chunk|
+        unless chunk.nil?
+          chunked_output += chunk
+        end
       end
 
-      result.should be_success
-      result.output.should == 'hello world'
+      result.exit_status.should == 0
+      result.output.should == "hello world"
       chunked_output.should == "hello world\r\n"
     end
 
-    it 'passes a result object to the block'
-
     it "can collect chunks from within a thread" do
       chunked_output = ''
       result = nil
       worker_thread = Thread.new do
-        result = command.run('echo before sleep; sleep 1; echo after sleep') do |result, chunk|
-          chunked_output += chunk
+        result = Buildbox::Command.run('echo before sleep; sleep 1; echo after sleep') do |chunk|
+          unless chunk.nil?
+            chunked_output += chunk
+          end
         end
       end
 
@@ -80,7 +84,7 @@ describe Buildbox::Command do
       worker_thread.join
 
       result.should_not be_nil
-      result.should be_success
+      result.exit_status.should == 0
       result.output.should == "before sleep\r\nafter sleep"
       chunked_output.should == "before sleep\r\nafter sleep\r\n"
     end
@@ -89,15 +93,15 @@ describe Buildbox::Command do
       result = nil
       second_result = nil
       thread = Thread.new do
-        result = command.run('sillycommandlololol')
-        second_result = command.run('export FOO=bar; doesntexist.rb')
+        result = Buildbox::Command.run('sillycommandlololol')
+        second_result = Buildbox::Command.run('export FOO=bar; doesntexist.rb')
       end
       thread.join
 
-      result.should_not be_success
+      result.exit_status.should_not == 0
       result.output.should =~ /sillycommandlololol.+not found/
 
-      second_result.should_not be_success
+      second_result.exit_status.should_not == 0
       # osx: `sh: doesntexist.rb: command not found`
       # ubuntu: `sh: 1: doesntexist.rb: not found`
       second_result.output.should =~ /doesntexist.rb:.+not found/
@@ -105,13 +109,22 @@ describe Buildbox::Command do
 
     it "captures color'd output" do
       chunked_output = ''
-      result = command.run("rspec #{FIXTURES_PATH.join('rspec', 'test_spec.rb')} --color") do |result, chunk|
-        chunked_output += chunk
+      result = Buildbox::Command.run("rspec #{FIXTURES_PATH.join('rspec', 'test_spec.rb')} --color") do |chunk|
+        chunked_output += chunk unless chunk.nil?
       end
 
-      result.should be_success
+      result.exit_status.should == 0
       result.output.should include("32m")
       chunked_output.should include("32m")
     end
+
+    it "supports utf8 characters" do
+      result = Buildbox::Command.run('echo "hello"; echo "\xE2\x98\xA0"')
+
+      result.exit_status.should == 0
+      # just trying to interact with the string that has utf8 in it to make sure that it
+      # doesn't blow up like it doesn on osx. this is hacky - need a better test.
+      added = result.output + "hello"
+    end
   end
 end