leonardo-bridge 0.4.3 → 0.6.5

data/lib/bridge/db.rb

@@ -1,27 +0,0 @@
-require 'redis'
-
-
-module Bridge
-  class DB < Redis
-    # retrieves all values in a given namespace
-    # e.g. server:name, server:port and server:location all belong in the server namespace
-    def namespace ns
-      ns_keys = keys("#{ns.to_s}:*")
-      ns_keys = ns_keys.inject({}) { |h,k| h.update(k => type(k)) }
-      pipelined do
-        ns_keys.each do |key,type|
-          case type
-          when 'hash'
-            hgetall(key)
-          else
-            get(key)
-          end
-        end
-      end
-    end
-    
-    def open_tables
-      lrange('opentables',0,llen('opentables')).map(&:to_i)
-    end
-  end
-end

data/lib/redis_model.rb

@@ -1,137 +0,0 @@
-require File.join(File.dirname(__FILE__),'uuid')
-require 'time'
-require 'json'
-
-# A basic Redis-backed Model implementation.
-# Extend it by specifying your desired attr_accessors
-# Enable timestamps by calling use_timestamps in your implementation
-# Features auto-incremented ids and id namespacing
-# Example:
-#   class Zorro < Fondue::RedisModel
-#     attr_accessor :sword, :mask
-#     use_timestamps
-#   end
-#   
-#   z = Zorro.new(:sword => 'rapier', :mask => 'lame')
-#   z.persist!
-#   z
-#   => #<Zorro @id="1", @sword => "rapier", @mask => "lame", @updated_at=2013-03-14 18:11:17 +0100, @created_at=2013-03-14 18:11:17 +0100>
-#
-class RedisModel
-  # the only default attribute
-  attr_accessor :id
-  
-  def initialize params = {}
-    params.map do |k,v| 
-      begin
-        send(:"#{k}=",JSON.parse(v))
-      rescue JSON::ParserError
-        send(:"#{k}=",v)
-      end
-    end
-    
-    # typecast some standard attributes
-    self.id = self.id.to_i if self.id
-    if use_timestamps?
-      self.created_at = Time.parse(self.created_at) if self.created_at.is_a?(String)
-      self.updated_at = Time.parse(self.updated_at) if self.updated_at.is_a?(String)
-    end
-  end
-  
-  def persist!
-    is_new = id.nil? or !self.class.exists?(id)
-    
-    if use_timestamps?
-      self.updated_at = Time.now
-      self.created_at = Time.now if is_new
-    end
-    
-    self.id = generate_id if is_new
-    
-    $redis.hmset(namespaced_id, *self.to_array)
-    $redis.expire(namespaced_id,expires_in) unless expires_in.nil?
-    return true
-  end
-  alias :save! :persist!
-  
-  def persist
-    persist!
-    self
-  end
-  alias :save :persist
-  
-  def destroy!
-    $redis.del(namespaced_id)
-  end
-  
-  def reload
-    self.class.load(namespaced_id)
-  end
-  
-  def to_hash
-    instance_variables.inject({}) do |h,v|
-      value = instance_variable_get(v)
-      value = value.is_a?(String) ? value : value.to_json
-      h.update v.to_s.gsub('@','') => value
-    end
-  end
-  
-  def use_timestamps?
-    self.class.instance_variable_get(:@use_timestamps)
-  end
-  
-  def expires_in
-    self.class.instance_variable_get(:@expires_in)
-  end
-  
-  def to_array
-    to_hash.to_a.flatten
-  end
-  
-  def namespaced_id
-    self.class.namespaced_id(self.id)
-  end
-  
-  # useful for testing, but also a general convenience
-  include Comparable
-  def <=>(other)
-    self.to_hash <=> other.to_hash
-  end
-  
-  class << self
-    @use_timestamps = false
-    
-    def namespaced_id(id)
-      "#{self}::#{id}"
-    end
-    
-    def all
-      $redis.namespace(self)
-    end
-    
-    def exists? id
-      $redis.exists(namespaced_id(id))
-    end
-    
-    def load id
-      hash = $redis.hgetall(namespaced_id(id))
-      hash == {} ? nil : new(hash)
-    end
-    alias :find :load
-    
-    def use_timestamps
-      @use_timestamps = true
-      self.send(:attr_accessor, :created_at)
-      self.send(:attr_accessor, :updated_at)
-    end
-    
-    def expire_in time
-      @expires_in = time
-    end
-  end
-  
-protected
-  def generate_id
-    $redis.incr("_#{self.class}_current_id")
-  end
-end

data/lib/uuid.rb

