nimble_nodes 0.1.9 → 0.2.0

data/Rakefile

@@ -5,12 +5,15 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "nimble_nodes"
-    gem.summary = "gem for connecting apps to the NimbleNodes server"
-    gem.description = "automatically scales dynos and workers at Heroku"
+    gem.summary = "coming soon"
+    gem.description = "coming soon"
     gem.email = "jordan@digitalignition.com"
     gem.homepage = "http://github.com/glasner/nimble_nodes"
     gem.authors = ["Jordan Glasner"]
     gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_development_dependency "mocha"
+    gem.add_development_dependency "fakeweb"
+    gem.add_dependency "json"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.9
+0.2.0

data/lib/nimble_nodes/app.rb

@@ -0,0 +1,51 @@
+module NimbleNodes
+  
+  module App
+    
+    #= Rails
+    
+    def self.rails?
+      defined?(RAILS_GEM_VERSION) ? true : false
+    end
+    
+    def self.rails_version
+      RAILS_GEM_VERSION.slice(0..2).to_f
+    end
+    
+    #== Check Rails version  
+    # returns true if gem is loaded in a pre 2.3 version of rails
+    def self.use_rails_filter?
+      NimbleNodes::App.rails? and NimbleNodes::App.rails_version < 2.3
+    end  
+      
+    # set through Heroku API when app is created
+    def self.name
+      ENV['NIMBLE_NODES_APP_NAME']
+    end
+    
+    # set through Heroku API when app is created at server
+    def self.token
+      ENV['NIMBLE_NODES_APP_TOKEN']
+    end
+    
+    # returns true if app has been setup at server correctly
+    def self.token?
+      not NimbleNodes::App.token.nil?
+    end
+    
+    # path at server for calling app resource and subresources
+    def self.path(subpath='/')
+      name = NimbleNodes::App.name
+      return nil if name.nil?
+      '/' + name + subpath
+    end
+    
+    # returns path to platform specific report implementation 
+    def self.reporter
+      path = NimbleNodes::App.use_rails_filter? ? '/rails/filter' : '/middleware'
+      NimbleNodes.lib_path(path)
+    end
+    
+  end
+  
+end

data/lib/nimble_nodes/dynos.rb

@@ -2,16 +2,65 @@ module NimbleNodes
   
   module Dynos
     
+    #= Settings
+    
+    # shortcut for accessing NimbleNodes.settings[:dynos_pool][key]
+    def self.[](key)
+      NimbleNodes::Dynos.settings[key]
+    end
+    
+    def self.settings
+      hash = NimbleNodes::Settings['dynos_pool']
+      hash.nil? ? {} : hash
+    end
+    
     def self.size
-      ENV['NN_DYNOS_POOL_SIZE']
+      NimbleNodes::Dynos['size']
+    end
+    
+    def self.min
+      NimbleNodes::Dynos['min']
     end
     
     def self.max
-      ENV['NN_DYNOS_POOL_MAX']
+      NimbleNodes::Dynos['max']
+    end
+    
+    def self.request_queue
+      hash = NimbleNodes::Dynos.settings['request_queue']
+      hash.nil? ? {} : hash
+    end
+    
+    def self.min_request_queue
+      NimbleNodes::Dynos.request_queue['min']
     end
     
     def self.max_request_queue
-      ENV['NN_DYNOS_REQUEST_QUEUE_MAX']
+      NimbleNodes::Dynos.request_queue['max']
+    end
+    
+    #= Status Inspector
+    
+    def self.paused?
+      not NimbleNodes::Dynos['paused_at'].nil? 
+    end
+    
+    #= Monitoring
+    
+    def self.monitor?
+      NimbleNodes.active? and !NimbleNodes::Dynos.paused?
+    end
+    
+    
+    # pass over the hash containing Rack env variables
+    # a Report will be created and posted if neccessary 
+    def self.monitor(env)
+      begin
+        report = NimbleNodes::Report.new(env)
+        report.post if report.post?
+      rescue
+        # rescues any possible errors to ensure app performace isn't affected
+      end
     end
     
   end

