qmore 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea8959be10d5ec78ec5612398283ce82570d5a00
-  data.tar.gz: d49b79823a0f090a8879d7a5874688e85f881440
+  metadata.gz: 81dfd049f15b6991030f758016c3b47f4590a591
+  data.tar.gz: e940b3230a609ae3d40c732d91ca017ca23d7dac
 SHA512:
-  metadata.gz: 3daa792fc5110b0f4e1e82f8550e65d05051401aa2d3ec34770daba088e75f404e6f41cd3837ad6b34dd0b9f9bbb9d2e5e4b75bfa54e4818628a7155b469f669
-  data.tar.gz: 37fc4d50b6ab18fc0027516d74dc72689eb01062ed0352a2297ed2067ff4e504f4966360ddfa8d1c128b66b52e652cf51d2dc3749db1d524109b156e52184e8d
+  metadata.gz: 4a34b907609e0c0aad6502255b847cadd2e1ac1576a77db9bb8dee1c2fc2a04015c9b0d9fee7a887b12274aa258fe396b6d9109799f0439b1603507b08dcf4ca
+  data.tar.gz: e897e91ffa701441f469f509a67006506cb968e3728d18974c89397e46a7987fe0aa9a0c08bc672e88e1514706e75103e2d7fa260a69f087ec4752b545d0ba55

data/.travis.yml

@@ -2,4 +2,7 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+services:
+  - redis-server
 script: bundle exec rspec spec

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.6.0 (02/25/2014)
+------------------
+
+Merge pull request #2 from backupify/sharded-qmore <a1d051b> [Matt Conway]
+add mri 2.1.0 to test targets <4b8f74c> [Matt Conway]
+enable redis for travis <4aafd15> [Matt Conway]
+qmore multiple client support <d1c11f6> [james-lawrence]
+
 0.5.3 (11/12/2013)
 ------------------
 

data/lib/qmore/job_reserver.rb

@@ -1,16 +1,26 @@
 module Qmore
   class JobReserver
     include Qmore::Attributes
+    # define queues for Qless worker to invoke.
     attr_reader :queues
+    attr_reader :clients
 
     def initialize(queues)
       @queues = queues
+      # Pull the regex off of the Qless::Queue#name, we want to keep the same interface
+      # that Qless reservers use.
+      @regexes = queues.collect(&:name).uniq
+      @clients = {}
+      queues.each do |q|
+        @clients[q.client] ||= []
+        @clients[q.client] << q.name
+      end
     end
 
     def description
-      @description ||= @queues.map(&:name).join(', ') + " (qmore)"
+      @description ||= @regexes.join(', ') + " (qmore)"
     end
-    
+
     def prep_for_work!
       # nothing here on purpose
     end
@@ -20,22 +30,33 @@ module Qmore
         job = q.pop
         return job if job
       end
-      
+
       nil
     end
-    
+
     private
-    
+
     def realize_queues
-      queue_names = @queues.collect(&:name)
-      real_queues = Qmore.client.queues.counts.collect {|h| h['name'] }
-      
-      realized_queues = expand_queues(queue_names, real_queues)
-      realized_queues = prioritize_queues(get_priority_buckets, realized_queues)
-      realized_queues = realized_queues.collect {|q| Qmore.client.queues[q] }
+      realized_queues = []
+
+      self.clients.each do |client, regexes|
+        # Cache the queues so we don't make multiple calls.
+        actual_queues = client.queues
+
+        # Grab all the actual queue names from the client.
+        queue_names = actual_queues.counts.collect {|h| h['name'] }
+
+        # Match the queue names against the regexes provided.
+        matched_names = expand_queues(regexes, queue_names)
+
+        # Prioritize the queues.
+        prioritized_names = prioritize_queues(get_priority_buckets, matched_names)
+
+        # add the matched queues to the resulting list.
+        realized_queues.concat(prioritized_names.collect {|name| actual_queues[name] })
+      end
+
       realized_queues
     end
-          
   end
-
-end
+end

data/lib/qmore/version.rb

@@ -1,3 +1,3 @@
 module Qmore
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/qmore.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec')
   s.add_development_dependency('rack-test')
+  s.add_development_dependency('pry')
   # Needed for correct ordering when passing hash params to rack-test
   s.add_development_dependency('orderedhash')
 

data/spec/job_reserver_spec.rb

@@ -2,40 +2,61 @@ require "spec_helper"
 
 describe "JobReserver" do
   include Qmore::Attributes
-  
+
   before(:each) do
     Qmore.client.redis.flushall
   end
