queueing_proxy 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'ext/gem_rake'
+Bundler::GemHelper.install_tasks

data/bin/queueing_proxy

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'queueing_proxy'
+
+QueueingProxy::CLI.start
+

data/ext/gem_rake.rb

@@ -0,0 +1,126 @@
+module Bundler
+  class GemHelper
+
+    def self.install_tasks
+      dir = caller.find{|c| /Rakefile:/}[/^(.*?)\/Rakefile:/, 1]
+      GemHelper.new(dir).install
+    end
+
+    attr_reader :spec_path, :base, :name
+
+    def initialize(base, name = nil)
+      @base = base
+      @name = name || interpolate_name
+      @spec_path = File.join(@base, "#{@name}.gemspec")
+    end
+
+    def install
+      desc 'Build your gem into the pkg directory'
+      task 'build' do
+        build_gem
+      end
+
+      desc 'Install your gem into the pkg directory'
+      task 'install' do
+        install_gem
+      end
+
+      desc 'Push your gem to rubygems'
+      task 'push' do
+        push_gem
+      end
+    end
+
+    def build_gem
+      file_name = nil
+      sh("gem build #{spec_path}") {
+        file_name = File.basename(built_gem_path)
+        FileUtils.mkdir_p(File.join(base, 'pkg'))
+        FileUtils.mv(built_gem_path, 'pkg')
+      }
+      File.join(base, 'pkg', file_name)
+    end
+
+    def install_gem
+      built_gem_path = build_gem
+      sh("gem install #{built_gem_path}")
+    end
+
+    def push_gem
+      guard_clean
+      guard_already_tagged
+      tag_version {
+        git_push
+        rubygem_push(build_gem)
+      }
+    end
+
+    protected
+    def rubygem_push(path)
+      sh("gem push #{path}")
+    end
+
+    def built_gem_path
+      Dir[File.join(base, "#{name}-*.gem")].sort_by{|f| File.mtime(f)}.last
+    end
+
+    def interpolate_name
+      gemspecs = Dir[File.join(base, "*.gemspec")]
+      raise "Unable to determine name from existing gemspec." unless gemspecs.size == 1
+
+      File.basename(gemspecs.first)[/^(.*)\.gemspec$/, 1]
+    end
+
+    def git_push
+      sh "git push --all"
+      sh "git push --tags"
+    end
+
+    def guard_already_tagged
+      sh('git tag').split(/\n/).include?(current_version_tag) and raise("This tag has already been committed to the repo.")
+    end
+
+    def guard_clean
+      clean? or raise("There are files that need to be committed first.")
+    end
+
+    def clean?
+      sh("git ls-files -dm").split("\n").size.zero?
+    end
+
+    def tag_version
+      sh "git tag #{current_version_tag}"
+      yield if block_given?
+    rescue
+      sh "git tag -d #{current_version_tag}"
+      raise
+    end
+
+    def current_version
+      raise("Version file could not be found at #{version_file_path}") unless File.exist?(version_file_path)
+      File.read(version_file_path)[/V(ERSION|ersion)\s*=\s*(["'])(.*?)\2/, 3]
+    end
+
+    def version_file_path
+      File.join(base, 'lib', name, 'version.rb')
+    end
+
+    def current_version_tag
+      "v#{current_version}"
+    end
+
+    def sh(cmd, &block)
+      output, code = sh_with_code(cmd, &block)
+      code == 0 ? output : raise(output)
+    end
+
+    def sh_with_code(cmd, &block)
+      output = ''
+      Dir.chdir(base) { 
+        output = `#{cmd}`
+        block.call if block and $? == 0
+      }
+      [output, $?]
+    end
+  end
+end

data/lib/queueing_proxy/cli.rb

@@ -0,0 +1,17 @@
+require 'thor'
+
+module QueueingProxy
+  class CLI < Thor
+    
+    def initialize
+      super
+    end
+    
+    default_task :start
+    
+    desc "start", "Start a proxy"
+    def start(config = '/etc/queueing_proxy.yml')
+      
+    end
+  end
+end

data/lib/queueing_proxy/dispatcher.rb

@@ -0,0 +1,56 @@
+module QueueingProxy
+  class Dispatcher
+    attr_reader :logger
+
+    def initialize(logger, to_host, to_port, beanstalk_host, tube)
+      @logger, @to_host, @to_port, @beanstalk_host, @tube = logger, to_host, to_port, beanstalk_host, tube
+      @beanstalk = EMJack::Connection.new(:host => @beanstalk_host, :tube => @tube)
+      @beanstalk.watch(@tube)
+      logger.info "Starting dispatcher on #{to_host}:#{to_port} using beanstalk at #{tube}@#{beanstalk_host}"
+    end
+    
+    def run
+      @beanstalk.reserve do |job|
+        logger.info "Dispatching #{job.jobid}"
+        parsed_job = JSON.parse(job.body)
+        begin
+          EventMachine.connect(@to_host, @to_port, DispatchClient) { |c|
+            c.payload = parsed_job['data']
+            c.dispatcher = self
+            c.logger = logger
+            c.job = job
+            c.dispatcher = self
+          }
+        rescue EventMachine::ConnectionError
+          job.release(:delay => 5)
+          logger.info("Problem connecting")
+          EM.add_timer(5){ run }
+        end
+      end
+    end
+    
+    class DispatchClient < EventMachine::Connection
+      attr_accessor :payload, :dispatcher, :logger, :dispatcher, :job
+      
+      def connection_completed
+        send_data(payload)
+      end
+
+      def receive_data(data)
+        status = Integer(data[/^HTTP\/(1\.1|1\.0) (\d+)/, 2])
+        close_connection
+        if status == 200
+          logger.info "Done dispatching #{job.jobid}"
+          job.delete
+        else
+          logger.info "Error #{status}"
+          job.release(:delay => 5)
+        end
+      end
+      
+      def unbind
+        dispatcher.run
+      end
+    end
+  end
+end

data/lib/queueing_proxy/dsl.rb

@@ -0,0 +1,48 @@
+require 'logger'
+
+module QueueingProxy
+  class DSL
+    def initialize(&block)
+      @dispatcher_count = 1
+      @logger = Logger.new(STDOUT)
+      instance_eval(&block) if block
+    end
+    
+    def to(host, port)
+      @to_host = host
+      @to_port = port
+      self
+    end
+
+    def from(host, port)
+      @from_host = host
+      @from_port = port
+      self
+    end
+
+    def times(count)
+      @dispatcher_count = count
+      self
+    end
+
+    def queue_with(beanstalk_host, tube)
+      @beanstalk_host = beanstalk_host
+      @tube = tube
+      self
+    end
+    
+    def logger(logger)
+      @logger = logger
+      self
+    end
+    
+    def run
+      unless EM.reactor_running?
+        EM.run{ run }
+      else
+        Queuer.new(@logger, @from_host, @from_port, @beanstalk_host, @tube).run
+        @dispatcher_count.times { Dispatcher.new(@logger, @to_host, @to_port, @beanstalk_host, @tube).run }
+      end
+    end
+  end
+end

data/lib/queueing_proxy/queuer.rb

@@ -0,0 +1,57 @@
+module QueueingProxy
+  class Queuer
+    attr_reader :logger
+
+    def initialize(logger, host, port, beanstalk_host, tube)
+      @logger, @host, @port, @beanstalk_host, @tube = logger, host, port, beanstalk_host, tube
+      logger.info "Starting queuer on #{host}:#{port} using beanstalk at #{tube}@#{beanstalk_host}"
+    end
+
+    def run
+      beanstalk = EMJack::Connection.new(:host => @beanstalk_host, :tube => @tube)
+      app = proc do |env|
+        logger.info "Queueing #{env['HTTP_VERSION']} #{env['PATH_INFO']} #{env['REQUEST_METHOD']}"
+        [200, {}, []]
+      end
+      backend = FakeBackend.new
+      EM.start_server(@host, @port, QueuerConnection) do |conn|
+        conn.beanstalk = beanstalk
+        conn.app = app
+        conn.backend = backend
+        conn.logger = logger
+      end
+    end
+
+    class FakeBackend
+      def connection_finished(conn)
+      end
+    end
+    
+    class QueuerConnection < Thin::Connection
+      attr_accessor :beanstalk, :logger
+
+      def post_init
+        @data = ''
+        super
+      end
+
+      def receive_data(data)
+        @data << data
+        super(data)
+      end
+
+      def unbind
+        queue_data
+        super
+      end
+
+      def queue_data
+        if @data != ''
+          beanstalk.put({:data => @data, :time => Time.new.to_i}.to_json) { |id|
+            logger.info "Job queued #{id}"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/queueing_proxy/version.rb

@@ -0,0 +1,3 @@
+module QueueingProxy
+  VERSION = '0.0.1'
+end

data/lib/queueing_proxy.rb

@@ -0,0 +1,22 @@
+require 'thin'
+require 'eventmachine'
+require 'em-jack'
+require 'json'
+
+require 'queueing_proxy/cli'
+require 'queueing_proxy/dsl'
+require 'queueing_proxy/queuer'
+require 'queueing_proxy/version'
+require 'queueing_proxy/dispatcher'
+
+module QueueingProxy
+
+  def self.from(host, port)
+    DSL.new.from(host, port)
+  end
+
+end
+
+def QueueingProxy(&blk)
+  QueueingProxy::DSL.new(&blk)
+end

data/queueing_proxy.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require File.join(File.dirname(__FILE__), 'lib', 'queueing_proxy', 'version')
+
+Gem::Specification.new do |s|
+  s.name = 'queueing_proxy'
+  s.version = QueueingProxy::VERSION
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Joshua Hull"]
+  s.date = '2010-07-21'
+  s.summary = "Queueing proxy backed by EM/Beanstalk for a very weird purpose."
+  s.description = "Queueing proxy backed by EM/Beanstalk for a very weird purpose."
+  s.email = %q{joshbuddy@gmail.com}
+  s.extra_rdoc_files = []
+  s.files = `git ls-files`.split("\n")
+  s.homepage = %q{http://github.com/joshbuddy/queueing_proxy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.test_files = `git ls-files`.split("\n").select{|f| f =~ /^spec/}
+  s.rubyforge_project = 'queueing_proxy'
+
+  # dependencies
+  s.add_runtime_dependency 'eventmachine'
+  s.add_runtime_dependency 'em-jack'
+  s.add_runtime_dependency 'thin'
+  s.add_runtime_dependency 'json'
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: queueing_proxy
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joshua Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-21 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: em-jack
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thin
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Queueing proxy backed by EM/Beanstalk for a very weird purpose.
+email: joshbuddy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Rakefile
+- bin/queueing_proxy
+- ext/gem_rake.rb
+- lib/queueing_proxy.rb
+- lib/queueing_proxy/cli.rb
+- lib/queueing_proxy/dispatcher.rb
+- lib/queueing_proxy/dsl.rb
+- lib/queueing_proxy/queuer.rb
+- lib/queueing_proxy/version.rb
+- queueing_proxy.gemspec
+has_rdoc: true
+homepage: http://github.com/joshbuddy/queueing_proxy
+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: queueing_proxy
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Queueing proxy backed by EM/Beanstalk for a very weird purpose.
+test_files: []
+