qless 0.9.1

data/Rakefile

@@ -0,0 +1,28 @@
+#!/usr/bin/env rake
+
+require 'bundler'
+Bundler.setup
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--profile --format progress]
+  t.ruby_opts  = "-Ispec -rsimplecov_setup"
+end
+
+# TODO: bump this up as test coverage increases. It was 90.29 when I last updated it on 2012-05-21.
+min_coverage_threshold = 90.0
+desc "Checks the spec coverage and fails if it is less than #{min_coverage_threshold}%"
+task :check_coverage do
+  percent = File.read("./coverage/coverage_percent.txt").to_f
+  if percent < min_coverage_threshold
+    raise "Spec coverage was not high enough: #{percent.round(2)}%"
+  else
+    puts "Nice job!  Spec coverage is still at least #{min_coverage_threshold}%"
+  end
+end
+
+task default: [:spec, :check_coverage]
+
+
+require 'qless/tasks'

data/bin/qless-campfire

@@ -0,0 +1,106 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'qless'
+require 'tinder'
+require 'micro-optparse'
+
+@options = Parser.new do |p|
+  p.banner = 'This agent lets you get campfire notifications for the progress of tracked jobs'
+  p.option :subdomain, 'campfire subdomain'    , :default => '', :value_satisfies => lambda { |subdomain| subdomain.is_a?(String) }
+  p.option :token    , 'campfire token for bot', :default => '', :value_satisfies => lambda { |subdomain| subdomain.is_a?(String) }
+  p.option :room     , 'campfire room to talk in (defaults to first room)', :default => ''
+  p.option :host     , 'host:port for your qless redis instance', :default => 'localhost:6379'
+  p.option :web      , 'host:port for your qless web ui', :default => 'localhost:5678'
+end.process!
+
+# Get a campfire object, and room
+puts 'Connecting to campfire...'
+@campfire = Tinder::Campfire.new @options[:subdomain], :token => @options[:token]
+if not @options[:room]
+  @room   = @campfire.rooms.first
+else
+  @room   = @campfire.find_room_by_name(@options[:room])
+end
+
+# And now qless stuff
+puts 'Connecting to qless...'
+@client   = Qless::Client.new(:host => @options[:host])
+
+def speak(message)
+  @room.speak message
+  puts "Said '#{message}'"
+end
+
+def paste(message)
+  @room.paste message
+  puts "Pasted '#{message}'"
+end
+
+def event(jid, &block)
+  job = @client.jobs[jid]
+  if job.nil?
+    speak("#{jid[0...8]} #{yield job} | http://#{@options[:host]}/jobs/#{jid}]")
+  else
+    speak("#{jid[0...8]} #{yield job} [#{job.tags.join(', ')}] | http://#{@options[:host]}/jobs/#{jid}")
+  end
+end
+
+@client.events.listen do |on|
+  on.canceled  { |jid| event(jid) { |job| 'canceled' } }
+  on.stalled   { |jid| event(jid) { |job| 'stalled'  } }
+  on.track     { |jid| event(jid) { |job| 'is being tracked'   } }
+  on.untrack   { |jid| event(jid) { |job| 'not longer tracked' } }
+  
+  on.completed do |jid|
+    event(jid) do |job|
+      if job
+        if job.queue_name.empty?
+          'completed'
+        else
+          "advanced to #{job.queue_name}"
+        end
+      else
+        'completed'
+      end
+    end
+  end
+  
+  on.popped do |jid|
+    event(jid) do |job|
+      if job
+        "popped by #{job.worker_name}"
+      else
+        'popped'
+      end
+    end
+  end
+  
+  on.put do |jid|
+    event(jid) do |job|
+      if job
+        "moved to #{job.queue_name}"
+      else
+        'moved'
+      end
+    end
+  end
+  
+  on.failed do |jid|
+    job = @client.jobs[jid]
+    if job
+      speak("#{jid} failed by #{job.failure['worker']} | http://#{@options[:web]}/jobs/#{jid}")
+      paste job.failure['message']
+    else
+      speak("#{jid} failed")
+    end
+  end
+  
+  puts 'Listening...'
+  
+  Signal.trap("INT") do
+    puts 'Exiting'
+    Process.exit(0)
+  end
+end

data/bin/qless-growl

