boned 0.2.6 → 0.3.0

data/lib/boned/cli.rb

@@ -1,62 +0,0 @@
-require 'boned/server'
-require 'pp'
-
-class Boned::CLI < Drydock::Command
-  attr_accessor :exit_code
-  
-  
-  def start
-    Boned.connect
-    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
-    Boned.connect(false)
-    Boned.stop_redis 
-    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 stop_redis
-    Boned.connect(false)
-    Boned.stop_redis
-  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(BONED_HOME, "config.ru")
-    @server_opts ||= {
-      :chdir                => Dir.pwd,
-      :environment          => @global.environment || 'development',
-      :address              => '0.0.0.0',
-      :port                 => port,
-      :timeout              => 30,
-      :log                  => "/tmp/boned-#{port}.log",
-      :pid                  => "/tmp/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

@@ -1,112 +0,0 @@
-
-# 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/); 
-        clean << k.split(':')[4..-1].join(':') 
-      }
-      clean
-    end
-    
-  end
-  
-end

data/lib/boned/models.rb

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

@@ -1,67 +0,0 @@
-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/try/10_bone_model.rb

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