fraggle 0.1.1 → 0.2.0

data/README.md

@@ -16,15 +16,18 @@
       # connected.  In the event of a lost connection, fraggle will attempt
       # other doozers until one accepts or it runs out of options; An
       # AssemlyError will be raised if that later happens.
-      c = Fraggle.connect "127.0.0.1:8046"
-
-      c.get "/foo" do |e|
-        if e.ok?
-          e.value   # => "bar"
-          e.cas     # => "123"
-          e.dir?    # => false
-          e.notdir? # => true
-        end
+      c = Fraggle.connect "doozerd://127.0.0.1:8046"
+
+      req = c.get "/foo" do |e|
+        e.value   # => "bar"
+        e.cas     # => "123"
+        e.dir?    # => false
+        e.notdir? # => true
+      end
+
+      req.error do |e|
+        e.err_code   # => nil
+        e.err_detail # => nil
       end
 
       watch = c.watch "/foo" do |e|
@@ -44,20 +47,15 @@
 
         # Phoney check for example
         if can_stop_watching?(path)
-          c.cancel(watch)
+          watch.cancel
         end
       end
 
       ## Setting a key (this will trigger the watch above)
-      c.set "/foo", "zomg!", :missing do |e|
+      req = c.set "/foo", "zomg!", :missing do |e|
         case true
         when e.mismatch? # CAS mis-match
           # retry if we must
-          c.set "/foo", "zomg!", e.cas do |e|
-            if ! e.ok?
-              # we give up
-            end
-          end
         when e.ok?
           e.cas # => "123"
         else
@@ -65,6 +63,24 @@
         end
       end
 
+      req.error do |e|
+        # This is the default behavior for fraggle.
+        # I'm showing this to bring attention to the use of the
+        # error callback.
+        raise e.err_detail
+      end
+
+      # Knowning when a command is done is useful in some cases.
+      # Use the `done` callback for those situations.
+      ents = []
+      req = c.getdir("/test") do |e|
+        ents << e
+      end
+
+      req.done do
+        p ents
+      end
+
     end
 
 

data/lib/fraggle.rb

@@ -1,322 +1,12 @@
-require 'beefcake'
-require 'eventmachine'
-require 'fraggle/proto'
+require 'fraggle/snap'
+require 'uri'
 
 module Fraggle
 
