redis-spawn 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (C) 2011 by Phil Stewart
+
+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:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,8 @@
+# redis-spawn
+
+An extension to redis-rb to facilitate spawning a redis-server specifically
+for your app.
+
+Phil Stewart, 201110
+
+License: MIT

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'redis/spawn'
+
+task :test do
+  require 'cutest'
+  
+  Cutest.run(Dir["./test/**/*_test.rb"])
+end
+
+task :pry do
+  require 'pry'
+  binding.pry
+end

data/lib/redis/spawn/version.rb

@@ -0,0 +1,5 @@
+class Redis
+  class SpawnServer
+    VERSION = "0.0.1"
+  end
+end

data/lib/redis/spawn.rb

@@ -0,0 +1,191 @@
+require "redis"
+
+class Redis
+  class SpawnServer
+    @_default_server_opts = {
+      port:                     "0",
+      bind:                     "127.0.0.1",
+      unixsocket:               "/tmp/redis-spawned.#{Process.pid}.sock",
+      loglevel:                 "notice",
+      logfile:                  "/tmp/redis-spawned.#{Process.pid}.log",
+      databases:                "16",
+      save:                     ["900 1", "300 10", "60 10000"],
+      rdbcompression:           "yes",
+      dbfilename:               "dump.rdb",
+      dir:                      "/tmp/redis-spawned.#{Process.pid}.data",
+      appendonly:               "no",
+      appendfsync:              "everysec",
+      vm_enabled:               "no",
+      hash_max_zipmap_entries:  "512",
+      hash_max_zipmap_value:    "64",
+      list_max_ziplist_entries: "512",
+      list_max_ziplist_value:   "64",
+      set_max_intset_entries:   "512",
+      activerehashing:          "yes"
+    }
+
+    @_running_servers = {}
+    
+    def self.default_server_opts
+      @_default_server_opts
+    end
+
+    def self.default_server_opts=(new_defaults_hash)
+      @_default_server_opts = new_defaults_hash
+    end
+
+    # Build a configuration file line
+    #
+    # @param [Symbol, String] key: The configuration parameter. Underscores in
+    #                              the key are transposed to dashes
+    # @param [String, Object] value: The value to set for this configuration
+    #                                parameter
+    #
+    # @return A line of Redis server configuration data
+    def self.build_config_line(key, value)
+      key.to_s.gsub(/_/, "-") + " " + value.to_s
+    end
+
+    # Spawn a Redis server configured with the supplied options. By default,
+    # the spawned server will be a child of the current process and won't
+    # daemonize (@todo allow daemonization)
+    #
+    # @param supplied_opts: options for this server including any configuration overrides
+    #
+    # @return [SpawnServer] instance corresponding to the spawned server
+    def self.spawn(supplied_opts = {})
+      self.new(supplied_opts)
+    end
+    
+    attr_reader :opts, :supplied_opts, :server_opts, :pid
+
+    def initialize(supplied_opts = {})
+      default_opts = {
+        generated_config_file: "/tmp/redis-spawned.#{Process.pid}.config",
+        cleanup_files:         [:socket, :log, :config],
+        server_opts:           {},
+        start:                 true
+      }
+      @supplied_opts = supplied_opts
+      @opts = default_opts.merge(supplied_opts)
+      self.server_opts = opts[:server_opts]
+      
+      @pid = opts[:start] ? self.start : 0
+
+      # Return the instance
+      self
+    end
+    
+    # Prepare a redis configuration file then start the server
+    #
+    # @return pid of the server
+    def start
+      # If config_file is passed in opts use it as the name of the config file.
+      # Otherwise, generate our own
+      @config_file = if opts.has_key?(:config_file)
+        # Don't attempt to cleanup files when supplied with pre-existing
+        # config file unless specifically asked
+        opts[:cleanup_files] = [] unless supplied_opts.has_key?(:cleanup_files)
+        opts[:config_file]
+      else
+        self.write_config
+      end
+      
+      # Ensure the data directory exists
+      Dir.exists?(self.server_opts[:dir]) || Dir.mkdir(self.server_opts[:dir])
+
+      # Spawn the redis server for this instance
+      self.spawn
+    end
+    
+    # Spawn a redis server. Only call this function once a config file exists
+    # and is specified
+    #
+    # @return the pid of the spawned server
+    def spawn
+      # Abort if there's no config file
+      unless @config_file && File.exist?(@config_file)
+        raise "Config file #{@config_file.inspect} not found"
+      end
+   
+      # Make sure we clean up after our children and avoid a zombie invasion
+      trap("CLD") do
+        pid = Process.wait
+      end
+
+      # Start the server
+      pid = fork { exec("redis-server #{@config_file}") }
+      #logger.info("Spawned redis server with PID #{pid}")
+
+      at_exit do
+        begin
+          Process.kill("TERM", pid) # Maybe make this configurable to allow the server to continue after exit
+        rescue Errno::ESRCH
+          # Already dead - do nothing
+        end
+        self.cleanup_files
+      end
+      
+      pid
+    end
+    
+    # Attribute write for server opts: merges supplied opts with defaults
+    # to create fully populated server opts
+    #
+    # @param [Hash] opts: partially populated server options hash
+    def server_opts=(opts)
+      @server_opts = self.class.default_server_opts.merge(opts)
+    end
+
+    # Write the Redis configuration file to disk.
+    #
+    # @return the name of the written file
+    def write_config
+      File.open(self.opts[:generated_config_file], "w") do |file|
+        ## @todo Migrate class based build_config to instance based build_config
+        file.write(self.build_config)
+      end
+      self.opts[:generated_config_file]
+    end
+
+    # Build configuration file data
+    #
+    # @return Redis server compatible configuration file data
+    def build_config
+      config_data = ""
+      self.server_opts.each do |key, value|
+        if value.kind_of?(Array)
+          value.each { |subvalue| config_data << self.class.build_config_line(key, subvalue) << "\n" }
+        else
+          config_data << self.class.build_config_line(key, value) << "\n"
+        end
+      end
+      config_data
+    end
+
+    # Clean up server files associated with this instance. Expects
+    # #opts[:cleanup_files] to already be set up
+    def cleanup_files
+      files_from_symbols(opts[:cleanup_files]) do |file|
+        File.exist?(file) && File.delete(file)
+      end
+    end
+
+    # Iterates over the supplied symbols and yields corresponding filenames
+    #
+    # @param [Array] file_syms: array of symbols to iterate over
+    def files_from_symbols(file_syms)
+      file_syms.each do |file_sym|
+        yield case file_sym
+          when :socket
+            server_opts[:unixsocket]
+          when :log
+            server_opts[:logfile]
+          when :config
+            @config_file || opts[:generated_config_file]
+        end
+      end
+    end
+
+  end
+end

