juici 0.0.0.alpha1

data/lib/juici/app.rb

@@ -0,0 +1,67 @@
+at_exit do
+  Juici::App.shutdown
+end
+
+module Juici
+  class App
+    @@watchers = []
+
+    def self.shutdown
+      ::Juici.dbgp "Shutting down Juici"
+      ::Juici::Watcher.instance.shutdown!
+
+      shutdown_build_queue
+    end
+
+    attr_reader :opts
+    def initialize(opts={})
+      Database.initialize!
+      @opts = opts
+      reset_stale_children
+      start_watcher
+      init_build_queue
+      reload_unfinished_work
+      start_queue
+    end
+
+  private
+
+    def init_build_queue
+      $build_queue ||= BuildQueue.new
+    end
+
+    def self.shutdown_build_queue
+      if $build_queue
+        $build_queue.shutdown!
+        $build_queue = nil
+      end
+
+      # Find any remaining children and kill them
+      # Ensure that any killed builds will be retried
+    end
+
+    def start_watcher
+      ::Juici::Watcher.instance.start
+    end
+
+    def reload_unfinished_work
+      # At this point no workers have started yet, we can safely assume that
+      # :started means aborted
+      Build.where(:status => Juici::BuildStatus::WAIT).each do |build|
+        $build_queue << build
+      end
+    end
+
+    def reset_stale_children
+      Build.where(:status => Juici::BuildStatus::START).each do |build|
+        build[:status] = Juici::BuildStatus::WAIT
+        build.save!
+      end
+    end
+
+    def start_queue
+      $build_queue.start!
+    end
+
+  end
+end

data/lib/juici/build_environment.rb

@@ -0,0 +1,38 @@
+module Juici
+  BUILD_SENSITIVE_VARIABLES = %w[RUBYOPT BUNDLE_GEMFILE RACK_ENV MONGOLAB_URI GEM_PATH WORKING_DIR]
+  class BuildEnvironment
+
+    attr_reader :env
+    def initialize
+      @env = ENV.to_hash.tap do |env|
+        BUILD_SENSITIVE_VARIABLES.each do |var|
+          env[var] = nil
+        end
+        env["BUNDLE_CONFIG"] = "/nonexistent"
+      end
+    end
+
+    def [](k)
+      env[k]
+    end
+
+    # XXX This is spectacular.
+    # Not in the good way
+    def load_json!(json)
+      return true if json == ""
+      loaded_json = JSON.load(json)
+      if loaded_json.is_a? Hash
+        env.merge!(loaded_json)
+        return true
+      end
+      false
+    rescue JSON::ParserError
+      return false
+    end
+
+    def to_hash
+      env
+    end
+
+  end
+end

data/lib/juici/build_logic.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+require 'tempfile'
+module Juici
+  module BuildLogic
+
+    def spawn_build
+      raise "No such work tree" unless FileUtils.mkdir_p(worktree)
+      spawn(command, worktree)
+    rescue AbortBuild
+      :buildaborted
+    end
+
+    def kill!
+      warn! "Killed!"
+      if pid = self[:pid]
+        Process.kill(15, pid)
+      end
+    end
+
+  private
+
+    def spawn(cmd, dir)
+      @buffer = Tempfile.new('juici-xxxx')
+      Process.spawn(environment, cmd,
+        :chdir => dir,
+        :in  => "/dev/null",
+        :out => @buffer.fileno,
+        :err => [:child, :out]
+      )
+    rescue Errno::ENOENT
+      :enoent
+    rescue TypeError
+      :invalidcommand
+    end
+
+  end
+end

data/lib/juici/build_queue.rb

