redis-dump 0.1.5 → 0.3.0

data/CHANGES.txt

@@ -1,5 +1,15 @@
 REDIS-DUMP, CHANGES
 
+#### 0.3.0 (2012-01-05) ###############################
+
+* ADDED: Redis::Dump.dump_strings
+* ADDED: New global options for redis-dump: -c, -O
+* CHANGED: memory optimizations for Redis::Dump#dump
+
+#### 0.2.0 (unreleased) ###############################
+
+* ADDED: Redis::Dump.chunk_size support for dump and report
+
 #### 0.1.5 (2011-06-04) ###############################
 
 * FIXED: Added drydock dependency to gemspec [Mike Dupont]

data/README.rdoc

@@ -1,10 +1,8 @@
-= Redis-Dump v0.1 ALPHA
+= Redis-Dump v0.3 ALPHA
 
 <i>Backup and restore your Redis data to and from JSON.</i>
 
-<b>NOTE: This is alpha software. DO NOT RELY ON IT FOR PRECIOUS THINGS!!</b>
-
-<b>ALSO: This is an unofficial tool.</b>
+<b>NOTE: This is alpha software. TEST IT BEFORE RELYING ON IT.</b>
 
 
 == Usage
@@ -24,7 +22,7 @@ All redis datatypes are output to a simple JSON object. All objects have the fol
 
 * db (Integer)
 * key (String)
-* ttl (Integer): The amount of time in seconds that the key will live . If no expire is set, it's -1. 
+* ttl (Integer): The amount of time in seconds that the key will live. If no expire is set, it's -1. 
 * type (String), one of: string, list, set, zset, hash, none. 
 * value (String): A JSON-encoded string. For keys of type list, set, zset, and hash, the data is given a specific structure (see below). 
 

data/Rakefile

@@ -11,7 +11,7 @@ end
  
 config = YAML.load_file("VERSION.yml")
 task :default => ["build"]
-CLEAN.include [ 'pkg', 'doc', '*gemspec' ]
+CLEAN.include [ 'pkg', 'doc' ]
 name = "redis-dump"
 
 begin
@@ -46,21 +46,3 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include("lib/**/*.rb")
 end
 
-
-# Rubyforge Release / Publish Tasks ==================================
-
-#about 'Publish website to rubyforge'
-task 'publish:rdoc' => 'doc/index.html' do
-  sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
-end
-
-#about 'Public release to rubyforge'
-task 'publish:gem' => [:package] do |t|
-  sh <<-end
-    rubyforge add_release -o Any -a CHANGES.txt -f -n README.md #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
-    rubyforge add_file -o Any -a CHANGES.txt -f -n README.md #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
-  end
-end
-
-
-

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :MAJOR: 0
-:MINOR: 1
-:PATCH: 5
+:MINOR: 3
+:PATCH: 0
 :BUILD: '001'

data/bin/redis-dump

@@ -27,6 +27,9 @@ class Redis::Dump::CLI
   
   global :u, :uri, String, "Redis URI (e.g. redis://hostname[:port])"
   global :d, :database, Integer, "Redis database (e.g. -d 15)"
+  global :s, :sleep, Integer, "Sleep for S seconds after dumping (for debugging)"
+  global :c, :count, Integer, "Chunk size (default: #{Redis::Dump.chunk_size})"
+  global :O, :without_optimizations, "Disable run time optimizations"
   global :V, :version, "Display version" do 
     puts "Version: #{Redis::Dump::VERSION.to_s}"
     exit 0