-  
+
+  context "multiple qless server environment" do
+    it "can reserve jobs from regex queue names on multiple clients" do
+      qless1 = Qless::Client.new(:redis => Redis.connect(:port => 6379))
+      qless2 = Qless::Client.new(:redis => Redis.connect(:port => 6380))
+      queue_a = qless1.queues["a"]
+      queue_b = qless2.queues["b"]
+      queue_a.put(SomeJob, [])
+      queue_b.put(SomeJob, [])
+
+      queue_a.length.should == 1
+      queue_b.length.should == 1
+
+      reserver = Qmore::JobReserver.new([qless1.queues["*"], qless2.queues["*"]])
+      worker = Qless::Worker.new(reserver, :run_as_single_process => true)
+      worker.work(0)
+
+      queue_a.length.should == 0
+      queue_b.length.should == 0
+    end
+  end
+
   context "basic qless behavior still works" do
 
     it "can reserve from multiple queues" do
-      high_queue = Qmore.client.queues['high'] 
-      critical_queue = Qmore.client.queues['critical'] 
+      high_queue = Qmore.client.queues['high']
+      critical_queue = Qmore.client.queues['critical']
 
       high_queue.put(SomeJob, [])
       critical_queue.put(SomeJob, [])
-      
+
       reserver = Qmore::JobReserver.new([critical_queue, high_queue])
       reserver.reserve.queue.name.should == 'critical'
       reserver.reserve.queue.name.should == 'high'
     end
 
     it "can work on multiple queues" do
-      high_queue = Qmore.client.queues['high'] 
-      critical_queue = Qmore.client.queues['critical'] 
+      high_queue = Qmore.client.queues['high']
+      critical_queue = Qmore.client.queues['critical']
       high_queue.put(SomeJob, [])
       critical_queue.put(SomeJob, [])
 
       high_queue.length.should == 1
       critical_queue.length.should == 1
-      
+
       reserver = Qmore::JobReserver.new([critical_queue, high_queue])
-      
+
       worker = Qless::Worker.new(reserver,
                                  :run_as_single_process => true)
       worker.work(0)
-      
+
       high_queue.length.should == 0
       critical_queue.length.should == 0
     end
@@ -43,7 +64,7 @@ describe "JobReserver" do
     it "can work on all queues" do
       queues = []
       ['high', 'critical', 'blahblah'].each do |q|
-        queue = Qmore.client.queues[q] 
+        queue = Qmore.client.queues[q]
         queue.put(SomeJob, [])
         queue.length.should == 1
         queues << queue
@@ -53,7 +74,7 @@ describe "JobReserver" do
       worker = Qless::Worker.new(reserver,
                                  :run_as_single_process => true)
       worker.work(0)
-      
+
       queues.each do |q|
         q.length.should == 0
       end
@@ -63,18 +84,18 @@ describe "JobReserver" do
       set_priority_buckets [{'pattern' => 'foo*', 'fairly' => false},
                             {'pattern' => 'default', 'fairly' => false},
                             {'pattern' => 'bar', 'fairly' => true}]
-      
-      
+
+
       queues = []
       ['other', 'blah', 'foobie', 'bar', 'foo'].each do |q|
-        queue = Qmore.client.queues[q] 
+        queue = Qmore.client.queues[q]
         queue.put(SomeJob, [])
         queue.length.should == 1
         queues << queue
       end
 
       reserver = Qmore::JobReserver.new([Qmore.client.queues['*'], Qmore.client.queues['!blah']])
-      
+
       reserver.reserve.queue.name.should == 'foo'
       reserver.reserve.queue.name.should == 'foobie'
       reserver.reserve.queue.name.should == 'other'

data/spec/{redis-test.conf → redis/qless01-test.conf}

@@ -18,7 +18,7 @@ daemonize yes
 
 # When running daemonized, Redis writes a pid file in ./tmp/run/redis.pid by
 # default. You can specify a custom pid file location here.
-pidfile ./redis.pid
+pidfile ./qless01-test.pid
 
 # Accept connections on the specified port, default is 6379
 port 6379
@@ -42,7 +42,7 @@ loglevel verbose
 # Specify the log file name. Also 'stdout' can be used to force
 # Redis to log on the standard output. Note that if you use standard
 # output for logging but daemonize, logs will be sent to /dev/null
-logfile ./redis-server.log
+logfile ./qless01-test-server.log
 
 # Set the number of databases. The default database is DB 0, you can select
 # a different one on a per-connection basis using SELECT <dbid> where
@@ -76,15 +76,15 @@ save 60 10000
 rdbcompression yes
 
 # The filename where to dump the DB
