juici 0.0.0.alpha1

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+config/mongoid.yml

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+ruby '1.9.3'
+
+gemspec :name => "juici"

data/Gemfile.lock

@@ -0,0 +1,74 @@
+PATH
+  remote: .
+  specs:
+    juici (0.0.0)
+      ansible
+      bson_ext
+      github-markdown
+      json
+      mongoid
+      sinatra
+      thin
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    ansible (0.2.0)
+    bson (1.7.0)
+    bson_ext (1.7.0)
+      bson (~> 1.7.0)
+    builder (3.0.4)
+    daemons (1.1.9)
+    diff-lcs (1.1.3)
+    eventmachine (1.0.0)
+    github-markdown (0.5.3)
+    i18n (0.6.1)
+    json (1.7.5)
+    metaclass (0.0.1)
+    mocha (0.11.4)
+      metaclass (~> 0.0.1)
+    mongoid (3.0.10)
+      activemodel (~> 3.1)
+      moped (~> 1.1)
+      origin (~> 1.0)
+      tzinfo (~> 0.3.22)
+    moped (1.2.7)
+    multi_json (1.3.7)
+    origin (1.0.10)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rake (0.9.2.2)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    thin (1.5.0)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.3)
+    tzinfo (0.3.34)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  juici!
+  mocha
+  rake
+  rspec

data/Procfile

@@ -0,0 +1 @@
+web: RACK_ENV=heroku bundle exec ruby bin/juici

data/README.md

