More consistent naming

Author: Juuso Mäyränen

lib/logstash/inputs/redis.rb

@@ -112,8 +112,8 @@ def register
       @run_method = method(:list_runner)
       @stop_method = method(:list_stop)
     elsif @data_type == 'pattern_list'
-      @run_method = method(:list_pattern_runner)
-      @stop_method = method(:list_pattern_stop)
+      @run_method = method(:pattern_list_runner)
+      @stop_method = method(:pattern_list_stop)
     elsif @data_type == 'channel'
       @run_method = method(:channel_runner)
       @stop_method = method(:subscribe_stop)
@@ -258,13 +258,13 @@ def reset_threadpool
   end
 
   # private
-  def list_pattern_stop
+  def pattern_list_stop
     reset_redis
     reset_threadpool
   end
 
   # private
-  def list_pattern_process_item(redis, output_queue, key)
+  def pattern_list_process_item(redis, output_queue, key)
     if stop?
       @logger.debug("Breaking from thread #{key} as it was requested to stop")
       return false
@@ -276,14 +276,14 @@ def list_pattern_process_item(redis, output_queue, key)
   end
 
   # private
-  def list_pattern_single_processor(redis, output_queue, key)
+  def pattern_list_single_processor(redis, output_queue, key)
     (0...@pattern_list_max_items).each do
-      break unless list_pattern_process_item(redis, output_queue, key)
+      break unless pattern_list_process_item(redis, output_queue, key)
     end
   end
 
   # private
-  def list_pattern_batch_processor(redis, output_queue, key)
+  def pattern_list_batch_processor(redis, output_queue, key)
     items_left = @pattern_list_max_items
     while items_left > 0
       limit = [items_left, @batch_count].min
@@ -297,11 +297,11 @@ def list_pattern_batch_processor(redis, output_queue, key)
   end
 
   # private
-  def worker_consume(output_queue, key)
+  def pattern_list_worker_consume(output_queue, key)
     @logger.debug("Launched worker for #{key}")
     begin
       redis ||= connect
-      @list_pattern_processor.call(redis, output_queue, key)
+      @pattern_list_processor.call(redis, output_queue, key)
     rescue ::Redis::BaseError => e
       @logger.warn("Redis connection problem in thread for key #{key}. Sleeping a while before exiting thread.", :exception => e)
       sleep 1
@@ -318,35 +318,35 @@ def threadpool_capacity?
   end
 
   # private
-  def launch_worker(output_queue, key)
+  def pattern_list_launch_worker(output_queue, key)
     @current_workers.add(key)
     @threadpool.post do
       begin
-        worker_consume(output_queue, key)
+        pattern_list_worker_consume(output_queue, key)
       ensure
         @current_workers.delete(key)
       end
     end
   end
 
   # private
-  def ensure_workers(output_queue)
+  def pattern_list_ensure_workers(output_queue)
     return unless threadpool_capacity?
     redis_runner do
       @redis.keys(@key).shuffle.each do |key|
         next if @current_workers.include?(key)
-        launch_worker(output_queue, key)
+        pattern_list_launch_worker(output_queue, key)
         break unless threadpool_capacity?
       end
     end
   end
 
   # private
-  def list_pattern_runner(output_queue)
-    @list_pattern_processor = batched? ? method(:list_pattern_batch_processor) : method(:list_pattern_single_processor)
+  def pattern_list_runner(output_queue)
+    @pattern_list_processor = batched? ? method(:pattern_list_batch_processor) : method(:pattern_list_single_processor)
     while !stop?
       init_threadpool if @threadpool.nil?
-      ensure_workers(output_queue)
+      pattern_list_ensure_workers(output_queue)
       sleep(@pattern_list_threadpool_sleep)
     end
   end

spec/inputs/redis_spec.rb

@@ -71,7 +71,7 @@ def process(conf, event_count)
         redis {
           type => "blah"
           key => "#{key}.*"
-          data_type => "list_pattern"
+          data_type => "pattern_list"
         }
       }
     CONFIG