pvdgm_beanstalk_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b885363a94242b1a19e7eada2e42aa05a9177b29
+  data.tar.gz: 0d4522c3003e3e923e538c4f3bb5a02f660b95b1
+SHA512:
+  metadata.gz: 35ee80c8f48e2f94be681e489f7752f71a7f5f39d8d99b128f2640119f78ba2f27bfd5b43d0f004d0b63ba06dbc9a4c438ed2c8f5687b41fd400a8f5ee92184a
+  data.tar.gz: be7d15b7e2f0b46d2c410f117f3f8549d836a2b308b5238be459cf2d98a589dbb33de90da13f56453afef26c6c0bd0a8fe5b7704ddbe569d549888ebc0646db7

data/README.md

@@ -0,0 +1,9 @@
+BeanstalkApi
+============
+
+This engine provides the RESTful apis to discover information
+about a connected beanstalk environment.
+
+You can add this engine to any Rails application that uses beanstalkd.
+
+Enjoy.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'BeanstalkApi'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+task :default => :spec

data/app/controllers/beanstalk_api/application_controller.rb

@@ -0,0 +1,68 @@
+module BeanstalkApi
+
+  class ApplicationController <  ActionController::Base
+    before_filter :restrict_access
+
+    def authenticated_entity
+      @api_key.try(:authenticateable)
+    end
+
+    private
+
+    #
+    # This is different from the standard API authentication because we need to
+    # restrict access to only the API key that is associated with the providigm account.
+    #
+    def restrict_access
+      authorization_header = request.headers['Authorization'] || ''
+      
+      if authorization_header =~ /^Basic/
+        authenticate_or_request_with_http_basic do | username, password |
+          @api_key = ApiKey.where(access_token: password).first
+          @api_key.present? && @api_key.authenticateable.id.to_s == username && username == '1'
+        end
+      else
+        authenticate_or_request_with_http_token do |token, options|
+          @api_key = ApiKey.where(access_token: token).first
+          @api_key.present? && @api_key.authenticateable.id.to_s == '1'
+        end
+      end
+    end
+
+    private
+
+    def format_job(job)
+      hash = {}
+      if job.is_a?(Hash)
+        job.each_pair do | host, job |
+          hash[job.id] = job.body
+        end
+      else
+        hash[job.id] = job.body
+      end
+      hash
+    end
+
+    def beanstalk_client
+      Ayl::Engine.get_active_engine
+    end
+
+    def pool
+      beanstalk_client.pool
+    end
+
+    def connection
+      pool.open_connections.first
+    end
+
+    def beanstalk_running
+      render json: { error: "Beanstalk not running" } unless beanstalk_client.asynchronous?
+    end
+
+    def default_tube
+      defined?(ASYNC_TUBE) ? ASYNC_TUBE : 'default'
+    end
+
+  end
+
+end

data/app/controllers/beanstalk_api/jobs_controller.rb

@@ -0,0 +1,27 @@
+module BeanstalkApi
+
+  class JobsController < BeanstalkApi::ApplicationController
+    attr_reader :job
+
+    before_filter :must_have_job
+
+    def show
+      render json: { job: format_job(job), statistics: connection.job_stats(params[:id]) }
+    end
+
+    def destroy
+      connection.delete(params[:id])
+      render json: { job: "Job '#{params[:id]}' Deleted" }
+    end
+
+    private
+    
+    def must_have_job
+      @job = pool.peek_job(params[:id])
+    rescue Beanstalk::NotFoundError
+      render json: { error: "Job '#{params[:id]}' not found" }
+    end
+
+  end
+
+end

data/app/controllers/beanstalk_api/tasks_controller.rb

@@ -0,0 +1,16 @@
+module BeanstalkApi
+
+  class TasksController < BeanstalkApi::ApplicationController
+
+    before_filter :beanstalk_running
+
+    respond_to :json
+
+    def overall_statistics
+      render json: pool.stats
+    end
+
+  end
+
+
+end

data/app/controllers/beanstalk_api/tubes_controller.rb

