spitball 0.1.0

data/Gemfile.sample

@@ -0,0 +1,7 @@
+source :rubygems
+
+gem 'mysql'
+gem 'json'
+
+gem 'activesupport'
+

data/bin/spitball

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'spitball'
+require 'optparse'
+require 'net/http'
+require 'fileutils'
+
+args = {}
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: spitball [options] GEMFILE ARCHIVE"
+  opts.separator ""
+  opts.separator "options:"
+
+  opts.on('-h', '--host HOST', 'Get the tarball from a remote spitball server') do |host|
+    args[:host] = host
+  end
+
+  opts.on('-p', '--port PORT', 'Specify the remote server port. Default 8080') do |port|
+    args[:port] = port
+  end
+
+  opts.on('--version') do
+    puts Spitball::VERSION
+    exit 0
+  end
+
+  opts.separator ""
+  opts.separator "environment variables:"
+  opts.separator "\tSPITBALL_CACHE\t\t     Specifies the cache dir. Defaults to /tmp/spitball"
+  opts.separator ""
+end
+
+opts.permute!(ARGV)
+
+
+args[:gemfile] = ARGV[0]
+args[:destination] = ARGV[1]
+
+unless args[:gemfile] and args[:destination]
+  puts opts.help
+  exit 1
+end
+
+gemfile = File.read(args[:gemfile])
+
+ball = args[:host] ?
+  Spitball::Remote.new(gemfile, args[:host], (args[:port] || 8080).to_i) :
+  Spitball.new(gemfile)
+
+ball.copy_to args[:destination]

data/bin/spitball-server

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'spitball'
+require 'sinatra'
+require 'json'
+
+mime_type :gemfile, 'text/plain'
+mime_type :tgz, 'application/x-compressed'
+
+# return json array of cached SHAs
+get '/list' do
+  content_type :json
+  JSON.dump Spitball::Repo.list_cached
+end
+
+# return tgz or gemfile of cached SHA or 404
+get '/:digest.:format' do |digest, format|
+  error 400 unless ['tgz', 'gemfile'].include? format
+
+  # this returns 404 on Errno::ENOENT
+  send_file Spitball::Repo.path(digest, format), :type => format
+end
+
+# POST a gemfile. Returns 201 Created if the bundle already exists, or 202 Accepted if it does not. The body of the response is the URI for the tarball.
+post '/create' do
+  p request.body.read
+  request.body.rewind
+  ball = Spitball.new(request.body.read)
+  url = "#{request.url.split("/create").first}/#{ball.digest}.tgz"
+  response['Location'] = url
+
+  if ball.cached?
+    status 201
+  else
+    status 202
+    fork { ball.cache! }
+  end
+
+  url
+end

data/lib/spitball.rb

@@ -0,0 +1,80 @@
+require 'fileutils'
+
+class Spitball
+  require 'spitball/digest'
+  require 'spitball/repo'
+  require 'spitball/file_lock'
+  require 'spitball/remote'
+
+  class SpitballServerFailure < StandardError; end
+  class SpitballClientFailure < StandardError; end
+  class BundleCreationFailure < StandardError; end
+
+  VERSION = '1.0'
+
+  include Spitball::Digest
+  include Spitball::FileLock
+
+  attr_reader :gemfile
+
+  def initialize(gemfile)
+    @gemfile = gemfile
+  end
+
+  def copy_to(dest)
+    cache!
+    FileUtils.cp(tarball_path, dest)
+  end
+
+  def cached?
+    File.exist? tarball_path
+  end
+
+  def cache!(sync = true)
+    Spitball::Repo.make_cache_dir
+
+    unless cached?
+      if acquire_lock bundle_path('lock')
+        begin
+          create_bundle
+        ensure
+          release_lock bundle_path('lock')
+        end
+      elsif sync
+        sleep 0.1 until cached?
+      end
+    end
+  end
+
+  def create_bundle
+    File.open(gemfile_path, 'w') {|f| f.write gemfile }
+    FileUtils.mkdir_p bundle_path
+
+    if system "bundle install #{bundle_path} --gemfile=#{gemfile_path} --disable-shared-gems > /dev/null"
+      FileUtils.rm_rf File.join(bundle_path, "cache")
+
+      system "tar czf #{tarball_path}.#{Process.pid} -C #{bundle_path} ."
+      system "mv #{tarball_path}.#{Process.pid} #{tarball_path}"
+
+    else
+      FileUtils.rm_rf gemfile_path
+      raise BundleCreationFailure, "Bundle build failure."
+    end
+
+    FileUtils.rm_rf bundle_path
+  end
+
+  # Paths
+
+  def bundle_path(extension = nil)
+    Repo.path(digest, extension)
+  end
+
+  def gemfile_path
+    Repo.path(digest, 'gemfile')
+  end
+
+  def tarball_path
+    Repo.path(digest, 'tgz')
+  end
+end