@@ -0,0 +1,111 @@
+# An object representing a queue. It merely manages creating child processes
+# and their priority, reaping them is a job for BuildThread
+#
+module Juici
+  class BuildQueue
+
+    def initialize
+      @builds = []
+      @child_pids = []
+      # This is never expired, for now
+      @builds_by_pid = {}
+      @started = false
+    end
+
+    def shutdown!
+      @child_pids.each do |pid|
+        ::Juici.dbgp "Killing off child pid #{pid}"
+        Process.kill(15, pid)
+      end
+    end
+
+    # Pushing a Build object into the BuildQueue is expressing that you want it
+    # run
+    def <<(other)
+      @builds << other
+      bump!
+    end
+
+    def current_min_priority
+      @builds.collect(&:priority).compact.min || 1
+    end
+
+    def next_child
+      @builds.sort_by(&:priority).first
+    end
+
+    def purge(by, build)
+      @builds.reject! do |i|
+        build.send(by) == i.send(by)
+      end
+    end
+
+    def delete(id)
+      purge(:_id, OpenStruct.new(:_id => id))
+    end
+
+    # Magic hook that starts a process if there's a good reason to.
+    # Stopgap measure that means you can knock on this if there's a chance we
+    # should start a process
+    def bump!
+      return unless @started
+      update_children
+      if not_working? && work_to_do?
+        Juici.dbgp "Starting another child process"
+        next_child.tap do |child|
+          if pid = child.build!
+            Juici.dbgp "Started child: #{pid}"
+            @child_pids << pid
+            @builds_by_pid[pid] = child
+          else
+            Juici.dbgp "Child #{child} failed to start"
+            bump! # Ruby's recursion isn't great, but re{try,do} may as well be
+                  # undefined behaviour here.
+          end
+        end
+      else
+        Juici.dbgp "I have quite enough to do"
+      end
+    end
+
+    def update_children
+      @child_pids.select! do |pid|
+        return false if pid.nil?
+        begin
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH
+          false
+        end
+      end
+    end
+
+    def get_build_by_pid(pid)
+      @builds_by_pid[pid]
+    end
+
+    def not_working?
+      @child_pids.length == 0
+    end
+
+    def work_to_do?
+      @builds.length > 0
+    end
+
+    def currently_building
+      @child_pids.map do |pid|
+        get_build_by_pid(pid)
+      end
+    end
+
+    def start!
+      @started = true
+      bump!
+    end
+
+    def builds
+      @builds
+    end
+
+  end
+end

data/lib/juici/callback.rb

@@ -0,0 +1,26 @@
+require 'net/http'
+module Juici
+  class Callback
+
+    attr_reader :url
+    attr_accessor :payload
+
+    def initialize(url, pl=nil)
+      @url = URI(url)
+      @payload = pl if pl
+    end
+
+    def process!
+      Net::HTTP.start(url.host, url.port) do |http|
+        request = Net::HTTP::Post.new(url.request_uri)
+        request.body = payload
+
+        http.request request # Net::HTTPResponse object
+      end
+    rescue SocketError => e
+      # We don't get a reference to build any more, can't warn :(
+      # TODO Throw a warning on the build
+    end
+
+  end
+end

data/lib/juici/config.rb

@@ -0,0 +1,11 @@
+class Juici::Config; class << self
+# XXX Temporary implementation to be replaced by a config reader
+  def workspace
+    "/tmp/juici/workspace"
+  end
+
+  def builds_per_page
+    10
+  end
+
+end; end

data/lib/juici/controllers.rb

@@ -0,0 +1,6 @@
+module Juici
+  module Controllers
+    class Base
+    end
+  end
+end

data/lib/juici/controllers/base.rb

@@ -0,0 +1,26 @@
+module Juici::Controllers
+  class Base
+
+    NotFound = Sinatra::NotFound
+
+    attr_accessor :params
+    def initialize(params)
+      @params = params
+    end
+
+    def build_opts(opts)
+      default_opts.merge(opts)
+    end
+
+    def default_opts
+      {
+        :styles => styles
+      }
+    end
+
+    def styles
+      []
+    end
+
+  end
+end

data/lib/juici/controllers/build_queue.rb

@@ -0,0 +1,14 @@
+module Juici::Controllers
+  class BuildQueue < Base
+
+    def list
+      builds = $build_queue.builds.sort_by(&:priority)
+      yield [:"queue/list", opts(:builds => builds)]
+    end
+
+    def opts(_opts={})
+      {:active => :queue}.merge(_opts)
+    end
+
+  end
+end

data/lib/juici/controllers/builds.rb