-  MaxInt32 = (1<<31)-1
-  MinInt32 = -(1<<31)
-
-  ##
-  # Response extensions
-  class Response
-    module Flag
-      VALID = 1
-      DONE  = 2
-    end
-
-    def valid?
-      (flags & Flag::VALID) > 0
-    end
-
-    def done?
-      (flags & Flag::DONE) > 0
-    end
-
-    # Err sugar
-    def ok?           ; err_code == nil               ; end
-    def other?        ; err_code == Err::OTHER        ; end
-    def tag_in_use?   ; err_code == Err::TAG_IN_USE   ; end
-    def unknown_verb? ; err_code == Err::UNKNOWN_VERB ; end
-    def redirect?     ; err_code == Err::REDIRECT     ; end
-    def invalid_snap? ; err_code == Err::INVALID_SNAP ; end
-    def mismatch?     ; err_code == Err::CAS_MISMATCH ; end
-    def notdir?       ; err_code == Err::NOTDIR       ; end
-    def dir?          ; err_code == Err::ISDIR        ; end
-
-    # CAS sugar
-    def missing?  ; cas ==  0 ; end
-    def clobber?  ; cas == -1 ; end
-    def dir?      ; cas == -2 ; end
-    def dummy?    ; cas == -3 ; end
-  end
-
-
-  class AssemblyError < StandardError
-  end
-
-
-  def self.connect(addr="127.0.0.1:8046", opts={})
-    # TODO: take a magnet link instead
-    host, port = addr.split(":")
-    EM.connect(host, port, self, addr, opts)
-  end
-
-  attr_reader :doozers, :addr, :opts
-
-  def initialize(addr, opts)
-    opts[:assemble] = opts.fetch(:assemble, true)
-
-    # TODO: take a magnet link and load into @doozers
-    @addr    = addr
-    @opts    = opts
-    @doozers = {}
-  end
-
-  ##
-  # Collect all cluster information for the event of a disconnect from the
-  # server; At which point we will want to attempt a connecting to them one by
-  # one until we have a connection or run out of options.
-  def assemble
-    return if ! opts[:assemble]
-
-    blk = Proc.new do |we|
-      if ! we.ok?
-        raise AssemblyError, we.err_detail
-      end
-
-      if we.value == ""
-        doozers.delete(we.path)
-      else
-        get "/doozer/info/#{we.value}/public-addr" do |e|
-          next if e.value == addr
-          doozers[we.path] = e.value
-        end
-      end
-    end
-
-    watch "/doozer/slot/*", &blk
-    walk  "/doozer/slot/*", &blk
-  end
-
-  ##
-  # Attempts to connect to another doozer when a connection is lost
-  def unbind
-    return if ! opts[:assemble]
-
-    _, @addr = doozers.shift
-    if ! @addr
-      raise AssemblyError, "All known doozers are down"
-    end
-
-    host, port = @addr.split(":")
-    reconnect(host, port)
-  end
-
-
-
-
-  ##
-  # Session generation
-  def gen_key(name, size=16)
-    nibbles = "0123456789abcdef"
-    "#{name}." + (0...size).map { nibbles[rand(nibbles.length)].chr }.join
-  end
-
-  def session(name="fraggle", &blk)
-    raise ArgumentError, "no block given" if ! blk
-
-    id = gen_key(name)
-
-    fun = lambda do |e|
-      raise e.err_detail if ! e.ok?
-      checkin(e.cas, id, &fun)
-    end
-
-    established = lambda do |e|
-      case true
-      when e.mismatch?
-        id = gen_key(name)
-        checkin(0, id, &established)
-      when ! e.ok?
-        raise e.err_detail
-      else
-        blk.call
-        checkin(e.cas, id, &fun)
-      end
-    end
-
-    checkin(0, id, &established)
-  end
-
-  def checkin(cas, id, &blk)
-    call(
-      Request::Verb::CHECKIN,
-      :cas => casify(cas),
-      :path => id.to_s,
-      &blk
-    )
-  end
-
-  def post_init
-    @buf = ""
-    @tag = 0
-    @cbx = {}
-    @len = nil
-
-    assemble
-  end
-
-  def receive_data(data)
-    @buf << data
-
-    got = true
-    while got
-      got = false
-
-      if @len.nil? && @buf.length >= 4
-        @len = @buf.slice!(0, 4).unpack("N").first
-      end
-
-      if @len && @buf.length >= @len
-        bytes = @buf.slice!(0, @len)
-        res   = Response.decode(bytes)
-        receive_response(res)
-        @len = nil
-        got = true
-      end
-    end
-  end
-
-  def receive_response(res)
-    blk = @cbx[res.tag]
-
-    if blk && res.valid?
-      if blk.arity == 2
-        blk.call(res, false)
-      else
-        blk.call(res)
-      end
-    end
-
-    if res.done?
-      if blk && blk.arity == 2
-        blk.call(nil, true)
-      end
-      @cbx.delete(res.tag)
-    end
-  end
-
-  def call(verb, attrs={}, &blk)
-    if @tag == MaxInt32
-      @tag = MinInt32
-    end
-
-    while true
-      break if ! @cbx.has_key?(@tag)
-      @tag += 1
-    end
-
-    attrs[:verb] = verb
-    attrs[:tag]  = @tag
-    @cbx[@tag]   = blk
-
-    send_request(Request.new(attrs))
-
-    @tag
-  end
-
-  def send_request(req)
-    buf = req.encode
-
-    send_data([buf.length].pack("N"))
-    send_data(buf)
-  end
-
-
-
-  ##
-  # Sugar
-  def get(path, sid=0, &blk)
-    call(
-      Request::Verb::GET,
-      :path => path,
-      :id => sid,
-      &blk
-    )
-  end
-
-  def set(path, body, cas, &blk)
-    call(
-      Request::Verb::SET,
-      :path => path,
-      :value => body,
-      :cas => casify(cas),
-      &blk
-    )
-  end
-
-  def del(path, cas, &blk)
-    call(
-      Request::Verb::DEL,
-      :path => path,
-      :cas  => casify(cas),
-      &blk
-    )
-  end
-
-  def watch(glob, &blk)
-    call(
-      Request::Verb::WATCH,
-      :path => glob,
-      &blk
-    )
-  end
-
-  def walk(glob, &blk)
-    call(
-      Request::Verb::WALK,
-      :path => glob,
-      &blk
-    )
-  end
-
-  def snap(&blk)
-    call(
-      Request::Verb::SNAP,
-      &blk
-    )
-  end
-
-  def delsnap(id, &blk)
-    call(
-      Request::Verb::DELSNAP,
-      :id => id,
-      &blk
-    )
-  end
-
-  def noop(&blk)
-    call(
-      Request::Verb::NOOP,
-      &blk
-    )
-  end
-
-  def cancel(tag)
-    blk = lambda do |e|
-      if e.ok?
-        if blk = @cbx.delete(tag)
-          blk.call(nil, true)
-        end
-      end
-    end
-
-    call(
-      Request::Verb::CANCEL,
-      :id => tag,
-      &blk
-    )
-  end
-
-  private
-
-  def casify(cas)
-    case cas
-    when :missing then 0
-    when :clobber then -1
-    else cas
-    end
+  def self.connect(uri, *args)
+    uri = URI(uri)
+    c = EM.connect(uri.host, uri.port, Client, uri, *args)
+    Snap.new(0, c)
   end
 
 end

