redisk 0.1.0

data/spec/redis-test.conf

@@ -0,0 +1,132 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+# dir ./tmp/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes
+
+# Use object sharing. Can save a lot of memory if you have many common
+# string in your dataset, but performs lookups against the shared objects
+# pool so it uses more CPU and can be a bit slower. Usually it's a good
+# idea.
+#
+# When object sharing is enabled (shareobjects yes) you can use
+# shareobjectspoolsize to control the size of the pool used in order to try
+# object sharing. A bigger pool size will lead to better sharing capabilities.
+# In general you want this value to be at least the double of the number of
+# very common strings you have in your dataset.
+#
+# WARNING: object sharing is experimental, don't enable this feature
+# in production before of Redis 1.0-stable. Still please try this feature in
+# your development environment so that we can test it better.
+shareobjects no
+shareobjectspoolsize 1024

data/spec/redisk_io_spec.rb

@@ -0,0 +1,348 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Redisk::IO do
+  before do
+    # load a file into an IO object
+    @io_name = 'rails.log'
+    @key = Redisk::IO.list_key(@io_name)
+    @file_as_array = []
+    File.foreach(File.dirname(__FILE__) + '/fixtures/rails.log') {|f|
+      @file_as_array << f
+      Redisk.redis.rpush @key, f
+    }
+    @io = Redisk::IO.new(@io_name)
+  end
+
+  after do
+    Redisk.redis.del @key
+  end
+
+  describe 'new' do    
+    it 'returns an IO object' do
+      @io.should be_instance_of(Redisk::IO)
+    end
+
+    it 'connects to the redis server' do
+      @io.redis.should be_instance_of(Redis::Namespace)
+    end
+
+    it 'stores the name of the key' do
+      @io.name.should == @io_name
+    end
+  end
+
+  describe 'foreach' do
+
+    it 'should yield each line to the block' do
+      Redisk::IO.foreach(@io_name) do |line|
+        line.should be_kind_of(String)
+      end
+    end
+
+    it 'should return nil' do
+      Redisk::IO.foreach(@io_name) {|l| l }.should == nil
+    end
+
+  end
+
+  describe 'open' do
+
+    it 'should return an IO object if no block is given' do
+      Redisk::IO.open('newlog').should be_kind_of(Redisk::IO)
+    end
+
+    it 'should yield the IO object to the block' do
+      Redisk::IO.open('newlog') do |log|
+        log.should be_kind_of(Redisk::IO)
+      end
+    end
+
+    it 'should return the value of the block' do
+      Redisk::IO.open('newlog') do |log|
+        'returned'
+      end.should == 'returned'
+    end
+
+  end
+
+  describe 'read' do
+
+    it 'should return the entire contents without arguments' do
+      Redisk::IO.read(@io_name).should == @file_as_array.join("\n")
+    end
+
+    it 'should return the first [length] contents' do
+      Redisk::IO.read(@io_name, 2).should == @file_as_array[0..1].join("\n")
+    end
+
+    it 'should return [length] contents starting at [offset]' do
+      Redisk::IO.read(@io_name, 2, 2).should == @file_as_array[2..3].join("\n")
+    end
+
+  end
+
+  describe 'readlines' do
+
+    it 'should return the entire contents as an array' do
+      Redisk::IO.readlines(@io_name).should == @file_as_array
+    end
+
+  end
+
+  describe 'instance methods' do
+    before(:each) do
+      @io = Redisk::IO.new(@io_name)
+    end
+
+    describe '#<<' do
+
+      it 'should append a line to the io' do
+        @io << 'whu'
+        @io.lineno = 100
+        @io.gets.should == 'whu'
+      end
+
+      it 'should return the text' do
+        (@io << 'whu').should == 'whu'
+      end
+
+      it 'should be able to chain' do
+        @io << 'whu ' << 'zuh'
+        @io.lineno = 100
+        @io.gets.should == 'whu zuh'
+      end
+
+    end
+
+    describe '#each' do
+
+      it 'should yield each line of the file' do
+        i = 0
+        @io.each {|l|
+          l.should be_kind_of(String)
+          l.should == @file_as_array[i]
+          i+=1
+        }
+        i.should == 100
+      end
+
+      it 'should advance the lineno for each iteration' do
+        i = 0
+        @io.each {|l|
+          i+=1
+          @io.lineno.should == i
+        }
+        @io.lineno.should == 100
+      end
+
+    end
+
+    describe '#eof' do
+
+      it 'should return false if lineno is not the end of the file' do
+        @io.eof.should == false
+      end
+
+      it 'should return true if lineno is at the end of the file' do
+        @io.each {|l| l }
+        @io.eof.should == true
+      end
+
+    end
+
+    describe '#gets' do
+
+      it 'should return the next line from the io' do
+        val = @io.gets
+        val.should be_kind_of(String)
+        val.should == @file_as_array[0]
+      end
+
+      it 'should advance the filedescriptor lineno' do
+        @io.gets.should == @file_as_array[0]
+        @io.lineno.should == 1
+        @io.gets.should == @file_as_array[1]
+        @io.lineno.should == 2
+      end
+
+      it 'should set the value of $_' do
+        val = @io.gets
+        @io._.should == val
+      end
+      
+    end
+
+    describe '#lineno' do
+      it 'should return the current lineno' do
+        @io.lineno.should == 0
+      end
+    end
+
+    describe '#lineno=' do
+      it 'should set the current lineno' do
+        @io.lineno = 50
+        @io.lineno.should == 50
+        @io.gets.should == @file_as_array[50]
+      end
+    end
+
+    describe '#print' do
+
+      it 'should append arguments into a string and write to io' do
+        @io.print('My ', 'name ', 'is ', 'redisk')
+        line = Redisk::IO.read(@io_name, 1, 100)
+        line.should == 'My name is redisk'
+      end
+
+      it 'should return nil' do
+        @io.print('whu').should == nil
+      end
+
+      it 'should write the contents of $_ if no arguments are provided' do
+        @io.gets
+        @io.print
+        line = Redisk::IO.read(@io_name, 1, 100)
+        line.should == @file_as_array[0]
+      end
+    end
+
+    describe '#printf' do
+
+      it 'should run the arguments through sprintf and print to the io' do
+        @io.printf('My name is %s', 'redisk')
+        line = Redisk::IO.read(@io_name, 1, 100)
+        line.should == 'My name is redisk'
+      end
+
+    end
+
+    describe '#puts' do
+
+      it 'should write each argument to the io' do
+        @io.puts('1', '2', '3')
+        @io.lineno = 100
+        @io.gets.should == '1'
+        @io.gets.should == '2'
+        @io.gets.should == '3'
+      end
+
+      it 'should write a blank string if no argument is passed' do
+        @io.puts
+        @io.lineno = 100
+        @io.gets.should == ''
+      end
+
+    end
+
+    describe '#readline' do
+
+      it 'should read the next line with gets' do
+        @io.readline.should == @file_as_array[0]
+        @io.lineno.should == 1
+      end
+
+      it 'should raise EOFError at the end of the lines' do
+        @io.lineno = 100
+        lambda {
+          @io.readline
+        }.should raise_error(Redisk::IO::EOFError)
+      end
+
+    end
+
+    describe '#readlines' do
+
+      it 'should return the lines as an array' do
+        @io.readlines.should == @file_as_array
+      end
+
+    end
+
+    describe '#rewind' do
+
+      it 'should set the lineno to 0' do
+        @io.lineno = 50
+        @io.rewind.should == 0
+        @io.lineno.should == 0
+      end
+      
+    end
+
+    describe '#seek' do
+
+      it 'should set the lineno to the absolute location' do
+        @io.seek(10)
+        @io.lineno.should == 10
+      end
+
+      it 'should set the lineno to the absolute location with SEEK_SET' do
+        @io.seek(15, IO::SEEK_SET)
+        @io.lineno.should == 15
+      end
+
+      it 'should set the lineno to the location relative to the end with SEEK_END' do
+        @io.seek(-5, IO::SEEK_END)
+        @io.lineno.should == 95
+      end
+
+      it 'should set the lineno to an offset position from the current line with SEEK_CUR' do
+        @io.lineno = 5
+        @io.lineno.should == 5
+        @io.seek(5, IO::SEEK_CUR)
+        @io.lineno.should == 10
+      end
+
+    end
+
+    describe '#stat' do
+
+      it 'should return a stat like object' do
+        @stat = @io.stat
+        @stat.should be_instance_of(Redisk::Stat)
+        @stat.atime.should be_instance_of(Time)
+        @stat.size.should == 0
+      end
+
+    end
+
+    describe '#write' do
+      
+      it 'should write the contents of string to the io' do
+        @io.write('123')
+        @io.lineno = 100
+        @io.gets.should == '123'
+      end
+
+      it 'should return the number of bytes written' do
+        @io.write('123').should == 3
+      end
+
+    end
+    
+    describe '#truncate(size)' do
+      
+      it 'should only keep the last [size] lines' do
+        @io.truncate(10).should == 10
+        @io.length.should == 10
+        @io.readlines.should == @file_as_array[90...100]
+      end
+      
+    end
+
+  end
+  
+  describe 'As an interface for logger' do
+    before do
+      @io = Redisk::IO.new('test.log')
+      @io.truncate
+      @logger = Logger.new(@io)
+    end
+     
+    it 'should write to the log' do
+      @logger.info "This should be info"
+      @logger.warn "This should be warn"
+      @io.length.should == 2
+    end    
+    
+  end
+end

