memcache_check 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93a54941a1ac5c17564d14f5ab974f3d1ace1148
-  data.tar.gz: faf2d53e47d3f989b43960978f7682b449f423a8
+  metadata.gz: e8c9f252507107f19b6767e5e377372087a3d0e9
+  data.tar.gz: ea8b9a78e5dbe898b2ff9b8ec0f2c06e4f1282e8
 SHA512:
-  metadata.gz: 3f9f221d9aba6cc31ab5c560abf0e48e369e7cc8e18471f8bec4f953d6a2a60b7e7e7bb179678317fcfc5671ef58063ead40d7f29d623c07c1bb24ccd8fc48c6
-  data.tar.gz: 506bdb02a49042a93ff2c2316fdd9aa242a9c5b815ffeb5e688e229e2a073392d451a3f9b724393082f0efc6b72d4e025c5714b716f24c12dc140b566c9db7cc
+  metadata.gz: b4bc79da94b12c7751d3fbb1e80beccee64df3aa47aeff0ce62ad05a15ac1d4ee8c563bf5439881c43220be112d7941dac57f2fb041a81c09d1532bbe9eebb06
+  data.tar.gz: 38291151d049fb7d0de9215a3537419fe2f524dd31779d1c377f50cb1f8402cdc45d9fc9ec916ee635a5a9bb96cee5a269a3d7862d89b1c50a2d7c8a5f885fe1

data/README.md

@@ -24,6 +24,11 @@ Or install it yourself as:
 
 ## Usage
 
+There are now 2 primary methods to use the gem. The original single server
+benchmark and the new group benchmark.
+
+### Single
+
 Create an instance of MemcacheCheck::Checker and pass in an argument of
 the server's IP address as a string. If you don't pass an IP address in it
 will default to localhost.  You can optionally pass in a second argument of
@@ -41,6 +46,7 @@ The start method returns an array of 3 numbers:
 
 example.rb
 
+    ```ruby
     require 'memcache_check'
 
     memcache_check = MemcacheCheck::Checker.new('127.0.0.1')
@@ -49,13 +55,61 @@ example.rb
     puts "Number of passes: #{passes}"
     puts "Number of failures: #{fails}"
     puts "Total time: #{time} seconds"
+    ```
 
 Running on my local machine this produces:
 
     Number of passes: 500
     Number of failures: 0
-    Total time: 0.61212 seconds
+    Total time: 0.369204 seconds
+
+### Group
+
+Pass a list of hostnames and/or IP addresses to
+MemcacheCheck::Checker.group_benchmark. It runs 100 set and get checks
+against each hostname and returns an array of Server objects once the
+benchmark has completed.
+
+The Server attributes available are:
+    - hostname   (string)
+    - port       (string)
+    - passes     (fixnum)
+    - fails      (fixnum)
+    - time       (Benchmark::Tms)
+
+example.rb
+
+    ```ruby
+    require 'memcache_check'
+
+    memcache_check = MemcacheCheck::Checker.group_benchmark('127.0.0.1', 'localhost', '127.0.0.1')
 
+    memcache_check.each do |server|
+      puts "Server: #{server.hostname}"
+      puts "Number of passes: #{server.passes}"
+      puts "Number of failures: #{server.fails}"
+      puts "Total time: #{server.time.real.round(3)}"
+      puts
+    end
+    ```
+
+Running on my local machine this produces:
+
+    Server: 127.0.0.1
+    Number of passes: 100
+    Number of failures: 0
+    Total time: 0.074
+
+    Server: localhost
+    Number of passes: 100
+    Number of failures: 0
+    Total time: 0.066
+
+
+    Server: 127.0.0.1
+    Number of passes: 100
+    Number of failures: 0
+    Total time: 0.082
 
 
 ## Contributing

data/lib/memcache_check.rb

