oria 0.0.3 → 0.1.0

data/.gitignore

@@ -1 +1,2 @@
+coverage/*
 pkg/*

data/README.markdown

@@ -144,46 +144,34 @@ Which means: **please report any problems you have using the  [Github issue trac
 Benchmarks
 -
 
-I've run some benchmarks comparing Oria to Redis. It's not pretty:
+Want to find out how well Oria will perform compared to existing solutions? Here are a few benchmarks.
 
-	                     user     system      total        real
-	Redis (write):   0.050000   0.020000   0.070000 (  0.115850)
-	Oria (write):    0.140000   0.110000   0.250000 (  1.267912)
-	Redis (read):    0.070000   0.020000   0.090000 (  0.145078)
-	Oria (read):     0.150000   0.110000   0.260000 (  1.247791)
-
-As you can see, Oria is about 10x slower than Redis on my development computer. Even worse, if you run the benchmark like so:
-
-	ruby redis_v_oria.rb 10000
-
-Oria's server will fail to fulfill all of those requests. Scary. Clearly, it needs some serious improvement. Oria will never be
-as performant as something like Redis - it's not meant to be (plus it's written in Ruby, not C). But it could use some reduction
-in overhead, and any help is welcome.
-
-But I knew Oria wouldn't compete with Redis. What about MySQL?
+Here's Redis and Oria:
 
 	                     user     system      total        real
-	MySQL (write):   0.270000   0.030000   0.300000 (  0.445586)
-	Oria (write):    0.170000   0.120000   0.290000 (  1.676674)
-	MySQL (read):    0.310000   0.020000   0.330000 (  0.484944)
-	Oria (read):     0.120000   0.120000   0.240000 (  1.616851)
+	Redis (write):   0.040000   0.020000   0.060000 (  0.112147)
+	Oria (write):    0.130000   0.100000   0.230000 (  0.394356)
+	Redis (read):    0.070000   0.020000   0.090000 (  0.140881)
+	Oria (read):     0.130000   0.100000   0.230000 (  0.394533)
+
+Obviously, Redis is going to smack Oria down no matter what. Still, it's in a competitive range.
 
-Ew. Oria is consistently about 4x slower than MySQL. But check this out: I removed persistence, and here are the new benchmarks:
+Here's MySQL and Oria:
 
 	                     user     system      total        real
-	Redis (write):   0.040000   0.020000   0.060000 (  0.113882)
-	Oria (write):    0.130000   0.100000   0.230000 (  0.396776)
-	Redis (read):    0.070000   0.020000   0.090000 (  0.145068)
-	Oria (read):     0.130000   0.100000   0.230000 (  0.395410)
+	MySQL (write):   0.260000   0.030000   0.290000 (  0.423971)
+	Oria (write):    0.140000   0.100000   0.240000 (  0.406949)
+	MySQL (read):    0.310000   0.020000   0.330000 (  0.468195)
+	Oria (read):     0.100000   0.100000   0.200000 (  0.330884)
 
-That's getting competitive. How about MySQL?
+Oh snap! Oria outperforms MySQL. How about SQLite3, in memory?
 
-	                     user     system      total        real
-	MySQL (write):   0.270000   0.030000   0.300000 (  0.453413)
-	Oria (write):    0.150000   0.110000   0.260000 (  0.430725)
-	MySQL (read):    0.320000   0.030000   0.350000 (  0.484978)
-	Oria (read):     0.100000   0.100000   0.200000 (  0.373431)
+	                      user     system      total        real
+	SQLite3 (write):  0.360000   0.010000   0.370000 (  0.376660)
+	Oria (write):     0.100000   0.100000   0.200000 (  0.368118)
+	SQLite3 (read):   0.370000   0.010000   0.380000 (  0.379038)
+	Oria (read):      0.150000   0.100000   0.250000 (  0.406342)
 
-Oh snap! Oria outperforms MySQL when persistence is disabled. So I'll have to refactor the code.
+Looks like Oria will write faster but read slower than SQLite3 in-memory.
 
 Copyright (c) 2009 Flip Sasser, released under the MIT license

data/Rakefile

@@ -1,5 +1,7 @@
 require 'rake'
 
+task :default => :spec
+
 begin
   require 'spec/rake/spectask'
 

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

data/benchmarks/em_stop_v_disconnect.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'eventmachine'
+require 'eventmachine/client'
+require 'benchmark'
+
+class StopClient < EchoClient
+  def receive_data(data)
+    @response = data
+    EventMachine.stop_event_loop
+  end
+end
+
+client = nil
+n = (ARGV.shift || 1000).to_i
+
+Benchmark.bm(25) do |bm|
+  bm.report("EM (stop_event_loop):") do
+    n.times do
+      EventMachine.run do
+        client = EventMachine.connect "0.0.0.0", 8080, StopClient
+        client.send_data('PUT foo bar')
+      end
+    end
+  end
+
+  bm.report("EM (close_connection):") do
+    n.times do
+      EventMachine.run do
+        client = EventMachine.connect "0.0.0.0", 8080, EchoClient
+        client.send_data('PUT foo bar')
+      end
+    end
+  end
+end

data/benchmarks/eventmachine/client.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'eventmachine'
+
+class EchoClient < EventMachine::Connection
+  attr_reader :response
+
+  def receive_data(data)
+    @response = data
+    close_connection
+  end
+
+  def unbind
+    EventMachine.stop_event_loop
+  end
+end

data/benchmarks/eventmachine/tcp_server.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'eventmachine'
+
+module EchoServer  
+  def receive_data(data)
+    send_data(data)
+  end
+end
+
+EventMachine.run do
+  EventMachine.start_server "0.0.0.0", 8080, EchoServer
+end

data/benchmarks/eventmachine/udp_server.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'eventmachine'
+
+module EchoServer  
+  def receive_data(data)
+    send_data(data)
+  end
+end
+
+EventMachine.run do
+  EventMachine.open_datagram_socket "0.0.0.0", 8080, EchoServer
+end

data/benchmarks/hash_v_redis.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'redis'
+require 'benchmark'
+
+redis = Redis.new
+hash = Hash.new
+n = (ARGV.shift || 1000).to_i
+
+Benchmark.bm(15) do |bm|
+  bm.report("Redis (write):") do
+    n.times do
+      redis['foo'] = 'bar'
+    end
+  end
+
+  bm.report("Hash (write):") do
+    n.times do
+      hash['foo'] = 'bar'
+    end
+  end
+
+  bm.report("Redis (read):") do
+    n.times do
+      foo = redis['foo']
+    end
+  end
+
+  bm.report("Hash (read):") do
+    n.times do
+      foo = hash['foo']
+    end
+  end
+end

data/benchmarks/tcp_v_redis.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'redis'
+require 'eventmachine'
+require 'eventmachine/client'
+require 'benchmark'
+
+redis = Redis.new
+client = nil
+n = (ARGV.shift || 1000).to_i
+
+Benchmark.bm(15) do |bm|
+  bm.report("Redis (write):") do
+    n.times do
+      redis['foo'] = 'bar'
+    end
+  end
+
+  bm.report("Echo (write):") do
+    n.times do
+      EventMachine.run do
+        client = EventMachine.connect "0.0.0.0", 8080, EchoClient
+        client.send_data('PUT foo bar')
+      end
+    end
+  end
+
+  bm.report("Redis (read):") do
+    n.times do
+      foo = redis['foo']
+    end
+  end
+
+  bm.report("Echo (read):") do
+    n.times do
+      EventMachine.run do
+        client = EventMachine.connect "0.0.0.0", 8080, EchoClient
+        client.send_data('GET foo')
+      end
+    end
+  end
+end

data/benchmarks/udp_v_redis.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'redis'
+require 'eventmachine'
+require 'eventmachine/client'
+require 'benchmark'
+
+redis = Redis.new
+client = nil
+n = (ARGV.shift || 1000).to_i
+
+Benchmark.bm(15) do |bm|
+  bm.report("Redis (write):") do
+    n.times do
+      redis['foo'] = 'bar'
+    end
+  end
+
+  bm.report("Echo (write):") do
+    n.times do
+      EventMachine.run do
+        # TODO: Figure out how EM handles connecting TO UDP servers
+        client = EventMachine.open_datagram_socket "0.0.0.0", 0, EchoClient
+        client.send_datagram('GET foo', "0.0.0.0", 8080)
+      end
+    end
+  end
+
+  bm.report("Redis (read):") do
+    n.times do
+      foo = redis['foo']
+    end
+  end
+
+  bm.report("Echo (read):") do
+    n.times do
+      EventMachine.run do
+        client = EventMachine.open_datagram_socket "0.0.0.0", 0, EchoClient
+        client.send_datagram('GET foo', "0.0.0.0", 8080)
+      end
+    end
+  end
+end

data/bin/oria

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 require 'optparse'
 require 'rubygems'
-require 'oria'
-# require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'oria'))
+# require 'oria'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'oria'))
 
 module OriaCommand
   def self.go
@@ -13,6 +13,7 @@ module OriaCommand
       stop
     when 'restart'
       stop
+      sleep 0.5
       start
     else
       puts parser
@@ -27,40 +28,48 @@ module OriaCommand
         @options[:port] = port
       end
       opts.on('-h', '--host [IP]', 'The hostname or IP Oria should listen on.') do |host|
-        @options[:host] = port
+        @options[:host] = host
       end
-      opts.on('-d', '--debug', 'Log output to /tmp/oria.log') do |debug|
-        @options[:debug] = true
+      opts.on('-d', '--daemonize', 'Daemonize the Oria process') do |daemonize|
+        @options[:daemonize] = true
+      end
+      opts.on('-D', '--debug', 'Log output to /tmp/oria.log') do |debug|
+        @options[:debug] ||= true
       end
     end
   end
 
   def self.parse_options
-    @options = {:host => '0.0.0.0', :port => 6851, :debug => false}
+    @options = {:host => '0.0.0.0', :port => Oria.port}
     parser.parse!
   end
 
   def self.start
     puts "Starting Oria..."
     parse_options
-    pid = fork do
-      begin
-        Oria::Server.start(@options[:host], @options[:port], nil, @options[:debug])
-      rescue RuntimeError
-        puts "\nOria cannot attach to port #{@options[:port]}. Maybe it's already running?"
-        exit
-      end
+    start_server = lambda {
+      $0 = "oria #{@options[:host]}:#{@options[:port]}#{' -d' if @options[:daemonize]}"
+      Oria::Server.start(@options[:host], @options[:port], @options[:debug], :puts => !@options[:daemonize])
+    }
+    if @options[:daemonize]
+      pid = fork &start_server
+      Process.detach(pid)
+    else
+      start_server.call
+    end
+    sleep 0.1
+    if Oria::Server.running?
+      puts "Oria listening on #{@options[:host]}:#{@options[:port]}"
     end
-    Process.detach(pid)
-    sleep 0.5
-    puts "Oria started successfull on proccess ##{pid}"
   end
 
   def self.stop
     puts "Stopping Oria..."
-    puts "Stopped!" if Oria::Server.stop
-  rescue Errno::ESRCH
-    puts "Oria does not appear to be running"
+    if Oria::Server.stop
+      puts "Stopped!"
+    else
+      puts "Oria does not appear to be running."
+    end
   end
 end
 

data/lib/oria/client.rb

@@ -8,7 +8,10 @@ module Oria
 
     def receive_data(data)
       @response = JSON.parse(data)
-      close_connection
+      # close_connection
+      # Note: Benchmarks found that calling stop_event_loop is slightly quicker
+      # than close_connection, which navigates the connection closing.
+      EventMachine.stop_event_loop
     end
 
     def unbind

data/lib/oria/server.rb

@@ -1,5 +1,6 @@
 require 'yaml'
 require 'tmpdir'
+
 module Oria
   class Server < EventMachine::Connection
     class << self
@@ -10,7 +11,11 @@ module Oria
       end
 
       def log(value, app_key = nil)
-        logger.debug("#{"#{app_key}: " if app_key}#{value}") if debug?
+        if debug? || @@options[:puts]
+          value = "#{Time.now.strftime('%d %b %H:%M:%S')} - #{"#{app_key}: " if app_key}#{value}"
+          logger.debug(value) if debug?
+          puts value if @@options[:puts]
+        end
       end
 
       def logger
@@ -18,34 +23,49 @@ module Oria
         @@logger ||= Logger.new(log_file, 0, 100 * 1024 * 1024) 
       end
 
-      def start(server, port, app_key = nil, debug = false)
-        at_exit do
-          Oria::Server.stop
-        end
-        pid = Process.pid
-        File.open(pid_file, 'w') do |file|
-          file.puts pid
-        end
-        app_key ||= 'default'
+      def running?
+        pid && !!Process.getpgid(pid)
+      rescue Errno::ESRCH
+        false
+      end
+
+      def start(server, port, debug = false, options = {})
+        @@debug = !!debug
+        @@options = options
+        log "Server started"
         @@servers ||= if File.exists?(yaml_store)
+          log "DB loaded from disk"
           YAML.load_file(yaml_store)
         else
           {}
         end
-        @@debug = !!debug
-        @@servers[app_key] ||= {}
+        pid = Process.pid
         EventMachine.run do
           EventMachine.start_server server, port, Oria::Server
+          File.open(pid_file, 'w') do |file|
+            file.puts pid
+          end
+          log "The server is now ready to accept connections on port #{port}"
         end
       end
 
       def stop
+        response = false
         if File.exists?(pid_file)
-          if pid
-            Process.kill(9, pid)
+          begin
+            if pid
+              Process.kill(9, pid)
+              response = true
+            end
+          rescue Errno::ESRCH
+            # TODO: We perform error reporting elsewhere. Still,
+            # an actionless rescue doesn't seem like a great idea.
+          ensure
+            File.unlink(pid_file)
+            @@pid = nil
           end
-          File.unlink(pid_file)
         end
+        response
       end
 
       def store_hash(app_key)
@@ -120,7 +140,7 @@ module Oria
 
     private
     def hash
-      @hash ||= @@servers[@app_key || 'default'] ||= {}
+      @hash ||= @@servers[@app_key && !@app_key.empty? ? @app_key : 'default'] ||= {}
     end
 
     def random_key

data/lib/oria.rb

@@ -3,6 +3,7 @@ require 'rubygems'
 require 'eventmachine'
 require 'json'
 require 'oria/errors'
+require 'tmpdir'
 
 module Oria
   autoload(:Client, 'oria/client')
@@ -25,34 +26,25 @@ module Oria
     @@app_key = key.to_s
   end
 
-  def self.auto_start
-    @@pid = fork do
-      Oria::Server.start(Oria.server, Oria.port, Oria.app_key)
-    end
-    Process.detach(@@pid)
-    at_exit {
-      Process.kill("HUP", @@pid)
-    }
-    sleep 1
-  end
-
   def self.clear
     store(:delete)
   end
 
-  def self.connect(server, port = nil, options = {})
-    @@server = server
+  def self.connect(server = Oria.server, port = Oria.port, debug = false)
+    @@server = server.to_s
     @@port = port.to_i unless port.to_i == 0
+    unless Oria::Server.running?
+      # That's right. Boot Oria on the command line so we don't bother forking or any
+      # of that other troublesome nonsense. It's smart enough to maintain its own
+      # status and start/stop/restart itself.
+      system("./bin/oria start -d -h #{@@server} -p #{@@port}")
+    end
   end
 
   def self.delete(key)
     store(:delete, :key => key)
   end
 
-  def self.disconnect
-    Oria::Server.stop
-  end
-
   def self.has_key?(key)
     key?(key)
   end
@@ -90,7 +82,13 @@ module Oria
     args = JSON.generate(args)
     do_store(method, args)
   rescue Oria::ConnectionError
-    auto_start
+    # Thanks to ActiveSupport for the "silence_stream" functionality - we're quieting STDOUT
+    # at autoconnect time.
+    old_stream = STDOUT.dup
+    STDOUT.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    STDOUT.sync = true
+    connect
+    STDOUT.reopen(old_stream)
     do_store(method, args)
   end
 end

data/oria.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{oria}
-  s.version = "0.0.3"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Flip Sasser"]
-  s.date = %q{2009-11-23}
+  s.date = %q{2009-11-27}
   s.default_executable = %q{oria}
   s.description = %q{
       Oria (oh-rye-uh) is an in-memory, Ruby-based Key-Value store. It's designed to handle moderate amounts of data quickly
@@ -28,10 +28,17 @@ Gem::Specification.new do |s|
      "README.markdown",
      "Rakefile",
      "VERSION",
-     "benchmarks/mysql_table.sql",
+     "benchmarks/em_stop_v_disconnect.rb",
+     "benchmarks/eventmachine/client.rb",
+     "benchmarks/eventmachine/tcp_server.rb",
+     "benchmarks/eventmachine/udp_server.rb",
+     "benchmarks/hash_v_redis.rb",
+     "benchmarks/mysql_v_oria.rb",
      "benchmarks/redis_v_oria.rb",
-     "benchmarks/sequel_v_oria.rb",
      "benchmarks/sqlite_v_oria.rb",
+     "benchmarks/support/mysql_table.sql",
+     "benchmarks/tcp_v_redis.rb",
+     "benchmarks/udp_v_redis.rb",
      "bin/oria",
      "lib/oria.rb",
      "lib/oria/client.rb",

data/spec/oria_spec.rb

@@ -28,128 +28,125 @@ describe Oria do
     end
   end
 
-  it "should provide a connect method" do
-    Oria.should respond_to(:connect)
-  end
-
-  it "should support per-app keys" do
-    Oria.should respond_to(:app_key)
-    Oria.should respond_to(:app_key=)
-  end
+  describe "class methods" do
+    it "should provide a connect method" do
+      Oria.should respond_to(:connect)
+    end
 
-  it "should support custom connections" do
-    Oria.connect("127.0.0.1", 4567)
-    Oria.server.should == "127.0.0.1"
-    Oria.port.should == 4567
-  end
+    it "should support per-app keys" do
+      Oria.should respond_to(:app_key)
+      Oria.should respond_to(:app_key=)
+    end
 
-  it "should automatically boot a server" do
-    # Oria.should_receive(:auto_start)
-    # Oria["foo"] = "bar"
-    # Oria.disconnect
+    it "should support custom connections" do
+      Oria.connect("127.0.0.1", 4567)
+      Oria.server.should == "127.0.0.1"
+      Oria.port.should == 4567
+      Oria::Server.stop
+      sleep 1
+    end
   end
 
   describe "app_key" do
     # it "should default to nil" do
     #   # This is bleeding over from the last example below. Frankly,
-    #   # I don't know how to fix it.
+    #   # I don't know how to fix it. I'm unclear on separating
+    #   # Rspec examples from each other at the class level like
+    #   # this.
     #   Oria.app_key.should be_nil
     # end
-
+  
     it "should be configurable" do
       Oria.app_key = "test_app"
       Oria.app_key.should == "test_app"
     end
   end
+  
+  describe "setting values" do
+    before :all do
+      Oria.connect
+      sleep 1
+    end
 
-  it "should be possible to disconnect" do
-    Oria::Server.should_receive(:stop)
-    Oria["foo"] = "bar"
-    Oria.disconnect
-  end
+    after :all do
+      # TODO: In general, I find "sleep" to be a terrible method of doing anything.
+      # Still, it gets the job done, albeit by delaying our specs.
+      Oria::Server.stop
+      sleep 0.5
+    end
+    
+    it "should set string values" do
+      Oria["foo"] = "bar"
+      Oria["foo"].should == "bar"
+    end
 
-  describe "setting values" do
-    describe "with a booted server" do
-      before :all do
-        @pid = fork do
-          Oria::Server.start(Oria.server, Oria.port, nil, true)
-        end
-        Process.detach(@pid)
-        sleep 0.5
-      end
-  
-      after :all do
-        Oria.clear
-        Oria::Server.stop
-        Process.kill("HUP", @pid)
-      end
-  
-      it "should set string values" do
-        Oria["foo"] = "bar"
-        Oria["foo"].should == "bar"
-      end
-  
-      it "should set integer values" do
-        Oria["foo"] = 12
-        Oria["foo"].should == 12
-      end
-  
-      it "should support Hashes" do
-        Oria["foo"] = {"Flip" => "Sasser"}
-        Oria["foo"].should == {"Flip" => "Sasser"}
-      end
-  
-      it "should support Arrays" do
-        Oria["foo"] = ["Foo", "Bar", "Baz"]
-        Oria["foo"].should == ["Foo", "Bar", "Baz"]
-      end
-  
-      it "should support Booleans" do
-        Oria["true"] = false
-        Oria["true"].should == false
-      end
-  
-      it "should support deleting values" do
-        Oria["memoria"] = "foobar"
-        Oria["dont_delete"] = "please"
-        Oria.delete("memoria").should == "foobar"
-        Oria["memora"].should be_nil
-        Oria["dont_delete"].should == "please"
-      end
-  
-      it "should support complete clearing" do
-        Oria["a"] = "c"
-        Oria["b"] = "d"
-        Oria["a"].should == "c"
-        Oria["b"].should == "d"
-        Oria.clear
-        Oria["a"].should be_nil
-        Oria["b"].should be_nil
-      end
-  
-      it "should support key-checking" do
-        Oria["key_check"] = "check-a-key"
-        Oria.key?("key_check").should be_true
-        Oria.key?("key_check_broken").should be_false
-        Oria.has_key?("key_check").should be_true
-        Oria.has_key?("key_check_broken").should be_false
-      end
-  
-      it "should support stashing" do
-        key = Oria.stash("foobar")
-        key.should_not be_nil
-        Oria[key].should == "foobar"
-      end
-  
-      it "should support different app_keys" do
-        Oria.app_key = "test_app_1"
-        Oria["test_app_1"] = "bar"
-        Oria["test_app_1"].should == "bar"
-        Oria.app_key = "test_app_2"
-        Oria["test_app_2"] = "baz"
-        Oria["test_app_1"].should be_nil
-        Oria["test_app_2"].should == "baz"
-      end
+    it "should set integer values" do
+      Oria["foo"] = 12
+      Oria["foo"].should == 12
+    end
+
+    it "should support Hashes" do
+      Oria["foo"] = {"Flip" => "Sasser"}
+      Oria["foo"].should == {"Flip" => "Sasser"}
+    end
+
+    it "should support Arrays" do
+      Oria["foo"] = ["Foo", "Bar", "Baz"]
+      Oria["foo"].should == ["Foo", "Bar", "Baz"]
+    end
+
+    it "should support Booleans" do
+      Oria["true"] = false
+      Oria["true"].should == false
+    end
+
+    it "should support deleting values" do
+      Oria["memoria"] = "foobar"
+      Oria["dont_delete"] = "please"
+      Oria.delete("memoria").should == "foobar"
+      Oria["memora"].should be_nil
+      Oria["dont_delete"].should == "please"
+    end
+
+    it "should support complete clearing" do
+      Oria["a"] = "c"
+      Oria["b"] = "d"
+      Oria["a"].should == "c"
+      Oria["b"].should == "d"
+      Oria.clear
+      Oria["a"].should be_nil
+      Oria["b"].should be_nil
+    end
+
+    it "should support key-checking" do
+      Oria["key_check"] = "check-a-key"
+      Oria.key?("key_check").should be_true
+      Oria.key?("key_check_broken").should be_false
+      Oria.has_key?("key_check").should be_true
+      Oria.has_key?("key_check_broken").should be_false
+    end
+
+    it "should support stashing" do
+      key = Oria.stash("foobar")
+      key.should_not be_nil
+      Oria[key].should == "foobar"
+    end
+
+    it "should support different app_keys" do
+      Oria.app_key = "test_app_1"
+      Oria["test_app_1"] = "bar"
+      Oria["test_app_1"].should == "bar"
+      Oria.app_key = "test_app_2"
+      Oria["test_app_2"] = "baz"
+      Oria["test_app_1"].should be_nil
+      Oria["test_app_2"].should == "baz"
     end
   end
+
+  # it "should automatically boot a server" do
+  #   Oria.should_receive(:connect)
+  #   Oria["foo"] = "bar"
+  #   Oria["foo"].should == "bar"
+  #   Oria::Server.stop
+  # end
 end

data/spec/spec_helper.rb

@@ -1,2 +1,7 @@
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 
+def start_server(debug = false)
+  fork do
+    Oria::Server.start(Oria.server, Oria.port, debug)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: oria
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Flip Sasser
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-23 00:00:00 -05:00
+date: 2009-11-27 00:00:00 -05:00
 default_executable: oria
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,10 +47,17 @@ files:
 - README.markdown
 - Rakefile
 - VERSION
-- benchmarks/mysql_table.sql
+- benchmarks/em_stop_v_disconnect.rb
+- benchmarks/eventmachine/client.rb
+- benchmarks/eventmachine/tcp_server.rb
+- benchmarks/eventmachine/udp_server.rb
+- benchmarks/hash_v_redis.rb
+- benchmarks/mysql_v_oria.rb
 - benchmarks/redis_v_oria.rb
-- benchmarks/sequel_v_oria.rb
 - benchmarks/sqlite_v_oria.rb
+- benchmarks/support/mysql_table.sql
+- benchmarks/tcp_v_redis.rb
+- benchmarks/udp_v_redis.rb
 - bin/oria
 - lib/oria.rb
 - lib/oria/client.rb