@@ -0,0 +1,74 @@
+module Juici::Controllers
+  class Builds < Base
+
+    def list
+      params[:page] = params[:page] ? params[:page].to_i : 0
+
+      project = ::Juici::Project.find_or_raise(NotFound, name: params[:project])
+
+      builds = ::Juici::Build.where(parent: project.name)
+
+      pages = (builds.count.to_f / ::Juici::Config.builds_per_page).ceil
+
+      builds = builds.desc(:_id).
+        limit(::Juici::Config.builds_per_page).
+        skip(params[:page].to_i * ::Juici::Config.builds_per_page)
+
+      yield [:"builds/list", build_opts({:project => project, :builds => builds, :pages => pages})]
+    end
+
+    def show
+      project = ::Juici::Project.find_or_raise(NotFound, name: params[:project])
+      build   = ::Juici::Build.find_or_raise(NotFound, parent: project.name, _id: params[:id])
+      # return 404 unless project && build
+      yield [:"builds/show", build_opts({:project => project, :build => build})]
+    end
+
+    def kill
+      project = ::Juici::Project.find_or_raise(NotFound, name: params[:project])
+      build   = ::Juici::Build.find_or_raise(NotFound, parent: project.name, _id: params[:id])
+
+      ::Juici.dbgp "Killing off build #{build[:_id]}"
+      build.kill! if build.status == ::Juici::BuildStatus::START
+      return build
+    end
+
+    def cancel
+      project = ::Juici::Project.find_or_raise(NotFound, name: params[:project])
+      build   = ::Juici::Build.find_or_raise(NotFound, parent: project.name, _id: params[:id])
+
+      ::Juici.dbgp "Cancelling build #{build[:_id]}"
+      build.cancel if build.status == ::Juici::BuildStatus::WAIT
+      return build
+    end
+
+    def new
+      yield [:"builds/new", {:active => :new_build}]
+    end
+
+    def styles
+      ["builds"]
+    end
+
+    def edit
+      project = ::Juici::Project.find_or_raise(NotFound, name: params[:project])
+      build   = ::Juici::Build.find_or_raise(NotFound, parent: project.name, _id: params[:id])
+      # return 404 unless project && build
+      yield [:"builds/edit", {:project => project, :build => build}]
+    end
+
+    def update!
+      project = ::Juici::Project.find_or_raise(NotFound, name: params[:project])
+      build   = ::Juici::Build.find_or_raise(NotFound, parent: project.name, _id: params[:id])
+
+      ::Juici::Build::EDITABLE_ATTRIBUTES[:string].each do |attr|
+        build[attr] = params[attr] if params[attr]
+      end
+      # binding.pry
+      build.tap do |b|
+        b.save!
+      end
+    end
+
+  end
+end

data/lib/juici/controllers/index.rb

@@ -0,0 +1,20 @@
+module Juici::Controllers
+  class Index
+
+    def index
+      yield [:index,  {:active => :index}]
+    end
+
+    def about
+      content = GitHub::Markdown.render(File.read("lib/juici/views/README.markdown"))
+      content.gsub!(/<h(\d+)>/, '<h\1 class="block-header">')
+      yield [:about, {:active => :about, :content => content}]
+    end
+
+    def support
+      yield [:support, {:active => :support}]
+    end
+
+  end
+end
+

data/lib/juici/controllers/trigger.rb

@@ -0,0 +1,85 @@
+module Juici::Controllers
+  class Trigger
+
+    attr_reader :project, :params
+    def initialize(project, params)
+      @project = ::Juici::Project.find_or_create_by(name: project)
+      @params = params
+    end
+
+    # Find an existing build, duplicate the sane parts of it.
+    def rebuild!
+      unless project = ::Juici::Project.where(name: params[:project]).first
+        not_found
+      end
+      unless build = ::Juici::Build.where(parent: project.name, _id: params[:id]).first
+        not_found
+      end
+
+      ::Juici::Build.new_from(build).tap do |new_build|
+        new_build.save!
+        $build_queue << new_build
+        $build_queue.bump!
+      end
+    end
+
+    def build!
+      environment = ::Juici::BuildEnvironment.new
+      ::Juici::Build.new(parent: project.name).tap do |build|
+        # The seperation of concerns around this madness is horrifying
+        unless environment.load_json!(params['environment'])
+          build.warn!("Failed to parse environment")
+        end
+
+        build[:command] = build_command
+        build[:priority] = build_priority
+        build[:environment] = environment.to_hash
+        build[:callbacks] = callbacks
+        build[:title] = title if title_given?
+
+        build.save!
+        $build_queue << build
+      end
+    end
+
+    # These accessors are not really the concern of a "Controller". On the
+    # other hand, this thing is also not a controller realistically, so I'm
+    # just going to carry on using this as a mechanism to poke at my model.
+    #
+    # I later plan to implement a more strictly bounded interface which bails
+    # instead of coercing.
+    def build_command
+      # TODO Throw 422 not acceptable if missing
+      params['command'].tap do |c|
+        raise "No command given" if c.nil?
+        # TODO Detect that we've recieved this from a browser session and only
+        # do this replacement there, we can trust API supplied data.
+        c.gsub!(/\r\n/, "\n")
+      end
+    end
+
+    def build_priority
+      if params['priority'] =~ /^[0-9]+$/
+        params['priority'].to_i
+      else
+        1
+      end
+    end
+
+    def callbacks
+      JSON.load(params['callbacks'])
+    rescue
+      []
+    end
+
+    def title
+      params['title']
+    end
+
+    def title_given?
+      t = params['title']
+      !(t.nil? || t.empty?)
+    end
+
+  end
+end