fraggel 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Blake Mizerany, Keith Rarick, Chris Moos
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software 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 Software.
+
+THE SOFTWARE 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 AUTHORS OR COPYRIGHT
+HOLDERS 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 SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# Fraggel
+**An EventMachine based Doozer client**
+
+## Install
+
+    $ gem install fraggel
+
+## Use
+
+    require 'rubygems'
+    require 'eventmachine'
+    require 'fraggel'
+
+    EM.start do
+      client = Fraggel.connect "127.0.0.1", 8046
+
+      ## Setting a key
+      client.set "/foo", "bar", :missing do |cas, err|
+        if err != nil
+          cas      # => "123"
+          cas.dir? # => false
+        end
+      end
+
+      client.get "/foo" do |body, cas, err|
+        if err != nil
+          body     # => "bar"
+          cas      # => "123"
+          cas.dir? # => false
+        end
+      end
+
+      watch = client.watch "/foo" do |path, body, cas, err|
+        # The event has:
+        # ------------------------
+        # NOTE:  `err` will be set iff the glob is bad
+        # err       # => nil
+        # path      # => "/foo"
+        # body      # => "bar"
+        # cas       # => "123"
+        # cas.set?  # => true
+        # cas.del?  # => false
+        # ------------------------
+
+        # Phoney check for example
+        if can_stop_watching?(path)
+          client.close(watch)
+        end
+      end
+
+    end
+
+
+## Develop
+
+**Clone**
+    $ git clone http://github.com/bmizerany/fraggel.git
+
+**Test**
+    $ gem install turn
+    $ turn

data/example/get.rb

@@ -0,0 +1,9 @@
+require 'fraggel'
+
+EM.run do
+  client = Fraggel.connect 8046
+
+  client.get "/ping" do |body, cas, err|
+    p [:got, body, cas, err]
+  end
+end

data/example/watch.rb

@@ -0,0 +1,13 @@
+require 'fraggel'
+
+Glob = "/letters/*"
+
+EM.run do
+  client = Fraggel.connect 8046
+
+  puts "Watching #{Glob}"
+
+  client.watch Glob do |path, body, cas, err|
+    p [:noticed, path, body, cas, err]
+  end
+end

data/lib/fraggel.rb

@@ -0,0 +1,238 @@
+require 'eventmachine'
+require 'fraggel/decoder'
+require 'fraggel/encoder'
+require 'fraggel/responder'
+
+module Fraggel
+  include Encoder
+
+  # Flags
+  Valid = 1
+  Done  = 2
+
+  # Cas
+  Dir     = "dir"
+  Missing = "0"
+  Clobber = ""
+
+  # Create an unique object to test for
+  # set or not-set
+  None  = Object.new
+
+  module Cas
+    def dir?
+      self == Dir
+    end
+
+    def del?
+      self == "0"
+    end
+
+    def dummy?
+      empty?
+    end
+
+    def set?
+      ! del? && ! dummy?
+    end
+
+  end
+
+  def self.connect(port, host="127.0.0.1")
+    EM.connect(host, port, self)
+  end
+
+  def post_init
+    @callbacks = {}
+    @opid      = 0
+
+    @responder = Responder.new do |value|
+      receive_response(value)
+    end
+
+    @decoder   = Decoder.new do |name, value|
+      @responder.receive_event(name, value)
+    end
+  end
+
+  def receive_data(data)
+    @decoder.receive_data(data)
+  end
+
+  def receive_response(response)
+    opid, flags, value = response
+
+    if blk = @callbacks[opid]
+      if (flags & Valid) > 0
+        blk.call(value)
+      end
+
+      if (flags & Done) > 0
+        blk.call(:done)
+        @callbacks.delete(opid)
+      end
+    else
+      # TODO: Log something?  Raise error?
+    end
+  end
+
+  def call(verb, args=None, &blk)
+    @opid += 1
+    @callbacks[@opid] = blk
+
+    request = [@opid, verb.to_s]
+    if args != None
+      request << args
+    end
+
+    encoded = encode(request)
+
+    # TODO: Chunk with next_tick
+    send_data(encoded)
+
+    @opid
+  end
+
+  def get(path, snap_id=0, &blk)
+    call :GET, [path, snap_id] do |res|
+      case res
+      when StandardError
+        blk.call(nil, nil, res)
+      when :done
+        # Do nothing
+      else
+        # Add sugar to the CAS token
+        res[1].extend Cas
+        blk.call(*res)
+      end
+    end
+  end
+
+  def set(path, body, cas, &blk)
+    call :SET, [path, body, casify(cas)] do |res|
+      case res
+      when StandardError
+        blk.call(nil, res)
+      when :done
+        # Do nothing
+      else
+        res.extend Cas
+        blk.call(res)
+      end
+    end
+  end
+
+  def sett(path, i, cas, &blk)
+    call :SETT, [path, i, casify(cas)] do |res|
+      case res
+      when StandardError
+        blk.call(nil, nil, res)
+      when :done
+        # Do nothing
+      else
+        res[1].extend Cas
+        blk.call(*res)
+      end
+    end
+  end
+
+  def close(opid, &blk)
+    call :CLOSE, opid do |res|
+      case res
+      when StandardError
+        blk.call(res)
+      when :done
+        # Do nothing
+      else
+        blk.call(nil)
+      end
+    end
+  end
+
+  def del(path, cas, &blk)
+    call :DEL, [path, cas] do |res|
+      case res
+      when StandardError
+        blk.call(res)
+      when :done
+        # Do nothing
+      else
+        blk.call(nil)
+      end
+    end
+  end
+
+  def noop(&blk)
+    call :NOOP do |res|
+      case res
+      when StandardError
+        blk.call(res)
+      when :done
+        # Do nothing
+      else
+        blk.call(nil)
+      end
+    end
+  end
+
+  def snap(&blk)
+    call :SNAP do |res|
+      case res
+      when StandardError
+        blk.call(nil, res)
+      when :done
+        # Do nothing
+      else
+        blk.call(res, nil)
+      end
+    end
+  end
+
+  def delsnap(&blk)
+    call :DELSNAP do |res|
+      case res
+      when StandardError
+        blk.call(nil, res)
+      when :done
+        # Do nothing
+      else
+        blk.call(res, nil)
+      end
+    end
+  end
+
+  def walk(glob, sid=0, &blk)
+    call :WALK, [glob, sid] do |res|
+      case res
+      when StandardError, :done
+        blk.call(nil, nil, nil, res)
+      else
+        res[2].extend Cas
+        blk.call(*res)
+      end
+    end
+  end
+
+  def watch(glob, &blk)
+    call :WATCH, glob do |res|
+      case res
+      when StandardError, :done
+        blk.call(nil, nil, nil, res)
+      else
+        res[2].extend Cas
+        blk.call(*res)
+      end
+    end
+  end
+
+  private
+
+    def casify(cas)
+      case cas
+      when :missing: "0"
+      when :clobber: ""
+      else cas
+      end
+    end
+
+end