@@ -43,15 +46,24 @@ class Redis::Dump::CLI
     obj.global.uri = 'redis://' << obj.global.uri unless obj.global.uri.match(/^redis:\/\//)
     obj.global.database &&= obj.global.database.to_i
     obj.global.database ||= (0..15)
+    Redis::Dump.with_optimizations = false if obj.global.without_optimizations
+    Redis::Dump.chunk_size = obj.global.count if obj.global.count
     Redis::Dump.ld " redis_uri: #{obj.global.uri} (#{obj.global.database})"
+    Redis::Dump.ld "Process: #{$$}; Memory: #{Redis::Dump.memory_usage}" if Redis::Dump.debug
+  end
+  
+  after do |obj|
+    Redis::Dump.ld "Process: #{$$}; Memory: #{Redis::Dump.memory_usage}" if Redis::Dump.debug
+    sleep obj.global.sleep.to_i if obj.global.sleep
   end
   
   usage "redis-dump > dumpfile_full.json"
   usage "redis-dump -d 15 > dumpfile_db15.json"
+  usage "redis-dump -d 15 -c 100_000 > dumpfile_db15.json"
   command :dump do |obj|
     rd = Redis::Dump.new obj.global.database, obj.global.uri
-    rd.dump do |record|
-      puts record
+    rd.dump do |records|
+      puts records
     end
   end
   
@@ -60,6 +72,8 @@ end
   
 begin
   Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+rescue RuntimeError => ex
+  STDERR.puts ex.message
 rescue Drydock::ArgError, Drydock::OptError => ex
   STDERR.puts ex.message
   STDERR.puts ex.usage

data/bin/redis-load

@@ -27,6 +27,7 @@ class Redis::Dump::CLI
   
   global :u, :uri, String, "Redis URI (e.g. redis://hostname[:port])"
   global :d, :database, Integer, "Redis database (e.g. -d 15)"
+  global :s, :sleep, Integer, "Sleep for S seconds after dumping (for debugging)"
   global :V, :version, "Display version" do 
     puts "Version: #{Redis::Dump::VERSION.to_s}"
     exit 0
@@ -44,20 +45,73 @@ class Redis::Dump::CLI
     obj.global.database &&= obj.global.database.to_i
     obj.global.database ||= (0..15)
     Redis::Dump.ld " redis_uri: #{obj.global.uri} (#{obj.global.database})"
+    Redis::Dump.ld "Process: #{$$}; Memory: #{Redis::Dump.memory_usage}" if Redis::Dump.debug
+  end
+  
+  after do |obj|
+    Redis::Dump.ld "Process: #{$$}; Memory: #{Redis::Dump.memory_usage}" if Redis::Dump.debug
+    sleep obj.global.sleep.to_i if obj.global.sleep
   end
   
   usage "<dumpfile_full.json redis-load"
   usage "<dumpfile_db15.json redis-load -d 15"
   command :load do |obj|
     rd = Redis::Dump.new obj.global.database, obj.global.uri
+    raise "Usage: cat dumpfile_db15.json | redis-load -d 15" if STDIN.tty?
     rd.load STDIN
   end
   
+  about "Add test data to redis"
+  usage "redis-load populate -c 1000"
+  usage "redis-load -d 1 populate -c 1000"
+  option :c, :count, Integer, "Populate the redis db with <count> keys"
+  option :FLUSH, "Flush the redis db before populating. THIS WILL DESTROY DATA."
+  command :populate do |obj|
+    require 'benchmark'
+    obj.option.count ||= 100_000
+    obj.global.database ||= 0
+    rd = Redis::Dump.new obj.global.database, obj.global.uri
+    rd.each_database do |redis|
+      now = Time.now.utc.to_i
+      if obj.option.FLUSH
+        puts "Flushing db #{redis.client.id}..."
+        redis.flushdb
+      end
+      puts "Generating..."
+      time = Benchmark.measure do
+        redis.pipelined do
+          obj.option.count.times do |idx|
+            grp = (idx % 10)+1
+            val = '0' * (grp*100).to_i
+            redis.set 'rdtemp:%d:idx-%d:group-%d' % [now, idx, grp], val
+          end
+        end
+      end
+      info = redis.info
+      puts '%s: %s' % [redis.client.id, info["db#{redis.client.db}"]]
+      puts 'Total used memory: %s' % [info['used_memory_human']]
+      puts time.to_s
+    end
+  end
+  
+  command :info do |obj|
+    rd = Redis::Dump.new obj.global.database, obj.global.uri
+    memory = nil
+    rd.each_database do |redis|
+      info = redis.info
+      memory ||= info['used_memory_human']
+      next unless info["db#{redis.client.db}"]
+      puts '%s: %s' % [redis.client.id, info["db#{redis.client.db}"]]
+    end
+    puts 'Total used memory: %s' % [memory]
+  end
 end
 
   
 begin
   Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+rescue RuntimeError => ex
+  STDERR.puts ex.message
 rescue Drydock::ArgError, Drydock::OptError => ex
   STDERR.puts ex.message
   STDERR.puts ex.usage

data/bin/redis-report

@@ -27,6 +27,7 @@ class Redis::Dump::CLI
   
   global :u, :uri, String, "Redis URI (e.g. redis://hostname[:port])"
   global :d, :database, Integer, "Redis database (e.g. -d 15)"
+  global :s, :sleep, Integer, "Sleep for S seconds after dumping (for debugging)"
   global :v, :verbose, "Increase output" do 
     @verbose ||= 0
     @verbose += 1
@@ -48,21 +49,20 @@ class Redis::Dump::CLI
     obj.global.database &&= obj.global.database.to_i
     obj.global.database ||= (0..15)
     Redis::Dump.ld " redis_uri: #{obj.global.uri} (#{obj.global.database})"
+    Redis::Dump.ld "Process: #{$$}; Memory: #{Redis::Dump.memory_usage}" if Redis::Dump.debug
   end
   
-  usage "<dumpfile_full.json redis-load"
-  usage "<dumpfile_db15.json redis-load -d 15"
+  after do |obj|
+    Redis::Dump.ld "Process: #{$$}; Memory: #{Redis::Dump.memory_usage}" if Redis::Dump.debug
+    sleep obj.global.sleep.to_i if obj.global.sleep
+  end
+  
+  usage "redis-report"
+  usage "redis-report -d 15"
   command :report do |obj|
     rd = Redis::Dump.new obj.global.database, obj.global.uri
     total_size, dbs = 0, {}
-    rd.report do |record|
-      puts record if obj.global.verbose >= 1
-      dbs[record['db']] ||= 0
-      dbs[record['db']] += record['size']
-      total_size += record['size']
-    end
-    puts dbs.keys.sort.collect { |db| "  db#{db}: #{dbs[db].to_bytes}" }
-    puts "total: #{total_size.to_bytes}"
+    report = rd.report
   end
   
 end
@@ -70,6 +70,8 @@ end
   
 begin
   Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+rescue RuntimeError => ex
+  STDERR.puts ex.message
 rescue Drydock::ArgError, Drydock::OptError => ex
   STDERR.puts ex.message
   STDERR.puts ex.usage

data/lib/redis/dump.rb

@@ -17,10 +17,15 @@ class Redis
     @encoder = Yajl::Encoder.new
     @parser = Yajl::Parser.new
     @safe = true
+    @chunk_size = 10000
+    @with_optimizations = true
     class << self
-      attr_accessor :debug, :encoder, :parser, :safe, :host, :port
+      attr_accessor :debug, :encoder, :parser, :safe, :host, :port, :chunk_size, :with_optimizations
       def ld(msg)
-        STDERR.puts "#{'%.4f' % Time.now.utc.to_f}: #{msg}" if @debug
+        STDERR.puts "#%.4f: %s" % [Time.now.utc.to_f, msg] if debug
+      end
+      def memory_usage
+        `ps -o rss= -p #{Process.pid}`.to_i # in kb
       end
     end
     attr_accessor :dbs, :uri
@@ -31,66 +36,99 @@ class Redis
       unless dbs.nil?
         @dbs = Range === dbs ? dbs : (dbs..dbs)
         @dbs = (@dbs.first.to_i..@dbs.last.to_i) # enforce integers
-        open_all_connections
+        @dbs.to_a.each { |db| redis(db) } # open_all_connections
       end
     end
-    def open_all_connections
-      dbs.to_a.each { |db| redis(db) } unless dbs.nil?
-    end
     def redis(db)
       redis_connections["#{uri}/#{db}"] ||= connect("#{uri}/#{db}")
     end
     def connect(this_uri)
-      self.class.ld 'CONNECT: ' << this_uri
+      #self.class.ld 'CONNECT: ' << this_uri
       Redis.connect :url => this_uri
     end
     
-    # Calls blk for each key. If keys is nil, this will iterate over
-    # every key in every open redis connection.
-    # * keys (Array, optional). If keys is provided it must contain URI::Redis objects.
-    def each_key(keys=nil, &blk)
-      if keys.nil?
-        @redis_connections.keys.sort.each do |redis_uri|
-          self.class.ld ['---', "DB: #{redis_connections[redis_uri].client.db}", '---'].join($/)
-          keys = redis_connections[redis_uri].keys
-          keys.each do |key|
-            blk.call redis_connections[redis_uri], key
-          end
-        end
-      else
-        keys.each do |key|
-          unless URI::Redis === key
-            raise Redis::Dump::Problem, "#{key} must be a URI::Redis object"
-          end
-          redis_uri = key.serverid
-          if redis_connections[redis_uri].nil?
-            raise Redis::Dump::Problem, "Not connected to #{redis_uri}"
-          end
-          blk.call redis_connections[redis_uri], key.key
-        end
+    def each_database
+      @redis_connections.keys.sort.each do |redis_uri|
+        yield redis_connections[redis_uri]
       end
     end
     
     # See each_key
-    def dump(keys=nil, &each_record)
-      values = []
-      each_key(keys) do |this_redis,key|
-        info = Redis::Dump.dump this_redis, key
-        self.class.ld " #{key} (#{info['type']}): #{info['size'].to_bytes}"
-        encoded = self.class.encoder.encode info
-        each_record.nil? ? (values << encoded) : each_record.call(encoded)
+    def dump filter='*'
+      entries = []
+      each_database do |redis|
+        chunk_entries = []
+        dump_keys = redis.keys(filter)
+        dump_keys_size = dump_keys.size
+        Redis::Dump.ld "Memory after loading keys: #{Redis::Dump.memory_usage}kb"
+        dump_keys.each_with_index do |key,idx|
+          entry, idxplus = key, idx+1
+          #self.class.ld " #{key} (#{key_dump['type']}): #{key_dump['size'].to_bytes}"
+          #entry_enc = self.class.encoder.encode entry
+          if block_given?
+            chunk_entries << entry
+            process_chunk idx, dump_keys_size do |count|
+              Redis::Dump.ld " dumping #{chunk_entries.size} (#{count}) from #{redis.client.id}"
+              output_buffer = []
+              chunk_entries.select! do |key| 
+                type = Redis::Dump.type(redis, key)
+                if self.class.with_optimizations && type == 'string' 
+                  true
+                else
+                  output_buffer.push self.class.encoder.encode(Redis::Dump.dump(redis, key, type))
+                  false
+                end
+              end
+              unless output_buffer.empty?
+                yield output_buffer 
+              end
+              unless chunk_entries.empty?
+                yield Redis::Dump.dump_strings(redis, chunk_entries) { |obj| self.class.encoder.encode(obj) } 
+              end
+              output_buffer.clear
+              chunk_entries.clear
+            end
+          else
+            entries << self.class.encoder.encode(Redis::Dump.dump(redis, entry))
+          end
+        end
       end
-      values
+      entries
     end
-    def report(&each_record)
+    
+    def process_chunk idx, total_size
+      idxplus = idx+1
+      yield idxplus if (idxplus % self.class.chunk_size).zero? || idxplus >= total_size
+    end
+    private :process_chunk
+    
+    def report filter='*'
       values = []
-      each_key do |this_redis,key|
-        info = Redis::Dump.report this_redis, key
-        self.class.ld " #{key} (#{info['type']}): #{info['size'].to_bytes}"
-        each_record.nil? ? (values << info) : each_record.call(info)
+      total_size, dbs = 0, {}
+      each_database do |redis|
+        chunk_entries = []
+        dump_keys = redis.keys(filter)
+        dump_keys_size = dump_keys.size
+        dump_keys.each_with_index do |key,idx|
+          entry, idxplus = Redis::Dump.report(redis, key), idx+1
+          chunk_entries << entry
+          process_chunk idx, dump_keys_size do |count|
+            Redis::Dump.ld " reporting on #{chunk_entries.size} (#{idxplus}) from #{redis.client.id}"
+            chunk_entries.each do |e|
+              #puts record if obj.global.verbose >= 1
+              dbs[e['db']] ||= 0
+              dbs[e['db']] += e['size']
+              total_size += e['size']
+            end
+            chunk_entries.clear
+          end
+        end
       end
+      puts dbs.keys.sort.collect { |db| "  db#{db}: #{dbs[db].to_bytes}" }
+      puts "total: #{total_size.to_bytes}"
       values
     end
+    
     def load(string_or_stream, &each_record)
       count = 0
       Redis::Dump.ld " LOAD SOURCE: #{string_or_stream}"
@@ -100,10 +138,10 @@ class Redis
           next
         end
         this_redis = redis(obj["db"])
-        Redis::Dump.ld "load[#{this_redis.hash}, #{obj}]"
+        #Redis::Dump.ld "load[#{this_redis.hash}, #{obj}]"
         if each_record.nil? 
           if Redis::Dump.safe && this_redis.exists(obj['key'])
-            Redis::Dump.ld " record exists (no change)"
+            #Redis::Dump.ld " record exists (no change)"
             next
           end
           Redis::Dump.set_value this_redis, obj['key'], obj['type'], obj['value'], obj['ttl']
@@ -125,29 +163,41 @@ class Redis
         info['type'] = type(this_redis, key)
         info['size'] = stringify(this_redis, key, info['type'], info['value']).size
         info['bytes'] = info['size'].to_bytes
-        ld "report[#{this_redis.hash}, #{info}]"
+        #ld "report[#{this_redis.hash}, #{info}]"
         info
       end
-      def dump(this_redis, key)
+      def dump(this_redis, key, type=nil)
+        type ||= type(this_redis, key)
         info = { 'db' => this_redis.client.db, 'key' => key }
         info['ttl'] = this_redis.ttl key
-        info['type'] = type(this_redis, key)
+        info['type'] = type
         info['value'] = value(this_redis, key, info['type'])
         info['size'] = stringify(this_redis, key, info['type'], info['value']).size
-        ld "dump[#{this_redis.hash}, #{info}]"
+        #ld "dump[#{this_redis.hash}, #{info}]"
         info
       end
+      def dump_strings(this_redis, keys)
+        vals = this_redis.mget *keys
+        idx = -1
+        keys.collect { |key|
+          idx += 1
+          info = { 
+            'db' => this_redis.client.db, 'key' => key,
+            'ttl' => this_redis.ttl(key), 'type' => 'string',
+            'value' => vals[idx].to_s, 'size' => vals[idx].to_s.size
+          }
+          block_given? ? yield(info) : info
+        }
+      end
       def set_value(this_redis, key, type, value, expire=nil)
         t ||= type
         send("set_value_#{t}", this_redis, key, value)
         this_redis.expire key, expire if expire.to_s.to_i > 0
       end
       def value(this_redis, key, t=nil)
-        t ||= type
         send("value_#{t}", this_redis, key)
       end
       def stringify(this_redis, key, t=nil, v=nil)
-        t ||= type
         send("stringify_#{t}", this_redis, key, v)
       end
       

data/redis-dump.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "redis-dump"
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Delano Mandelbaum"]
+  s.date = "2012-01-05"
+  s.description = "Backup and restore your Redis data to and from JSON."
+  s.email = "delano@solutious.com"
+  s.executables = ["redis-dump", "redis-load", "redis-report"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    "CHANGES.txt",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION.yml",
+    "bin/redis-dump",
+    "bin/redis-load",
+    "bin/redis-report",
+    "lib/redis/dump.rb",
+    "redis-dump.gemspec",
+    "try/10_redis_dump_try.rb",
+    "try/20_dump_specific_keys_try.rb",
+    "try/db0.json",
+    "try/redis-server.conf"
+  ]
+  s.homepage = "http://github.com/delano/redis-dump"
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "redis-dump"
+  s.rubygems_version = "1.8.10"
+  s.summary = "Backup and restore your Redis data to and from JSON."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<yajl-ruby>, [">= 0.1"])
+      s.add_runtime_dependency(%q<redis>, [">= 2.0"])
+      s.add_runtime_dependency(%q<uri-redis>, [">= 0.4.0"])
+      s.add_runtime_dependency(%q<drydock>, [">= 0.6.9"])
+    else
+      s.add_dependency(%q<yajl-ruby>, [">= 0.1"])
+      s.add_dependency(%q<redis>, [">= 2.0"])
+      s.add_dependency(%q<uri-redis>, [">= 0.4.0"])
+      s.add_dependency(%q<drydock>, [">= 0.6.9"])
+    end
+  else
+    s.add_dependency(%q<yajl-ruby>, [">= 0.1"])
+    s.add_dependency(%q<redis>, [">= 2.0"])
+    s.add_dependency(%q<uri-redis>, [">= 0.4.0"])
+    s.add_dependency(%q<drydock>, [">= 0.6.9"])
+  end
+end
+

