timberline 0.3.1 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 01da0a8b72d0153c044386ba5d2a2947ceba809a
+  data.tar.gz: b56730906aa005b6107cea4f1c693362e8a1ee99
+SHA512:
+  metadata.gz: e997f4fc10c86d1c64f2f4a18982e1fa9a2a30042d078988c3db13b1f675f7ca5260bad1b45a9b75b055292ff5e0a8d712e0fc7fe5e9ab0804d417510d0b71a2
+  data.tar.gz: a4c464628b537811773da27a6f95828bba46566b23bd53bfec452d17497dd99a464ef8c7adb3373df1f0ee4fd1d5534e42cbc9de8fb6a3ac18b860c4be747e7e

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+timberline

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - jruby-head
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+services: 
+  - redis-server

data/Gemfile

@@ -1,4 +1,4 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in treeline.gemspec
+# Gem dependencies specified in timberline.gemspec
 gemspec

data/README.markdown

@@ -1,5 +1,7 @@
 # Timberline
 
+![](https://travis-ci.org/treehouse/timberline.svg)
+
 ## Purpose
 
 Timberline is a dead-simple queuing service written in Ruby and backed by Redis.
@@ -64,7 +66,7 @@ queue (more on that later). There are 3 ways to configure Timberline:
 
 1. The most direct way is to configure Timberline via ruby code as follows:
 
-        Timberline.config do |c|
+        Timberline.configure do |c|
           c.database = 1
           c.host = "192.168.1.105"
           c.port = 12345
@@ -81,10 +83,13 @@ queue (more on that later). There are 3 ways to configure Timberline:
    automatically detect it and load it up. The syntax for this file is
    shockingly boring:
 
-        database: 1
-        host: 192.168.1.105
-        port: 12345
-        password: foobar
+        development:
+          database: 1
+          host: 192.168.1.105
+          port: 12345
+          password: foobar
+        production:
+          ...etc.
 
 3. Like the yaml format but you're not using Rails? Don't worry, just write your
    yaml file and set the TIMBERLINE\_YAML constant inside your app like so:
@@ -205,7 +210,7 @@ should probably change, but it probably won't until someone needs it to.
 Gem requirements/etc. should be handled by Bundler.
 
 ## License
-Copyright (C) 2012 by Tommy Morgan
+Copyright (C) 2014 by Tommy Morgan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

data/Rakefile

@@ -1,8 +1,7 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new do |t|
-  t.libs << "test"
-  t.test_files = FileList['test/unit/test_*.rb']
-  t.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/timberline/config.rb

@@ -35,6 +35,7 @@ class Timberline
       config
     end
 
+  private
     def load_from_yaml(yaml_config)
       raise "Missing yaml configs!" if yaml_config.nil?
       ["database","host","port","timeout","password","logger","namespace"].each do |setting|

data/lib/timberline/queue.rb

@@ -3,13 +3,16 @@ class Timberline
     attr_reader :queue_name, :read_timeout
 
     def initialize(queue_name, read_timeout= 0)
+      if queue_name.nil?
+        raise ArgumentError.new("Queue name must be provided.")
+      end
       @queue_name = queue_name
       @read_timeout = read_timeout
       @redis = Timberline.redis
       @redis.sadd "timberline_queue_names", queue_name
     end
 
-    def delete!
+    def delete
       @redis.del @queue_name
       @redis.keys("#{@queue_name}:*").each do |key|
         @redis.del key

data/lib/timberline/version.rb

@@ -1,3 +1,3 @@
 class Timberline
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/timberline.rb

@@ -13,141 +13,137 @@ require_relative "timberline/envelope"
 
 class Timberline
   class << self
-
     attr_reader :config
+    attr_accessor :watch_proc
+  end
 
-    def redis=(server)
-      initialize_if_necessary
-      if server.is_a? Redis
-        @redis = Redis::Namespace.new(@config.namespace, :redis => server)
-      elsif server.is_a? Redis::Namespace
-        @redis = server
-      elsif server.nil?
-        @redis = nil
-      else
-        raise "Not a valid Redis connection."
-      end
+  def self.redis=(server)
+    initialize_if_necessary
+    if server.is_a? Redis
+      @redis = Redis::Namespace.new(@config.namespace, :redis => server)
+    elsif server.is_a? Redis::Namespace
+      @redis = server
+    elsif server.nil?
+      @redis = nil
+    else
+      raise "Not a valid Redis connection."
     end
+  end
 
-    def redis
-      initialize_if_necessary
-      if @redis.nil?
-        self.redis = Redis.new(@config.redis_config)
-      end
-
-      @redis
+  def self.redis
+    initialize_if_necessary
+    if @redis.nil?
+      self.redis = Redis.new(@config.redis_config)
     end
 
-    def all_queues
-      Timberline.redis.smembers("timberline_queue_names").map { |name| queue(name) }
-    end
+    @redis
+  end
 
-    def error_queue
-      @error_queue ||= Queue.new("timberline_errors")
-    end
+  def self.all_queues
+    Timberline.redis.smembers("timberline_queue_names").map { |name| queue(name) }
+  end
 
-    def queue(queue_name)
-      if @queue_list[queue_name].nil?
-        @queue_list[queue_name] = Queue.new(queue_name)
-      end
-      @queue_list[queue_name]
-    end
+  def self.error_queue
+    @error_queue ||= Queue.new("timberline_errors")
+  end
 
-    def push(queue_name, data, metadata={})
-      queue(queue_name).push(data, metadata)
-    end
+  def self.queue(queue_name)
+    Queue.new(queue_name)
+  end
 
-    def retry_item(item)
-      if (item.retries < max_retries)
-        item.retries += 1
-        item.last_tried_at = Time.now.to_f
-        queue(item.origin_queue).push(item)
-        raise ItemRetried
-      else
-        error_item(item)
-      end
-    end
+  def self.push(queue_name, data, metadata={})
+    queue(queue_name).push(data, metadata)
+  end
 
-    def error_item(item)
-      item.fatal_error_at = Time.now.to_f
-      error_queue.push(item)
-      raise ItemErrored
+  def self.retry_item(item)
+    if (item.retries < max_retries)
+      item.retries += 1
+      item.last_tried_at = Time.now.to_f
+      queue(item.origin_queue).push(item)
+    else
+      error_item(item)
     end
+  end
 
-    def pause(queue_name)
-      queue(queue_name).pause
-    end
+  def self.error_item(item)
+    item.fatal_error_at = Time.now.to_f
+    error_queue.push(item)
+  end
 
-    def unpause(queue_name)
-      queue(queue_name).unpause
-    end
+  def self.pause(queue_name)
+    queue(queue_name).pause
+  end
 
-    def config(&block)
-      initialize_if_necessary
-      yield @config
-    end
+  def self.unpause(queue_name)
+    queue(queue_name).unpause
+  end
 
-    def max_retries
-      initialize_if_necessary
-      @config.max_retries
-    end
+  def self.configure(&block)
+    initialize_if_necessary
+    yield @config
+  end
 
-    def stat_timeout
-      initialize_if_necessary
-      @config.stat_timeout
-    end
+  def self.max_retries
+    initialize_if_necessary
+    @config.max_retries
+  end
 
-    def stat_timeout_seconds
-      initialize_if_necessary
-      @config.stat_timeout * 60
-    end
+  def self.stat_timeout
+    initialize_if_necessary
+    @config.stat_timeout
+  end
+
+  def self.stat_timeout_seconds
+    initialize_if_necessary
+    @config.stat_timeout * 60
+  end
 
-    def watch(queue_name, &block)
-      queue = queue(queue_name)
-      while(true)
-        item = queue.pop
-        fix_binding(block)
-        item.started_processing_at = Time.now.to_f
-
-        begin
-          block.call(item, self)
-        rescue ItemRetried
-          queue.add_retry_stat(item)
-        rescue ItemErrored
-          queue.add_error_stat(item)
-        else
-          item.finished_processing_at = Time.now.to_f
-          queue.add_success_stat(item)
-        end
+  def self.watch(queue_name, &block)
+    queue = queue(queue_name)
+    while(self.watch?)
+      item = queue.pop
+      fix_binding(block)
+      item.started_processing_at = Time.now.to_f
+
+      begin
+        block.call(item, self)
+      rescue ItemRetried
+        queue.add_retry_stat(item)
+      rescue ItemErrored
+        queue.add_error_stat(item)
+      else
+        item.finished_processing_at = Time.now.to_f
+        queue.add_success_stat(item)
       end
     end
+  end
 
-    private
-    # Don't know if I like doing this, but we want the configuration to be
-    # lazy-loaded so as to be sure and give users a chance to set up their
-    # configurations.
-    def initialize_if_necessary
-      @config ||= Config.new
-    end
+  private
+  def self.initialize_if_necessary
+    @config ||= Config.new
+  end
 
-    # Hacky-hacky. I like the idea of calling retry_item(item) and
-    # error_item(item)
-    # directly from the watch block, but this seems ugly. There may be a better
-    # way to do this.
-    def fix_binding(block)
-      binding = block.binding
-      binding.eval <<-HERE
-        def retry_item(item)
-          Timberline.retry_item(item)
-          raise Timberline::ItemRetried
-        end
-
-        def error_item(item)
-          Timberline.error_item(item)
-          raise Timberline::ItemErrored
-        end
-      HERE
-    end
+  # Hacky-hacky. I like the idea of calling retry_item(item) and
+  # error_item(item)
+  # directly from the watch block, but this seems ugly. There may be a better
+  # way to do this.
+  def self.fix_binding(block)
+    binding = block.binding
+    binding.eval <<-HERE
+      def retry_item(item)
+        Timberline.retry_item(item)
+        raise Timberline::ItemRetried
+      end
+
+      def error_item(item)
+        Timberline.error_item(item)
+        raise Timberline::ItemErrored
+      end
+    HERE
+  end
+
+  def self.watch?
+    watch_proc.nil? ? true : watch_proc.call
   end
 
   class ItemRetried < Exception
@@ -156,5 +152,3 @@ class Timberline
   class ItemErrored < Exception
   end
 end
-
-Timberline.instance_variable_set("@queue_list", {})

data/spec/fake_rails/config/timberline.yaml

@@ -0,0 +1,7 @@
+development:
+  host: localhost
+  port: 12345
+  timeout: 10
+  password: foo
+  database: 3
+  namespace: treecurve

data/spec/lib/timberline/config_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Timberline::Config do
+  describe "newly created" do
+    context "when the TIMBERLINE_YAML constant is defined" do
+      context "and the specified file exists" do
+        before do
+          SpecSupport::TimberlineYaml.load_constant
+        end
+
+        after do
+          SpecSupport::TimberlineYaml.destroy_constant
+        end
+
+        it "loads the host variable from the config file" do
+          expect(subject.host).to eq("localhost")
+        end
+
+        it "loads the port variable from the config file" do
+          expect(subject.port).to eq(12345)
+        end
+
+        it "loads the timeout variable from the config file" do
+          expect(subject.timeout).to eq(10)
+        end
+
+        it "loads the password from the config file" do
+          expect(subject.password).to eq("foo")
+        end
+
+        it "loads the database from the config file" do
+          expect(subject.database).to eq(3)
+        end
+
+        it "loads the namespace from the config file" do
+          expect(subject.namespace).to eq("treecurve")
+        end
+      end
+
+      context "and the specified file doesn't exist" do
+        before do
+          SpecSupport::TimberlineYaml.load_constant_for_missing_file
+        end
+
+        after do
+          SpecSupport::TimberlineYaml.destroy_constant
+        end
+
+        it "raises an exception to let you know the file doesn't exist" do
+          expect { Timberline::Config.new }.to raise_error
+        end
+      end
+    end
+
+    context "if Rails.root is defined" do
+      context "and a config/timberline.yaml file exists" do
+        before do
+          SpecSupport::FakeRails.create_fake_env
+        end
+
+        after do
+          SpecSupport::FakeRails.destroy_fake_env
+        end
+
+        it "loads the host variable from the config file" do
+          expect(subject.host).to eq("localhost")
+        end
+
+        it "loads the port variable from the config file" do
+          expect(subject.port).to eq(12345)
+        end
+
+        it "loads the timeout variable from the config file" do
+          expect(subject.timeout).to eq(10)
+        end
+
+        it "loads the password from the config file" do
+          expect(subject.password).to eq("foo")
+        end
+
+        it "loads the database from the config file" do
+          expect(subject.database).to eq(3)
+        end
+
+        it "loads the namespace from the config file" do
+          expect(subject.namespace).to eq("treecurve")
+        end
+      end
+
+      context "and a config/timberline.yaml file does not exist" do
+        before do
+          SpecSupport::FakeRails.create_fake_env_without_config
+        end
+
+        after do
+          SpecSupport::FakeRails.destroy_fake_env
+        end
+
+        it "configures a default namespace of 'timberline'" do
+          expect(subject.namespace).to eq("timberline")
+        end
+
+        it "configures a default max_retries of 5" do
+          expect(subject.max_retries).to eq(5)
+        end
+
+        it "configures a stat_timeout of 60" do
+          expect(subject.stat_timeout).to eq(60)
+        end
+
+        it "doesn't configure any redis settings so that redis will use its own defaults" do
+          [:database, :host, :port, :timeout, :password, :logger].each do |value|
+            expect(subject.send(value)).to be_nil
+          end
+        end
+      end
+    end
+
+    context "when no configuration exists" do
+      it "configures a default namespace of 'timberline'" do
+        expect(subject.namespace).to eq("timberline")
+      end
+
+      it "configures a default max_retries of 5" do
+        expect(subject.max_retries).to eq(5)
+      end
+
+      it "configures a stat_timeout of 60" do
+        expect(subject.stat_timeout).to eq(60)
+      end
+
+      it "doesn't configure any redis settings so that redis will use its own defaults" do
+        [:database, :host, :port, :timeout, :password, :logger].each do |value|
+          expect(subject.send(value)).to be_nil
+        end
+      end
+    end
+  end
+
+  describe "#redis_config" do
+    subject { Timberline::Config.new }
+
+    it "returns a hash" do
+      expect(subject.redis_config).to be_a Hash
+    end
+
+    context "when only defaults have been configured" do
+      it "is empty" do
+        expect(subject.redis_config).to be_empty
+      end
+    end
+
+    context "when it has been fully configured" do
+      before do
+        subject.database = 1
+        subject.host     = "localhost"
+        subject.port     = 1234
+        subject.timeout  = 15
+        subject.password = "fritters"
+        subject.logger   = Logger.new(STDOUT)
+      end
+
+      it "includes the appropriate redis configuration keys" do
+        [:db, :host, :port, :timeout, :password, :logger].each do |key|
+          expect(subject.redis_config).to have_key key
+        end
+      end
+    end
+  end
+end

data/spec/lib/timberline/envelope_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Timberline::Envelope do
+  describe "newly created" do
+    it "has no contents" do
+      expect(subject.contents).to be_nil
+    end
+
+    it "has a metadata object" do
+      expect(subject.metadata).not_to be_nil
+    end
+
+    it "has an empty hash for metadata" do
+      expect(subject.metadata).to eq({})
+    end
+  end
+
+  describe "#to_s" do
+    context "When the envelope has no contents" do
+      before do
+        subject.contents = nil
+      end
+
+      it "raises a MissingContentException" do
+        expect { subject.to_s }.to raise_error(Timberline::MissingContentException)
+      end
+    end
+
+    context "When the envelope has contents" do
+      before do
+        subject.contents = "Wheeee!"
+      end
+
+      it "renders a JSON string of the envelope's data" do
+        expect(subject.to_s).to eq(JSON.unparse({contents: "Wheeee!"}))
+      end
+    end
+
+    context "When the envelope has contents and metadata" do
+      before do
+        subject.contents = "Wheeee!"
+        subject.fritters = "the bacon kind"
+      end
+
+      it "renders a JSON string of the envelope's data" do
+        expect(subject.to_s).to eq(JSON.unparse({contents: "Wheeee!", fritters: "the bacon kind"}))
+      end
+    end
+  end
+
+  describe "#method_missing" do
+    context "When the missing method has an = at the end" do
+      before do
+        subject.fritters = "the bacon kind"
+      end
+
+      it "acts like a setter for the metadata object" do
+        expect(subject.metadata["fritters"]).to eq("the bacon kind")
+      end
+    end
+
+    context "When the missing method doesn't have an = at the end" do
+      before do
+        subject.metadata["fritters"] = "the bacon kind"
+      end
+
+      it "acts like a getter for the metadata object" do
+        expect(subject.fritters).to eq("the bacon kind")
+      end
+    end
+  end
+
+  describe ".from_json" do
+    let(:data_hash) { { contents: "hey guys!", test: true, fritters: "the bacon kind" } }
+    let(:json_string) { JSON.unparse(data_hash) }
+    let(:envelope) { Timberline::Envelope.from_json(json_string) }
+
+    it "creates a Timberline::Envelope" do
+      expect(envelope).to be_a Timberline::Envelope
+    end
+
+    it "correctly parses the contents" do
+      expect(envelope.contents).to eq(data_hash[:contents])
+    end
+
+    it "correctly parses the metadata" do
+      expect(envelope.test).to be true
+      expect(envelope.fritters).to eq "the bacon kind"
+    end
+  end
+end