data/test/build_config_helper.rb

@@ -0,0 +1,14 @@
+# Monkeypatch Process to allow for consistent value of Process.pid in tests
+module Process
+  class << self
+    alias :redis_spawn_original_pid :pid
+  
+    def pid
+      if caller[0] =~ /redis\/spawn/
+        return 0
+      else
+        return redis_spawn_original_pid
+      end
+    end
+  end
+end

data/test/build_config_test.rb

@@ -0,0 +1,80 @@
+require File.expand_path("./build_config_helper", File.dirname(__FILE__))
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+test "build_config_line" do
+  assert "key value"                     == Redis::SpawnServer.build_config_line("key", "value")
+  assert "symbolkey value"               == Redis::SpawnServer.build_config_line(:symbolkey, "value")
+  assert "symbol-with-underscores value" == Redis::SpawnServer.build_config_line(:symbol_with_underscores, "value")
+  assert "key 0"                         == Redis::SpawnServer.build_config_line("key", 0)
+end
+
+setup do
+  @test_config_defaults = <<TEST_CONF_END
+port 0
+bind 127.0.0.1
+unixsocket /tmp/redis-spawned.0.sock
+loglevel notice
+logfile /tmp/redis-spawned.0.log
+databases 16
+save 900 1
+save 300 10
+save 60 10000
+rdbcompression yes
+dbfilename dump.rdb
+dir /tmp/redis-spawned.0.data
+appendonly no
+appendfsync everysec
+vm-enabled no
+hash-max-zipmap-entries 512
+hash-max-zipmap-value 64
+list-max-ziplist-entries 512
+list-max-ziplist-value 64
+set-max-intset-entries 512
+activerehashing yes
+TEST_CONF_END
+end
+
+test "build_config with defaults" do
+  assert @test_config_defaults == Redis::SpawnServer.new(start: false).build_config
+end
+
+setup do
+  @test_config_defaults = <<TEST_CONF_END
+port 0
+bind 127.0.0.1
+unixsocket /tmp/redis-spawned.override.sock
+loglevel notice
+logfile /tmp/redis-spawned.override.log
+databases 8
+save 900 1
+save 300 10
+save 100 1000
+save 60 10000
+rdbcompression no
+dbfilename dump.rdb
+dir /tmp/redis-spawned.override.data
+appendonly no
+appendfsync everysec
+vm-enabled no
+hash-max-zipmap-entries 512
+hash-max-zipmap-value 64
+list-max-ziplist-entries 512
+list-max-ziplist-value 64
+set-max-intset-entries 512
+activerehashing yes
+TEST_CONF_END
+end
+  
+test "build_config with overrides" do
+  overrides = {
+    unixsocket:     "/tmp/redis-spawned.override.sock",
+    logfile:        "/tmp/redis-spawned.override.log",
+    databases:      8,
+    save:           ["900 1", "300 10", "100 1000", "60 10000"],
+    rdbcompression: "no",
+    dir:            "/tmp/redis-spawned.override.data"
+  }
+  assert @test_config_defaults == Redis::SpawnServer.new(start: false, server_opts: overrides).build_config
+end
+
+  