-dbfilename dump.rdb
+dbfilename ./qless01-test-dump.rdb
 
 # The working directory.
 #
 # The DB will be written inside this directory, with the filename specified
 # above using the 'dbfilename' configuration directive.
-# 
+#
 # Also the Append Only File will be created inside this directory.
-# 
+#
 # Note that you must specify a directory here, not a file name.
 dir .
 
@@ -112,7 +112,7 @@ dir .
 #
 # This should stay commented out for backward compatibility and because most
 # people do not need auth (e.g. they run their own servers).
-# 
+#
 # Warning: since Redis is pretty fast an outside user can try up to
 # 150k passwords per second against a good box. This means that you should
 # use a very strong password otherwise it will be very easy to break.
@@ -172,7 +172,7 @@ appendonly no
 # appendfilename appendonly.aof
 
 # The fsync() call tells the Operating System to actually write data on disk
-# instead to wait for more data in the output buffer. Some OS will really flush 
+# instead to wait for more data in the output buffer. Some OS will really flush
 # data on disk, some other OS will just try to do it ASAP.
 #
 # Redis supports three different modes:
@@ -195,91 +195,13 @@ appendonly no
 appendfsync everysec
 # appendfsync no
 
-################################ VIRTUAL MEMORY ###############################
-
-# Virtual Memory allows Redis to work with datasets bigger than the actual
-# amount of RAM needed to hold the whole dataset in memory.
-# In order to do so very used keys are taken in memory while the other keys
-# are swapped into a swap file, similarly to what operating systems do
-# with memory pages.
-#
-# To enable VM just set 'vm-enabled' to yes, and set the following three
-# VM parameters accordingly to your needs.
-
-vm-enabled no
-# vm-enabled yes
-
-# This is the path of the Redis swap file. As you can guess, swap files
-# can't be shared by different Redis instances, so make sure to use a swap
-# file for every redis process you are running. Redis will complain if the
-# swap file is already in use.
-#
-# The best kind of storage for the Redis swap file (that's accessed at random) 
-# is a Solid State Disk (SSD).
-#
-# *** WARNING *** if you are using a shared hosting the default of putting
-# the swap file under /tmp is not secure. Create a dir with access granted
-# only to Redis user and configure Redis to create the swap file there.
-vm-swap-file ./tmp/redis.swap
-
-# vm-max-memory configures the VM to use at max the specified amount of
-# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
-# is, if there is still enough contiguous space in the swap file.
-#
-# With vm-max-memory 0 the system will swap everything it can. Not a good
-# default, just specify the max amount of RAM you can in bytes, but it's
-# better to leave some margin. For instance specify an amount of RAM
-# that's more or less between 60 and 80% of your free RAM.
-vm-max-memory 0
-
-# Redis swap files is split into pages. An object can be saved using multiple
-# contiguous pages, but pages can't be shared between different objects.
-# So if your page is too big, small objects swapped out on disk will waste
-# a lot of space. If you page is too small, there is less space in the swap
-# file (assuming you configured the same number of total swap file pages).
-#
-# If you use a lot of small objects, use a page size of 64 or 32 bytes.
-# If you use a lot of big objects, use a bigger page size.
-# If unsure, use the default :)
-vm-page-size 32
-
-# Number of total memory pages in the swap file.
-# Given that the page table (a bitmap of free/used pages) is taken in memory,
-# every 8 pages on disk will consume 1 byte of RAM.
-#
-# The total swap size is vm-page-size * vm-pages
-#
-# With the default of 32-bytes memory pages and 134217728 pages Redis will
-# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
-#
-# It's better to use the smallest acceptable value for your application,
-# but the default is large in order to work in most conditions.
-vm-pages 134217728
-
-# Max number of VM I/O threads running at the same time.
-# This threads are used to read/write data from/to swap file, since they
-# also encode and decode objects from disk to memory or the reverse, a bigger
-# number of threads can help with big objects even if they can't help with
-# I/O itself as the physical device may not be able to couple with many
-# reads/writes operations at the same time.
-#
-# The special value of 0 turn off threaded I/O and enables the blocking
-# Virtual Memory implementation.
-vm-max-threads 4
-
 ############################### ADVANCED CONFIG ###############################
-
-# Glue small output buffers together in order to send small replies in a
-# single TCP packet. Uses a bit more CPU but most of the times it is a win
-# in terms of number of queries per second. Use 'yes' if unsure.
-glueoutputbuf yes
-
 # Hashes are encoded in a special way (much more memory efficient) when they
 # have at max a given numer of elements, and the biggest element does not
 # exceed a given threshold. You can configure this limits with the following
 # configuration directives.