@@ -1,78 +1,3 @@
-require "memcache_check/version"
-require 'dalli'
-require 'faker'
-require 'benchmark'
-
-module MemcacheCheck
-    class Checker
-        attr_reader :passes, :fails
-
-        def initialize(server = 'localhost', port = '11211')
-            @server = Server.new(server, port)
-            @passes = 0
-            @fails = 0
-        end
-
-        def start(num_times = 50)
-            time = Benchmark.measure do
-                num_times.times do
-                    test_server
-                end
-            end
-            [@passes, @fails, time.real]
-        end
-
-        def test_server
-            key, value = create_key_value_pair
-            begin
-                @server.set(key, value)
-                if is_valid?(key, value)
-                    @passes += 1
-                else
-                    @fails += 1
-                end
-            rescue
-                @fails += 1
-            end
-        end
-
-        def create_key_value_pair
-            [Utils.generate_key, Utils.generate_test_data]
-        end
-
-        def is_valid?(key, value)
-            value == @server.get(key)
-        end
-    end
-
-    class Server
-        def initialize(host, port)
-            @memcache = Dalli::Client.new("#{host}:#{port}")
-        end
-
-        def set(key, value)
-            @memcache.set(key, value)
-        end
-
-        def get(key)
-            @memcache.get(key)
-        end
-    end
-
-    class Utils
-        def self.generate_key
-            "MemcacheCheck" + Time.now.strftime("%s%6N")
-        end
-
-        def self.generate_test_data
-            {
-                name: Faker::Name.name,
-                email: Faker::Internet.email,
-                phone: Faker::PhoneNumber.phone_number,
-                city: Faker::Address.city,
-                state: Faker::Address.state,
-                bio: Faker::Lorem.words(num = 100).join(", ")
-            }
-        end
-    end
-end
+require 'memcache_check/utils'
+require 'memcache_check/server'
+require 'memcache_check/checker'

data/lib/memcache_check/checker.rb

@@ -0,0 +1,22 @@
+module MemcacheCheck
+  class Checker
+    def initialize(hostname = 'localhost', port = '11211')
+      @server = Server.new(hostname, port)
+    end
+
+    def start(num_times = 50)
+      @server.benchmark(num_times)
+      [@server.passes, @server.fails, @server.time.real]
+    end
+
+    def self.group_benchmark(*args)
+      group = []
+      args.each do |hostname|
+        server = Server.new(hostname)
+        server.benchmark(100)
+        group << server
+      end
+      group
+    end
+  end
+end

data/lib/memcache_check/server.rb

@@ -0,0 +1,60 @@
+require 'dalli'
+require 'benchmark'
+
+module MemcacheCheck
+  class Server
+    attr_reader :hostname, :port, :passes, :fails, :time
+
+    def initialize(hostname = '127.0.0.1', port = '11211')
+      @memcache_client = Dalli::Client.new("#{hostname}:#{port}")
+      @hostname = hostname
+      @port = port
+      @passes = 0
+      @fails = 0
+    end
+
+    def benchmark(num_times)
+      test_run
+      @time = Benchmark.measure do
+        num_times.times do
+          run_test
+        end
+      end
+    end
+
+    def run_test
+      key, value = Utils.generate_key_value_pair
+      begin
+        set(key, value)
+        if is_valid?(key, value)
+          @passes += 1
+        else
+          @fails += 1
+        end
+      rescue
+        @fails += 1
+      end
+    end
+
+    def test_run
+      key, value = Utils.generate_key_value_pair
+      begin
+        set(key, value)
+        get(key)
+      rescue
+      end
+    end
+
+    def set(key, value)
+      @memcache_client.set(key, value)
+    end
+
+    def get(key)
+      @memcache_client.get(key)
+    end
+
+    def is_valid?(key, value)
+      value == get(key)
+    end
+  end
+end

data/lib/memcache_check/utils.rb

@@ -0,0 +1,26 @@
+require 'faker'
+
+module MemcacheCheck
+  module Utils
+    extend self
+
+    def generate_key_value_pair
+      [generate_key, generate_test_data]
+    end
+
+    def generate_key
+      "MemcacheCheck" + Time.now.strftime("%s%6N")
+    end
+
+    def generate_test_data
+      {
+        name: Faker::Name.name,
+        email: Faker::Internet.email,
+        phone: Faker::PhoneNumber.phone_number,
+        city: Faker::Address.city,
+        state: Faker::Address.state,
+        bio: Faker::Lorem.words(num = 100).join(", ")
+      }
+    end
+  end
+end

data/lib/memcache_check/version.rb

@@ -1,3 +1,3 @@
 module MemcacheCheck
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/memcache_check.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = MemcacheCheck::VERSION
   spec.authors       = ["Mike Admire"]
   spec.email         = ["mike@mikeadmire.com"]