@@ -0,0 +1,99 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'qless'
+require 'ruby-growl'
+require 'micro-optparse'
+
+@options = Parser.new do |p|
+  p.banner = 'This agent lets you get campfire notifications for the progress of tracked jobs'
+  p.option :growl    , 'host for the growl daemon', :default => 'localhost'
+  p.option :app      , 'application name for notifications', :default => 'qless'
+  p.option :host     , 'host:port for your qless redis instance', :default => 'localhost:6379'
+  p.option :web      , 'host:port for your qless web ui', :default => 'localhost:5678'
+end.process!
+
+# Connect to growl
+puts 'Connecting to growl...'
+@growl  = Growl::GNTP.new @options[:growl], @options[:app]
+
+# Qless client
+puts 'Connecting to qless...'
+@client = Qless::Client.new(:host => @options[:host])
+
+%w{canceled completed failed popped stalled put track untrack}.each do |t|
+  @growl.add_notification(t)
+end
+@growl.register
+
+def notify(jid, event, &block)
+  job = @client.jobs[jid]
+  if job.nil?
+    message = yield job
+    puts "#{jid} -> Notifying #{message}"
+    @growl.notify(event, "#{jid[0...8]}", "#{message}", 0, false, jid, "http://#{@options[:web]}/jobs/#{jid}")
+  else
+    message = yield job
+    puts "#{jid} -> Notifying #{message}"
+    @growl.notify(event, "#{jid[0...8]} [#{job.tags.join(', ')}]", "#{message}", 0, false, jid, "http://#{@options[:web]}/jobs/#{jid}")
+  end
+end
+
+@client.events.listen do |on|
+  on.canceled  { |jid| notify(jid, 'canceled') { |job| 'canceled' } }
+  on.stalled   { |jid| notify(jid, 'canceled') { |job| 'stalled'  } }
+  on.track     { |jid| notify(jid, 'canceled') { |job| 'is being tracked'  } }
+  on.untrack   { |jid| notify(jid, 'canceled') { |job| 'no longer tracked' } }
+  
+  on.completed do |jid|
+    notify(jid, 'completed') do |job|
+      if job
+        if job.queue_name.empty?
+          "completed"
+        else
+          "advanced to #{job.queue_name}"
+        end
+      else
+        "completed"
+      end
+    end
+  end
+  
+  on.failed do |jid|
+    notify(jid, 'failed') do |job|
+      if job
+        "failed by #{job.failure['worker']}"
+      else
+        "failed"
+      end
+    end
+  end
+  
+  on.popped do |jid|
+    notify(jid, 'popped') do |job|
+      if job
+        "popped by #{job.worker_name}"
+      else
+        "popped"
+      end
+    end
+  end
+  
+  on.put do |jid|
+    notify(jid, 'put') do |job|
+      if job
+        "moved to #{job.queue_name}"
+      else
+        "moved"
+      end
+    end
+  end
+  
+  puts 'Listening...'
+  
+  Signal.trap("INT") do
+    puts 'Exiting'
+    Process.exit(0)
+  end
+end

data/bin/qless-web

@@ -0,0 +1,23 @@
+#! /usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+begin
+  require 'vegas'
+rescue LoadError
+  require 'rubygems'
+  require 'vegas'
+end
+
+require 'qless/server'
+
+Vegas::Runner.new(Qless::Server, 'qless-web', {
+  :before_run => lambda {|v|
+    path = (ENV['RESQUECONFIG'] || v.args.first)
+    load path.to_s.strip if path
+  }
+}) do |runner, opts, app|
+  # opts.on('-r redis-connection', "--redis redis-connection", "set the Redis connection string") {|redis_conf|
+  #   runner.logger.info "Using Redis connection '#{redis_conf}'"
+  #   Resque.redis = redis_conf
+  # }
+end

data/lib/qless.rb