-hash-max-zipmap-entries 64
-hash-max-zipmap-value 512
+hash-max-ziplist-entries 64
+hash-max-ziplist-value 512
 
 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
 # order to help rehashing the main Redis hash table (the one mapping top-level
@@ -288,7 +210,7 @@ hash-max-zipmap-value 512
 # that is rhashing, the more rehashing "steps" are performed, so if the
 # server is idle the rehashing is never complete and some more memory is used
 # by the hash table.
-# 
+#
 # The default is to use this millisecond 10 times every second in order to
 # active rehashing the main dictionaries, freeing memory when possible.
 #

data/spec/redis/qless02-test.conf

@@ -0,0 +1,234 @@
+# Redis configuration file example
+
+# Note on units: when memory size is needed, it is possible to specifiy
+# it in the usual form of 1k 5GB 4M and so forth:
+#
+# 1k => 1000 bytes
+# 1kb => 1024 bytes
+# 1m => 1000000 bytes
+# 1mb => 1024*1024 bytes
+# 1g => 1000000000 bytes
+# 1gb => 1024*1024*1024 bytes
+#
+# units are case insensitive so 1GB 1Gb 1gB are all the same.
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in ./tmp/run/redis.pid when daemonized.
+daemonize yes
+
+# When running daemonized, Redis writes a pid file in ./tmp/run/redis.pid by
+# default. You can specify a custom pid file location here.
+pidfile ./qless02-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 6380
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for incoming connections.
+#
+bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# verbose (many rarely useful info, but not a mess like the debug level)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel verbose
+
+# Specify the log file name. Also 'stdout' can be used to force
+# Redis to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile ./qless02-test-server.log
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################ SNAPSHOTTING  #################################
+#
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+#
+#   Note: you can disable saving at all commenting all the "save" lines.
+
+save 900 1
+save 300 10
+save 60 10000
+
+# Compress string objects using LZF when dump .rdb databases?
+# For default that's set to 'yes' as it's almost always a win.
+# If you want to save some CPU in the saving child set it to 'no' but
+# the dataset will likely be bigger if you have compressible values or keys.
+rdbcompression yes
+
+# The filename where to dump the DB
+dbfilename ./qless02-test-dump.rdb
+
+# The working directory.
+#
+# The DB will be written inside this directory, with the filename specified
+# above using the 'dbfilename' configuration directive.
+#
+# Also the Append Only File will be created inside this directory.
+#
+# Note that you must specify a directory here, not a file name.
+dir .
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+#
+# slaveof <masterip> <masterport>
+
+# If the master is password protected (using the "requirepass" configuration
+# directive below) it is possible to tell the slave to authenticate before
+# starting the replication synchronization process, otherwise the master will
+# refuse the slave request.
+#
+# masterauth <master-password>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+#
+# Warning: since Redis is pretty fast an outside user can try up to
+# 150k passwords per second against a good box. This means that you should
+# use a very strong password otherwise it will be very easy to break.
+#
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limits.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+#
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+#
+# maxmemory <bytes>
+
+############################## APPEND ONLY MODE ###############################
+
+# By default Redis asynchronously dumps the dataset on disk. If you can live
+# with the idea that the latest records will be lost if something like a crash
+# happens this is the preferred way to run Redis. If instead you care a lot
+# about your data and don't want to that a single record can get lost you should
+# enable the append only mode: when this mode is enabled Redis will append
+# every write operation received in the file appendonly.aof. This file will
+# be read on startup in order to rebuild the full dataset in memory.
+#
+# Note that you can have both the async dumps and the append only file if you
+# like (you have to comment the "save" statements above to disable the dumps).
+# Still if append only mode is enabled Redis will load the data from the
+# log file at startup ignoring the dump.rdb file.
+#
+# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
+# log file in background when it gets too big.
+
+appendonly no
+
+# The name of the append only file (default: "appendonly.aof")
+# appendfilename appendonly.aof
+
+# The fsync() call tells the Operating System to actually write data on disk
+# instead to wait for more data in the output buffer. Some OS will really flush
+# data on disk, some other OS will just try to do it ASAP.
+#
+# Redis supports three different modes:
+#
+# no: don't fsync, just let the OS flush the data when it wants. Faster.
+# always: fsync after every write to the append only log . Slow, Safest.
+# everysec: fsync only if one second passed since the last fsync. Compromise.
+#
+# The default is "everysec" that's usually the right compromise between
+# speed and data safety. It's up to you to understand if you can relax this to
+# "no" that will will let the operating system flush the output buffer when
+# it wants, for better performances (but if you can live with the idea of
+# some data loss consider the default persistence mode that's snapshotting),
+# or on the contrary, use "always" that's very slow but a bit safer than
+# everysec.
+#
+# If unsure, use "everysec".
+
+# appendfsync always
+appendfsync everysec
+# appendfsync no
+
+############################### ADVANCED CONFIG ###############################
+# Hashes are encoded in a special way (much more memory efficient) when they
+# have at max a given numer of elements, and the biggest element does not
+# exceed a given threshold. You can configure this limits with the following
+# configuration directives.
+hash-max-ziplist-entries 64
+hash-max-ziplist-value 512
+
+# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
+# order to help rehashing the main Redis hash table (the one mapping top-level
+# keys to values). The hash table implementation redis uses (see dict.c)
+# performs a lazy rehashing: the more operation you run into an hash table
+# that is rhashing, the more rehashing "steps" are performed, so if the
+# server is idle the rehashing is never complete and some more memory is used
+# by the hash table.
+#
+# The default is to use this millisecond 10 times every second in order to
+# active rehashing the main dictionaries, freeing memory when possible.
+#
+# If unsure:
+# use "activerehashing no" if you have hard latency requirements and it is
+# not a good thing in your environment that Redis can reply form time to time
+# to queries with 2 milliseconds delay.
+#
+# use "activerehashing yes" if you don't have such hard requirements but
+# want to free memory asap when possible.
+activerehashing yes
+
+################################## INCLUDES ###################################
+
+# Include one or more other config files here.  This is useful if you
+# have a standard template that goes to all redis server but also need
+# to customize a few per-server settings.  Include files can include
+# other files, so use this wisely.
+#
+# include /path/to/local.conf
+# include /path/to/other.conf