-  spec.description   = %q{Run checks against a Memcached server}
+  spec.description   = %q{Ruby gem to test the speed of a Memcached server and verify that it's working correctly.}
   spec.summary       = %q{MemcacheCheck runs a series of set and get commands against a Memcache host to validate data integrity, verify that the host is responding correctly, and benchmark host speed.}
   spec.homepage      = "https://github.com/mikeadmire/memcache_check"
   spec.license       = "MIT"
@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "ZenTest", "~> 4.9.2"
+  spec.add_development_dependency "ZenTest", "~> 4.9.3"
 
   spec.add_runtime_dependency "dalli"
   spec.add_runtime_dependency "faker"

data/spec/lib/memcache_check_spec.rb

@@ -5,34 +5,81 @@ require 'memcache_check'
 describe MemcacheCheck do
 
   describe "Checker" do
-
     before(:each) do
       @checker = MemcacheCheck::Checker.new
     end
 
     it { MemcacheCheck::Checker.should respond_to(:new) }
 
-    context "start" do
-        it { @checker.should respond_to(:start).with(1).arguments }
+    describe "start" do
+      it { @checker.should respond_to(:start).with(1).arguments }
+
+      it "returns an array" do
+        expect(@checker.start).to be_an_instance_of(Array)
+      end
+
+      it "returns an array with 3 numeric elements" do
+        passes, fails, time = @checker.start
+        expect(passes).to be_an_instance_of(Fixnum)
+        expect(fails).to be_an_instance_of(Fixnum)
+        expect(time).to be_an_instance_of(Float)
+      end
+
+      it "passes and fails should add up to correct number" do
+        passes, fails, time = @checker.start(50)
+        expect(passes + fails).to eq(50)
+      end
 
-        it "returns an array" do
-            expect(@checker.start).to be_an_instance_of(Array)
+      it "passes while running locally" do
+        passes, fails, time = @checker.start(50)
+        expect(passes).to eq(50)
+      end
+    end # context 'start'
+
+    describe "group_benchmark" do
+      before(:each) do
+        @response_array = MemcacheCheck::Checker.group_benchmark('localhost', '127.0.0.1', 'localhost')
+      end
+
+      it { MemcacheCheck::Checker.should respond_to(:group_benchmark) }
+
+      it "returns an array the same length as the number of hostname arguments" do
+        expect(@response_array.length).to eq(3)
+      end
+
+      it "returns an array of Server objects" do
+        expect(@response_array.first).to be_an_instance_of(MemcacheCheck::Server)
+      end
+
+      it "passes and fails should add up to the correct number" do
+        @response_array.each do |i|
+          expect(i.passes + i.fails).to eq(100)
         end
+      end
 
-        it "returns an array with 3 numeric elements" do
-            passes, fails, time = @checker.start
-            expect(passes).to be_an_instance_of(Fixnum)
-            expect(fails).to be_an_instance_of(Fixnum)
-            expect(time).to be_an_instance_of(Float)
+      it "passes every time when running local" do
+        @response_array.each do |i|
+          expect(i.passes).to eq(100)
         end
+      end
 
-        it "passes and fails should add up to correct number" do
-            passes, fails, time = @checker.start(50)
-            expect(passes + fails).to eq(50)
+      it "response hostname and time are populated" do
+        @response_array.each do |i|
+          expect(i.hostname).to_not be_nil
+          expect(i.time).to be_an_instance_of(Benchmark::Tms)
         end
-    end
+      end
 
-  end
+      it "localhost should be close to the same twice in a row" do
+        first = @response_array[0]
+        second = @response_array[1]
+        third = @response_array[2]
+        expect(first.time.real.round(1)).to eq(second.time.real.round(1))
+        expect(second.time.real.round(1)).to eq(third.time.real.round(1))
+      end
+    end # group_benchmark
+
+  end # Checker
 
   context "Server" do
     before(:each) do
@@ -49,69 +96,67 @@ describe MemcacheCheck do
     it "set and retrieve data from memcached" do
       key = "abc123"
       value = {name: 'Mike Admire',
-               text: "Lorem ipsum dolor sit amet, consectetur adipisicing" }
+        text: "Lorem ipsum dolor sit amet, consectetur adipisicing" }
       @tester.set(key, value)
       expect(@tester.get(key)).to eq(value)
     end
-  end
+  end # context 'Server'
 
 
   describe "Utils" do
-    it { MemcacheCheck::Utils.should respond_to :generate_key }
-    it { MemcacheCheck::Utils.should respond_to :generate_test_data }
+    it { MemcacheCheck::Utils.should respond_to :generate_key_value_pair }
 
