fraggle 0.4.0 → 1.0.0pre

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fraggle.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+HOME  = ENV["HOME"]
+PBDIR = HOME+"/src/doozer/src/pkg/proto"
+
+namespace :proto do
+  task :update do
+    ENV["BEEFCAKE_NAMESPACE"] = "Fraggle"
+    sh(
+      "protoc",
+      "--beefcake_out", "lib/fraggle",
+      "-I",  PBDIR,
+      PBDIR+"/msg.proto"
+    )
+  end
+end

data/example/again.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  c = Fraggle.connect
+  c.level = Fraggle::Logger::INFO
+
+  paths = []
+
+  c.walk("/**") do |e|
+    paths << e.path+"="+e.value
+  end.again do |w|
+    # We've been connected to to a new server, Resend the request
+    c.send(w)
+  end.done do
+    puts "## DONE", *paths
+  end
+
+end

data/example/getdir.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect
+  c.level = Fraggle::Logger::INFO
+
+  ents = []
+  req = c.getdir "/doozer" do |e|
+    ents << e.path
+  end
+
+  req.error do
+    puts *ents
+  end
+
+
+end

data/example/ping.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect
+
+  EM.add_periodic_timer(1) do
+    c.get nil, "/ping" do |e|
+      p [:e, e]
+    end
+  end
+
+end

data/example/session.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect :level => Fraggle::Client::DEBUG
+
+  c.session "example." do |session_id|
+    c.debug "established session (#{session_id})!"
+  end
+end

data/example/set.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect
+
+  EM.add_periodic_timer(1) do
+    c.get "/hello" do |e|
+      p [:e, e]
+    end
+  end
+
+  c.set '/hello', 'world', :missing do |e|
+    p e
+  end
+end

data/example/stat.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect
+
+  EM.add_periodic_timer(1) do
+    c.stat "/example" do |e|
+      p e
+    end
+  end
+
+  EM.add_periodic_timer(0.5) do
+    c.set "/example/#{rand(10)}", "test", :clobber
+  end
+
+end

data/example/walk.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect
+
+  paths = []
+  req = c.walk "/**" do |e|
+    paths << e.path+"="+e.value
+  end
+
+  req.done do
+    puts *paths
+  end
+
+
+end

data/example/watch.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fraggle'
+
+EM.run do
+
+  EM.error_handler do |e|
+    $stderr.puts e.message + "\n" + (e.backtrace * "\n")
+  end
+
+  c = Fraggle.connect
+  c.level = Fraggle::Logger::WARN
+
+  c.watch "/example/*" do |e|
+    p e
+  end
+
+  EM.add_periodic_timer(0.5) do
+    c.set "/example/#{rand(10)}", "test", :clobber
+  end
+
+end

data/fraggle.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fraggle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fraggle"
+  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", "~>0.3"
+
+  s.add_development_dependency "turn"
+end

data/lib/fraggle.rb

@@ -1,50 +1,43 @@
 require 'fraggle/client'
-require 'fraggle/errors'
-require 'fraggle/logger'
-require 'uri'
 
 module Fraggle
-  extend Logger
 
