boned 0.2.0

data/CHANGES.txt

@@ -0,0 +1,5 @@
+BONED, CHANGES
+
+#### 0.1.0 (2009-12-13) ###############################
+
+Initial release

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Solutious Inc, Delano Mandelbaum
+
+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.md

@@ -0,0 +1,32 @@
+## Bone - 0.2 ##
+
+**Bones it!**
+
+
+== Running
+    
+    $ redis-server config/redis-server.conf
+    $ boned start
+    
+    
+== Installation
+
+    $ sudo gem install boned
+    
+
+== More Information
+
+
+== Credits
+
+* Delano Mandelbaum (http://solutious.com)
+
+
+== Thanks 
+
+* Kalin Harvey for the early feedback. 
+
+
+== License
+
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1,55 @@
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'hanna/rdoctask'
+require 'rake/testtask'
+require 'shoulda/tasks'
+require 'rake/runtest'
+require 'fileutils'
+include FileUtils
+ 
+task :default => :test
+
+
+# PACKAGE =============================================================
+
+name = "boned"
+load "#{name}.gemspec"
+
+version = @spec.version
+
+Rake::GemPackageTask.new(@spec) do |p|
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :test do
+  puts "Success!"
+end
+
+task :install => [ :rdoc, :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{name}}
+end
+
+
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'doc'
+	t.title    = @spec.summary
+	t.options << '--line-numbers' <<  '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('LICENSE.txt')
+	t.rdoc_files.include('README.md')
+	t.rdoc_files.include('CHANGES.txt')
+	#t.rdoc_files.include('Rudyfile')  # why is the formatting f'd?
+	t.rdoc_files.include('bin/*')
+	t.rdoc_files.include('lib/**/*.rb')
+end
+
+CLEAN.include [ 'pkg', '*.gem', '.config', 'doc', 'coverage*' ]
+
+
+

data/bin/boned

@@ -0,0 +1,72 @@
+#!/usr/bin/ruby
+
+# = Boned
+# 
+#
+# Usage:
+# 
+#     $ boned -h
+#     $ boned [-d] start-master
+#
+#--
+
+# Put our local lib in first place
+BASE_PATH = File.expand_path File.join(File.dirname(__FILE__), '..')
+lib_dir = File.join(BASE_PATH, 'lib')
+$:.unshift lib_dir  
+#$:.unshift '/Users/delano/Projects/opensource/drydock/lib'
+
+require 'drydock'
+require 'boned'
+require 'boned/cli'
+
+# Command-line interface for bin/stella
+class Boned::CLI::Definition
+  extend Drydock
+
+  debug :off
+  
+  default :info
+  
+  global :V, :version, "Display version" do
+    puts "Boned: #{Boned::VERSION} (api: #{Boned::APIVERSION})"
+    exit
+  end
+  
+  global :R, :rackup, String, "Specify a rackup file"
+  global :e, :environment, String, "Rack environment"
+  global :v, :verbose, "Increase output" do; 1 end
+  global :d, :daemon, "Run as a daemon"
+  global :p, :port, Integer, "Port to run on"
+  global :D, :debug do
+    Drydock.debug true
+    Boned.enable_debug
+  end
+  
+  command :start => Boned::CLI
+  command :stop => Boned::CLI
+  command :info => Boned::CLI
+  
+end
+
+  
+begin
+  Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+rescue Boned::Problem => ex
+  STDERR.puts ex.message
+  STDERR.puts ex.backtrace if Drydock.debug?
+  exit 1
+rescue Drydock::ArgError, Drydock::OptError => ex
+  STDERR.puts ex.message
+  STDERR.puts ex.usage
+rescue Drydock::InvalidArgument => ex
+  STDERR.puts ex.message
+rescue Drydock::UnknownCommand => ex
+  STDERR.puts "Unknown command: %s" % ex.name
+rescue Interrupt
+  puts $/, "Exiting... "
+  exit 1
+rescue => ex
+  STDERR.puts "ERROR (#{ex.class.to_s}): #{ex.message}"
+  STDERR.puts ex.backtrace if Drydock.debug?
+end

data/boned.gemspec

@@ -0,0 +1,45 @@
+@spec = Gem::Specification.new do |s|
+  s.name = "boned"
+  s.rubyforge_project = 'boned'
+  s.version = "0.2.0"
+  s.summary = "Get Bones"
+  s.description = s.summary
+  s.author = "Delano Mandelbaum"
+  s.email = "delano@solutious.com"
+  s.homepage = ""
+  
+  s.extra_rdoc_files = %w[README.md LICENSE.txt CHANGES.txt]
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]
+  s.require_paths = %w[lib]
+  
+  s.executables = %w[boned]
+  
+  # = MANIFEST =
+  # git ls-files
+  s.files = %w(
+  LICENSE.txt
+  README.md
+  Rakefile
+  bin/boned
+  boned.gemspec
+  config/redis-default.yml
+  config/redis-server-default.conf
+  config/stella/api-set.rb
+  config/stella/api.rb
+  lib/boned.rb
+  lib/boned/api.rb
+  lib/boned/api/debug.rb
+  lib/boned/api/redis.rb
+  lib/boned/api/service.rb
+  lib/boned/cli.rb
+  lib/boned/models.rb
+  lib/boned/models/bone.rb
+  lib/boned/server.rb
+  public/index.html
+  try/10_bone_model.rb
+  views/redisviewer/keys.erb
+  )
+
+  
+end

data/config/redis-default.yml

@@ -0,0 +1,14 @@
+:development: 
+#  :password: e89da64b29cf622e7c0fa545b537d7
+  :host: localhost
+  :port: "6379"
+  :db: 1
+  :timeout: 5
+  :thread_safe: true
+:production: 
+#  :password: e89da64b29cf622e7c0fa545b537d7
+  :host: localhost
+  :port: "6379"
+  :db: 0
+  :timeout: 5
+  :thread_safe: true

data/config/redis-server-default.conf

@@ -0,0 +1,171 @@
+# 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 no
+
+# 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 /var/run/redis.pid
+
+# Accept connections on the specified port, default is 6379
+port 6379
+
+# 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 ./
+
+# 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>
+
+############################## APPEND ONLY MODE ###############################
+
+# By default Redis asynchronously dumps the dataset on disk. If you can live
+# with the idea that the latest records will be lost if something like a crash
+# happens this is the preferred way to run Redis. If instead you care a lot
+# about your data and don't want to that a single record can get lost you should
+# enable the append only mode: when this mode is enabled Redis will append
+# every write operation received in the file appendonly.log. This file will
+# be read on startup in order to rebuild the full dataset in memory.
+#
+# Note that you can have both the async dumps and the append only file if you
+# like (you have to comment the "save" statements above to disable the dumps).
+# Still if append only mode is enabled Redis will load the data from the
+# log file at startup ignoring the dump.rdb file.
+#
+# The name of the append only file is "appendonly.log"
+
+appendonly no
+
+# The fsync() call tells the Operating System to actually write data on disk
+# instead to wait for more data in the output buffer. Some OS will really flush 
+# data on disk, some other OS will just try to do it ASAP.
+#
+# Redis supports three different modes:
+#
+# no: don't fsync, just let the OS flush the data when it wants. Faster.
+# always: fsync after every write to the append only log . Slow, Safest.
+# everysec: fsync only if one second passed since the last fsync. Compromise.
+#
+# The default is "always" that's the safer of the options. It's up to you to
+# understand if you can relax this to "everysec" that will fsync every second
+# or to "no" that will let the operating system flush the output buffer when
+# it want, for better performances (but if you can live with the idea of
+# some data loss consider the default persistence mode that's snapshotting).
+
+appendfsync always
+# appendfsync everysec
+# appendfsync no
+
+############################### 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/config/stella/api-set.rb

@@ -0,0 +1,32 @@
+
+
+usecase "Set" do
+  set :key    => :simple
+  set :token    => '1901484c41b8752d61863e323c743abe2c6e90f8841bbdfa789e1d70bc6f4899'
+  
+  get "/v1/set/:key" do
+    set :value => (rand*100000).to_i
+    param :token    => resource(:token)
+    param :value  => resource(:value)
+  end
+  
+  get "/v1/get/:key" do
+    param :token    => resource(:token)
+    response 200 do
+      p [resource(:value), body.to_i]
+    end
+  end
+  
+  get "/v1/set/:key" do
+    param :key => rand(1000).to_i
+    set :value => (rand*100000).to_i
+    param :token    => resource(:token)
+    param :value  => resource(:value)
+  end
+  
+  xpost "/v1/set/:key" do
+    param :key    => :file
+    body file('/tmp/file')
+  end
+  
+end

data/config/stella/api.rb

@@ -0,0 +1,51 @@
+
+
+usecase do
+  set :token    => '1901484c41b8752d61863e323c743abe2c6e90f8841bbdfa789e1d70bc6f4899'
+  set :key    => :simple
+  
+  post "/v1/set/:key" do
+    set :value => (rand*100000).to_i
+    param :token    => resource(:token)
+    param :value  => resource(:value)
+  end
+  
+  get "/v1/get/:key" do
+    param :token    => resource(:token)
+    response 200 do
+      p [resource(:value), body.to_i]
+    end
+  end
+  
+  post "/v1/set/:key" do
+    param :key => 'rand(1000).to_i'
+    set :value => (rand*100000).to_i
+    param :token    => resource(:token)
+    param :value  => resource(:value)
+  end
+  
+  xpost "/v1/set/:key" do
+    param :key    => :file
+    body file('/tmp/file')
+  end
+  
+  get "/v1/keys/:key" do
+    param :token => resource(:token)
+  end
+  
+  get "/v1/keys" do
+    param :token => resource(:token)
+  end
+  
+  delete "/v1/del/:key" do
+    header :'X-BONE-TOKEN' => resource(:token)
+  end
+  
+  get "/v1/get/:key" do
+    param :token => resource(:token)
+    response 404 do
+      # This is the correct response so don't fail
+    end
+  end
+  
+end

data/lib/boned/api/debug.rb

@@ -0,0 +1,21 @@
+
+class Boned::API::Debug < Boned::API
+  set :public => 'public/debug/'
+  set :views => 'views/debug/'
+  
+  not_found do
+    'not found'
+  end
+  
+  get '/env/?' do
+    content_type 'text/plain'
+    env.to_yaml
+  end
+  
+  get '/slideshow' do
+    content_type 'text/html'
+    erb :slideshow
+  end
+end
+
+

data/lib/boned/api/redis.rb

@@ -0,0 +1,44 @@
+
+
+class Boned::API::RedisViewer < Boned::API
+
+  set :public => 'public/'
+  set :views => 'views/redisviewer/'
+  
+  before do
+    content_type 'text/html' 
+  end
+  
+  get '/list/:name' do
+    Boned.redis.lrange(params[:name], 0, -1).to_yaml
+  end
+  
+  get '/smembers/:name' do
+    Boned.redis.smembers(params[:name]).to_yaml
+  end
+  
+  get '/opts' do
+    Boned.redis_opts.to_yaml
+  end
+
+  get '/get/:name' do
+    '%s=%s' % [params[:name], Boned.redis.get(params[:name])]
+  end
+  
+  get '/:key' do
+    @keys = Boned.redis.keys("*#{params[:key]}*")
+    erb :keys
+  end
+  
+  get '/?' do
+    @keys = Boned.redis.keys("*")
+    erb :keys
+  end
+  
+  
+  helpers do
+    def key_kind(key)
+      Boned.redis.type key
+    end
+  end
+end

data/lib/boned/api/service.rb

@@ -0,0 +1,86 @@
+require 'pp'
+
+#     /get/bashrc?path=/Users/delano/&env=development&role=fe&token=1901484c41b8752d61863e323c743abe2c6e90f8841bbdfa789e1d70bc6f4899
+#     /set/bashrc?value=1000&path=/Users/delano/&env=development&role=fe&token=1901484c41b8752d61863e323c743abe2c6e90f8841bbdfa789e1d70bc6f4899
+#
+class Boned::API::Service < Boned::API
+  set :public => 'public/'
+  set :views => 'views/'
+  
+  error do
+    "Bad bone rising"
+  end
+  
+  get '/' do
+    'Throw me a fricken bone'
+  end
+  
+  get '/rev/?' do
+    Boned::VERSION.inspect
+  end
+  
+  get '/get/:key/?' do
+    carefully do
+      assert_params :key
+      assert_exists current_token, "No token"
+      assert_sha256 current_token
+      bone = Bone.get current_token, params[:key], params
+      bone.value
+    end
+  end
+  
+  post '/set/:key/?' do
+    carefully do
+      assert_params :key, :value
+      assert_exists current_token, "No token"
+      assert_sha256 current_token
+      bone = Bone.new current_token, params[:key], params[:value], params
+      bone.save
+    end
+    params[:value]
+  end
+  
+  delete "/del/:key/?" do
+    carefully do
+      assert_params :key
+      assert_exists current_token, "No token"
+      assert_sha256 current_token
+      bone = Bone.del current_token, params[:key], params
+      bone.value
+    end
+  end
+  
+  get '/keys/:key' do
+    carefully do
+      assert_params :key
+      assert_exists current_token, "No token"
+      assert_sha256 current_token
+      keys = Bone.keys current_token, params[:key]
+      keys.join($/)
+    end
+  end
+  
+  get '/keys/?' do
+    carefully do
+      assert_exists current_token, "No token"
+      assert_sha256 current_token
+      keys = Bone.keys current_token, '*'
+      keys.join($/)
+    end
+  end
+  
+  #post '/set/:key/?' do
+  #  carefully do
+  #    assert_params :key
+  #    assert_sha256 current_token
+  #    #assert_exists current_token
+  #    #key, filter, path = params.values_at :key, :filter, :path
+  #    #Boned::Object.set current_token, key
+  #    pp request
+  #    pp env['rack.input'].read
+  #  end
+  #end
+  
+end
+
+

data/lib/boned/api.rb

@@ -0,0 +1,98 @@
+
+require 'boned'
+
+
+class Boned::API < Sinatra::Base
+  
+  set :public => 'public/'
+  set :views => 'views/'
+  set :static => true
+  
+  before do
+    puts ENV['RACK_ENV']
+  end
+  
+  configure :development do
+    before do
+      Boned.enable_debug
+      Boned.ld '  --> ' << env['REQUEST_URI']
+      content_type 'text/plain'
+    end
+  end
+  
+  configure :production do
+    Boned.disable_debug
+    before do
+      content_type 'application/json'
+    end
+  end
+  
+  helpers do
+    def carefully(ret='', &blk)
+      begin
+        ret = blk.call
+      rescue Boned::BadBone => ex
+        return error(404, ex.message)
+      rescue => ex
+        Boned.ld "#{current_token}:#{params[:key]}", ex.message
+        Boned.ld ex.backtrace
+        return error(400, "Bad bone rising")
+      end
+      ret
+    end 
+    
+    def current_token() @env['HTTP_X_BONE_TOKEN'] || params[:token] end
+    def current_sig() @env['HTTP_X_BONE_SIGNATURE'] || params[:sig] end
+  
+    def uri(*path)
+      [root_path, path].flatten.join('/')
+    end
+    def root_path
+      env['SCRIPT_NAME']
+    end
+    
+    # +names+ One or more a required parameter names (Symbol)
+    def assert_params(*names)
+      names.each do |n|
+        if params[n].nil? || params[n].empty?
+          return error(400, "Missing param: %s" % n)
+        end
+      end
+    end
+    alias_method :assert_param, :assert_params
+
+    def assert_exists(val, msg)
+      return error(400, msg) if val.nil? || 
+                                      (val.respond_to?(:empty?) && val.empty?)
+    end
+
+    def assert_true(val, msg)
+      return error(400, msg) if val == true
+    end
+    
+    def assert_sha1(val)
+      return error(400, "#{val} is not a sha1 digest") unless is_sha1?(val)
+    end
+    
+    def assert_sha256(val)
+      return error(400, "#{val} is not a sha256 digest") unless is_sha256?(val)
+    end
+    
+    def is_sha1?(val)
+      val.match(/\A[0-9a-f]{40}\z/)
+    end
+    def is_sha256?(val)
+      val.match(/\A[0-9a-f]{64}\z/)
+    end
+    
+  end
+end
+
+class Boned::API::Stub < Boned::API
+  get '/' do
+    content_type 'text/plain'
+    "Do you want to get bones?"
+  end
+end
+
+require 'boned/api/service'

data/lib/boned/cli.rb

@@ -0,0 +1,58 @@
+require 'boned/server'
+require 'pp'
+
+class Boned::CLI < Drydock::Command
+  attr_accessor :exit_code
+  
+  def init
+    Boned.load_config Dir.pwd, :development
+    Boned.connect
+  end
+  
+  def start
+    if Boned.service_available?('127.0.0.1', server_opts[:port])
+      raise Boned::Server::ServerRunning, server_opts[:port]
+    end
+    Boned::Controllers::Controller.new(server_opts).start 
+  end
+  
+  def stop
+    if not Boned.service_available?('127.0.0.1', server_opts[:port])
+      raise Boned::Server::ServerNotRunning, server_opts[:port]
+    end
+    Boned::Controllers::Controller.new(server_opts).stop 
+  end
+  
+  def info
+    require 'yaml'
+    if Boned.service_available?('127.0.0.1', server_opts[:port])
+      puts "boned is running on port #{server_opts[:port]}"
+    else
+      puts "No boned"
+    end
+    puts "Options:", server_opts.to_yaml if @global.verbose > 0
+  end
+  
+  private
+  
+  def server_opts
+    port = @global.port || Boned::Server::DEFAULT_PORT
+    config = @global.rackup || File.join(Dir.pwd, "config.ru")
+    @server_opts ||= {
+      :chdir                => Dir.pwd,
+      :environment          => @global.environment || 'development',
+      :address              => '0.0.0.0',
+      :port                 => port,
+      :timeout              => 30,
+      :log                  => "log/boned-#{port}.log",
+      :pid                  => "tmp/pids/boned-#{port}.pid",
+      :max_conns            => Thin::Server::DEFAULT_MAXIMUM_CONNECTIONS,
+      :max_persistent_conns => Thin::Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS,
+      :require              => [],
+      :wait                 => Thin::Controllers::Cluster::DEFAULT_WAIT_TIME,
+      :backend              => "Boned::Server",
+      :rackup               => config,
+      :daemonize            => @global.daemon || false
+    }
+  end
+end

data/lib/boned/models/bone.rb

@@ -0,0 +1,113 @@
+
+# Bone:a462b9ebda71f16cb1567ba8704695ae8dba9999:simple 
+# Bone:a462b9ebda71f16cb1567ba8704695ae8dba9999:us-east-1a-dev-fe:simple
+# Bone:a462b9ebda71f16cb1567ba8704695ae8dba9999:dev-fe:simple
+# Bone:a462b9ebda71f16cb1567ba8704695ae8dba9999:us-east-1a:simple
+
+class Bone < Boned::Model
+  
+  primarykey :boneid
+  
+  field :token
+  field :name
+  field :value
+  field :prop
+  
+  def initialize(token, name, value, prop={})
+    @prop ||= {}
+    prop ||= {}
+    prop.each_pair { |n,v| @prop[n.to_sym] ||= v }
+    @token, @name = token, name
+    @new = refresh!.nil?
+    @value = value unless value.nil? # use the new value if provided
+    @prop[:created] = Time.now.utc.to_i if new? || @prop[:created].nil?
+    # resolve string/symbol ambiguity for properties
+    def @prop.[](k) super(k.to_s.to_sym) || super(k.to_s) end
+    def @prop.[]=(k,v) super(k.to_s.to_sym,v) end
+  end
+  
+  def [](k) 
+    self.respond_to?(k) ? self.send : self.prop[k]
+  end
+  
+  def new?() @new == true end
+    
+  def file?
+    !prop[:file].nil?
+  end
+  
+  def region() prop[:region] end
+  def env() prop[:env] end
+  def role() prop[:role] end
+  def num() prop[:num] end
+  def path() prop[:path] end
+    
+  def boneid
+    loc = [region, env, role, num].compact.join('-')
+    parts = loc.empty? ? [token] : [token, loc]
+    parts << path.gsub(/\A\//, '').tr('/', '-') unless path.nil? # TODO: support windows
+    parts << name
+    parts.collect { |p| p.to_s.tr(':', '-') }.join(':')
+  end
+  
+  def key(*parts)
+    parts.unshift boneid
+    self.class.key *parts
+  end
+  
+  def save
+    redis.set(key, value)
+    prop[:modified] = Time.now.utc.to_i
+    redis.set(key(:prop), prop.to_json)
+  end
+  
+  def refresh!
+    Boned.ld "REFRESH: #{key}"
+    @value = redis.get key
+    prop = redis.get key(:prop)
+    prop &&= JSON.parse(prop) rescue {}
+    # Merge the stored props with the current ones. Enforce symbols!
+    prop.each_pair { |n,v| @prop[n.to_sym] ||= v }
+    Boned.ld " -> #{@value} #{@prop.inspect}"
+    self
+  rescue
+    nil
+  end
+  
+  def destroy!
+    Boned.ld "DESTROY: #{key}"
+    redis.del key
+    redis.del key(:prop)
+  end
+  
+  class << self
+    
+    def del(token, name, opts={})
+      bone = get(token, name, opts)
+      bone.destroy!
+      bone
+    end
+    
+    def get(token, name, opts={})
+      bone = Bone.new token, name, nil, opts
+      raise Boned::BadBone, bone.name if bone.value.nil?
+      bone
+    end
+    
+    def keys(token, k=nil, opts={})
+      search = key(token) << '*'
+      search << k unless k.nil?
+      Boned.ld "SEARCHING: #{search}"
+      dirty = redis.keys search  # contains :prop when no keyname specified
+      clean = []
+      dirty.each { |k| 
+        next if k.match(/prop\z/); 
+        p k
+        clean << k.split(':')[4..-1].join(':') 
+      }
+      clean
+    end
+    
+  end
+  
+end

data/lib/boned/models.rb

@@ -0,0 +1,34 @@
+
+
+module Boned
+  class Model < Storable
+    def self.key(*el)
+      raise "#{self}: nil keypart: #{el.inspect}" if el.size != el.compact.size
+      a = "v1::#{self}"
+      a << ':' << el.join(':') unless el.empty?
+      a
+    end
+    def self.redis
+      Boned.redis
+    end
+    def self.primarykey(v=nil)
+      unless v.nil?
+        @primarykey = v
+        class_eval do  
+          def primarykey() send(self.class.primarykey) end
+        end
+      end
+      @primarykey
+    end
+    def redis
+      self.class.redis
+    end
+    def save
+      redis.sadd(self.class.key(kind, :all), self.primarykey) &&
+      redis.set(key(:created), self.time.to_i) &&
+      redis.set(key(:object), to_json)
+    end
+  end
+end
+
+Boned.require_glob 'boned', 'models', '*.rb'

data/lib/boned/server.rb

@@ -0,0 +1,67 @@
+require 'thin'
+require 'logging'
+require 'forwardable'
+
+module Boned
+  class Server < Thin::Backends::Base
+    DEFAULT_PORT = 6043.freeze
+    
+    class ServerRunning < Boned::Problem
+      def message() "Server already running on port: #{super}" end
+    end
+    
+    class ServerNotRunning < Boned::Problem
+      def message() "Server not running on port: #{super}" end
+    end
+    
+    class << self
+    end
+    
+    # Address and port on which the server is listening for connections.
+    attr_accessor :host, :port
+    
+    def initialize(host, port, options)
+      @host = host
+      @port = port
+      super()
+    end
+
+    # Connect the server
+    def connect
+      @signature = EventMachine.start_server(@host, @port, Thin::Connection, &method(:initialize_connection))
+    rescue => ex
+      puts ex.message
+      puts ex.backtrace if Boned.debug
+      stop!
+    end
+
+    # Stops the server
+    def disconnect
+      EventMachine.stop_server(@signature)
+    end
+    
+    def to_s
+      "#{@host}:#{@port}"
+    end
+    
+  end
+  module Controllers
+    class Controller < Thin::Controllers::Controller
+    end
+    class Service < Thin::Controllers::Service
+    end
+    class Cluster < Thin::Controllers::Cluster
+    end
+  end
+end
+
+
+
+
+#controller = case
+#when cluster? then Thin::Controllers::Cluster.new(options)
+#when service? then Thin::Controllers::Service.new(options)
+#else               Thin::Controllers::Controller.new(options)
+#end
+
+

data/lib/boned.rb

@@ -0,0 +1,139 @@
+require 'rack/auth/digest/md5'
+
+require 'redis'
+require 'redis/namespace'
+require 'storable'
+require 'attic'
+require 'gibbler/aliases'
+require 'sysinfo'
+require 'socket'
+
+unless defined?(BONED_HOME)
+  BONED_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..') )
+end
+
+module Boned
+  APIVERSION = 'v1'.freeze unless defined?(APIVERSION)
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+    PATCH = '001'
+    def self.inspect; [to_s, PATCH].join('.'); end
+    def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
+    def self.to_f; self.to_s.to_f; end
+    def self.patch; PATCH; end
+  end
+  
+  class Problem < RuntimeError; end
+  class BadBone < Problem
+    def message() "No such bone: #{super}" end
+  end
+  
+  @debug = false
+  @conf  = nil
+  @redis = nil
+  @sysinfo = nil
+  class << self
+    attr_accessor :debug
+    attr_reader :conf
+    attr_accessor :redis
+    def debug?() @debug == true end
+    def enable_debug() @debug = true end
+    def disable_debug() @debug = false end
+    def sysinfo
+      @sysinfo = SysInfo.new.freeze if @sysinfo.nil?
+      @sysinfo 
+    end
+  end
+  
+  # Connect to Redis and Mongo. 
+  def self.connect(conf=@conf)
+    @redis = Redis.new conf[:redis]
+  end
+  
+  # Loads the yaml config files from config/
+  # * +base+ path where config dir lives
+  # * +env one of: :development, :production
+  # Returns a Hash: conf[:mongo][:host], ...
+  def self.load_config(base=Dir.pwd, env=:development)
+    @conf = {}                       
+    [:redis].each do |n|
+      Boned.ld "LOADING CONFIG: #{n}"
+      tmp = YAML.load_file(File.join(base, "config", "#{n}.yml"))
+      @conf[n] = tmp[ env.to_sym ]
+    end
+    @conf
+  end
+  
+  # <tt>require</tt> a library from the vendor directory.
+  # The vendor directory should be organized such
+  # that +name+ and +version+ can be used to create
+  # the path to the library. 
+  #
+  # e.g.
+  # 
+  #     vendor/httpclient-2.1.5.2/httpclient
+  #
+  def self.require_vendor(name, version)
+    path = File.join(BONED_HOME, 'vendor', "#{name}-#{version}", 'lib')
+    $:.unshift path
+    Boned.ld "REQUIRE VENDOR: ", path
+    require name
+  end
+  
+  def self.require_glob(*path)
+    path = [BONED_HOME, 'lib', path].flatten
+    libs = Dir.glob(File.join(*path))
+    Boned.ld "REQUIRE GLOB: ", libs
+    libs.each do |lib|
+      next if lib == __FILE__
+      require lib if File.file? lib
+    end
+  end
+  
+  # Checks whether something is listening to a socket. 
+  # * +host+ A hostname
+  # * +port+ The port to check
+  # * +wait+ The number of seconds to wait for before timing out. 
+  #
+  # Returns true if +host+ allows a socket connection on +port+. 
+  # Returns false if one of the following exceptions is raised:
+  # Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error
+  #
+  def self.service_available?(host, port, wait=3)
+    if Boned.sysinfo.vm == :java
+      begin
+        iadd = Java::InetSocketAddress.new host, port      
+        socket = Java::Socket.new
+        socket.connect iadd, wait * 1000  # milliseconds
+        success = !socket.isClosed && socket.isConnected
+      rescue NativeException => ex
+        puts ex.message, ex.backtrace if Boned.debug?
+        false
+      end
+    else 
+      begin
+        status = Timeout::timeout(wait) do
+          socket = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+          sockaddr = Socket.pack_sockaddr_in( port, host )
+          socket.connect( sockaddr )
+        end
+        true
+      rescue Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error => ex
+        puts ex.class, ex.message, ex.backtrace if Boned.debug?
+        false
+      end
+    end
+  end
+  
+  
+  def self.ld(*msg)
+    return unless Boned.debug
+    prefix = "D(#{Thread.current.object_id}):  "
+    puts "#{prefix}" << msg.join("#{$/}#{prefix}")
+  end
+  
+end
+
+require 'boned/models'

data/public/index.html

@@ -0,0 +1,4 @@
+<html>
+<body>
+</body>
+</html>

data/try/10_bone_model.rb

@@ -0,0 +1,21 @@
+# ruby -rubygems -Ilib try/10_bone_model.rb
+require 'boned'
+Boned.load_config 
+Boned.connect
+Boned.enable_debug
+
+token = Digest::SHA256.hexdigest('1901484c41b8752d61863e323c743')
+key = 'simple'
+
+puts Bone.keys(token)
+
+__END__
+opts = { :env => 'dev', :region => 'us-east-1a', :num => '01', :role => 'fe', :path => Dir.pwd  }
+bone = Bone.new token, key, rand(100000).to_i, opts
+#puts "BONE: " << bone.inspect, $/
+bone.save
+#puts "KEYS: " << Bone.keys( token, key).inspect, $/
+
+bone = Bone.get( token, key, opts)
+puts "GET: " << bone.inspect, $/
+puts bone.to_json

data/views/redisviewer/keys.erb

@@ -0,0 +1,12 @@
+<% @keys.each do |key| %>
+  <div class="key">
+    <% kind = key_kind(key) %>
+    <% if kind == 'string' %> 
+      <a href="<%= root_path %>/get/<%= key %>"><%= key %></a> <%= (kind) %>
+    <% elsif kind == 'set' %>
+      <a href="<%= root_path %>/smembers/<%= key %>"><%= key %></a> <%= (kind) %>
+    <% elsif kind == 'list' %>
+      <a href="<%= root_path %>/list/<%= key %>"><%= key %></a> <%= (kind) %>
+    <% end %>
+  </div>
+<% end %>

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: boned
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Delano Mandelbaum
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-13 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: Get Bones
+email: delano@solutious.com
+executables: 
+- boned
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE.txt
+- CHANGES.txt
+files: 
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/boned
+- boned.gemspec
+- config/redis-default.yml
+- config/redis-server-default.conf
+- config/stella/api-set.rb
+- config/stella/api.rb
+- lib/boned.rb
+- lib/boned/api.rb
+- lib/boned/api/debug.rb
+- lib/boned/api/redis.rb
+- lib/boned/api/service.rb
+- lib/boned/cli.rb
+- lib/boned/models.rb
+- lib/boned/models/bone.rb
+- lib/boned/server.rb
+- public/index.html
+- try/10_bone_model.rb
+- views/redisviewer/keys.erb
+- CHANGES.txt
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --title
+- Get Bones
+- --main
+- README.rdoc
+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: boned
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Get Bones
+test_files: []
+