daikon 0.7.4 → 0.7.5

data/daikon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{daikon}
-  s.version = "0.7.4"
+  s.version = "0.7.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nick Quaranto"]
-  s.date = %q{2011-02-11}
+  s.date = %q{2011-02-17}
   s.default_executable = %q{daikon}
   s.description = %q{daikon, a radishapp.com client}
   s.email = %q{nick@quaran.to}
@@ -32,7 +32,6 @@ Gem::Specification.new do |s|
     "lib/daikon/configuration.rb",
     "lib/daikon/daemon.rb",
     "lib/daikon/monitor.rb",
-    "lib/daikon/namespace_tools.rb",
     "lib/daikon/redis_hacks.rb",
     "spec/client_spec.rb",
     "spec/configuration_spec.rb",

data/lib/daikon.rb

@@ -18,7 +18,6 @@ $LOAD_PATH.unshift __DIR__ unless
   $LOAD_PATH.include?(__DIR__) ||
   $LOAD_PATH.include?(File.expand_path(__DIR__))
 
-require 'daikon/namespace_tools'
 require 'daikon/configuration'
 require 'daikon/client'
 require 'daikon/daemon'
@@ -26,5 +25,5 @@ require 'daikon/monitor'
 require 'daikon/redis_hacks'
 
 module Daikon
-  VERSION = "0.7.4"
+  VERSION = "0.7.5"
 end

data/lib/daikon/client.rb

@@ -1,7 +1,5 @@
 module Daikon
   class Client
-    include NamespaceTools
-
     EXCEPTIONS = [Timeout::Error,
                   Errno::EINVAL,
                   Errno::ECONNRESET,
@@ -58,21 +56,6 @@ module Daikon
                                 "Content-Type"   => "application/json"})
     end
 