-  DefaultUri = "doozer:?"+
-    # Default host/port
-    "ca=127.0.0.1:8046&"+
-
-    # Default host + test-cluster ports
-    "ca=127.0.0.1:8041&"+
-    "ca=127.0.0.1:8042&"+
+  DEFAULT_URI = "doozerd:?" + [
+    "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)
+    uri = uri || ENV["DOOZER_URI"] || DEFAULT_URI
+
+    addrs = uri(uri)
+
+    if addrs.length == 0
+      raise ArgumentError, "there were no addrs supplied in the uri (#{uri.inspect})"
+    end
 
-  def self.connect(*args)
-    opts  = args.last.is_a?(Hash) ? args.pop : {}
-    uri   = args.shift || ENV["DOOZER_URI"] || DefaultUri
-    addrs = addrs_for(uri)
+    addr = addrs.shift
+    host, port = addr.split(":")
 
-    host, port = addrs.first.split(":")
-    EM.connect(host, port, Client, addrs.shift, addrs, opts)
+    cn = EM.connect(host, port, Connection, addr)
+    Client.new(cn, addrs)
   end
 
-  def self.addrs_for(uri)
-    params = uri.gsub(/^doozer:\?/, '').split("&")
-    addrs  = []
-
-    params.each do |param|
-      k, v = param.split("=")
-      if k == "ca"
-        # Perform a liberal validation to weed out most mistakes
-        if v =~ /^[\d\w\-.]+:\d+$/
-          addrs << v
-        else
-          warn "invalid addr (#{v}) in #{uri}"
+  def self.uri(u)
+    if u =~ /^doozerd:\?(.*)$/
+      parts = $1.split("&")
+      parts.inject([]) do |m, pt|
+        k, v = pt.split("=")
+        if k == "ca"
+          m << v
         end
+        m
       end
+    else
+      raise ArgumentError, "invalid doozerd uri"
     end
-
-    if addrs.empty?
-      raise NoAddrs
-    end
-
-    addrs
   end
 
 end

data/lib/fraggle/client.rb

@@ -1,253 +1,99 @@
-require 'fraggle/errors'
-require 'fraggle/logger'
-require 'fraggle/meta'
-require 'fraggle/protocol'
-require 'fraggle/request'
-require 'fraggle/response'
-require 'set'
-require 'uri'
+require 'eventmachine'
+require 'fraggle/connection'
 
 module Fraggle
+  class Client
+    include Request::Verb
 
-  module Client
-    include Protocol
-    include Logger
-
-    class Error < StandardError ; end
-
-
-    MinTag = 0
-    MaxTag = (1<<32)
-
-    Nibbles = "0123456789abcdef"
-
-    def initialize(addr, addrs=[], opts={})
-      @cbx   = {}
-
-      @addr  = addr
-      @addrs = {}
-
-      addrs.each_with_index do |addr, i|
-        @addrs[i] = addr
-      end
-
-      # Logging
-      @level   = opts[:level] || ERROR
-      @writer  = $stderr
+    class NoMoreAddrs < StandardError
     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
+    attr_reader :cn
 
-      if (res.flags & Response::Flag::DONE) > 0
-        if req = @cbx.delete(res.tag)
-          req.emit(:done)
-        end
-      end
-    end
-
-    def rev
-      req = Request.new
-      req.verb = Request::Verb::REV
-
-      resend(req)
+    def initialize(cn, addrs)
+      @cn, @addrs = cn, addrs
     end
 
-    def checkin(path, rev)
+    def set(rev, path, value, &blk)
       req = Request.new
-      req.verb = Request::Verb::CHECKIN
-      req.path = path
-      req.rev  = casify(rev)
-
-      resend(req)
-    end
-
-    def session(prefix=nil, &blk)
-      name    = "#{prefix}#{genkey}"
-      estab   = false
-
-      f = Proc.new do |e|
-        # If this is the first response from the server, it's go-time.
-        if ! estab
-          blk.call(name)
-        end
-
-        # We've successfully established a session.  Say so.
-        estab = true
-
-        # Get back to the server ASAP
-        checkin(name, e.rev).valid(&f)
-      end
+      req.verb  = SET
+      req.rev   = rev
+      req.path  = path
+      req.value = value
+      req.valid(&blk)
 
-      checkin(name, 0).valid(&f)
+      send(req)
     end
 
-    def get(rev, path)
+    def get(rev, path, &blk)
       req = Request.new
+      req.verb = GET
       req.rev  = rev
-      req.verb = Request::Verb::GET
       req.path = path
+      req.valid(&blk)
 
-      resend(req)
+      send(req)
     end
 
-    def stat(rev, path)
+    def del(rev, path, &blk)
       req = Request.new
+      req.verb = DEL
       req.rev  = rev
-      req.verb = Request::Verb::STAT
       req.path = path
-
-      resend(req)
-    end
-
-    def getdir(rev, path, offset, limit)
-      req = Request.new
-      req.rev    = rev
-      req.verb   = Request::Verb::GETDIR
-      req.offset = offset if offset != 0
-      req.limit  = limit  if limit  != 0
-      req.path   = path
-
-      resend(req)
-    end
-
-    def set(path, value, rev)
-      req = Request.new
-      req.verb  = Request::Verb::SET
-      req.path  = path
-      req.value = value
-      req.rev   = casify(rev)
-
-      send(req)
-    end
-
-    def del(path, rev)
-      req = Request.new
-      req.verb  = Request::Verb::DEL
-      req.path  = path
-      req.rev   = casify(rev)
+      req.valid(&blk)
 
       send(req)
     end
 
-    def walk(rev, glob, offset=nil, limit=nil)
+    def getdir(rev, path, offset=nil, limit=nil, &blk)
       req = Request.new
-      req.verb   = Request::Verb::WALK
-      req.rev    = rev
-      req.path   = glob
+      req.verb = GETDIR
+      req.rev  = rev
+      req.path = path
       req.offset = offset
       req.limit  = limit
+      req.valid(&blk)
 
-      cancelable(resend(req))
+      send(req)
     end
 
-    def watch(rev, glob)
+    def walk(rev, path, offset=nil, limit=nil, &blk)
       req = Request.new
+      req.verb = WALK
       req.rev  = rev
-      req.verb = Request::Verb::WATCH
-      req.path = glob
+      req.path = path
+      req.offset = offset
+      req.limit  = limit
+      req.valid(&blk)
 
-      cancelable(resend(req))
+      send(req)
     end
 
-    def monitor(rev, glob)
+    def watch(rev, path, &blk)
       req = Request.new
+      req.verb = WATCH
       req.rev  = rev
-      req.path = glob
-
-      wt = nil
-      wk = nil
-
-      req.metadef :cancel do
-        wt.cancel if wt
-        wk.cancel if wk
-      end
-
-      wk = walk(rev, glob).valid do |e|
-        req.emit(:valid, e)
-      end.error do |e|
-        req.emit(:error, e)
-      end.done do
-        req.emit(:done)
-
-        wt = watch(rev+1, glob).valid do |e|
-          req.emit(:valid, e)
-        end.error do |e|
-          req.emit(:error, e)
-        end
-      end
-
-      req
-    end
-
-    def noop(&blk)
-      req = Request.new
-      req.verb = Request::Verb::NOOP
+      req.path = path
+      req.valid(&blk)
 
       send(req)
     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)
