gemerald_beanstalk 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,27 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+
+before_script:
+  - bundle config
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || git clone https://github.com/beanstalkd/beaneater.git /tmp/beaneater'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || BUNDLE_GEMFILE=/tmp/beaneater/Gemfile bundle install'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || git clone https://github.com/nesquena/backburner.git /tmp/backburner'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || BUNDLE_GEMFILE=/tmp/backburner/Gemfile bundle install'
+
+script:
+  - rake test
+  - sudo sed -i 's/^\(127.0.0.1.*\)$/\1 coveralls.io/' /etc/hosts
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || rake start_gemerald_beanstalk_test_server &'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || cd /tmp/beaneater'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || BUNDLE_GEMFILE=/tmp/beaneater/Gemfile bundle exec rake test:full'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || cd /tmp/backburner'
+  - '[ "$TRAVIS_RUBY_VERSION" = "jruby-19mode" ] && (exit 0) || BUNDLE_GEMFILE=/tmp/backburner/Gemfile bundle exec rake'
+
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'beanstalk_integration_tests', '~> 0.0.8'
+  gem 'coveralls', :require => false
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Freewrite.org
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# GemeraldBeanstalk
+[![Build Status](https://travis-ci.org/gemeraldbeanstalk/gemerald_beanstalk.png?branch=master)](https://travis-ci.org/gemeraldbeanstalk/gemerald_beanstalk)
+[![Coverage Status](https://coveralls.io/repos/gemeraldbeanstalk/gemerald_beanstalk/badge.png)](https://coveralls.io/r/gemeraldbeanstalk/gemerald_beanstalk)
+[![Code Climate](https://codeclimate.com/github/gemeraldbeanstalk/gemerald_beanstalk.png)](https://codeclimate.com/github/gemeraldbeanstalk/gemerald_beanstalk)
+[![Dependency Status](https://gemnasium.com/gemeraldbeanstalk/gemerald_beanstalk.png)](https://gemnasium.com/gemeraldbeanstalk/gemerald_beanstalk)
+
+
+GemeraldBeanstalk offers a Ruby implementation of beanstalkd for testing and other uses.
+
+## Usage
+
+GemeraldBeanstalk should work as a drop in replacement for beanstalkd. You can
+start a server via GemeraldBeanstalk::Server.start:
+```ruby
+
+  # Start a GemeraldBeanstalk bound to 0.0.0.0:11300
+  GemeraldBeanstalk::Server.start
+
+  # Customize server binding
+  GemeraldBeanstalk::Server.start('192.168.1.10', 11301)
+```
+
+GemeraldBeanstalk::Server.start returns an array containing the Thread the
+server is running in and the server's GemeraldBeanstalk::Beanstalk instance.
+
+The internals of GemeraldBeanstalk are undocumented at this point, with the
+expectation being that it should be interacted with strictly via the [beanstalkd
+protocol](https://github.com/kr/beanstalkd/blob/master/doc/protocol.md). This
+will likely change in the future, allowing more programatic access directly to
+the GemeraldBeanstalk::Beanstalk.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'gemerald_beanstalk'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gemerald_beanstalk
+
+## Unbugs!
+In the process of building GemeraldBeanstalk, a number of bugs and inconsistencies
+with Beanstalkd protocol were discovered. Patches have been submitted to correct
+the various bugs and inconsistencies, but they have not yet been merged into
+beanstalkd.
+
+It would be fairly tedious to reproduce the behavior of some of the bugs, and as
+such, GemeraldBeanstalk doesn't suffer from them. This can be troubling when
+you run tests that work against GemeraldBeanstalk, but then fail against an
+actual beanstalkd server. Below are a list of those protocol issues that exist
+with Beanstalk, but not with GemeraldBeanstalk.
+ * [Pause tube should check tube name valid](https://github.com/kr/beanstalkd/pull/217)
+ * [Can't ignore tube with name 200 chars long](https://github.com/kr/beanstalkd/issues/212)
+ * [Use of 200-char tube name causes INTERNAL_ERROR](https://github.com/kr/beanstalkd/issues/211)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'gemerald_beanstalk'
+
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+task :start_gemerald_beanstalk_test_server do
+  Thread.abort_on_exception = true
+  server_thread, beanstalk = GemeraldBeanstalk::Server.start(ENV['BIND_ADDRESS'], ENV['PORT'])
+  trap("SIGINT") { server_thread.kill }
+  puts "GemeraldBeanstalk listening on #{beanstalk.address}"
+  server_thread.join
+end
+
+task :default => :test

data/gemerald_beanstalk.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gemerald_beanstalk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gemerald_beanstalk'
+  spec.version       = GemeraldBeanstalk::VERSION
+  spec.authors       = ['Freewrite.org']
+  spec.email         = ['dev@freewrite.org']
+  spec.description   = %q{RubyGem implementation of beanstalkd}
+  spec.summary       = %q{Gemerald Beanstalk offers a Ruby implementation of beanstalkd for testing and other uses.}
+  spec.homepage      = 'https://github.com/gemeraldbeanstalk/gemerald_beanstalk'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'eventmachine'
+  spec.add_dependency 'thread_safe'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/lib/gemerald_beanstalk.rb

@@ -0,0 +1,10 @@
+require 'set'
+require 'gemerald_beanstalk/version'
+require 'thread_safe'
+require 'gemerald_beanstalk/job'
+require 'gemerald_beanstalk/beanstalk'
+require 'gemerald_beanstalk/connection'
+require 'gemerald_beanstalk/command'
+require 'gemerald_beanstalk/jobs'
+require 'gemerald_beanstalk/tube'
+require 'gemerald_beanstalk/server'

data/lib/gemerald_beanstalk/beanstalk.rb

@@ -0,0 +1,289 @@
+require 'securerandom'
+require 'socket'
+require 'gemerald_beanstalk/beanstalk_helper'
+
+class GemeraldBeanstalk::Beanstalk
+
+  # contains functionality supporting core commands
+  include GemeraldBeanstalk::BeanstalkHelper
+
+  # Colon-separated host and port of the Server the Beanstalk instance is
+  # running on.
+  attr_reader :address
+
+  # The maximum size in bytes that a job can be. Jobs exceeding this threshold
+  # will result in JOB_TOO_BIG responses.
+  attr_reader :max_job_size
+
+
+  # Initializes a new Beanstalk instance with the given +address+ and
+  # +maximum_job_size+. +address+ is a string identifying the host and port
+  # that the Beanstalk instance is running on. +maximum_job_size+ is the
+  # maximum size in bytes that a job can be. Jobs exceeding this threshold will
+  # result in JOB_TOO_BIG responses.
+  #
+  #   beanstalk = GemeraldBeanstalk::Beanstalk.new('localhost:11300')
+  def initialize(address, maximum_job_size = 2**16)
+    @max_job_size = maximum_job_size
+    @address = address
+    @connections = ThreadSafe::Array.new
+    @delayed = ThreadSafe::Array.new
+    @id = SecureRandom.base64(16)
+    @jobs = GemeraldBeanstalk::Jobs.new
+    @mutex = Mutex.new
+    @paused = ThreadSafe::Array.new
+    @reserved = ThreadSafe::Cache.new {|reserved, key| reserved[key] = [] }
+    @stats = ThreadSafe::Hash.new(0)
+    @tubes = ThreadSafe::Cache.new
+    @up_at = Time.now.to_f
+
+    tube('default', :create_if_missing)
+  end
+
+
+  protected
+
+  def bury(connection, job_id, priority, *args)
+    adjust_stats_key(:'cmd-bury')
+    job = find_job(job_id, :only => JOB_RESERVED_STATES)
+    return NOT_FOUND if job.nil? || !job.bury(connection, priority)
+
+    @reserved[connection].delete(job)
+    return BURIED
+  end
+
+
+  def delete(connection, job_id = nil, *args)
+    adjust_stats_key(:'cmd-delete')
+    job = find_job(job_id)
+    return NOT_FOUND if job.nil?
+
+    original_state = job.state
+    return NOT_FOUND unless job.delete(connection)
+
+    tube(job.tube_name).delete(job)
+    @jobs[job.id - 1] = nil
+    @reserved[connection].delete(job) if JOB_RESERVED_STATES.include?(original_state)
+
+    return DELETED
+  end
+
+
+  def ignore(connection, tube_name)
+    adjust_stats_key(:'cmd-ignore')
+    return NOT_IGNORED if (watched_count = connection.ignore(tube_name)).nil?
+    tube = tube(tube_name)
+    tube.ignore unless tube.nil?
+    return "WATCHING #{watched_count}\r\n"
+  end
+
+
+  def kick(connection, limit, *args)
+    adjust_stats_key(:'cmd-kick')
+    limit = limit.to_i
+    kicked = 0
+    JOB_INACTIVE_STATES.each do |job_state|
+      # GTE to handle negative limits
+      break if kicked >= limit
+      until (job = tube(connection.tube_used).next_job(job_state, :peek)).nil?
+        kicked += 1 if job.kick
+        break if kicked == limit
+      end
+      break if kicked > 0
+    end
+
+    return "KICKED #{kicked}\r\n"
+  end
+
+
+  def kick_job(connection, job_id = nil, *args)
+    job = find_job(job_id, :only => JOB_INACTIVE_STATES)
+    return (!job.nil? && job.kick) ? KICKED : NOT_FOUND
+  end
+
+
+  def list_tubes(connection)
+    adjust_stats_key(:'cmd-list-tubes')
+    return tube_list(active_tubes.keys)
+  end
+
+
+  def list_tube_used(connection)
+    adjust_stats_key(:'cmd-list-tube-used')
+    return "USING #{connection.tube_used}\r\n"
+  end
+
+
+  def list_tubes_watched(connection)
+    adjust_stats_key(:'cmd-list-tubes-watched')
+    return tube_list(connection.tubes_watched)
+  end
+
+
+  def pause_tube(connection, tube_name, delay)
+    adjust_stats_key(:'cmd-paue-tube')
+    return NOT_FOUND if (tube = tube(tube_name)).nil?
+    tube.pause(delay.to_i % 2**32)
+    @paused << tube
+    return PAUSED
+  end
+
+
+  def peek(connection, job_id = nil, *args)
+    adjust_stats_key(:'cmd-peek')
+    return peek_message(find_job(job_id))
+  end
+
+
+  def peek_buried(connection)
+    return peek_by_state(connection, :buried)
+  end
+
+
+  def peek_delayed(connection)
+    return peek_by_state(connection, :delayed)
+  end
+
+
+  def peek_ready(connection)
+    return peek_by_state(connection, :ready)
+  end
+
+
+  def put(connection, priority, delay, ttr, bytes, body)
+    adjust_stats_key(:'cmd-put')
+    bytes = bytes.to_i
+    return JOB_TOO_BIG if bytes > @max_job_size
+    return EXPECTED_CRLF if body.slice!(-2, 2) != CRLF || body.length != bytes
+
+    job = nil
+    # Ensure job insertion order and ID
+    @mutex.synchronize do
+      job = GemeraldBeanstalk::Job.new(self, @jobs.next_id, connection.tube_used, priority, delay, ttr, bytes, body)
+      @jobs.enqueue(job)
+      tube(connection.tube_used).put(job)
+    end
+
+    # Send async so client doesn't wait while we check if job can be immediately dispatched
+    connection.transmit("INSERTED #{job.id}\r\n")
+
+    connection.producer = true
+
+    case job.state
+    when :ready
+      honor_reservations(job)
+    when :delayed
+      @delayed << job
+    end
+    return nil
+  end
+
+
+  def quit(connection)
+    disconnect(connection)
+    return nil
+  end
+
+
+  def release(connection, job_id, priority, delay)
+    adjust_stats_key(:'cmd-release')
+    job = find_job(job_id, :only => JOB_RESERVED_STATES)
+    return NOT_FOUND if job.nil? || !job.release(connection, priority, delay)
+
+    @reserved[connection].delete(job)
+    @delayed << job if job.delayed?
+    return RELEASED
+  end
+
+
+  def reserve(connection, *args)
+    adjust_stats_key(:'cmd-reserve')
+    return BAD_FORMAT unless args.empty?
+    reserve_job(connection)
+    return nil
+  end
+
+
+  def reserve_with_timeout(connection, timeout = 0, *args)
+    adjust_stats_key(:'cmd-reserve-with-timeout')
+    timeout = timeout.to_i
+    return nil if reserve_job(connection, timeout) || timeout != 0
+    connection.wait_timed_out
+    return TIMED_OUT
+  end
+
+
+  def stats(connection)
+    adjust_stats_key(:'cmd-stats')
+    stats = @jobs.counts_by_state.merge(stats_commands).merge({
+      'job-timeouts' => @stats[:'job-timeouts'],
+      'total-jobs' => @jobs.total_jobs,
+      'max-job-size' => @max_job_size,
+      'current-tubes' => active_tubes.length,
+    }).merge(stats_connections).merge({
+      'pid' => Process.pid,
+      'version' => GemeraldBeanstalk::VERSION,
+      'rusage-utime' => 0,
+      'rusage-stime' => 0,
+      'uptime' => uptime,
+      'binlog-oldest-index' => 0,
+      'binlog-current-index' => 0,
+      'binlog-records-migrated' => 0,
+      'binlog-records-written' => 0,
+      'binlog-max-size' => 10485760,
+      'id' => @id,
+      'hostname' => Socket.gethostname,
+    })
+    return yaml_response(stats.map{|stat, value| "#{stat}: #{value}" })
+  end
+
+
+  def stats_job(connection, job_id = nil, *args)
+    adjust_stats_key(:'cmd-stats-job')
+    job = find_job(job_id)
+    return NOT_FOUND if job.nil?
+
+    return yaml_response(job.stats.map{ |stat, value| "#{stat}: #{value}" })
+  end
+
+
+  def stats_tube(connection, tube_name)
+    adjust_stats_key(:'cmd-stats-tube')
+    return NOT_FOUND if (tube = tube(tube_name)).nil?
+
+    return yaml_response(tube.stats.map{ |stat, value| "#{stat}: #{value}" })
+  end
+
+
+  def touch(connection, job_id = nil, *args)
+    adjust_stats_key(:'cmd-touch')
+    job = find_job(job_id, :only => JOB_RESERVED_STATES)
+    return NOT_FOUND if job.nil? || !job.touch(connection)
+
+    return TOUCHED
+  end
+
+
+  def use(connection, tube_name)
+    adjust_stats_key(:'cmd-use')
+    tube(connection.tube_used).stop_use
+    tube(tube_name, :create_if_missing).use
+    connection.use(tube_name)
+
+    return "USING #{tube_name}\r\n"
+  end
+
+
+  def watch(connection, tube_name)
+    adjust_stats_key(:'cmd-watch')
+    if connection.tubes_watched.include?(tube_name)
+      watched_count = connection.tubes_watched.length
+    else
+      tube(tube_name, :create_if_missing).watch
+      watched_count = connection.watch(tube_name)
+    end
+
+    return "WATCHING #{watched_count}\r\n"
+  end
+
+end