@@ -0,0 +1,138 @@
+## JuiCI
+
+JuiCI is a CI server that has a notion of queuing and priority.
+
+It's designed to work well with [agent99](https://github.com/99designs/agent99) but will play nicely with most frontends to CI.
+
+## Features
+
+* callbacks are created as builds are requested
+* Builds are executed sequentially in a series of parallel queues.
+* Queues can be dynamically created
+* Build status visualised
+
+## Important but Miscellaneous
+
+If you create child processes in modules/plugins then you need to register your
+disinterest or JuiCI will think they're builds and that would be bad.
+
+## Setup
+
+JuiCI is deliberately very light on the setup front.
+
+```bash
+bundle install
+bundle exec bin/juici
+```
+
+is all you need to have a working instance (provided that you have mongo installed)
+
+### Gotchas
+
+Make sure you don't do something innocuous like
+
+```bash
+bundle install --path .bundle
+```
+
+this might look sane (and it is, kinda) but owing to a quick in bundler, it
+will break any ruby code you try to build.
+
+I'm working on a workaround, but in the meantime the fix is to not do it!
+
+## Usage
+
+JuiCI is very focused on minimal configuration; meaning that beyond starting
+the server and pointing it at a mongoDB instance, you do not need to do
+anything special to build a new project. Just request a build; however this
+means that on your first build you will need to send the commands to create
+your test environment)
+
+Example:
+
+```bash
+curl --data-ascii @/dev/stdin <<EOF
+payload={"environment":{
+"SHA1":"e8b179f75bbc8717c948af052353424d458af981"},
+"command":"[ -d .git ] || (git init .; git remote add origin git://github.com/richo/twat.git); git fetch; git checkout $SHA1; bundle install; bundle exec rake spec"
+EOF
+```
+
+Using a convention like `script/cibuild` as in janky/hubot etc is advisable,
+although bear in mind that the logic to checkout the repo will need to be
+seperate.
+
+## Priority
+
+JuiCI supports the notion of priority. Builds given without a priority will be
+assigned priority 1 (to allow for marking a build as less important with
+priority 0).
+
+If juici recieves a new build with priority higher than any currently
+unfinished, it will pause whatever it's doing and build the new project. If
+there is a tie for priority, a FIFO queue is assumed.
+
+JuiCI uses `SIGSTOP` and `SIGCONT` internally for job control.
+
+## Hooks
+
+You may specify one or more callbacks when you request a build. They will be
+called with an (as yet unformalised) json body as the body if/when the build
+reaches that state. Alternately you may specify "any" as the callback state and
+it will be called on all state changes.
+
+## Integration
+
+Apps written in ruby wanting to interact with Juici can include the
+`juici-interface` gem, which presently exposes a few constants to line up with
+JuiCI's internal state.
+Over time this will be expanded, but for now they are:
+
+```ruby
+Juici::BuildStatus::PASS
+Juici::BuildStatus::FAIL
+Juici::BuildStatus::START
+Juici::BuildStatus::WAIT
+```
+
+## Security
+
+JuiCI poses some interesting security conecerns. First off, it will allow
+anyone with access to run arbitrary commands on your server. I have
+deliberately not implemented any kind of security inside JuiCI, it plays nicely
+as a Rack application, and middlewares are much better suited to this task.
+
+It should go without saying, but any builds started by JuiCI will inherit its
+environment. This means that if you run it in dev mode and forward your ssh
+agent, builds can ssh to other machines as you!
+
+When running in production you should take steps to ensure that the user JuiCI
+runs as is no more privileged than it needs to be, and sanitise its
+environment before execution.
+
+## A note on subprocesses
+
+JuiCI by default invokes everything in a subshell- indeed this is the only way
+to approach this if you want to execute more than one command.
+
+What this means to you as the user though is that unless you go to lengths to
+specifically implement it, your process won't see any of the signal handling
+madness. The shell(`/bin/sh`) will see everything, and if killed, your
+processes will become orphaned, but carry on.
+
+## Authors
+
+* [Richo Healey](https://github.com/rcho)
+* [Alec Sloman](https://github.com/alecsloman)
+
+## Contact
+
+JuiCI's code lives on [Github](https://github.com/richo/juici)
+and the [author](mailto:richo@psych0tik.net) can be contacted on
+ [Twitter](https://twitter.com/rich0H)
+
+## Legalese
+
+(c) Richo Healey 2012, richo@psych0tik.net
+
+Released under the terms of the MIT license.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+require 'juici/database'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+desc 'Default: run specs'
+task :default => :spec
+
+namespace :db do
+  desc "Destroy the test db specified in mongoid.yml"
+  task :destroy do
+    Juici::Database.initialize!
+    Mongoid.purge!
+  end
+end
+
+desc "Build all gems"
+task :gems do
+  %w[juici juici-interface].each do |gem|
+    `gem build #{gem}.gemspec`
+  end
+end
+
+desc "Delete all built gems"
+task :clean do
+  Dir["juici-*.gem"].each do |gem|
+    File.unlink(gem)
+  end
+end

data/TODO.md

@@ -0,0 +1,28 @@
+* This awkward `::Juici::Model` kludge inside views is a pain.
+
+* RSS feed for build status (spyware)
+
+* Paginated builds to avoid blocking up a connection
+
+* Proper callback support
+
+* Graphing of build times and statuses
+
+* Search
+
+## Only child model
+
+`lib/juici/watcher +21`
+
+Basically, it would be nice to have a watcher get started with the first build
+out of the ranks, and then die on ECHILD
+
+This means that with lots of builds passing through we can retain a single
+watcher, and when we're idle we let him die and then spawn a new one when we
+need
+
+* Neat method of either resuming or starting a build
+
+* RSS api
+
+* Import of Xdefaults/itermcolors.plist for output colors

data/bin/juici

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path("../../lib", __FILE__))
+require 'juici'
+
+port = ENV['PORT'] || 9000
+
+Juici::Server.start('localhost', port)

data/bin/juicic

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'net/http'
+require 'json'
+require 'juici/interface'
+
+# TODO Refactor
+def main(args)
+  action = args.shift.to_sym
+  options = {}
+
+  until args.empty?
+    case args.shift
+    when "--command"
+      command = args.shift
+      options[:command] = if command == "-"
+        File.read(command)
+      else
+        command
+      end
+    when "--host"
+      options[:host] = args.shift
+    when "--title"
+      options[:title] = args.shift
+    when "--project"
+      options[:project] = args.shift
+    when "--priority"
+      options[:priority] = args.shift
+    end
+  end
+
+  send(action, options)
+end
+
+def build(opts)
+  host = URI(opts[:host])
+  Net::HTTP.start(host.host, host.port) do |h|
+    req = Net::HTTP::Post.new(Juici::Routes::NEW_BUILD)
+    req.body = _create_payload(opts)
+    h.request req
+  end
+end
+
+def _create_payload(opts)
+  URI.encode_www_form({
+    "project" => opts[:project],
+    "environment" => (opts[:environment] || {}).to_json,
+    "command" => opts[:command],
+    "priority" => opts[:priority] || 1,
+    "callbacks" => (opts[:callbacks] || []).to_json,
+    "title" => opts[:title]
+  })
+end
+
+main(ARGV.dup)

data/config/mongoid.yml.sample

@@ -0,0 +1,25 @@
+development:
+  sessions:
+    default:
+      database: juici
+      hosts:
+        - localhost:27017
+
+production:
+  sessions:
+    default:
+      database: juici
+      hosts:
+        - localhost:27017
+
+test:
+  sessions:
+    default:
+      database: juici-test
+      hosts:
+        - localhost:27017
+
+heroku:
+  sessions:
+    default:
+      uri: <%= ENV['MONGOLAB_URI'] %>

data/juici-interface.gemspec

@@ -0,0 +1,19 @@
+# vim: ft=ruby
+#
+require File.expand_path("../lib/juici/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "juici-interface"
+  s.version     = Juici::VERSION
+  s.authors     = ["Richo Healey"]
+  s.email       = ["richo@psych0tik.net"]
+  s.homepage    = "http://github.com/richo/juici"
+  s.summary     = "Interface definition for JuiCI callbacks and API"
+  s.description = s.summary
+
+  s.files         = "lib/juici/interface.rb"
+  s.require_paths = ["lib"]
+  s.executables   = "juicic"
+end
+
+

data/juici.gemspec

@@ -0,0 +1,32 @@
+# vim: ft=ruby
+#
+require File.expand_path("../lib/juici/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "juici"
+  s.version     = Juici::VERSION
+  s.authors     = ["Richo Healey"]
+  s.email       = ["richo@psych0tik.net"]
+  s.homepage    = "http://github.com/richo/juici"
+  s.summary     = "Minimal CI server with some support for dynamic"
+  s.description = s.summary
+
+  s.add_dependency "sinatra"
+  s.add_dependency "thin"
+  s.add_dependency "json"
+  s.add_dependency "mongoid"
+  s.add_dependency "bson_ext"
+  s.add_dependency "github-markdown"
+  s.add_dependency "ansible"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rspec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = 'juici'
+  s.require_paths = ["lib"]
+end
+
+

data/lib/juici.rb

@@ -0,0 +1,24 @@
+require 'github/markdown'
+require 'ansible'
+
+ENV['RACK_ENV'] ||= "development"
+
+module Juici
+  def self.dbgp(*args)
+    if ENV['JUICI_DEBUG'] || env == "development"
+      $stderr.puts(args)
+    end
+  end
+
+  def self.env
+    ENV['JUICI_ENV'] || ENV['RACK_ENV']
+  end
+end
+
+# Load juici core, followed by extras
+["", "controllers", "models"].each do |el|
+  Dir[File.dirname(__FILE__) + "/juici/#{el}/*.rb"].each  do |file|
+    Juici.dbgp "Loading #{file}"
+    require file
+  end
+end