data/lib/fraggle/client.rb

@@ -0,0 +1,325 @@
+require 'fraggle/logger'
+require 'fraggle/meta'
+require 'fraggle/protocol'
+require 'fraggle/request'
+require 'fraggle/response'
+require 'uri'
+
+module Fraggle
+
+  module Client
+    include Protocol
+    include Logger
+
+    class Error < StandardError ; end
+
+
+    MinTag = 0
+    MaxTag = (1<<32)
+
+
+    def initialize(uri)
+      # Simplied for now.  Later we'll take a real uri
+      # and disect it to init the addrs list
+      uri = URI(uri.to_s)
+
+      @addr  = [uri.host, uri.port] * ":"
+      @addrs = {}
+      @shun  = {}
+      @cbx   = {}
+
+      # Logging
+      @level   = ERROR
+      @writer  = $stderr
+    end
+
+    def receive_response(res)
+      debug "received response: #{res.inspect}"
+
+      if res.err_code
+        if req = @cbx.delete(res.tag)
+          req.emit(:error, res)
+          return
+        end
+      end
+
+      if (res.flags & Response::Flag::VALID) > 0
+        if req = @cbx[res.tag]
+          req.emit(:valid, res)
+        end
+      end
+
+      if (res.flags & Response::Flag::DONE) > 0
+        if req = @cbx.delete(res.tag)
+          req.emit(:done)
+        end
+      end
+    end
+
+    def checkin(path, cas, &blk)
+      req = Request.new
+      req.verb  = Request::Verb::CHECKIN
+      req.path  = path
+      req.cas   = casify(cas)
+
+      send(req, &blk)
+    end
+
+    def session(prefix=nil, &blk)
+      nibbles = "0123456789abcdef"
+      postfix = (0...16).map { nibbles[rand(nibbles.length)].chr }.join
+      name    = prefix ? prefix+"."+postfix : postfix
+      estab   = false
+
+      f = Proc.new do |e|
+        # If this is the first response from the server, it's go-time.
+        if ! estab
+          blk.call
+        end
+
+        # We've successfully established a session.  Say so.
+        estab = true
+
+        # Get back to the server ASAP
+        checkin(name, e.cas, &f)
+      end
+
+      checkin(name, 0, &f)
+    end
+
+    def get(sid, path, &blk)
+      req = Request.new
+      req.verb = Request::Verb::GET
+      req.id   = sid if sid != 0 # wire optimization
+      req.path = path
+
+      send(req, &blk)
+    end
+
+    def stat(sid, path, &blk)
+      req = Request.new
+      req.verb = Request::Verb::STAT
+      req.id   = sid if sid != 0 # wire optimization
+      req.path = path
+
+      send(req, &blk)
+    end
+
+    def getdir(sid, path, offset, limit, &blk)
+      req = Request.new
+      req.verb   = Request::Verb::GETDIR
+      req.id     = sid    if sid != 0
+      req.offset = offset if offset != 0
+      req.limit  = limit  if limit  != 0
+      req.path   = path
+
+      send(req, &blk)
+    end
+
+    def set(path, value, cas, &blk)
+      req = Request.new
+      req.verb  = Request::Verb::SET
+      req.path  = path
+      req.value = value
+      req.cas   = casify(cas)
+
+      send(req, &blk)
+    end
+
+    def del(path, cas, &blk)
+      req = Request.new
+      req.verb  = Request::Verb::DEL
+      req.path  = path
+      req.cas   = casify(cas)
+
+      send(req, &blk)
+    end
+
+    def walk(sid, glob, &blk)
+      req = Request.new
+      req.verb = Request::Verb::WALK
+      req.id   = sid if sid != 0 # wire optimization
+      req.path = glob
+
+      cancelable(send(req, &blk))
+    end
+
+    def watch(glob, &blk)
+      req = Request.new
+      req.verb = Request::Verb::WATCH
+      req.path = glob
+
+      cancelable(send(req, &blk))
+    end
+
+    def snap(&blk)
+      req = Request.new
+      req.verb = Request::Verb::SNAP
+
+      send(req, &blk)
+    end
+
+    def delsnap(sid, &blk)
+      req = Request.new
+      req.verb = Request::Verb::DELSNAP
+      req.id = sid
+
+      send(req, &blk)
+    end
+
+    def noop(&blk)
+      req = Request.new
+      req.verb = Request::Verb::NOOP
+
+      send(req, &blk)
+    end
+
+    # Be careful with this.  It is recommended you use #cancel on the Request
+    # returned to ensure you don't run into a race-condition where you cancel an
+    # operation you may have thought was something else.
+    def __cancel__(what, &blk)
+      req = Request.new
+      req.verb = Request::Verb::CANCEL
+      req.id = what.tag
+
+      # Hold on to the tag as unavaiable for reuse until the cancel succeeds.
+      @cbx[what.tag] = nil
+
+      send(req) do |res|
+        # Do not send any more responses from the server to this request.
+        @cbx.delete(what.tag)
+        blk.call(res) if blk
+      end
+    end
+
+    def send(req, &blk)
+      tag = MinTag
+
+      while @cbx.has_key?(tag)
+        tag += 1
+        if tag > MaxTag
+          tag = MinTag
+        end
+      end
+
+      req.tag = tag
+
+      if blk
+        req.valid(&blk)
+      end
+
+      # Setup a default error handler that gives useful information
+      req.error do |e|
+        raise Error.new("'error (%d) (%s)' for: %s" % [
+          e.err_code,
+          e.err_detail.inspect,
+          req.inspect
+        ])
+      end
+
+      @cbx[req.tag] = req
+
+      debug "sending request:   #{req.inspect}"
+      send_request(req)
+
+      req
+    end
+
+    def cancelable(req)
+      c   = self
+      can = true
+
+      req.metadef :cancel do
+        if can
+          can = false
+          c.__cancel__(self)
+        end
+      end
+
+      req.metadef :canceled? do
+        !can
+      end
+
+      req
+    end
+
+    def post_init
+      info "successfully connected to #{@addr}"
+
+      @last_received = Time.now
+
+      EM.add_periodic_timer(2) do
+        if (n = Time.now - last_received) >= 3
+          error("timeout talking to #{@addr}")
+          close_connection
+        else
+          debug("ping")
+          get(0, "/ping") { debug("pong") }
+        end
+      end
+
+      waw = Proc.new do |e|
+        if e.value == ""
+          addr = @addrs.delete(e.path)
+          if addr
+            error "noticed #{addr} is gone; removing"
+          end
+        else
+          get 0, "/doozer/info/#{e.value}/public-addr" do |a|
+            if @shun.has_key?(a.value)
+              if (n = Time.now - @shun[a.value]) > 3
+                info "pardoning #{a.value} after #{n} secs"
+                @shun.delete(a.value)
+              else
+                info "ignoring shunned addr #{a.value}"
+                next
+              end
+            end
+            # TODO: Be defensive and check the addr value is valid
+            @addrs[e.path] = a.value
+            info("added #{e.path} addr #{a.value}")
+          end
+        end
+      end
+
+      watch    "/doozer/slot/*", &waw
+      walk  0, "/doozer/slot/*", &waw
+    end
+
+    # What happens when a connection is closed for any reason.
+    def unbind
+      error "disconnected from #{@addr}"
+
+      # Shun the address we were currently attempting/connected to.
+      @shun[@addr] = Time.now
+      @addrs.delete_if {|_, v| v == @addr }
+
+      # We don't want the timer to race us while
+      # we're trying to reconnect.  Once the reconnect
+      # has been complete, we'll start the timer again.
+      EM.cancel_timer(@timer)
+
+      _, @addr = @addrs.shift rescue nil
+
+      if ! @addr
+        # We are all out of addresses to try
+        raise "No more doozers!"
+      end
+
+      host, port = @addr.split(":")
+      info "attempting reconnect to #{host}:#{port}"
+      reconnect(host, port.to_i)
+      post_init
+    end
+
+    def casify(cas)
+      case cas
+      when :missing then Response::Missing
+      when :clobber then Response::Clobber
+      else cas
+      end
+    end
+
+  end
+
+end