data/lib/nimble_nodes/middleware.rb

@@ -6,7 +6,7 @@ module NimbleNodes
 
 
     def call(env)
-      NimbleNodes.monitor(env)
+      NimbleNodes::Dynos.monitor(env) if NimbleNodes::Dynos.monitor?
       # now, execute the request using our Rails app
       response = @app.call(env)
     end

data/lib/nimble_nodes/rails/filter.rb

@@ -0,0 +1,17 @@
+module NimbleNodes
+  module Rails
+    module Filter
+
+      # Use as a before_filter
+      def monitor_heroku_app
+        NimbleNodes::Dynos.monitor(request.env) if NimbleNodes::Dynos.monitor?
+      end
+
+
+    end
+  end
+  
+  
+end
+
+ActionController::Base.send(:include, NimbleNodes::Rails::Filter)

data/lib/nimble_nodes/report.rb

@@ -2,11 +2,6 @@ module NimbleNodes
       
   class Report
     
-    
-    def self.path
-      "/#{ENV['NN_APP_NAME']}/dynos/reports.json"
-    end
-    
     def initialize(env)
       @dynos_in_use = env['HTTP_X_HEROKU_DYNOS_IN_USE'].to_i
       @request_queue_depth = env['HTTP_X_HEROKU_QUEUE_DEPTH'].to_i
@@ -16,29 +11,36 @@ module NimbleNodes
       params = {
         :dynos_in_use => @dynos_in_use,
         :request_queue_size => @request_queue_depth }
-      NimbleNodes::Server.post(self.class.path, params)
+      NimbleNodes::Server.post('/dynos/reports.json', params)
     end
     
+    # returns true if report needs to be posted to server
     def post?
-      return false unless NimbleNodes.installed?
       return true
-      return false if NimbleNodes.paused?
-      dynos_maxed_out? or queue_depth_too_long? or unused_dynos?
+      dynos_maxed_out? or queue_depth_too_long? or queue_depth_too_short? or idle_dynos?
     end
     
+    # returns true if app is using all available dynos
     def dynos_maxed_out?
       return false if @dynos_in_use.nil?
-      @dynos_in_use >= Dynos.max
+      @dynos_in_use >= NimbleNodes::Dynos.max
     end
-  
+    
+    # returns true if queue depth is over max
     def queue_depth_too_long?
       return false if @request_queue_depth.nil?
-      @request_queue_depth > Dynos.max_request_queue
+      @request_queue_depth > NimbleNodes::Dynos.max_request_queue
+    end
+    
+    def queue_depth_too_short?
+      return false if @request_queue_depth.nil?
+      @request_queue_depth < NimbleNodes::Dynos.min_request_queue
     end
     
-    def unused_dynos?
+    # returns true if app isn't using all of it's dynos
+    def idle_dynos?
       return false if @dynos_in_use.nil?
-      @dynos_in_use < Dynos.size
+      @dynos_in_use < NimbleNodes::Dynos.size
     end
 
   end

data/lib/nimble_nodes/server.rb

@@ -4,18 +4,63 @@ module NimbleNodes
   
   class Server
     
-    def self.post(path,args)    
-      url = URI.parse(url_to(path))
-      request = Net::HTTP::Post.new(url.path)
-      request.set_form_data({:token => ENV['NN_APP_TOKEN'], :json => args.to_json, :created_at => Time.now })
-      response = Net::HTTP.start(url.host, url.port) {|http| http.request(request)}
+    #= HTTP Requests 
+    # GETs and POSTs both add App.token to request automatically
+    
+    def self.get(path)   
+      begin
+        path = NimbleNodes::App.path(path)
+        uri = uri_with_token(path)     
+        path = uri.route_from(NimbleNodes::Server.url[0..-2]).to_s
+        request = Net::HTTP::Get.new(path)
+        return Net::HTTP.start(uri.host, uri.port) {|http| http.request(request)}.body
+      rescue
+        return nil
+      end
+    end    
+
+
+    def self.post(path,params)    
+      begin
+        path = NimbleNodes::App.path(path)
+        uri = uri(path)
+        request = Net::HTTP::Post.new(uri.path)
+        request.set_form_data({:token => NimbleNodes::App.token, :json => params.to_json, :created_at => Time.now })
+        return Net::HTTP.start(uri.host, uri.port) {|http| http.request(request)}
+      rescue
+        return nil
+      end
+    end
+    
+  
+    #= Domain & URLs
+    
+    # set ENV variable in development to override production domain
+    def self.domain
+      ENV['NIMBLE_NODES_DOMAIN'].nil? ? 'nimblenodes.com' : ENV['NIMBLE_NODES_DOMAIN']
     end
     
-    def self.url_to(path)
-      'http://' + ENV['NN_SERVER_DOMAIN'] + path
-      # 'http://nimblenodes.com' + path
+    # returns string for url to given path at server
+    def self.url(path='/')
+      'http://' + domain + path
     end
     
+    # returns parsed URI for given path at server
+    def self.uri(path)
+      URI.parse(url(path))
+    end
+    
+    # returns parsed URI with App.token in query
+    def self.uri_with_token(path)
+      uri = uri(path)
+      query = (uri.query || '').split('&')
+      query.push("token=#{NimbleNodes::App.token}")
+      uri.query = query.join('&')
+      uri
+    end
+    
+    
+    
   end
   
 end

data/lib/nimble_nodes/settings.rb

@@ -0,0 +1,51 @@
+module NimbleNodes
+  
+  class Settings
+    
+    #= Setting accessor
+    #= allows NimbleNodes::Settings to be treated as a hash
+    # shortcut for accessing NimbleNodes.settings cache
+    def self.[](key)
+      cache[key]
+    end
+    
+    private
+    
+    #= Cache
+    # settings are fetched once from server and cached in global constant
+    
+    # returns hash of settings from cache or fetched from nimblenodes.com
+    def self.cache
+      return CACHE if cache? and fresh_cache?
+      const_set('CACHE',NimbleNodes::Settings.fetch_from_server) 
+    end    
+    
+    #== Fetch from server
+    
+    # returns hash from parsed server response
+    def self.fetch_from_server
+      response = NimbleNodes::Server.get("/settings.json")
+      return {} if response.nil?
+      JSON[response].merge('fetched_at' => Time.now)
+    end
+    
+    #== Cache Inspectors
+    
+    # returns true if local settings have been set
+    def self.cache?
+      defined?(NimbleNodes::Settings::CACHE) and !NimbleNodes::Settings::CACHE.nil? and !NimbleNodes::Settings::CACHE.empty?
+    end 
+    
+    def self.fresh_cache?
+      fetched_at = CACHE['fetched_at']
+      return false if fetched_at.nil?
+      age = Time.now.to_i - fetched_at.to_i
+      five_minutes = 300
+      age > five_minutes
+    end
+    
+    
+    
+  end
+  
+end

data/lib/nimble_nodes/workers.rb

@@ -0,0 +1,35 @@
+module NimbleNodes
+  
+  module Workers
+    
+    def self.active?
+      ENV.has_key?('NN_WORKERS_POOL_ACTIVE')
+    end
+    
+    def self.size
+      ENV['NN_WORKERS_POOL_SIZE']
+    end
+    
+    def self.min
+      ENV['NN_WORKERS_POOL_MIN']
+    end
+    
+    def self.max
+      ENV['NN_WORKERS_POOL_MAX']
+    end
+    
+    def self.min
+      ENV['NN_WORKERS_POOL_MIN']
+    end
+    
+    def self.min_job_queue
+      ENV['NN_WORKERS_JOB_QUEUE_MIN']
+    end
+    
+    def self.max_job_queue
+      ENV['NN_WORKERS_JOB_QUEUE_MAX']
+    end
+    
+  end
+  
+end

data/lib/nimble_nodes.rb

@@ -1,36 +1,34 @@
+require 'json'
+
 module NimbleNodes
   
-  # returns array of files
-  def self.files
-    files = %w(dynos report server)
-    files.push NimbleNodes.legacy? ? 'filter' : 'middleware'
-    files
-  end
-  
+  #= Check Rails version  
   # returns true if gem is loaded in a pre 2.3 version of rails
   def self.legacy?
     defined?(RAILS_GEM_VERSION) and RAILS_GEM_VERSION.slice(0..2).to_f < 2.3
-  end
+  end  
   
-  #= Monitoring
-  # pass over the hash containing Rack env variables
-  # a Report will be created and posted if neccessary 
-  def self.monitor(env)
-    report = NimbleNodes::Report.new(env)
-    report.post if report.post?
+  #= App status inspectors  
+  def self.active?
+    NimbleNodes::App.token? and !NimbleNodes.paused?
   end
   
-  def self.installed?
-    not ENV['NN_SERVER_DOMAIN'].nil?
+  def self.paused?
+    not NimbleNodes::Settings[:paused_at].nil?
   end
   
-  def self.paused?
-    not ENV['NN_APP_PAUSED_AT'].nil?
+  
+  
+  def self.lib_path(path='')
+    File.dirname(__FILE__) + '/nimble_nodes' + path
   end
   
 end
 
-NimbleNodes.files.each { |file| require File.dirname(__FILE__) + "/nimble_nodes/#{file}" }
+files = %w(app settings dynos workers report server)
+files.each { |file| require NimbleNodes.lib_path('/' + file) }
+
+require NimbleNodes::App.reporter
 
 
 