data/try/20_dump_specific_keys_try.rb

@@ -27,14 +27,14 @@ Redis::Dump.safe = true
 #=> 5
 
 ## Dump these specific keys
-@rdump.dump(@keys).sort
-#=> ['{"db":0,"key":"gloria:0","ttl":-1,"type":"string","value":"gloria_value[0]","size":15}','{"db":0,"key":"gloria:1","ttl":-1,"type":"string","value":"gloria_value[1]","size":15}','{"db":0,"key":"gloria:2","ttl":-1,"type":"string","value":"gloria_value[2]","size":15}','{"db":1,"key":"nikola:0","ttl":-1,"type":"string","value":"nikola_value[0]","size":15}', '{"db":1,"key":"nikola:1","ttl":-1,"type":"string","value":"nikola_value[1]","size":15}']
+@rdump.dump('*gloria*').sort
+#=> ['{"db":0,"key":"gloria:0","ttl":-1,"type":"string","value":"gloria_value[0]","size":15}','{"db":0,"key":"gloria:1","ttl":-1,"type":"string","value":"gloria_value[1]","size":15}','{"db":0,"key":"gloria:2","ttl":-1,"type":"string","value":"gloria_value[2]","size":15}']
 
 
-## Dump none existent keys
+## Dump none existent keys (NOT SUPPORTED AS OF 0.3.0)
 unknown_keys = [URI.parse("#{@uri_base}/0/unknownkey1"), URI.parse("#{@uri_base}/1/unknownkey2")]
 @rdump.dump(unknown_keys).sort
-#=> ['{"db":0,"key":"unknownkey1","ttl":-1,"type":"none","value":"","size":0}', '{"db":1,"key":"unknownkey2","ttl":-1,"type":"none","value":"","size":0}']
+##=> ['{"db":0,"key":"unknownkey1","ttl":-1,"type":"none","value":"","size":0}', '{"db":1,"key":"unknownkey2","ttl":-1,"type":"none","value":"","size":0}']
 
 
 Redis::Dump.safe = true

metadata

@@ -2,7 +2,7 @@
 name: redis-dump
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-04 00:00:00 -04:00
-default_executable: 
+date: 2012-01-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: yajl-ruby
@@ -78,17 +77,17 @@ files:
 - bin/redis-load
 - bin/redis-report
 - lib/redis/dump.rb
+- redis-dump.gemspec
 - try/10_redis_dump_try.rb
 - try/20_dump_specific_keys_try.rb
 - try/db0.json
 - try/redis-server.conf
-has_rdoc: true
 homepage: http://github.com/delano/redis-dump
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -106,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: redis-dump
-rubygems_version: 1.5.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Backup and restore your Redis data to and from JSON.