-    def fetch_commands
-      raw_commands = request(:get, "/api/v1/commands.json")
-      commands = JSON.parse(raw_commands.body)
-
-      commands.each do |id, command|
-        result = evaluate_redis(command)
-        pretty = StringIO.new
-        PP.pp(result, pretty)
-
-        push :put, "/api/v1/commands/#{id}.json", {"response" => pretty.string.strip}
-      end
-    rescue *EXCEPTIONS => ex
-      exception(ex)
-    end
-
     def rotate_monitor(start, stop)
       payload = monitor.rotate.merge({
         "start" => start,
@@ -89,41 +72,5 @@ module Daikon
     rescue *EXCEPTIONS => ex
       exception(ex)
     end
-
-    def evaluate_redis(command)
-      # Attempt to parse the given command string.
-      argv =
-        begin
-          Shellwords.shellwords(command.to_s)
-        rescue Exception => e
-          exception(e)
-          return e.message
-        end
-      return "No command received." unless argv[0]
-
-      begin
-        execute_redis(argv)
-      rescue Exception => e
-        exception(e)
-        e.message
-      end
-    end
-
-    def namespace
-      nil
-    end
-
-    def execute_redis(argv)
-      # Apply the current namespace to any fields that need it.
-      argv = namespace_input(namespace, *argv)
-
-      raise "Not a Redis command." unless argv.kind_of? Array
-
-      # Send the command to Redis.
-      result = redis.send(*argv)
-
-      # Remove the namespace from any commands that return a key.
-      denamespace_output namespace, argv.first, result
-    end
   end
 end

data/lib/daikon/monitor.rb

@@ -59,6 +59,9 @@ module Daikon
     def push(raw_command)
       command, key, *rest = raw_command.strip.gsub('"', '').split
       command.upcase!
+
+      return unless ALL_COMMANDS.member?(command)
+
       lock do
         incr_command(command)
         incr_total(command)
@@ -85,7 +88,7 @@ module Daikon
     end
 
     def incr_command(command)
-      data["commands"][command] += 1 if ALL_COMMANDS.member?(command)
+      data["commands"][command] += 1
     end
 
     def incr_key(key)

data/spec/client_spec.rb

@@ -37,72 +37,6 @@ describe Daikon::Client, "setup" do
   end
 end
 
-shared_examples_for "a command api consumer" do
-  it "sends a request for commands" do
-    http.should have_received(:request).with(
-      :method  => "GET",
-      :path    => "/api/v1/commands.json",
-      :headers => {"Authorization" => api_key})
-  end
-
-  it "processes each command" do
-    subject.should have_received(:evaluate_redis).with("INCR foo")
-    subject.should have_received(:evaluate_redis).with("DECR foo")
-  end
-
-  it "shoots the results back to radish" do
-    results = {"response" => "9999"}.to_json
-
-    headers = {
-      "Authorization"  => api_key,
-      "Content-Length" => results.size.to_s,
-      "Content-Type"   => "application/json"
-    }
-
-    http.should have_received(:request).with(
-      :method  => "PUT",
-      :path    => "/api/v1/commands/42.json",
-      :body    => results,
-      :headers => headers)
-
-    http.should have_received(:request).with(
-      :method  => "PUT",
-      :path    => "/api/v1/commands/43.json",
-      :body    => results,
-      :headers => headers)
-  end
-end
-
-describe Daikon::Client, "fetching commands" do
-  subject       { Daikon::Client.new }
-  let(:body)    { {"42" => "INCR foo", "43" => "DECR foo"}.to_json }
-  let(:http)    { stub("http", :request => Excon::Response.new(:body => body)) }
-
-  before do
-    subject.stubs(:evaluate_redis => 9999)
-    subject.stubs(:http => http)
-
-    subject.setup(config)
-    subject.fetch_commands
-  end
-
-  context "with default configuration" do
-    let(:api_key) { config.api_key }
-    let(:server)  { "https://radish.heroku.com" }
-    let(:config)  { Daikon::Configuration.new([]) }
-
-    it_should_behave_like "a command api consumer"
-  end
-
-  context "with custom settings" do
-    let(:api_key) { "0987654321" }
-    let(:server)  { "http://localhost:9999" }
-    let(:config)  { Daikon::Configuration.new(["-k", api_key, "-s", "http://localhost:9999"]) }
-
-    it_should_behave_like "a command api consumer"
-  end
-end
-
 describe Daikon::Client, "when server is down" do
   subject       { Daikon::Client.new }
   before do
@@ -114,7 +48,7 @@ describe Daikon::Client, "when server is down" do
 
   it "does not commit suicide" do
     lambda {
-      subject.fetch_commands
+      subject.report_info
     }.should_not raise_error
   end
 end
@@ -129,7 +63,7 @@ describe Daikon::Client, "when it returns bad json" do
 
   it "does not commit suicide" do
     lambda {
-      subject.fetch_commands
+      subject.report_info
     }.should_not raise_error
   end
 end
@@ -194,27 +128,6 @@ describe Daikon::Client, "rotate monitor" do
   end
 end
 
-describe Daikon::Client, "pretty printing results" do
-  subject      { Daikon::Client.new }
-  let(:body)   { {"13" => "LRANGE foo 0 -1"}.to_json }
-  let(:list)   { %w[apples bananas carrots] }
-  let(:server) { "https://radish.heroku.com" }
-  let(:config) { Daikon::Configuration.new }
-  let(:http)   { stub("http", :request => Excon::Response.new(:body => body)) }
-
-  before do
-    subject.stubs(:evaluate_redis => list, :http => http)
-    subject.setup(config)
-    subject.fetch_commands
-  end
-
-  it "returns pretty printed results" do
-    http.should have_received(:request).with(has_entry(
-      :body => {"response" => "[\"apples\", \"bananas\", \"carrots\"]"}.to_json
-    ))
-  end
-end
-
 shared_examples_for "a info api consumer" do
   it "shoots the results back to radish" do
     headers = {

data/spec/monitor_spec.rb

@@ -160,3 +160,17 @@ describe Daikon::Monitor, "#rotate that collects namespaces" do
     data["namespaces"]["s3"].should == 1
   end
 end
+
+describe Daikon::Monitor, "#rotate with values that have spaces" do
+  before do
+    subject.parse("set g:2470920:mrn 11")
+    subject.parse("Email Error")
+  end
+
+  it "keeps track of namespace accesses" do
+    data = subject.rotate
+    data["commands"].should   == {"SET" => 1}
+    data["keys"].should       == {"g:2470920:mrn" => 1}
+    data["namespaces"].should == {"g" => 1}
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 7
-  - 4
-  version: 0.7.4
+  - 5
+  version: 0.7.5
 platform: ruby
 authors: 
 - Nick Quaranto
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-11 00:00:00 -05:00
+date: 2011-02-17 00:00:00 -05:00
 default_executable: daikon
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -165,7 +165,6 @@ files:
 - lib/daikon/configuration.rb
 - lib/daikon/daemon.rb
 - lib/daikon/monitor.rb
-- lib/daikon/namespace_tools.rb
 - lib/daikon/redis_hacks.rb
 - spec/client_spec.rb
 - spec/configuration_spec.rb

data/lib/daikon/namespace_tools.rb

@@ -1,122 +0,0 @@
-module Daikon
-  module NamespaceTools
-    def namespace_input(ns, command, *args)
-      command = command.to_s.downcase
-
-      case command
-
-      when "multi", "exec", "discard"
-
-        # No arguments.
-
-        [ command ]
-
-      when "exists", "del", "type", "keys", "ttl", "set", "get", "getset",
-           "setnx", "incr", "incrby", "decr", "decrby", "rpush", "lpush",
-           "llen", "lrange", "ltrim", "lindex", "lset", "lrem", "lpop", "rpop",
-           "sadd", "srem", "spop", "scard", "sismember", "smembers", "srandmember",
-           "zadd", "zrem", "zincrby", "zrange", "zrevrange", "zrangebyscore",
-           "zcard", "zscore", "zremrangebyscore", "expire", "expireat", "hlen",
-           "hkeys", "hvals", "hgetall", "hset", "hget", "hincrby", "hexists",
-           "hdel", "hmset"
-
-        # Only the first argument is a key.
-
-        head = add_namespace(ns, args.first)
-        tail = args[1, args.length - 1] || []
-
-        [ command, head, *tail ]
-
-      when "smove"
-
-        # The first two parmeters are keys.
-
-        result = [ command ]
-
-        args.each_with_index do |arg, i|
-          result << ((i == 0 || i == 1) ? add_namespace(ns, arg) : arg)
-        end
-
-        result
-
-      when "mget", "rpoplpush", "sinter", "sunion", "sdiff", "info",
-           "sinterstore", "sunionstore", "sdiffstore", "dbsize"
-
-        # All arguments are keys.
-
-        keys = add_namespace(ns, args)
-
-        [ command, *keys ]
-
-      when "mset", "msetnx"
-
-        # Every other argument is a key, starting with the first.
-
-        hash1 = Hash[*args]
-        hash2 = {}
-
-        hash1.each do |k, v|
-          hash2[add_namespace(ns, k)] = hash1.delete(k)
-        end
-
-        [ command, hash2 ]
-
-      when "sort"
-
-        return [] if args.count == 0
-
-        key = add_namespace(ns, args.shift)
-        parms = {}
-
-        while keyword = args.shift.andand.downcase
-          case keyword
-          when "by", "get", "store"
-            k = keyword.intern
-            v = add_namespace(ns, args.shift)
-
-            parms[k] = v
-          when "limit"
-            parms[:limit] = [ args.shift.to_i, args.shift.to_i ]
-          when "asc", "desc", "alpha"
-            parms[:order].andand << " "
-            parms[:order] ||= ""
-            parms[:order] << keyword
-          end
-        end
-
-        [ command, key, parms ]
-
-      end
-    end
-
-    def denamespace_output(namespace, command, result)
-      case command.to_s.downcase
-
-      when "keys"
-        remove_namespace namespace, result
-
-      else
-        result
-
-      end
-    end
-
-    def add_namespace(namespace, key)
-      return key unless namespace
-
-      case key
-      when String then "#{namespace}:#{key}"
-      when Array  then key.map {|k| add_namespace(namespace, k)}
-      end
-    end
-
-    def remove_namespace(namespace, key)
-      return key unless namespace
-
-      case key
-      when String then key.gsub(/^#{namespace}:/, "")
-      when Array  then key.map {|k| remove_namespace(namespace, k)}
-      end
-    end
-  end
-end