data/nimble_nodes.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{nimble_nodes}
-  s.version = "0.1.9"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jordan Glasner"]
-  s.date = %q{2010-03-23}
-  s.description = %q{automatically scales dynos and workers at Heroku}
+  s.date = %q{2010-04-04}
+  s.description = %q{coming soon}
   s.email = %q{jordan@digitalignition.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -24,23 +24,32 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/nimble_nodes.rb",
+     "lib/nimble_nodes/app.rb",
      "lib/nimble_nodes/dynos.rb",
-     "lib/nimble_nodes/filter.rb",
      "lib/nimble_nodes/middleware.rb",
+     "lib/nimble_nodes/rails/filter.rb",
      "lib/nimble_nodes/report.rb",
      "lib/nimble_nodes/server.rb",
+     "lib/nimble_nodes/settings.rb",
+     "lib/nimble_nodes/workers.rb",
      "nimble_nodes.gemspec",
      "test/helper.rb",
-     "test/test_nimble_nodes.rb"
+     "test/unit/test_app.rb",
+     "test/unit/test_dynos.rb",
+     "test/unit/test_nimble_nodes.rb",
+     "test/unit/test_settings.rb"
   ]
   s.homepage = %q{http://github.com/glasner/nimble_nodes}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
-  s.summary = %q{gem for connecting apps to the NimbleNodes server}
+  s.summary = %q{coming soon}
   s.test_files = [
     "test/helper.rb",
-     "test/test_nimble_nodes.rb"
+     "test/unit/test_app.rb",
+     "test/unit/test_dynos.rb",
+     "test/unit/test_nimble_nodes.rb",
+     "test/unit/test_settings.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -49,11 +58,20 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
     else
       s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<fakeweb>, [">= 0"])
+      s.add_dependency(%q<json>, [">= 0"])
     end
   else
     s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+    s.add_dependency(%q<json>, [">= 0"])
   end
 end
 

data/test/helper.rb

@@ -1,10 +1,11 @@
 require 'rubygems'
 require 'test/unit'
+
 require 'shoulda'
+require 'mocha'
+require 'fakeweb'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'nimble_nodes'
+require File.expand_path(File.dirname(__FILE__)) + '/../lib/nimble_nodes'
 
 class Test::Unit::TestCase
 end

data/test/unit/test_app.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../helper'
+
+class TestApp < Test::Unit::TestCase
+  
+  context "An App" do
+    
+    setup { @module = NimbleNodes::App }
+    
+    context "on Rails" do
+      
+      setup { @module.stubs(:rails?).returns(true) }
+      
+      context "2.3 or later" do
+        setup { @module.stubs(:rails_version).returns(2.3) }
+        
+        should "not use rails before_filter" do
+          assert(!@module.use_rails_filter?)
+        end
+        
+        should "return NimbleNodes::Middleware as reporter" do
+          assert_equal 'middleware', @module.reporter.split('/').last
+        end
+        
+      end
+      
+      context "prior to 2.3" do
+        setup { NimbleNodes::App.stubs(:rails_version).returns(2.2) }
+        
+        should "use rails before_filter" do
+          assert(@module.use_rails_filter?)
+        end
+        
+        should "return NimbleNodes::Filter as reporter" do
+          assert_equal 'filter', @module.reporter.split('/').last
+        end
+        
+      end
+      
+      
+    end
+    
+    context "off Rails" do
+      
+      should "return false for rails?" do
+        # we're not in Rails so this works
+        assert_equal false, @module.rails?
+      end
+      
+      should "return NimbleNodes::Middleware as reporter" do
+        assert_equal 'middleware', @module.reporter.split('/').last
+      end
+      
+    end
+  
+  
+    context "installed at NimbleNodes" do
+    
+      setup { 
+        ENV['NIMBLE_NODES_APP_NAME']  = 'nimble-nodes-test'
+        ENV['NIMBLE_NODES_APP_TOKEN'] = 'test'
+      }
+      
+      should "return name from ENV" do
+        assert_equal ENV['NIMBLE_NODES_APP_NAME'], @module.name
+      end
+      
+      should "return token from ENV" do
+        assert_equal ENV['NIMBLE_NODES_APP_TOKEN'], @module.token
+      end
+      
+      should "return true for token?" do
+        assert @module.token?
+      end
+      
+      should "return relative path at NN server" do
+        assert_equal '/nimble-nodes-test/', @module.path
+      end
+      
+      should "return relative path to app resource for given path" do
+        assert_equal '/nimble-nodes-test/dynos', @module.path('/dynos')
+      end
+      
+
+    end
+    
+    context "not installed at NimbleNodes" do
+      
+      setup { 
+        ENV['NIMBLE_NODES_APP_NAME']  = nil
+        ENV['NIMBLE_NODES_APP_TOKEN'] = nil
+      }
+      
+      should "return false for token?" do
+        assert_equal false, @module.token?
+      end
+      
+    end
+    
+    
+  end
+  
+end

data/test/unit/test_dynos.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../helper'
+
+class Test::Unit::TestCase
+  
+  def self.should_not_raise_anything_when_monitored
+    should "not raise any exceptions when sent :monitored?" do
+      assert_nothing_raised { @module.monitor? }
+      NimbleNodes::Server.stubs(:post).returns(nil)
+      assert_nothing_raised { @module.monitor({}) }
+    end
+  end
+  
+  def self.should_not_be_monitored
+    should "not be monitored" do
+      assert_equal false, @module.monitor?
+    end
+  end
+  
+  
+end
+
+
+class TestDynos < Test::Unit::TestCase
+  
+  context "Dynos" do
+      
+    setup { 
+      @module = NimbleNodes::Dynos 
+    }
+    
+    context "App setup at NimbleNodes" do
+      
+      setup { 
+        NimbleNodes::App.stubs({
+          :name => 'nimble-nodes-test',
+          :token => 'token'
+        })
+         @module.stubs(:settings).returns({
+            'paused_at' => nil,
+            'min' => 1,
+            'max' => 2
+          })
+      }
+  
+      context "and App not paused" do
+        setup { NimbleNodes.stubs(:paused?).returns(false)  }
+        
+        should "be monitored" do
+          assert @module.monitor?
+        end
+        
+        should_not_raise_anything_when_monitored
+        
+        context "and Dynos paused" do
+          setup {
+            @module.stubs(:settings).returns({
+              'paused_at' => Time.now,
+              'min' => 1,
+              'max' => 2
+            })
+          }
+          
+          should "be paused" do
+            assert @module.paused?
+          end
+          
+          should_not_be_monitored
+          should_not_raise_anything_when_monitored
+          
+        end
+        
+        
+      end
+      
+       context "and App paused" do
+        setup { NimbleNodes.stubs(:paused?).returns(true)  }
+        should_not_be_monitored
+        should_not_raise_anything_when_monitored
+
+      end
+      
+  
+    end
+     
+    context "App *not* setup at NimbleNodes.com" do
+ 
+      should_not_be_monitored
+
+      should_not_raise_anything_when_monitored
+
+ 
+    end
+    
+    
+  end
+  
+end

data/test/unit/test_nimble_nodes.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../helper'
+
+class TestNimbleNodes < Test::Unit::TestCase
+  
+  
+  context "NimbleNodes module" do
+    setup { @module = NimbleNodes }
+    
+    context "in a Rails app" do
+      
+      setup { NimbleNodes::App.stubs(:rails?).returns(true) }
+
+      context "pre 2.3" do
+        setup { NimbleNodes::App.stubs(:rails_version).returns(2.2) }
+
+        should "use NimbleNodes::Filter as reporter" do
+          assert_equal 'filter', @module.reporter.split('/').last
+        end
+
+      end 
+      
+      context "2.3 or later" do
+        setup { NimbleNodes::App.stubs(:rails_version).returns(2.3) }
+
+        should "use NimbleNodes::Middleware as reporter" do
+          assert_equal 'middleware', @module.reporter.split('/').last
+        end
+
+      end   
+
+    end
+    
+    context "in a non-Rails app" do
+      setup { NimbleNodes::App.stubs(:rails?).returns(false) }
+      
+      should "use NimbleNodes::Middleware" do
+        assert_equal 'middleware8', @module.reporter.split('/').last
+      end
+      
+    end
+
+    context "App installed at NimbleNodes" do
+
+      setup { 
+        NimbleNodes::App.stubs({
+          :name => 'nimble-nodes-test',
+          :token => 'token'
+        })
+      } 
+
+      context "not paused" do
+
+        setup {
+          @module.stubs(:paused?).returns(false)
+        }
+
+        should "be active" do
+          assert @module.active?
+        end
+      end
+
+      context "paused" do
+
+        setup {
+          @module.stubs(:paused?).returns(true)
+        }
+
+        should "be not active" do
+          assert(!@module.active?)
+        end
+      end
+
+    end
+    
+    
+  end
+  
+
+  
+end

data/test/unit/test_settings.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__)) + '/../helper'
+
+class Test::Unit::TestCase
+  
+  def self.should_not_raise_any_errors_when_fetching_from_server
+    should "not raise any errors when fetching from server" do
+      assert_nothing_raised { @module.fetch_from_server }
+    end
+  end
+  
+  def self.should_not_raise_any_errors_on_unknown_keys
+    should "not raise errors on any unknown keys" do
+      assert_nothing_raised { @module.cache['bogus-key'] }
+    end
+  end
+  
+  
+end
+
+class TestSettings < Test::Unit::TestCase
+  
+  context "Settings" do
+    
+    setup { 
+      @module = NimbleNodes::Settings 
+      @module.send(:remove_const,'CACHE') if defined?(@module::CACHE)
+    }
+    
+    context "App is installed at NimbleNodes.com" do
+      setup do
+        NimbleNodes::App.stubs({
+          :name => "nimble-nodes-test", 
+          :token => 'test'
+        })
+      end
+      
+      context "server responds with JSON" do
+        
+        setup {
+          @json = '{"paused_at":null,"dynos_pool":{"size":1,"paused_at":null,"max":1,"request_queue":{"max":5,"min":0},"min":1}}'
+          @parsed = JSON[@json]
+          NimbleNodes::Server.expects(:get).returns(@json)
+        }        
+        
+        should "only fetch from server once" do
+          @module.expects(:fetch_from_server).once
+          @module['paused_at']
+          @module['dynos_pool']
+        end
+        
+        should "save parsed parsed response in cache" do
+          cached = @module.cache
+          cached.delete('fetched_at')
+          assert_equal @parsed, cached
+        end
+        
+        should "add fetched_at to server response" do
+          assert_not_nil @module['fetched_at']
+        end        
+        
+        should_not_raise_any_errors_on_unknown_keys
+        
+        should_not_raise_any_errors_when_fetching_from_server        
+        
+      end
+      
+      context "server responds with error" do
+        setup { NimbleNodes::Server.expects(:get).once.returns(nil) }
+        should_not_raise_any_errors_on_unknown_keys
+        should_not_raise_any_errors_when_fetching_from_server
+      end
+      
+    end
+    
+    context "App is *not* installed at NimbleNodes.com" do
+      
+      setup {
+        NimbleNodes::App.stubs({
+          :name => nil, 
+          :token => nil
+        })
+        NimbleNodes::Server.expects(:get).returns(nil)
+      }
+      
+      should_not_raise_any_errors_on_unknown_keys
+      should_not_raise_any_errors_when_fetching_from_server
+      
+    end
+    
+    
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nimble_nodes
 version: !ruby/object:Gem::Version 
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jordan Glasner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -04:00
+date: 2010-04-04 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,7 +22,37 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-description: automatically scales dynos and workers at Heroku
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: coming soon
 email: jordan@digitalignition.com
 executables: []
 
