zoology 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7fb8d471eda9b3d0294c62df3da33a0475be0971
+  data.tar.gz: 976e309a76a19d24f178663de8e1b6fb421652a5
+SHA512:
+  metadata.gz: 943704e42385bdd91a5ec07f32fda23f2e81fc2815e48255b09c5e31e2d3312b0ecd302770871b94797f306244b4fef8cd1a0f6666ee7d5bceda09db535b3289
+  data.tar.gz: 43e63331b7a033963531bd64d3581b4dc0fd32187d252dedade6f11dbbdb360fbd86af6c00c9cdf7523e1e83d2dc4eea30148848d01d557b52d21e3b8b1a9aaa

data/.gitignore

@@ -0,0 +1 @@
+*.swp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org/'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    zoology (0.1)
+      state_machine
+      zookeeper
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    state_machine (1.2.0)
+    zookeeper (1.4.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  zoology!

data/Rakefile

@@ -0,0 +1,2 @@
+require 'rdoc/task'
+require 'bundler/gem_tasks'

data/lib/zoology.rb

@@ -0,0 +1,4 @@
+require 'zoology/logging'
+require 'zoology/callbacks'
+require 'zoology/client'
+require 'zoology/path_cache'

data/lib/zoology/callbacks.rb

@@ -0,0 +1,17 @@
+module Zoology
+  module Callbacks
+    def call(callback, *args)
+      cb = @callbacks[callback]
+      cb.call(*args) if cb
+    end
+
+    private
+
+    def callbacks(*callbacks)
+      @callbacks ||= {}
+      callbacks.each do |cb|
+        self.class.send(:define_method, cb) { |&blk| @callbacks[cb] = blk }
+      end
+    end
+  end
+end

data/lib/zoology/client.rb

@@ -0,0 +1,128 @@
+module Zoology
+  class Client
+    require 'zookeeper'
+
+    include Logging
+    include Callbacks
+
+    def initialize(servers = 'localhost:2181', opts = {}, klass = Zookeeper)
+      @servers   = servers
+      @heartbeat = opts[:heartbeat] || 2000
+      @klass     = klass
+
+      callbacks :on_connected, :on_expired, :on_disconnected
+    end
+
+    def connect
+      logger.debug 'Connect to ZK'
+      @zookeeper = @klass.new(@servers, @heartbeat, method(:watcher))
+    end
+
+    def reopen
+      logger.debug 'reopen it'
+      @zookeeper.reopen
+    end
+
+    def connected?
+      if @zookeeper
+        @zookeeper.connected?
+      else
+        false
+      end
+    end
+
+    def when_path(path, &blk)
+      req = @zookeeper.get(:path => path)
+      if req[:rc] == ::Zookeeper::ZOK
+        blk.call
+      else
+        wait_for_path(path, path, [], &blk)
+      end
+    end
+
+    def method_missing(sym, *args, &blk)
+      logger.debug "Call to zookeeper #{sym}: #{args.map(&:to_s).join(',')}"
+      @zookeeper.send(sym, *args, &blk)
+    end
+
+    def watcher_callback(&blk)
+      Zookeeper::Callbacks::WatcherCallback.create(&blk)
+    end
+
+    private
+
+    def watcher(event)
+      case event[:state]
+      when ::Zookeeper::ZOO_CONNECTED_STATE
+        logger.debug 'Received connected state'
+        call(:on_connected)
+      when ::Zookeeper::ZOO_CONNECTING_STATE
+        logger.debug 'Received connecting state'
+        call(:on_disconnected)
+      when ::Zookeeper::ZOO_EXPIRED_SESSION_STATE
+        logger.debug 'Received expired state'
+        call(:on_expired)
+        reopen
+      end
+    end
+
+    def wait_for_path(complete_path, wait_path, rest = [], &blk)
+      cb = watcher_callback do |event|
+        if event.type != ::Zookeeper::ZOO_SESSION_EVENT
+          next_path = join(wait_path, rest.first)
+          if @zookeeper.get(:path => next_path)[:rc] == ::Zookeeper::ZOK
+            if next_path == complete_path
+              logger.debug "#{complete_path} now exists, watching it"
+              blk.call
+            else
+              logger.debug "#{next_path} exists, moving on to next"
+              rest.shift
+              wait_for_path(complete_path, next_path, rest, &blk)
+            end
+          else
+            wait_for_path(complete_path, wait_path, rest, &blk)
+          end
+        end
+      end
+
+      req = @zookeeper.get_children(:path => wait_path, :watcher => cb)
+      case req[:rc]
+      when ::Zookeeper::ZOK
+        logger.debug "Now watching #{wait_path}"
+      when ::Zookeeper::ZNONODE
+        logger.debug 'Re-resolving paths'
+        wait_path, rest = find_wait_path(complete_path)
+        wait_for_path(complete_path, wait_path, rest, &blk)
+      else
+        logger.warn "wait_for_path #{wait_path} failed: #{req[:rc]}"
+      end
+    end
+
+    def find_wait_path(complete_path)
+      parts = split(complete_path)
+      rest = [parts.pop]
+      until parts.empty?
+        path = join(*parts)
+        if @zookeeper.get(:path => path)[:rc] == ::Zookeeper::ZOK
+          break
+        end
+        rest.unshift parts.pop
+      end
+      [path, rest]
+    end
+
+    def join(*path)
+      p = ::File.join(*path)
+      if p == ''
+        '/'
+      else
+        p
+      end
+    end
+
+    def split(path)
+      head, *tail = path.split('/')
+      [head] + tail.reject(&:empty?)
+    end
+  end
+end

data/lib/zoology/logging.rb

@@ -0,0 +1,26 @@
+module Zoology
+  module Logging
+    require 'logger'
+    require 'stringio'
+
+    def logger
+      @logger ||= Logging.logger(self.class)
+    end
+
+    class << self
+      attr_accessor :level
+
+      def disable!
+        @disable = true
+      end
+
+      def logger(name)
+        sink = @disable ? StringIO.new : STDOUT
+        logger = Logger.new(sink)
+        logger.level = @level || Logger::INFO
+        logger.progname = name
+        logger
+      end
+    end
+  end
+end

data/lib/zoology/path_cache.rb

@@ -0,0 +1,57 @@
+module Zoology
+  class PathCache
+    require 'zoology/path_cache/watcher'
+
+    include Logging
+
+    def initialize(client, path, &callback)
+      @client   = client
+      @watches  = {}
+      @watcher  = nil
+      @path     = path
+      @callback = callback
+      @client.on_connected do |_event|
+        if @sleep
+          logger.debug "Sleeping for #{@sleep}s to avoid thundering herd"
+          sleep(@sleep) if @sleep
+        end
+        watch_paths
+      end
+      @client.on_expired do |_event|
+        @watches.each { |_path, watcher| watcher.shutdown }
+        @watches = {}
+        @sleep   = rand(10)
+      end
+      if @client.connected?
+        watch_paths
+      end
+    end
+
+    private
+
+    def watch_paths
+      watcher = lambda do |_wpath, type, req|
+        if type == :update
+          update_watches(req[:children]) if req[:rc] == Zookeeper::ZOK
+        else
+          @client.when_path(@path) { watch_paths }
+        end
+      end
+
+      @watcher = Watcher.new(@client, @path, :get_children, &watcher)
+      @watcher.watch
+    end
+
+    def update_watches(children)
+      paths = children.map { |child| File.join(@path, child) }
+      (paths - @watches.keys).each do |path|
+        @watches[path] = Watcher.new(@client, path, &@callback)
+      end
+      (@watches.keys - paths).each do |path|
+        @watches.delete(path).shutdown
+      end
+      @watches.each { |_name, watcher| watcher.watch }
+    end
+
+  end
+end

data/lib/zoology/path_cache/watcher.rb

@@ -0,0 +1,67 @@
+module Zoology; class PathCache
+  class Watcher
+    require 'state_machine'
+
+    include Logging
+
+    state_machine :state, :initial => :not_watching do
+      after_transition :not_watching => :watching, :do => :set_watch
+      before_transition any => :shutdown, :do => :deleted
+
+      event :watch do
+        transition :not_watching => :watching
+      end
+
+      event :not_watching do
+        transition :watching => :not_watching
+      end
+
+      event :shutdown do
+        transition all => :shutdown
+      end
+
+      state :shutdown do
+        def call(type, data = nil)
+          logger.debug "Received call request, but in shutdown so not doing anything: #{@path}"
+        end
+      end
+
+      state all - [:shutdown] do
+        def call(type, data = nil)
+          @callback.call @path, type, data
+        end
+      end
+    end
+
+    def initialize(client, path, zk_call = :get, &callback)
+      @client   = client
+      @path     = path
+      @zk_call  = zk_call
+      @callback = callback
+
+      super()
+    end
+
+    def set_watch
+      watcher = @client.watcher_callback do |event|
+        set_watch if event.type != Zookeeper::ZOO_SESSION_EVENT
+      end
+      begin
+        req = @client.send(@zk_call, :path => @path, :watcher => watcher)
+        if req[:rc] == Zookeeper::ZOK
+          call(:update, req)
+        elsif req[:rc] == Zookeeper::ZNONODE
+          shutdown
+        else
+          not_watching
+        end
+      rescue Zookeeper::Exceptions::ContinuationTimeoutError
+        not_watching
+      end
+    end
+
+    def deleted
+      call(:deleted)
+    end
+  end
+end; end

data/zoology.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |gem|
+  gem.name          = 'zoology'
+  gem.version       = '0.1'
+  gem.authors       = ['Torbjörn Norinder']
+  gem.email         = ['torbjorn@genunix.se']
+  gem.description   = "Zookeeper utilities and recipes"
+  gem.summary       = gem.description
+  gem.homepage      = 'https://github.com/campanja/zoology'
+  gem.platform      = Gem::Platform::RUBY
+
+  gem.add_dependency 'zookeeper'
+  gem.add_dependency 'state_machine'
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = []
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: zoology
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Torbjörn Norinder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zookeeper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Zookeeper utilities and recipes
+email:
+- torbjorn@genunix.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/zoology.rb
+- lib/zoology/callbacks.rb
+- lib/zoology/client.rb
+- lib/zoology/logging.rb
+- lib/zoology/path_cache.rb
+- lib/zoology/path_cache/watcher.rb
+- zoology.gemspec
+homepage: https://github.com/campanja/zoology
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Zookeeper utilities and recipes
+test_files: []