@@ -0,0 +1,185 @@
+require "socket"
+require "redis"
+require "json"
+require "securerandom"
+
+require "qless/version"
+require "qless/config"
+require "qless/queue"
+require "qless/job"
+require "qless/lua"
+
+module Qless
+  extend self
+
+  def generate_jid
+    SecureRandom.uuid.gsub('-', '')
+  end
+
+  def stringify_hash_keys(hash)
+    hash.each_with_object({}) do |(key, value), result|
+      result[key.to_s] = value
+    end
+  end
+
+  # This is a unique identifier for the worker
+  def worker_name
+    @worker_name ||= [Socket.gethostname, Process.pid.to_s].join('-')
+  end
+
+  class UnsupportedRedisVersionError < StandardError; end
+
+  class ClientJobs
+    def initialize(client)
+      @client = client
+    end
+    
+    def complete(offset=0, count=25)
+      @client._jobs.call([], ['complete', offset, count])
+    end
+    
+    def tracked
+      results = JSON.parse(@client._track.call([], []))
+      results['jobs'] = results['jobs'].map { |j| Job.new(@client, j) }
+      results
+    end
+    
+    def tagged(tag, offset=0, count=25)
+      JSON.parse(@client._tag.call([], ['get', tag, offset, count]))
+    end
+    
+    def failed(t=nil, start=0, limit=25)
+      if not t
+        JSON.parse(@client._failed.call([], []))
+      else
+        results = JSON.parse(@client._failed.call([], [t, start, limit]))
+        results['jobs'] = results['jobs'].map { |j| Job.new(@client, j) }
+        results
+      end
+    end
+    
+    def [](id)
+      results = @client._get.call([], [id])
+      if results.nil?
+        results = @client._recur.call([], ['get', id])
+        if results.nil?
+          return nil
+        end
+        return RecurringJob.new(@client, JSON.parse(results))
+      end
+      Job.new(@client, JSON.parse(results))
+    end
+  end
+  
+  class ClientWorkers
+    def initialize(client)
+      @client = client
+    end
+    
+    def counts
+      JSON.parse(@client._workers.call([], [Time.now.to_i]))
+    end
+    
+    def [](name)
+      JSON.parse(@client._workers.call([], [Time.now.to_i, name]))
+    end
+  end
+  
+  class ClientQueues
+    def initialize(client)
+      @client = client
+    end
+    
+    def counts
+      JSON.parse(@client._queues.call([], [Time.now.to_i]))
+    end
+    
+    def [](name)
+      Queue.new(name, @client)
+    end
+  end
+  
+  class ClientEvents
+    def initialize(redis)
+      @redis   = redis
+      @actions = Hash.new()
+    end
+    
+    def canceled(&block) ; @actions[:canceled ] = block; end
+    def completed(&block); @actions[:completed] = block; end
+    def failed(&block)   ; @actions[:failed   ] = block; end
+    def popped(&block)   ; @actions[:popped   ] = block; end
+    def stalled(&block)  ; @actions[:stalled  ] = block; end
+    def put(&block)      ; @actions[:put      ] = block; end
+    def track(&block)    ; @actions[:track    ] = block; end
+    def untrack(&block)  ; @actions[:untrack  ] = block; end
+    
+    def listen
+      yield(self) if block_given?
+      @redis.subscribe(:canceled, :completed, :failed, :popped, :stalled, :put, :track, :untrack) do |on|
+        on.message do |channel, message|
+          callback = @actions[channel.to_sym]
+          if not callback.nil?
+            callback.call(message)
+          end
+        end
+      end
+    end
+    
+    def stop
+      @redis.unsubscribe
+    end
+  end
+  
+  class Client
+    # Lua scripts
+    attr_reader :_cancel, :_config, :_complete, :_fail, :_failed, :_get, :_heartbeat, :_jobs, :_peek, :_pop
+    attr_reader :_priority, :_put, :_queues, :_recur, :_retry, :_stats, :_tag, :_track, :_workers, :_depends
+    # A real object
+    attr_reader :config, :redis, :jobs, :queues, :workers
+    
+    def initialize(options = {})
+      # This is the redis instance we're connected to
+      @redis   = options[:redis] || Redis.connect(options) # use connect so REDIS_URL will be honored
+      @options = options
+      assert_minimum_redis_version("2.5.5")
+      @config = Config.new(self)
+      ['cancel', 'config', 'complete', 'depends', 'fail', 'failed', 'get', 'heartbeat', 'jobs', 'peek', 'pop',
+        'priority', 'put', 'queues', 'recur', 'retry', 'stats', 'tag', 'track', 'workers'].each do |f|
+        self.instance_variable_set("@_#{f}", Lua.new(f, @redis))
+      end
+      
+      @jobs    = ClientJobs.new(self)
+      @queues  = ClientQueues.new(self)
+      @workers = ClientWorkers.new(self)
+    end
+    
+    def events
+      # Events needs its own redis instance of the same configuration, because
+      # once it's subscribed, we can only use pub-sub-like commands. This way,
+      # we still have access to the client in the normal case
+      @events ||= ClientEvents.new(Redis.connect(@options))
+    end
+    
+    def track(jid)
+      @_track.call([], ['track', jid, Time.now.to_i])
+    end
+    
+    def untrack(jid)
+      @_track.call([], ['untrack', jid, Time.now.to_i])
+    end
+    
+    def tags(offset=0, count=100)
+      JSON.parse(@_tag.call([], ['top', offset, count]))
+    end
+  private
+
+    def assert_minimum_redis_version(version)
+      redis_version = @redis.info.fetch("redis_version")
+      return if Gem::Version.new(redis_version) >= Gem::Version.new(version)
+
+      raise UnsupportedRedisVersionError,
+        "You are running redis #{redis_version}, but qless requires at least #{version}"
+    end
+  end
+end

data/lib/qless/config.rb

@@ -0,0 +1,31 @@
+require "qless/lua"
+require "redis"
+require "json"
+
+module Qless
+  # A configuration class associated with a qless client
+  class Config
+    def initialize(client)
+      @client = client
+    end
+    
+    def [](key)
+      @client._config.call([], ['get', key])
+    end
+    
+    def []=(key, value)
+      @client._config.call([], ['set', key, value])
+    end
+    
+    # Get the specified `qless` configuration option, or if
+    # none is provided, get the complete current configuration
+    def all
+      return JSON.parse(@client._config.call([], ['get']))
+    end
+    
+    # Restore this option to the default (remove this option)
+    def clear(option)
+      @client._config.call([], ['unset', option])
+    end
+  end
+end