data/spec/spec_helper.rb

@@ -1,32 +1,31 @@
 require 'rspec'
 require 'coveralls'
+require 'pry'
 Coveralls.wear!
 
 require 'qmore'
 
 # No need to start redis when running in Travis
 unless ENV['CI']
+  redis_configs_directory = File.join(File.dirname(File.expand_path(__FILE__)), "redis")
+  redis_configs = Dir.entries(redis_configs_directory).select{|f| !File.directory? f}
 
-  begin
-    Qmore.client.queues.counts
-  rescue Errno::ECONNREFUSED
-    spec_dir = File.dirname(File.expand_path(__FILE__))
-    REDIS_CMD = "redis-server #{spec_dir}/redis-test.conf"
-    
+  redis_configs.each do |config|
+    redis_cmd = "redis-server #{redis_configs_directory}/#{config}"
     puts "Starting redis for testing at localhost..."
-    puts `cd #{spec_dir}; #{REDIS_CMD}`
-    
+    puts `cd #{redis_configs_directory}; #{redis_cmd}`
+
     # Schedule the redis server for shutdown when tests are all finished.
     at_exit do
+      redis_instance_name = config.chomp(".conf")
       puts 'Stopping redis'
-      pid = File.read("#{spec_dir}/redis.pid").to_i rescue nil
+      pid = File.read("#{redis_configs_directory}/#{redis_instance_name}.pid").to_i rescue nil
       system ("kill -9 #{pid}") if pid.to_i != 0
-      File.delete("#{spec_dir}/redis.pid") rescue nil
-      File.delete("#{spec_dir}/redis-server.log") rescue nil
-      File.delete("#{spec_dir}/dump.rdb") rescue nil
+      File.delete("#{redis_configs_directory}/#{redis_instance_name}.pid") rescue nil
+      File.delete("#{redis_configs_directory}/#{redis_instance_name}-server.log") rescue nil
+      File.delete("#{redis_configs_directory}/#{redis_instance_name}-dump.rdb") rescue nil
     end
   end
-  
 end
 
 def dump_redis

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qmore
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Matt Conway
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-12 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: qless
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: orderedhash
   requirement: !ruby/object:Gem::Requirement
@@ -123,7 +137,8 @@ files:
 - qmore.gemspec
 - spec/attributes_spec.rb
 - spec/job_reserver_spec.rb
-- spec/redis-test.conf
+- spec/redis/qless01-test.conf
+- spec/redis/qless02-test.conf
 - spec/server_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -145,14 +160,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: qmore
-rubygems_version: 2.0.6
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: A qless plugin that gives more control over how queues are processed
 test_files:
 - spec/attributes_spec.rb
 - spec/job_reserver_spec.rb
-- spec/redis-test.conf
+- spec/redis/qless01-test.conf
+- spec/redis/qless02-test.conf
 - spec/server_spec.rb
 - spec/spec_helper.rb
-has_rdoc: