boned 0.2.6 → 0.3.0

data/lib/boned.rb

@@ -1,178 +1,46 @@
-require 'rack/auth/digest/md5'
-
-require 'redis'
-require 'redis/namespace'
-require 'storable'
-require 'attic'
-require 'gibbler/aliases'
-require 'sysinfo'
-require 'socket'
-require 'uri'
-require 'rye'
 
 unless defined?(BONED_HOME)
   BONED_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..') )
 end
 
-module Boned  
-  unless defined?(APIVERSION)
-    APIVERSION = 'v1'.freeze 
-    BONED_REDIS = "redis://127.0.0.1:8045/1".freeze
-  end
-  
+local_libs = %w{bone}
+local_libs.each { |dir| 
+  a = File.join(BONED_HOME, '..', '..', 'opensource', dir, 'lib')
+  $:.unshift a
+}
+
+module Boned
   module VERSION
-    MAJOR = 0
-    MINOR = 2
-    TINY  = 6
-    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
-  @redis_thread = nil
-  @sysinfo = nil
-  class << self
-    attr_accessor :debug
-    attr_reader :conf
-    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 
+    def self.to_s
+      load_config
+      [@version[:MAJOR], @version[:MINOR], @version[:PATCH]].join('.')
     end
-    def redis() 
-      @redis || Boned.connect
+    alias_method :inspect, :to_s
+    def self.load_config
+      require 'yaml'
+      @version ||= YAML.load_file(File.join(BONED_HOME, '..', 'VERSION.yml'))
     end
   end
-    
-  # Connect to Redis and Mongo. 
-  def self.connect(start_redis=true)
-    update_redis_client_config
-    ld "CONNECT: start_redis(#{start_redis})"
-    if start_redis 
-      self.start_redis
-      abort "No Redis" unless redis_available?
-    end
-    @redis = Redis.new @conf[:redis]
-  end
-  
-  def self.start_redis
-    return if redis_available? 
-    conf_path = File.join(BONED_HOME, 'config', 'redis-server.conf')
-    ld "REDIS SERVER CONF: #{conf_path}"
-    @redis_thread = Thread.new do
-      Rye.shell 'redis-server', conf_path
-    end
-    sleep 2  # Give redis time to start. 
-  end
-  
-  def self.stop_redis
-    ld "SHUTDOWN REDIS #{redis_available?}"
-    ld @redis.inspect
-    # Shutdown command returns "-ERR operation not permitted" ??
-    @redis.shutdown if !@redis.nil?  && redis_available? rescue nil
-    return if @redis_thread.nil? || !@redis_thread.alive?
-  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)
-    a = Socket.getaddrinfo @conf[:redis][:host], @conf[:redis][:port]
-    ip_addr = a[0][3]
-    ld "SERVICE: #{host} (#{ip_addr}) #{port}"
-    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
+
+
+require 'bone'
+
+Bone.source = 'redis://localhost:8045'
+Bone.debug = false
+
+module Boned
+  @allow_register = false
+  class << self
+    attr_reader :allow_register
+    # Disabled the API method for regsitering given tokens.
+    # The value is automatically frozen so it will only
+    # work once per instance of Ruby.
+    def allow_register= v
+      @allow_register = v.freeze unless @allow_register.frozen?
     end
   end
-  
-  def self.redis_available?
-    service_available? @conf[:redis][:host], @conf[:redis][:port]
-  end
-  
-  def self.update_redis_client_config(uri=nil)
-    uri ||= ENV['BONED_REDIS'] || BONED_REDIS
-    uri = URI.parse(uri)
-    @conf ||= {}
-    @conf[:redis] = {
-      :host => uri.host,
-      :port => uri.port || 8045,
-      :database => uri.path.sub(/\D/, "").to_i || 1,
-      :password => uri.user || nil
-    }
-    ld "REDIS: #{@conf[:redis].inspect}"
-  end
-  
-  def self.ld(*msg)
-    return unless Boned.debug
-    prefix = "D(#{Thread.current.object_id}):  "
-    puts "#{prefix}" << msg.join("#{$/}#{prefix}")
-  end
-  
-  update_redis_client_config  # parse ENV['BONED_REDIS']
 end
 
-require 'boned/models'
+
+

data/try/10_basics_try.rb

@@ -0,0 +1,37 @@
+# try try/10_basics_try.rb
+
+require 'boned'
+#Bone.debug = true
+Bone.source = "http://localhost:3073"  
+Bone.credentials = 'atoken:crystal'
+
+## Bone.register
+Bone.register Bone.token, Bone.secret
+#=> 'atoken'
+
+## Bone.register is not possible for existing key
+Bone.register Bone.token, Bone.secret
+#=> nil
+
+## Bone.generate
+@token, @secret = *Bone.generate
+@token.size
+#=> 24
+
+## Can destroy a token
+Bone.destroy @token
+#=> true
+
+## Cannot destroy a token that doesn't exist
+Bone.destroy 'bogus'
+#=> false
+
+## Bone.get returns nil for bad key
+Bone['bogus']
+#=> nil
+
+## Bone.keys returns empty array
+Bone.keys
+#=> []
+
+Bone.destroy Bone.token

data/try/11_signature_try.rb

@@ -0,0 +1,11 @@
+require 'boned'
+#Bone.debug = true
+Bone.source = "http://localhost:3073"  
+Bone.credentials = "11_signature:crystal"
+
+## Bone.register
+Bone.register Bone.token, Bone.secret
+#=> '11_signature'
+
+
+Bone.destroy Bone.token

data/try/20_keys_try.rb

@@ -0,0 +1,34 @@
+require 'boned'
+#Bone.debug = true
+Bone.source = "http://localhost:3073"  
+Bone.credentials = '20_keys_try:crystal'
+
+## Bone.credentials
+[Bone.token, Bone.secret]
+#=> ['20_keys_try', 'crystal']
+
+## Bone.register
+Bone.register Bone.token, Bone.secret
+#=> '20_keys_try'
+
+## Bone.set 
+Bone['akey1'] = 'value1'
+Bone['akey1']
+#=> 'value1'
+
+## Bone.set 
+Bone['akey2'] = 'value2'
+Bone['akey2']
+#=> 'value2'
+
+## Bone.get
+Bone['akey1']
+#=> 'value1'
+
+## Bone.keys
+Bone.keys.sort
+#=> ['akey1', 'akey2']
+
+## Bone.destroy
+Bone.destroy Bone.token
+#=> true

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: boned
 version: !ruby/object:Gem::Version 
-  version: 0.2.6
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,83 +15,119 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-17 00:00:00 -04:00
-default_executable: 
+date: 2010-12-17 00:00:00 -05:00
+default_executable: boned
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bone
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thin
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.2.6
-    version: 
-description: The bone daemon
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: HTTP server companion for Bone (remote environment variables)
 email: delano@solutious.com
 executables: 
 - boned
 extensions: []
 
 extra_rdoc_files: 
-- README.md
 - LICENSE.txt
-- CHANGES.txt
+- README.md
 files: 
+- .gitignore
 - CHANGES.txt
 - LICENSE.txt
 - README.md
 - Rakefile
+- VERSION.yml
 - api/api-set.rb
 - api/api.rb
+- app.ru
 - bin/boned
 - boned.gemspec
-- config.ru
 - config/redis-server.conf
 - 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
+- lib/boned/api/base.rb
+- lib/boned/app.rb
 - public/index.html
-- try/10_bone_model.rb
+- try/10_basics_try.rb
+- try/11_signature_try.rb
+- try/20_keys_try.rb
 - views/redisviewer/keys.erb
 has_rdoc: true
-homepage: http://github.com/solutious/boned
+homepage: https://github.com/solutious/boned
 licenses: []
 
 post_install_message: 
 rdoc_options: 
-- --line-numbers
-- --title
-- The bone daemon
-- --main
-- README.md
+- --charset=UTF-8
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: boned
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: The bone daemon
+summary: HTTP server companion for Bone (remote environment variables)
 test_files: []
 

data/config.ru

@@ -1,31 +0,0 @@
-# Rackup - GetBones.com
-# 2009-12-11
-
-ENV['RACK_ENV'] ||= 'production'
-ENV['APP_ROOT'] = ::File.expand_path(::File.join(::File.dirname(__FILE__)))
-$:.unshift(::File.join(ENV['APP_ROOT'], 'lib'))
-
-require 'sinatra'
-
-require 'boned/api'
-
-disable :run    # disable sinatra's auto-application starting
-
-configure :production do
-  Boned.debug = false
-  
-  map("/bone/#{Boned::APIVERSION}/")  { run Boned::API::Service      }
-  
-end
-
-configure :development do
-  use Rack::ShowExceptions
-  
-  require 'boned/api/debug'
-  require 'boned/api/redis'
-  
-  map("/bone/#{Boned::APIVERSION}/")  { run Boned::API::Service      }
-  map("/debug")                       { run Boned::API::Debug        }  
-  map("/redis")                       { run Boned::API::RedisViewer  }
-
-end

data/lib/boned/api/debug.rb

@@ -1,21 +0,0 @@
-
-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

@@ -1,44 +0,0 @@
-
-
-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

@@ -1,86 +0,0 @@
-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
-
-