data/lib/spitball/digest.rb

@@ -0,0 +1,11 @@
+require 'digest/sha1'
+
+module Spitball::Digest
+  def digest
+    @digest ||= ::Digest::SHA1.hexdigest gemfile
+  end
+
+  def hash
+    digest.hash
+  end
+end

data/lib/spitball/file_lock.rb

@@ -0,0 +1,20 @@
+require 'fileutils'
+
+module Spitball::FileLock
+  def acquire_lock(lock_path)
+    pre_lock_path = "#{lock_path}_pre_#{Process.pid}"
+
+    File.open(pre_lock_path, 'w') {|f| f.write Process.pid }
+
+    # is this atomic?
+    system "mv -n #{pre_lock_path} #{lock_path}"
+    File.read(lock_path).to_i == Process.pid
+  ensure
+    FileUtils.rm_f pre_lock_path
+  end
+
+  # seems silly to lock to release lock
+  def release_lock(lock_path)
+    FileUtils.rm_f lock_path if acquire_lock lock_path
+  end
+end

data/lib/spitball/remote.rb

@@ -0,0 +1,41 @@
+require 'net/http'
+require 'uri'
+
+class Spitball::Remote
+
+  def initialize(gemfile, host, port)
+    @gemfile = gemfile
+    @host = host
+    @port = port
+  end
+
+  def copy_to(path)
+    File.open(path, 'w') do |f|
+      f.write get_tarball_data
+    end
+  end
+
+  def get_tarball_data
+    url = URI.parse("http://#{@host}:#{@port}/create")
+    res = Net::HTTP.start(url.host, url.port) do |http|
+      http.post(url.path, @gemfile)
+    end
+
+    case res.code
+    when '201' # Created
+      Net::HTTP.get(URI.parse(res['Location']))
+    when '202' # Accepted
+      loop do
+        sleep 2
+        try = Net::HTTP.get_response(URI.parse(res['Location']))
+        next if try.code != '200'
+        return try.body
+      end
+    else
+      raise SpitballServerFailure, "Expected 2xx response code. Got #{res.code}."
+    end
+  rescue URI::InvalidURIError => e
+    raise SpitballClientError, e.message
+  end
+
+end

data/lib/spitball/repo.rb

@@ -0,0 +1,28 @@
+module Spitball::Repo
+  extend self
+
+  WORKING_DIR = ENV['SPITBALL_CACHE'] || '/tmp/spitball'
+
+  def path(digest, extension = nil)
+    extension = ".#{extension}" unless extension.nil? or extension.empty?
+    File.join WORKING_DIR, "bundle_#{digest}#{extension}"
+  end
+
+  def exist?(digest)
+    File.exist? path(digest, 'tgz')
+  end
+
+  def gemfile(digest)
+    File.read path(digest, 'gemfile')
+  end
+
+  def list_cached
+    Dir[File.join(WORKING_DIR, 'bundle_*.tgz')].map do |path|
+      path.match(/bundle_(.*?)\.tgz$/)[1]
+    end.compact.uniq.sort
+  end
+
+  def make_cache_dir
+    FileUtils.mkdir_p WORKING_DIR
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: spitball
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matt Freels
+- Brandon Mitchell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Use bundler to generate gem tarball packages.
+email: freels@twitter.com
+executables: 
+- spitball
+- spitball-server
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile.sample
+- bin/spitball
+- bin/spitball-server
+- lib/spitball.rb
+- lib/spitball/digest.rb
+- lib/spitball/file_lock.rb
+- lib/spitball/remote.rb
+- lib/spitball/repo.rb
+has_rdoc: true
+homepage: http://twitter.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: get a bundle
+test_files: []
+