-    context "generate_key" do
+    describe "generate_key_value_pair" do
       before(:each) do
-        @key = MemcacheCheck::Utils.generate_key
+        @key, @data = MemcacheCheck::Utils.generate_key_value_pair
       end
 
-      it "can generate an appropriate sized key" do
-        expect(@key.length).to be >= 25
-      end
+      context "key" do
+        it "can generate an appropriate sized key" do
+          expect(@key.length).to be >= 25
+        end
 
-      it "starts with the string MemCacheCheck in key" do
-        expect(@key).to start_with("MemcacheCheck")
-      end
+        it "starts with the string MemCacheCheck in key" do
+          expect(@key).to start_with("MemcacheCheck")
+        end
 
-      it "is unique" do
-        key1 = MemcacheCheck::Utils.generate_key
-        key2 = MemcacheCheck::Utils.generate_key
-        key3 = MemcacheCheck::Utils.generate_key
-        expect(@key).to_not eq(key1)
-        expect(@key).to_not eq(key2)
-        expect(@key).to_not eq(key3)
-        expect(key1).to_not eq(key2)
-        expect(key1).to_not eq(key3)
-        expect(key2).to_not eq(key3)
-      end
-    end # generate_key
+        it "is unique" do
+          key1 = MemcacheCheck::Utils.generate_key_value_pair.first
+          key2 = MemcacheCheck::Utils.generate_key_value_pair.first
+          key3 = MemcacheCheck::Utils.generate_key_value_pair.first
+          expect(@key).to_not eq(key1)
+          expect(@key).to_not eq(key2)
+          expect(@key).to_not eq(key3)
+          expect(key1).to_not eq(key2)
+          expect(key1).to_not eq(key3)
+          expect(key2).to_not eq(key3)
+        end
+      end # context 'key'
 
-    context "generate_test_data" do
-      before(:each) do
-        @data = MemcacheCheck::Utils.generate_test_data
-      end
+      context "value" do
+        it "generates a data hash" do
+          expect(@data).to be_an_instance_of(Hash)
+        end
 
-      it "generates a data hash" do
-        expect(@data).to be_an_instance_of(Hash)
-      end
+        it "is a reasonable amount of data" do
+          expect(@data.length).to be >= 5
+          expect(@data.to_s.length).to be >= 500
+        end
 
-      it "is a reasonable amount of data" do
-        expect(@data.length).to be >= 5
-        expect(@data.to_s.length).to be >= 500
-      end
+        it "is unique" do
+          data1 = MemcacheCheck::Utils.generate_key_value_pair.last
+          data2 = MemcacheCheck::Utils.generate_key_value_pair.last
+          data3 = MemcacheCheck::Utils.generate_key_value_pair.last
+          expect(@data).to_not eq(data1)
+          expect(@data).to_not eq(data2)
+          expect(@data).to_not eq(data3)
+          expect(data1).to_not eq(data2)
+          expect(data1).to_not eq(data3)
+          expect(data2).to_not eq(data3)
+        end
+      end # context 'value'
 
-      it "is unique" do
-        data1 = MemcacheCheck::Utils.generate_test_data
-        data2 = MemcacheCheck::Utils.generate_test_data
-        data3 = MemcacheCheck::Utils.generate_test_data
-        expect(@data).to_not eq(data1)
-        expect(@data).to_not eq(data2)
-        expect(@data).to_not eq(data3)
-        expect(data1).to_not eq(data2)
-        expect(data1).to_not eq(data3)
-        expect(data2).to_not eq(data3)
-      end
-    end # generate_test_data
+    end # generate_key_value_pair
   end # Utils
-  
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memcache_check
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Mike Admire
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-08 00:00:00.000000000 Z
+date: 2013-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.9.2
+        version: 4.9.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.9.2
+        version: 4.9.3
 - !ruby/object:Gem::Dependency
   name: dalli
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +94,8 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Run checks against a Memcached server
+description: Ruby gem to test the speed of a Memcached server and verify that it's
+  working correctly.
 email:
 - mike@mikeadmire.com
 executables: []
@@ -109,6 +110,9 @@ files:
 - Rakefile
 - autotest/discover.rb
 - lib/memcache_check.rb
+- lib/memcache_check/checker.rb
+- lib/memcache_check/server.rb
+- lib/memcache_check/utils.rb
 - lib/memcache_check/version.rb
 - memcache_check.gemspec
 - spec/lib/memcache_check_spec.rb