data/spec/redisk_logger_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Redis::Logger do
+  before(:each) do
+    @io = Redisk::IO.new('test.log').truncate(0)
+  end
+  
+  describe 'initializing' do
+    before do
+      @logger = Redisk::Logger.new('test.log')
+    end
+    
+    it 'should initialize a logger' do
+      @logger.logger.should be_instance_of(::Logger)
+    end
+    
+    it 'should initialize an io' do
+      @logger.io.should be_instance_of(Redisk::IO)
+      @logger.io.name.should == 'test.log'
+    end
+    
+    it 'should return a Redis::Logger' do
+      @logger.should be_instance_of(Redisk::Logger)
+    end
+  end
+  
+  describe 'logging' do
+    
+    it 'should delegate logging methods to logger' do
+      @logger = Redisk::Logger.new('test.log')
+      @logger.info('info').should == true
+      @logger.length.should == 1
+    end
+    
+  end
+  
+  describe 'initializing with :truncate' do
+    
+    it 'should trim the log after _n lines' do
+      @logger = Redisk::Logger.new('test.log', :truncate => 5)
+      5.times do |n|
+        @logger.info("#{n} time")
+      end
+      @logger.length.should == 5
+      @logger.info("another time")
+      @logger.length.should == 5
+      @logger.info("and again")
+      @logger.length.should == 5
+    end
+    
+  end
+  
+end