+    def rev(&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).valid do |res|
-        # Do not send any more responses from the server to this request.
-        @cbx.delete(what.tag)
-        what.emit(:valid, res)
-      end
-    end
-
-    def next_tag
-      tag = MinTag
-
-      while @cbx.has_key?(tag)
-        tag += 1
-        if tag > MaxTag
-          tag = MinTag
-        end
-      end
-
-      tag
-    end
-
-    def send(req)
-      req.tag ||= next_tag
+      req.verb = REV
+      req.valid(&blk)
 
-      @cbx[req.tag] = req
-
-      debug "sending request:   #{req.inspect}"
-      send_request(req)
-
-      req
+      send(req)
     end
 
-    def resend(req)
-      req.tag ||= next_tag
+    def send(req, &onre)
+      wr = Request.new(req.to_hash)
+      wr = cn.send_request(wr)
 
-      wrap = Request.new(req.to_hash)
+      req.tag = wr.tag
 
-      req.valid do |e|
+      wr.valid do |e|
         if req.offset
           req.offset += 1
         end
@@ -260,108 +106,45 @@ module Fraggle
           req.rev = e.rev
         end
 
-        wrap.emit(:valid, e)
-      end
-
-      req.error do |err|
-        if err.disconnected?
-          send(req)
-        else
-          wrap.emit(:error, err)
-        end
+        req.emit(:valid, e)
       end
 
-      req.done do
-        wrap.emit(:done)
+      wr.done  do
+        req.emit(:done)
       end
 
-      send(req)
-
-      wrap
-    end
-
-    def cancelable(req)
-      c   = self
-      can = true
-
-      req.metadef :cancel do
-        if can
-          can = false
-          c.__cancel__(self)
+      wr.error do |e|
+        case true
+        when cn.err? || e.redirect?
+          reconnect!
+          onre.call if onre
+        else
+          req.emit(:error, e)
         end
       end
 
-      req.metadef :canceled? do
-        !can
-      end
-
       req
     end
 
-    def post_init
-      info "successfully connected to #{@addr}"
-
-      res = Response.new(:err_code => Errno::ECONNREFUSED::Errno)
-      @cbx.values.compact.each do |req|
-        debug "sending disconnected error to #{req.inspect}"
-        req.emit(:error, res)
-      end
-
-      if ! @tracking
-        trackaddrs
-        @tracking = true
-      end
-    end
-
-    # Track addresses of doozers in a cluster.  This will retry
-    # in the event of a new connection.
-    def trackaddrs
-      rev.valid do |v|
-        monitor(v.rev, "/doozer/slot/*").valid do |e|
-          if e.value == ""
-            @addrs.delete(e.path)
-          else
-            get(v.rev, "/doozer/info/#{e.value}/addr").valid do |g|
-              next if g.value == @addr
-              @addrs[e.path] = g.value
-            end
-          end
-        end.error do |err|
-          error "address tracking: #{err.inspect} for #{req.inspect}"
-        end
-      end
-    end
-
-    # What happens when a connection is closed for any reason.
-    def unbind
-      info "disconnected from #{@addr}"
-
-      _, @addr = @addrs.shift
-      if ! @addr
-        raise "No more addrs"
+    def resend(req)
+      send(req) do
+        req.tag = nil
+        resend(req)
       end
-
-      host, port = @addr.split(":")
-
-      info "attempting connection to #{@addr}"
-
-      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
+    def reconnect!
+      if addr = @addrs.shift
+        reconnect(addr)
+      else
+        raise NoMoreAddrs
       end
     end
 
-    def genkey
-      (0...16).map { Nibbles[rand(Nibbles.length)].chr }.join
+    def reconnect(addr)
+      host, port = addr.split(":")
+      @cn = EM.connect(host, port, Fraggle::Connection, @addrs)
     end
 
   end
-
 end