@@ -1,280 +0,0 @@
-#!/usr/bin/env ruby
-### http://mput.dip.jp/mput/uuid.txt
-
-# Copyright(c) 2005 URABE, Shyouhei.
-#
-# Permission is hereby granted, free of  charge, to any person obtaining a copy
-# of  this code, to  deal in  the code  without restriction,  including without
-# limitation  the rights  to  use, copy,  modify,  merge, publish,  distribute,
-# sublicense, and/or sell copies of the code, and to permit persons to whom the
-# code 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 code.
-#
-# THE  CODE 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
-# AUTHOR  OR  COPYRIGHT  HOLDER 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 CODE OR THE  USE OR OTHER  DEALINGS IN THE
-# CODE.
-#
-# 2009-02-20:  Modified by Pablo Lorenzoni <pablo@propus.com.br>  to  correctly
-# include the version in the raw_bytes.
-
-
-require 'digest/md5'
-require 'digest/sha1'
-require 'tmpdir'
-
-# Pure ruby UUID generator, which is compatible with RFC4122
-UUID = Struct.new :raw_bytes
-
-class UUID
-  private_class_method :new
-
-  class << self
-    def mask19 v, str # :nodoc
-      nstr = str.bytes.to_a
-      version = [0, 16, 32, 48, 64, 80][v]
-      nstr[6] &= 0b00001111
-      nstr[6] |= version
-#      nstr[7] &= 0b00001111
-#      nstr[7] |= 0b01010000
-      nstr[8] &= 0b00111111
-      nstr[8] |= 0b10000000
-      str = ''
-      nstr.each { |s| str << s.chr }
-      str
-    end
-
-    def mask18 v, str # :nodoc
-      version = [0, 16, 32, 48, 64, 80][v]
-      str[6] &= 0b00001111
-      str[6] |= version
-#      str[7] &= 0b00001111
-#      str[7] |= 0b01010000
-      str[8] &= 0b00111111
-      str[8] |= 0b10000000
-      str
-    end
-
-    def mask v, str
-      if RUBY_VERSION >= "1.9.0"
-        return mask19 v, str
-      else
-        return mask18 v, str
-      end
-    end
-    private :mask, :mask18, :mask19
-
-    # UUID generation using SHA1. Recommended over create_md5.
-    # Namespace object is another UUID, some of them are pre-defined below.
-    def create_sha1 str, namespace
-      sha1 = Digest::SHA1.new
-      sha1.update namespace.raw_bytes
-      sha1.update str
-      sum = sha1.digest
-      raw = mask 5, sum[0..15]
-      ret = new raw
-      ret.freeze
-      ret
-    end
-    alias :create_v5 :create_sha1
-
-    # UUID generation using MD5 (for backward compat.)
-    def create_md5 str, namespace
-      md5 = Digest::MD5.new
-      md5.update namespace.raw_bytes
-      md5.update str
-      sum = md5.digest
-      raw = mask 3, sum[0..16]
-      ret = new raw
-      ret.freeze
-      ret
-    end
-    alias :create_v3 :create_md5
-
-    # UUID  generation  using  random-number  generator.   From  it's  random
-    # nature, there's  no warranty that  the created ID is  really universaly
-    # unique.
-    def create_random
-      rnd = [
-        rand(0x100000000),
-        rand(0x100000000),
-        rand(0x100000000),
-        rand(0x100000000),
-      ].pack "N4"
-      raw = mask 4, rnd
-      ret = new raw
-      ret.freeze
-      ret
-    end
-    alias :create_v4 :create_random
-
-    def read_state fp        # :nodoc:
-      fp.rewind
-      Marshal.load fp.read
-    end
-
-    def write_state fp, c, m  # :nodoc:
-      fp.rewind
-      str = Marshal.dump [c, m]
-      fp.write str
-    end
-
-    private :read_state, :write_state
-    STATE_FILE = 'ruby-uuid'
-
-    # create  the "version  1" UUID  with current  system clock,  current UTC
-    # timestamp, and the IEEE 802 address (so-called MAC address).
-    #
-    # Speed notice: it's slow.  It writes  some data into hard drive on every
-    # invokation. If you want to speed  this up, try remounting tmpdir with a
-    # memory based filesystem  (such as tmpfs).  STILL slow?  then no way but
-    # rewrite it with c :)
-    def create clock=nil, time=nil, mac_addr=nil
-      c = t = m = nil
-      Dir.chdir Dir.tmpdir do
-        unless FileTest.exist? STATE_FILE then
-          # Generate a pseudo MAC address because we have no pure-ruby way
-          # to know  the MAC  address of the  NIC this system  uses.  Note
-          # that cheating  with pseudo arresses here  is completely legal:
-          # see Section 4.5 of RFC4122 for details.
-          sha1 = Digest::SHA1.new
-          256.times do
-            r = [rand(0x100000000)].pack "N"
-            sha1.update r
-          end
-          str = sha1.digest
-          r = rand 14 # 20-6
-          node = str[r, 6] || str
-          if RUBY_VERSION >= "1.9.0"
-            nnode = node.bytes.to_a
-            nnode[0] |= 0x01
-            node = ''
-            nnode.each { |s| node << s.chr }
-          else
-            node[0] |= 0x01 # multicast bit
-          end
-          k = rand 0x40000
-          open STATE_FILE, 'w' do |fp|
-            fp.flock IO::LOCK_EX
-            write_state fp, k, node
-            fp.chmod 0o777 # must be world writable
-          end
-        end
-        open STATE_FILE, 'r+' do |fp|
-          fp.flock IO::LOCK_EX
-          c, m = read_state fp
-          c = clock % 0x4000 if clock
-          m = mac_addr if mac_addr
-          t = time
-          if t.nil? then
-            # UUID epoch is 1582/Oct/15
-            tt = Time.now
-            t = tt.to_i*10000000 + tt.tv_usec*10 + 0x01B21DD213814000
-          end
-          c = c.succ # important; increment here
-          write_state fp, c, m
-        end
-      end
-
-      tl = t & 0xFFFF_FFFF
-      tm = t >> 32
-      tm = tm & 0xFFFF
-      th = t >> 48
-      th = th & 0x0FFF
-      th = th | 0x1000
-      cl = c & 0xFF
-      ch = c & 0x3F00
-      ch = ch >> 8
-      ch = ch | 0x80
-      pack tl, tm, th, cl, ch, m
-    end
-    alias :create_v1 :create
-
-    # A  simple GUID  parser:  just ignores  unknown  characters and  convert
-    # hexadecimal dump into 16-octet object.
-    def parse obj
-      str = obj.to_s.sub %r/\Aurn:uuid:/, ''
-      str.gsub! %r/[^0-9A-Fa-f]/, ''
-      raw = str[0..31].lines.to_a.pack 'H*'
-      ret = new raw
-      ret.freeze
-      ret
-    end
-
-    # The 'primitive constructor' of this class
-    # Note UUID.pack(uuid.unpack) == uuid
-    def pack tl, tm, th, ch, cl, n
-      raw = [tl, tm, th, ch, cl, n].pack "NnnCCa6"
-      ret = new raw
-      ret.freeze
-      ret
-    end
-  end
-
-  # The 'primitive deconstructor', or the dual to pack.
-  # Note UUID.pack(uuid.unpack) == uuid
-  def unpack
-    raw_bytes.unpack "NnnCCa6"
-  end
-
-  # Generate the string representation (a.k.a GUID) of this UUID
-  def to_s
-    a = unpack
-    tmp = a[-1].unpack 'C*'
-    a[-1] = sprintf '%02x%02x%02x%02x%02x%02x', *tmp
-    "%08x-%04x-%04x-%02x%02x-%s" % a
-  end
-  alias guid to_s
-
-  # Convert into a RFC4122-comforming URN representation
-  def to_uri
-    "urn:uuid:" + self.to_s
-  end
-  alias urn to_uri
-
-  # Convert into 128-bit unsigned integer
-  # Typically a Bignum instance, but can be a Fixnum.
-  def to_int
-    tmp = self.raw_bytes.unpack "C*"
-    tmp.inject do |r, i|
-      r * 256 | i
-    end
-  end
-  alias to_i to_int
-
-  # Gets the version of this UUID
-  # returns nil if bad version
-  def version
-    a = unpack
-    v = (a[2] & 0xF000).to_s(16)[0].chr.to_i
-    return v if (1..5).include? v
-    return nil
-  end
-
-  # Two  UUIDs  are  said  to  be  equal if  and  only  if  their  (byte-order
-  # canonicalized) integer representations are equivallent.  Refer RFC4122 for
-  # details.
-  def == other
-    to_i == other.to_i
-  end
-
-  include Comparable
-  # UUIDs are comparable (don't know what benefits are there, though).
-  def <=> other
-    to_s <=> other.to_s
-  end
-
-  # Pre-defined UUID Namespaces described in RFC4122 Appendix C.
-  NameSpace_DNS = parse "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
-  NameSpace_URL = parse "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
-  NameSpace_OID = parse "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
-  NameSpace_X500 = parse "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
-
-  # The Nil UUID in RFC4122 Section 4.1.7
-  Nil = parse "00000000-0000-0000-0000-000000000000"
-end

data/spec/db_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe DB do
-  # set up in spec_helper
-  subject { $redis }
-  it { subject.should be_a(Redis) }
-  
-  describe '#namespace' do
-    before { 
-      subject.set('server:bob','bob.bridge.com')
-      subject.set('server:dave','dave.bridge.com')
-    }
-    
-    it { subject.namespace('server').should be_a(Array) }
-    it { subject.namespace('server').size.should eq(2) }
-    it { subject.namespace('server').first.should eq('bob.bridge.com') }
-    it { subject.namespace('server').last.should eq('dave.bridge.com') }
-  end
-end