oria 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Flip Sasser
+
+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.markdown

@@ -0,0 +1,133 @@
+Oria
+===
+
+Oria (oh-rye-uh) is an in-memory, Ruby-based Key-Value Store. It's designed to handle moderate amounts of data quickly
+and easily without causing deployment issues or server headaches. It uses EventMachine to provide a networked interface
+to a semi-persistent KVS and asynchronously writes the in-memory data to YAML files.
+
+Installation
+-
+
+Oria is a provided as a Gem. Use the following command to install it:
+
+	gem install oria --source http://gemcutter.org
+
+That's it! You're ready to start storing basic data in memory. Now add
+
+	require "oria"
+
+so's you can access Oria.
+
+Command Line
+-
+
+The recommended pattern for starting and stopping Oria is using the Oria command line application, like so:
+
+	$ oria start|stop|restart
+
+That's it! Oria will run in-memory, and you can always shut it down using `oria stop`.
+
+Auto-Start and Daeomonizing 
+-
+
+Yes, I recommend you use the command line. But on _[certain platforms](http://heroku.com)_, you don't have access to the
+command line. And since Oria was built to be simple to use and to deploy, it also supports auto-starting and stopping. It
+will detect a downed server and boot itself up in a separate thread. I should warn you, however: this functionality means
+Oria requires a *nix environment - sorry, IronRuby users!
+
+Oria auto-starts transparently, so just use it normally to take advantage of this feature. **Note:** this feature is currently
+untested, so please test it heavily before deploying, and _report any issues you may have!_
+
+Usage
+-
+
+Okay, now for the fun part. Oria behaves (mostly) like a Hash - you could say that it responds to 2/3 of @wycats' Moneta
+plugin. Specifically, it responds to the following Hash methods:
+
+	[]=(value)			Set a key to ... something.
+	
+	[]					Retrieve a key
+	
+	delete(key)			Delete and return a key's value
+	
+	key?(key)			Returns a boolean value for whether or not that key exists
+	
+	has_key?(key)		Same as key
+	
+	clear				Clears all keys and values from Oria
+
+In addition to those methods, Oria also supports a cool option inspired by some other KVS's:
+
+	stash(value)		Stash a value in Oria. Returns the randomly generated key it stored the value under. This
+						is useful for when you need to store something temporarily, e.g. stash it, pass the key
+						in a URL, and retrieve / delete it.
+
+So let's play:
+
+	Oria[:foo] = 'bar'	#=> "bar"
+	Oria[:foo] 			#=> "bar"
+	Oria.key?(:foo) 	#=> true
+	Oria.delete(:foo) 	#=> foo
+	Oria[:foo] 			#=> nil
+	Oria.stash("baz") 	#=> "wZ"
+
+Nothing exciting? Try shutting your app down and booting it back up.
+
+	Oria[:wZ]			#=> "baz"
+
+Bam. A relatively fast KVS with no configuration or special server setup.
+
+But wait, I stored a <Ruby-specific object>! WTF?
+-
+
+Ah yes. You've found Oria's Achilles heel. Oria speaks JSON, so everything you give it must be capable of JSON'ing.
+That means `Oria[:user] = User.find(1)` ain't working any time soon. Likewise, and perhaps more unfortunately, things like
+`Oria[:my_cool_hash] = {:key => "Key!!!!!1", :value => "valyooooo"}` are going to return `{"key" => "Key", etc...}` so
+your hashes are going to respond to string keys and not symbols once they've been through Oria.
+
+It's a bummer, I know. But this is an in-memory KVS, and not Rails sessions where we're marshaling and un-marshaling everything
+every request. I realize that it'll most likely only ever speak to Ruby clients (specifically this one), but this is where
+it is. Sorry.
+
+Configuration
+-
+
+Oria is built the be configuration-less out of the box, but if you really need to, you can tell it to do lots of
+things. It's built on top of EventMachine, so networking is an option - but if you're networking your KVS, you should
+think about upgrading to something like Redis or Memcached. Oria is meant to be used in situations where a database OR
+a high-powered KVS would be overkill. But then again, you can use Oria to decentralize some of your tasks over a network,
+which is fun. Observe:
+
+	Oria.connect(server, port)		Connect to a server / port. Defaults to localhost and 6851
+
+	Oria.disconnect					Kills the running server... maybe (see command line vs auto-start above)
+
+	Oria.app_key = value			Oria supports "splitting" your apps, much like how Resque supports named queues. Specifying an
+									app key will effectively change the hash you are working with. It defaults to "default," cause
+									I'm original like that.
+
+Let's try it out:
+
+	Oria.app_key = "my_app_1"
+	Oria[:foo] = "bar"
+	Oria[:foo] #=> "bar"
+
+	Oria.app_key = "my_app_2"
+	Oria[:foo] #=> nil
+	Oria.app_key = "my_app_1"
+	Oria[:foo] #=> "bar"
+
+Dependencies
+-
+
+Oria speaks JSON, so it relies on the JSON gem. It depends on the newest stable version (1.2.0), so be sure to add the right version
+checking code to your legacy apps before using Oria!
+
+It also needs [EventMachine](http://github.com/eventmachine/eventmachine) to do everything. Yes, I could have used Drb or straight
+UDP sockets, and spent a lifetime on this. But EventMachine is seriously, seriously, seriously awesome, and works very well
+without me writing an insane amount of code I couldn't write very well anyway. Check it out and see for yourself.
+
+That's it! I hope you enjoy Oria, and please let me know if you find any issues or have any trouble. As you will no doubt see from
+the current version information, it's a very young project, and any contribution is welcome.
+
+Copyright (c) 2009 Flip Sasser, released under the MIT license

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+
+begin
+  require 'spec/rake/spectask'
+
+  desc "Run all examples"
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = FileList['spec/**/*.rb']
+  end
+
+  desc "Run all examples with RCov"
+  Spec::Rake::SpecTask.new('spec:rcov') do |t|
+    t.spec_files = FileList['spec/**/*.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec,gem']
+  end
+rescue LoadError
+  puts "Could not load Rspec. To run tests, use `gem install rspec`"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "oria"
+    gemspec.summary = "A Ruby-based, in-memory KVS with one half of the peristence you want"
+    gemspec.description = %{
+      Oria (oh-rye-uh) is an in-memory, Ruby-based Key-Value store. It's designed to handle moderate amounts of data quickly
+      and easily without causing deployment issues or server headaches. It uses EventMachine to provide a networked interface
+      to a semi-persistent KVS and asynchronously writes the in-memory data to YAML files.
+    }
+    gemspec.email = "flip@x451.com"
+    gemspec.homepage = "http://github.com/flipsasser/oria"
+    gemspec.authors = ["Flip Sasser"]
+    gemspec.add_dependency('eventmachine', '>= 0.12.10')
+    gemspec.add_dependency('json', '>= 1.2.0')
+  end
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/oria

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# require 'oria'
+
+# Oria.run!

data/lib/oria/client.rb

@@ -0,0 +1,19 @@
+module Oria
+  class Client < EventMachine::Connection
+    attr_reader :response
+
+    def connection_completed
+      @connected = true
+    end
+
+    def receive_data(data)
+      @response = JSON.parse(data)
+      close_connection
+    end
+
+    def unbind
+      raise Oria::ConnectionError.new("Could not connect to the Oria server") unless @connected
+      EventMachine.stop_event_loop
+    end
+  end
+end

data/lib/oria/errors.rb

@@ -0,0 +1,4 @@
+module Oria
+  class ConnectionError < StandardError
+  end
+end

data/lib/oria/server.rb

@@ -0,0 +1,111 @@
+require 'yaml'
+require 'tmpdir'
+module Oria
+  class Server < EventMachine::Connection
+    class << self
+      def debug?
+        @@debug
+      end
+
+      def logger
+        require 'logger'
+        @@logger ||= Logger.new(log_file, 0, 100 * 1024 * 1024) 
+      end
+
+      def start(server, port, app_key = nil, debug = false)
+        @@pid = Process.pid
+        app_key ||= 'default'
+        @@servers ||= if File.exists?(yaml_store)
+          YAML.load_file(yaml_store)
+        else
+          {}
+        end
+        @@debug = !!debug
+        @@servers[app_key] ||= {}
+        EventMachine.run do
+          EventMachine.start_server server, port, Oria::Server
+        end
+      end
+
+      def stop
+        Process.kill('HUP', @@pid) if defined?(@@pid)
+      end
+
+      def write_hash
+        @@write_hash ||= proc do
+          File.open(yaml_store, 'w') do |store|
+            store.puts YAML.dump(@@servers)
+          end
+        end
+      end
+
+      protected
+      def log_file
+        @@log_file ||= File.join(Dir.tmpdir, 'oria.log')
+      end
+
+      def yaml_store
+        @@yaml_store ||= File.join(Dir.tmpdir, 'oria.yml')
+      end
+    end
+
+    def post_init
+      log "Client connected"
+    end
+
+    def receive_data(data)
+      log "Responding to #{data}"
+      data = data.split(' ')
+      method = data.shift
+      data = JSON.parse(data.join(' '))
+      @app_key = data.delete('app_key')
+      case method
+      when 'GET'
+        response = hash[data['key']]
+      when 'DELETE'
+        if data.empty?
+          hash.clear
+        else
+          response = hash.delete(data['key'])
+        end
+      when 'PUT'
+        if data.key?('key')
+          hash[data['key']] = data['value']
+          response = data['value']
+        elsif data.key?('value')
+          response = random_key
+          hash[response] = data['value']
+        end
+      end
+      if defined?(response)
+        response = JSON.generate({:response => response})
+        log "Sending response: #{response}"
+        send_data response
+      end
+      EventMachine.defer(Oria::Server.write_hash)
+    end
+
+    def unbind
+    end
+
+    private
+    def hash
+      @hash ||= @@servers[@app_key || 'default'] ||= {}
+    end
+
+    def log(value)
+      if Oria::Server.debug?
+        Oria::Server.logger.debug(value)
+      end
+    end
+
+    def random_key
+      chars = ['a'..'z', 'A'..'Z', 0..9].map(&:to_a).flatten
+      max = [hash.length, 2].max
+      while hash.key?(key = (1..max).map{|i| chars[rand(chars.length)]}.join)
+        key = (1..max).map{|i| chars[rand(chars.length)]}.join
+      end
+      key
+    end
+  end
+end

data/lib/oria.rb

@@ -0,0 +1,96 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+require 'rubygems'
+require 'eventmachine'
+require 'json'
+require 'oria/errors'
+
+module Oria
+  autoload(:Client, 'oria/client')
+  autoload(:Server, 'oria/server')
+
+  def self.[](key)
+    store(:get, :key => key)
+  end
+
+  def self.[]=(key, value)
+    store(:put, :key => key, :value => value)
+    value
+  end
+
+  def self.app_key
+    @@app_key ||= nil
+  end
+
+  def self.app_key=(key)
+    @@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
+    @@port = port.to_i unless port.to_i == 0
+  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
+
+  def self.key?(key)
+    !self.[](key).nil?
+  end
+
+  def self.port
+    @@port ||= "Oria is easily the coolest in-memory, super-simple KVS. Cool people use it.".split("").inject(0) {|total, char| total += char[0]}
+  end
+
+  def self.server
+    @@server ||= '0.0.0.0'
+  end
+
+  def self.stash(value)
+    store(:put, :value => value)
+  end
+
+  private
+  def self.do_store(method, args)
+    client = nil
+    EventMachine.run do
+      client = EventMachine.connect(Oria.server, Oria.port, Oria::Client)
+      client.send_data("#{method.to_s.upcase}#{" #{args}" if args}")
+    end
+    if client.response
+      client.response['response']
+    end
+  end
+
+  def self.store(method, args = {})
+    args.merge!(:app_key => Oria.app_key)
+    args = JSON.generate(args)
+    do_store(method, args)
+  rescue Oria::ConnectionError
+    auto_start
+    do_store(method, args)
+  end
+end

data/spec/oria_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "oria"
+
+describe Oria do
+  describe "Moneta methods" do
+    it "should include []" do
+      Oria.should respond_to(:[])
+    end
+
+    it "should include []=" do
+      Oria.should respond_to(:[]=)
+    end
+
+    it "should include clear" do
+      Oria.should respond_to(:clear)
+    end
+
+    it "should include delete" do
+      Oria.should respond_to(:delete)
+    end
+
+    it "should include has_key?" do
+      Oria.should respond_to(:has_key?)
+    end
+
+    it "should include key?" do
+      Oria.should respond_to(:key?)
+    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
+
+  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 automatically boot a server" do
+    # Oria.should_receive(:auto_start)
+    # Oria["foo"] = "bar"
+    # Oria.disconnect
+  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.
+    #   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
+
+  it "should be possible to disconnect" do
+    Oria::Server.should_receive(:stop)
+    Oria["foo"] = "bar"
+    Oria.disconnect
+  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
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1 @@
+--exclude "spec/*,gems/*"

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: oria
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Flip Sasser
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-22 00:00:00 -05:00
+default_executable: oria
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.10
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+description: "\n      Oria (oh-rye-uh) is an in-memory, Ruby-based Key-Value store. It's designed to handle moderate amounts of data quickly\n      and easily without causing deployment issues or server headaches. It uses EventMachine to provide a networked interface\n      to a semi-persistent KVS and asynchronously writes the in-memory data to YAML files.\n    "
+email: flip@x451.com
+executables: 
+- oria
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- bin/oria
+- lib/oria.rb
+- lib/oria/client.rb
+- lib/oria/errors.rb
+- lib/oria/server.rb
+- spec/oria_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/flipsasser/oria
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Ruby-based, in-memory KVS with one half of the peristence you want
+test_files: 
+- spec/oria_spec.rb
+- spec/spec_helper.rb