data/test/helper.rb

@@ -0,0 +1,4 @@
+$:.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'redis/spawn'
+

data/test/spawn_test.rb

@@ -0,0 +1,8 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+test "spawn with defaults" do
+  spawn_instance = Redis::SpawnServer.new
+  assert_equal `ps -o cmd= -p #{spawn_instance.pid}`, "redis-server /tmp/redis-spawned.#{Process.pid}.config\n"
+  Process.kill("TERM", spawn_instance.pid)
+end
+

data/test/write_config_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path("./helper", File.dirname(__FILE__))
+require 'digest/sha1'
+
+setup do
+  testdir = "/tmp/redis-spawn-write-config-test.dir"
+  filename = "/tmp/redis-spawn-write-config-test.config"
+  spawn_instance = Redis::SpawnServer.new(start:                 false,
+                                          generated_config_file: filename,
+                                          server_opts:           {dir: testdir})
+  Dir.exists?(testdir) && Dir.rmdir(testdir)
+  {
+    filename:       filename,
+    spawn_instance: spawn_instance,
+    config_sha:     Digest::SHA1.hexdigest(spawn_instance.build_config)
+  }
+end
+
+test "write_config" do |params|
+  begin
+    filename = params[:spawn_instance].write_config
+    assert_equal filename, params[:filename]
+    assert_equal Digest::SHA1.hexdigest(File.read(filename)), params[:config_sha]
+#    assert Dir.exist?(params[:spawn_instance].server_opts[:dir])
+  ensure
+    File.delete(params[:filename])
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: redis-spawn
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Phil Stewart
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-26 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis-rb
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cutest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :development
+  version_requirements: *id002
+description: Insert something more verbose than the summary here.
+email: 
+- phil.stewart@lichp.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/redis/spawn/version.rb
+- lib/redis/spawn.rb
+- README
+- LICENSE
+- Rakefile
+- test/write_config_test.rb
+- test/helper.rb
+- test/spawn_test.rb
+- test/build_config_helper.rb
+- test/build_config_test.rb
+has_rdoc: true
+homepage: http://github.com/lichp/redis-spawn
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An extension to redis-rb to facilitate spawning a redis-server specifically for your app.
+test_files: []
+