@@ -0,0 +1,149 @@
+module BeanstalkApi
+
+  class TubesController < BeanstalkApi::ApplicationController
+    attr_reader :tube
+
+    before_filter :must_have_existing_tube, only: [ :show, :ready, :delayed, :buried, :worker, :kick ]
+    before_filter :must_have_tube, only: [ :one_job, :all_jobs ]
+
+    respond_to :json
+
+    def index
+      tubes = pool.list_tubes
+      
+      render json: tubes.values.flatten
+    end
+
+    def show
+      render json: pool.stats_tube(tube)
+    end
+
+    def ready
+      pool.use(tube)
+
+      job = pool.peek_ready
+
+      render json: { error: "No job in ready state on '#{tube}' tube" } and return if job.nil?
+
+      render json: format_job(job)
+    end
+
+    def delayed
+      pool.use(tube)
+
+      job = pool.peek_delayed
+
+      render json: { error: "No job in delayed state on '#{tube}' tube" } and return if job.nil?
+
+      render json: format_job(job)
+    end
+
+    def buried
+      pool.use(tube)
+
+      job = pool.peek_buried
+
+      render json: { error: "No job in buried state on '#{tube}' tube" } and return if job.nil?
+
+      render json: format_job(job)
+    end
+
+    def one_job
+      pool.watch(tube)
+
+      job = pool.reserve(0)
+      job.delete if job.present?
+
+      render json: { eat_job: "1 job deleted" }
+    rescue Beanstalk::TimedOut
+      render json: { eat_job: "No job to eat on tube '#{tube}'" }
+    end
+
+    def all_jobs
+      count = 0
+
+      pool.watch(tube)
+
+      while ((job = pool.reserve(0)).present?)
+        count += 1
+        job.delete
+      end
+
+      # So, be aware that under ALL circumstances the loop will end with a
+      # Beanstalk::TimedOut exception. We simply catch it and report the
+      # number of jobs eaten. There is no case where this method will not
+      # raise one of these two exceptions.
+    rescue Beanstalk::TimedOut
+      render json: { eat_job: "#{count} job(s) deleted" }
+    end
+
+    def move
+      from_tube = Base64.urlsafe_decode64(params[:id])
+      to_tube = Base64.urlsafe_decode64(params[:to_tube])
+
+      count = 0
+
+      pool.watch(from_tube)
+      pool.use(to_tube)
+      while true
+        job = pool.reserve(0)
+        if job.present?
+          count += 1
+          pool.put(job.body)
+          job.delete
+        else
+          break
+        end
+      end
+
+      # So, be aware that under ALL circumstances the loop will end with a
+      # Beanstalk::TimedOut exception. We simply catch it and report the
+      # number of jobs eaten. There is no case where this method will not
+      # raise one of these two exceptions.
+    rescue Beanstalk::TimedOut
+      render json: { eat_job: "#{count} job(s) moved from '#{from_tube}' to '#{to_tube}'" }
+    rescue Beanstalk::NotFoundError
+      render json: { eat_job: "Tube '#{tube}' not found" }
+    end
+
+    def worker
+      pool.use(tube)
+      pool.put({ type: :ayl, code: 'Kernel.exit' }.to_yaml)
+      render json: { kill_worker: "Put kill worker message on tube '#{tube}'" }
+    end
+
+    def kick
+      bound = params[:bound] || '1'
+
+      pool.use(tube)
+      connection.kick(bound.to_i)
+
+      render json: { kick: "Up to #{bound} jobs were kicked on tube '#{tube}'" }
+    end
+
+    private
+
+    def must_have_existing_tube
+      if params[:id]
+        @tube = Base64.urlsafe_decode64(params[:id])
+        begin
+          pool.stats_tube(@tube)
+        rescue Beanstalk::NotFoundError
+          render json: { error: "Specified tube does not exist: #{@tube}" }, status: 404
+        end
+      else
+        render json: { error: "Must specify tube name" }, status: 404
+      end
+    end
+
+    def must_have_tube
+      if params[:id]
+        @tube = Base64.urlsafe_decode64(params[:id])
+      else
+        render json: { error: "Must specify tube name" }, status: 404
+      end
+    end
+
+  end
+
+end

data/app/helpers/beanstalk_api/application_helper.rb

@@ -0,0 +1,4 @@
+module BeanstalkApi
+  module ApplicationHelper
+  end
+end