@@ -39,14 +69,20 @@ files:
 - Rakefile
 - VERSION
 - lib/nimble_nodes.rb
+- lib/nimble_nodes/app.rb
 - lib/nimble_nodes/dynos.rb
-- lib/nimble_nodes/filter.rb
 - lib/nimble_nodes/middleware.rb
+- lib/nimble_nodes/rails/filter.rb
 - lib/nimble_nodes/report.rb
 - lib/nimble_nodes/server.rb
+- lib/nimble_nodes/settings.rb
+- lib/nimble_nodes/workers.rb
 - nimble_nodes.gemspec
 - test/helper.rb
-- test/test_nimble_nodes.rb
+- test/unit/test_app.rb
+- test/unit/test_dynos.rb
+- test/unit/test_nimble_nodes.rb
+- test/unit/test_settings.rb
 has_rdoc: true
 homepage: http://github.com/glasner/nimble_nodes
 licenses: []
@@ -74,7 +110,10 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: gem for connecting apps to the NimbleNodes server
+summary: coming soon
 test_files: 
 - test/helper.rb
-- test/test_nimble_nodes.rb
+- test/unit/test_app.rb
+- test/unit/test_dynos.rb
+- test/unit/test_nimble_nodes.rb
+- test/unit/test_settings.rb

data/lib/nimble_nodes/filter.rb

@@ -1,15 +0,0 @@
-module NimbleNodes
-  
-  module Filter
-    
-    # Use as a before_filter
-    def monitor_heroku_app
-      NimbleNodes.monitor(request.env)
-    end
-    
-    
-  end
-  
-end
-
-ActionController::Base.send(:include, NimbleNodes::Filter)

data/test/test_nimble_nodes.rb

@@ -1,7 +0,0 @@
-require 'helper'
-
-class TestNimbleNodes < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
-end