fraggle-spanx 4.0.1.1

data/example/walk.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'fraggle'
+
+EM.run do
+  c = Fraggle.connect do |c, err|
+    if err
+      fail err.message
+    end
+
+    c.rev do |v|
+      # Valid
+      req = c.walk(v, "/ctl/node/**") do |ents, err|
+        if err
+          p [:err, err]
+        else
+          ents.each do |e|
+            puts File.join(req.path, e.path) + "=" + e.value
+          end
+        end
+      end
+
+      # Limit 0 return nothing
+      c.walk(v, "/ctl/node/**", 0, 0) do |ents, err|
+        p [:nothing, ents, err]
+      end
+
+      # Error
+      c.walk(v, "/nothere") do |ents, err|
+        p [:nothere, ents, err]
+      end
+    end
+  end
+end

data/example/watch.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'fraggle'
+
+EM.run do
+  c = Fraggle.connect do |c, err|
+    if err
+      fail err.message
+    end
+
+    c.rev do |v|
+      c.watch(v, "/ctl/node/**") do |e, err|
+        p [e, err]
+      end
+    end
+  end
+end

data/fraggle.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fraggle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fraggle-spanx"
+  s.version     = Fraggle::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Blake Mizerany"]
+  s.email       = ["blake.mizerany@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{An EventMachine Client for Doozer}
+  s.description = s.summary
+
+  s.rubyforge_project = "fraggle"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "beefcake-spanx"
+  s.add_dependency "eventmachine"
+
+  s.add_development_dependency "turn"
+  s.add_development_dependency "statsample"
+  s.add_development_dependency "rake"
+end

data/lib/fraggle.rb

@@ -0,0 +1,59 @@
+require 'fraggle/client'
+
+module Fraggle
+  include Response::Err
+
+  Clobber = Client::MaxInt64
+
+  DEFAULT_URI = "doozer:?" + [
+    "ca=127.0.0.1:8046",
+    "ca=127.0.0.1:8041",
+    "ca=127.0.0.1:8042",
+    "ca=127.0.0.1:8043"
+  ].join("&")
+
+  def self.connect(uri=nil, &blk)
+    uri = uri || ENV["DOOZER_URI"] || DEFAULT_URI
+
+    addrs, sk = uri(uri)
+
+    if addrs.length == 0
+      raise ArgumentError, "there were no addrs supplied in the uri (#{uri.inspect})"
+    end
+
+    addr = addrs.shift
+    host, port = addr.split(":")
+
+    cn = EM.connect(host, port, Connection, addr)
+    c  = Client.new(cn, addrs)
+    c.access(sk) do |_, err|
+      if err
+        blk.call(nil, err)
+      else
+        blk.call(c, nil)
+      end
+    end
+  end
+
+  def self.uri(u)
+    addrs, sk = [], ""
+
+    if u =~ /^doozer:\?(.*)$/
+      parts = $1.split("&")
+      parts.each do |pt|
+        k, v = pt.split("=")
+        case k
+        when "ca"
+          addrs << v
+        when "sk"
+          sk = v
+        end
+      end
+    else
+      raise ArgumentError, "invalid doozer uri"
+    end
+
+    [addrs, sk]
+  end
+
+end

data/lib/fraggle/client.rb

@@ -0,0 +1,211 @@
+require 'eventmachine'
+require 'fraggle/connection'
+
+module Fraggle
+  class Client
+    include Request::Verb
+
+    MaxInt64 = 1<<63 - 1
+
+    attr_reader :cn, :addrs
+
+    def initialize(cn, addrs)
+      @cn, @addrs = cn, addrs
+      @attempt = Proc.new {|_| true }
+    end
+
+    def addr
+      cn.addr
+    end
+
+    def set(rev, path, value, &blk)
+      req = Request.new
+      req.verb  = SET
+      req.rev   = rev
+      req.path  = path
+      req.value = value
+
+      idemp(req, &blk)
+    end
+
+    def get(rev, path, &blk)
+      req = Request.new
+      req.verb = GET
+      req.rev  = rev
+      req.path = path
+
+      resend(req, &blk)
+    end
+
+    def del(rev, path, &blk)
+      req = Request.new
+      req.verb = DEL
+      req.rev  = rev
+      req.path = path
+
+      idemp(req, &blk)
+    end
+
+    def _getdir(rev, path, offset, &blk)
+      req = Request.new
+      req.verb   = GETDIR
+      req.rev    = rev
+      req.path   = path
+      req.offset = offset
+
+      resend(req, &blk)
+    end
+
+    def _walk(rev, path, offset, &blk)
+      req = Request.new
+      req.verb   = WALK
+      req.rev    = rev
+      req.path   = path
+      req.offset = offset
+
+      resend(req, &blk)
+    end
+
+    def wait(rev, path, &blk)
+      req = Request.new
+      req.verb = WAIT
+      req.rev  = rev
+      req.path = path
+
+      resend(req, &blk)
+    end
+
+    def rev(&blk)
+      req = Request.new
+      req.verb = REV
+
+      resend(req) do |v, _|
+        blk.call(v.rev)
+      end
+    end
+
+    def stat(rev, path, &blk)
+      req = Request.new
+      req.rev  = rev
+      req.verb = STAT
+      req.path = path
+
+      resend(req, &blk)
+    end
+
+    def access(secret, &blk)
+      req = Request.new
+      req.verb  = ACCESS
+      req.value = secret
+
+      resend(req, &blk)
+    end
+
+    def watch(rev, path, &blk)
+      wait(rev, path) do |e, err|
+        blk.call(e, err)
+        if ! err
+          watch(e.rev+1, path, &blk)
+        end
+      end
+    end
+
+    def getdir(rev, path, off=0, lim=MaxInt64, ents=[], &blk)
+      all(:_getdir, rev, path, off, lim, ents, &blk)
+    end
+
+    def walk(rev, path, off=0, lim=MaxInt64, ents=[], &blk)
+      all(:_walk, rev, path, off, lim, ents, &blk)
+    end
+
+    def all(m, rev, path, off, lim, ents=[], &blk)
+      # We're decrementing lim as we go, so we need to return
+      # the accumulated values
+      if lim == 0
+        cn.next_tick { blk.call(ents, nil) }
+        return
+      end
+
+      __send__(m, rev, path, off) do |e, err|
+        case err && err.code
+        when nil
+          all(m, rev, path, off+1, lim-1, ents << e, &blk)
+        when Fraggle::Response::Err::RANGE
+          blk.call(ents, nil)
+        else
+          blk.call(nil, e)
+        end
+      end
+    end
+
+    # Sends a request to the server.  Returns the request with a new tag
+    # assigned.
+    def send(req, &blk)
+      cb = Proc.new do |e, err|
+        case err
+        when Connection::DisconnectedError
+          if cn.err?
+            reconnect!
+          end
+        end
+        blk.call(e, err)
+      end
+
+      cn.send_request(req, cb)
+    end
+
+    def resend(req, &blk)
+      send(req) do |e, err|
+        case err
+        when Connection::DisconnectedError
+          req.tag = nil
+          resend(req, &blk)
+        else
+          blk.call(e, err)
+        end
+      end
+    end
+
+    def idemp(req, &blk)
+      send(req) do |e, err|
+        case err
+        when Connection::DisconnectedError
+          # If we're trying to update a value that isn't missing or that we're
+          # not trying to clobber, it's safe to retry.  We can't idempotently
+          # update missing values because there may be a race with another
+          # client that sets and/or deletes the key during the time between your
+          # read and write.
+          if (req.rev || 0) > 0
+            req.tag = nil
+            idemp(req, &blk)
+          else
+            blk.call(e, err)
+          end
+        else
+          blk.call(e, err)
+        end
+      end
+    end
+
+    ##
+    # Setting `blk` will cause a client to call it before attempting to reconnect.
+    # `blk` is called with one parameter `addr`, which is the address that will be
+    # for reconnect.
+    def attempt(&blk)
+      @attempt = blk
+    end
+
+    def reconnect!
+      addr = @addrs.slice(rand(@addrs.length))
+      if @attempt.call(addr)
+        reconnect(addr)
+      end
+    end
+
+    def reconnect(addr)
+      host, port = addr.split(":")
+      @cn = EM.connect(host, port, Fraggle::Connection, addr)
+    end
+
+  end
+end

data/lib/fraggle/connection.rb

@@ -0,0 +1,124 @@
+require 'fraggle/response'
+
+module Fraggle
+
+  module Connection
+
+    # Raised when a request is invalid
+    class SendError < StandardError
+      def initialize(req, msg=nil)
+        @req = req
+        super(msg)
+      end
+    end
+
+    class DisconnectedError < StandardError
+      def ==(o)
+        return false if ! o.kind_of?(self.class)
+        message == o.message
+      end
+    end
+
+    class ResponseError < StandardError
+      attr_reader :code
+
+      alias :detail :message
+
+      def initialize(res)
+        @code = res.err_code
+        super("#{res.name_for(Response::Err, code)}: #{res.err_detail}")
+      end
+
+      def ==(o)
+        return false if ! o.kind_of?(self.class)
+        code == o.code && message == o.message
+      end
+    end
+
+
+    attr_reader :addr
+
+    def initialize(addr)
+      @addr, @cb = addr, {}
+    end
+
+    def receive_data(data)
+      (@buf ||= "") << data
+
+      while @buf.length > 0
+        if @len && @buf.length >= @len
+          bytes = @buf.slice!(0, @len)
+          @len = nil
+          res = Response.decode(bytes)
+          receive_response(res)
+        elsif @buf.length >= 4
+          bytes = @buf.slice!(0, 4)
+          @len = bytes.unpack("N")[0]
+        else
+          break
+        end
+      end
+    end
+
+    # The default receive_response
+    def receive_response(res)
+      return if err?
+      req, blk = @cb.delete(res.tag)
+      return if ! blk
+      if res.err_code
+        blk.call(nil, ResponseError.new(res))
+      else
+        blk.call(res, nil)
+      end
+    end
+
+    def send_request(req, blk)
+      if req.tag
+        raise SendError, "Already sent #{req.inspect}"
+      end
+
+      if err?
+        next_tick { blk.call(nil, DisconnectedError.new(self.addr)) }
+        return req
+      end
+
+      req.tag = 0
+      while @cb.has_key?(req.tag)
+        req.tag += 1
+
+        req.tag %= 2**31
+      end
+
+      # TODO: remove this!
+      @cb[req.tag] = [req, blk]
+
+      data = req.encode
+      head = [data.length].pack("N")
+
+      send_data("#{head}#{data}")
+
+      req
+    end
+
+    def unbind
+      @err = true
+      @cb.values.each do |_, blk|
+        blk.call(nil, DisconnectedError.new(self.addr))
+      end
+    end
+
+    def err?
+      !!@err
+    end
+
+    def timer(n, &blk)
+      EM.add_timer(n, &blk)
+    end
+
+    def next_tick(&blk)
+      EM.next_tick(&blk)
+    end
+
+  end
+
+end