data/app/views/layouts/beanstalk_api/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>BeanstalkApi</title>
+  <%= stylesheet_link_tag    "beanstalk_api/application", :media => "all" %>
+  <%= javascript_include_tag "beanstalk_api/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,19 @@
+BeanstalkApi::Engine.routes.draw do
+
+  get '/' => 'tasks#overall_statistics'
+
+  resources :jobs, only: [ :show, :destroy ]
+
+  resources :tubes, only: [ :index, :show ] do
+    member do
+      get 'ready'
+      get 'delayed'
+      get 'buried'
+      delete 'one_job'
+      delete 'all_jobs'
+      delete 'move/:to_tube' => :move 
+      delete 'worker'
+      get 'kick(/:bound)' => :kick
+    end
+  end
+end

data/lib/beanstalk_api.rb

@@ -0,0 +1,4 @@
+require "beanstalk_api/engine"
+
+module BeanstalkApi
+end

data/lib/beanstalk_api/engine.rb

@@ -0,0 +1,11 @@
+module BeanstalkApi
+  class Engine < ::Rails::Engine
+    isolate_namespace BeanstalkApi
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/beanstalk_api/version.rb

@@ -0,0 +1,3 @@
+module BeanstalkApi
+  VERSION = "0.1.0"
+end

data/lib/tasks/beanstalk_api_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :beanstalk_api do
+#   # Task goes here
+# end

data/spec/controllers/application_controller_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe BeanstalkApi::ApplicationController do
+
+  context '#format_job' do
+
+    it "should deal with the specified job if it is a hash" do
+      mock_job1 = double("Job")
+      mock_job1.should_receive(:id).and_return(1)
+      mock_job1.should_receive(:body).and_return('hello world')
+
+      mock_job2 = double("Job")
+      mock_job2.should_receive(:id).and_return(2)
+      mock_job2.should_receive(:body).and_return('goodbye world')
+
+      job = { 'localhost' => mock_job1, 'otherhost' => mock_job2 }
+
+      expect(controller.send(:format_job, job)).to eq( { 1 => 'hello world', 2 => 'goodbye world' } )
+    end
+
+    it "should with the job if it is just a job" do
+      mock_job1 = double("Job")
+      mock_job1.should_receive(:id).and_return(1)
+      mock_job1.should_receive(:body).and_return('hello world')
+
+      expect(controller.send(:format_job, mock_job1)).to eq( { 1 => 'hello world' } )
+    end
+
+  end
+
+  context '#beanstalk_client' do
+
+    it "should retrive the active engine" do
+      mock_engine = double("BSEngine")
+
+      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_engine)
+
+      expect(controller.send(:beanstalk_client)).to be(mock_engine)
+    end
+
+  end
+
+  context '#pool' do
+
+    it "should return the pool from the beanstalk client" do
+      mock_pool = double("BeanstalkPool")
+
+      mock_client = double("BeanstalkClient")
+      mock_client.should_receive(:pool).and_return(mock_pool)
+
+      controller.should_receive(:beanstalk_client).and_return(mock_client)
+
+      expect(controller.send(:pool)).to be(mock_pool)
+    end
+
+  end
+
+  context '#connection' do
+
+    it "should return the first open connection from the pool" do
+      mock_conn1 = double("BeanstalkConnection")
+      mock_conn2 = double("BeanstalkConnection")
+
+      mock_pool = double("BeanstalkPool")
+      mock_pool.should_receive(:open_connections).and_return([ mock_conn1, mock_conn2 ])
+
+      controller.should_receive(:pool).and_return(mock_pool)
+
+      expect(controller.send(:connection)).to be(mock_conn1)
+    end
+
+  end
+
+  context '#default_tube' do
+
+    it "should return 'default' if the ASYNC_TUBE constant is not defined" do
+      # expect(controller.send(:default_tube)).to eq('default')
+    end
+
+    it "should return the value of ASYNC_TUBE if ASYNC_TUBE is defined" do
+      ASYNC_TUBE ||= 'stupendous'
+      expect(controller.send(:default_tube)).to eq(ASYNC_TUBE)
+    end
+
+  end
+
+end