data/spec/redisk_stat_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Redisk::Stat do
+  before(:each) do
+    @stat = Redisk::Stat.new('test_stat')
+  end
+  
+  after(:each) do
+    keys = Redisk.redis.keys('test_stat:*')
+    keys.each do |key|
+      Redisk.redis.del key.gsub(/^redisk\:/, '')
+    end
+  end
+  
+  describe 'initialize' do
+    
+    it 'should return a Redisk::Stat object' do
+      @stat.should be_instance_of(Redisk::Stat)
+    end
+    
+    it 'should set name' do
+      @stat.name.should == 'test_stat'
+    end
+    
+    it 'should write defaults for new files' do
+      @stat.size.should == 0
+      @stat.atime.should be_instance_of(Time)
+    end 
+  end
+
+  describe 'atime' do
+    
+    it 'should return a time' do
+      @stat.atime.should be_instance_of(Time)
+    end
+    
+    it 'should return the last access time' do
+      inital_time = @stat.atime
+      sleep 1  
+      @stat = Redisk::Stat.new('test_stat')
+      new_time = @stat.atime
+      new_time.should > inital_time
+    end
+    
+  end
+  
+  describe 'ctime' do
+    
+    it 'should return a time' do
+      @stat.ctime.should be_instance_of(Time)
+    end
+    
+    it 'should return the last changed time' do
+      inital_time = @stat.ctime
+      sleep 1
+      @stat.write_attribute('size', 4000)
+      new_time = @stat.ctime
+      new_time.should > inital_time
+    end
+    
+  end
+  
+  describe 'mtime' do
+    
+    it 'should return a time' do
+      @stat.mtime.should be_instance_of(Time)
+    end
+    
+    it 'should return the last modification of the io' do
+      inital_time = @stat.mtime
+      sleep 1
+      @io = Redisk::IO.new('test_stat')
+      @io.write '123'
+      new_time = @stat.mtime
+      new_time.should > inital_time
+    end
+  end
+  
+  describe 'size' do
+    it 'should return the length of the IO in bytes' do
+      @io = Redisk::IO.new('test_stat')
+      @io.write '123'
+      @stat.size.should == 3
+    end  
+  end
+
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(dir)
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+require 'fileutils'
+require 'rubygems'
+require 'redisk'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end
+
+## Redis test bootsrapping 
+## Stolen with love from @defunkt's resque
+## github.com/defunkt/resque
+
+#
+# make sure we can run redis
+#
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+
+#
+# start our own redis when the tests start,
+# kill it when they end
+#
+
+at_exit do
+  exit_with = $!
+  next unless exit_with.is_a?(SystemExit)
+  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb`
+  Process.kill("KILL", pid.to_i)
+  exit exit_with.status
+end
+
+FileUtils.mkdir_p(File.join(dir, 'tmp'))
+puts "Starting redis for testing at localhost:9736..."
+puts `redis-server #{dir}/redis-test.conf`
+Redisk.redis = 'localhost:9736'