data/lib/fraggel/decoder.rb

@@ -0,0 +1,133 @@
+module Fraggel
+
+  class Decoder
+
+    class Poisioned < StandardError ; end
+
+    def initialize(&blk)
+      @receiver = blk
+    end
+
+    def receive_data(data)
+      @buf ||= ""
+      @buf << data
+
+      if ! @dcs
+        read_type
+      else
+        @dcs.call
+      end
+    end
+
+    def dcs(&blk)
+      @dcs = blk
+      @dcs.call
+    end
+
+    def read_type
+      dcs do
+        case @buf.slice!(0)
+        when nil
+          # Wait for next byte
+        when ?\r
+          finish do
+            read_type
+          end
+        when ?:
+          read_integer do |i|
+            @receiver.call(:value, i)
+            read_type
+          end
+        when ?$
+          read_string do |s|
+            @receiver.call(:value, s)
+            read_type
+          end
+        when ?+
+          read_line do |msg|
+            @receiver.call(:status, msg)
+            read_type
+          end
+        when ?-
+          read_line do |msg|
+            @receiver.call(:error, msg)
+            read_type
+          end
+        when ?*
+          read_integer do |count|
+            @receiver.call(:array, count)
+            read_type
+          end
+        else
+          raise Poisioned
+        end
+      end
+    end
+
+    def finish(&blk)
+      dcs do
+        c = @buf.slice!(0)
+        case c
+        when nil
+          # Wait for next byte
+        when ?\n
+          blk.call
+        else
+          raise Poisioned
+        end
+      end
+    end
+
+    def read_integer(&blk)
+      @int = ""
+      dcs do
+        while c = @buf.slice!(0)
+          case c
+          when ?0..?9
+            @int << c.chr
+          when ?\r
+            finish do
+              blk.call(Integer(@int))
+            end
+          else
+            raise Poisioned
+          end
+        end
+      end
+    end
+
+    def read_string(&blk)
+      read_integer do |count|
+        dcs do
+          if @buf.length >= count
+            string = @buf.slice!(0, count)
+            dcs do
+              case @buf.slice!(0)
+              when nil
+                # Wait for next byte
+              when ?\r
+                finish do
+                  blk.call(string)
+                end
+              else
+                raise Poisioned
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def read_line(&blk)
+      dcs do
+        if line = @buf.slice!(/.*\r/)
+          finish do
+            blk.call(line.chomp)
+          end
+        end
+      end
+    end
+
+  end
+
+end