celluloid-presence 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83c3287a94c2f820bab2be50041e10183562379d
+  data.tar.gz: 5e94a2416dcaca6535a64291eb525b5117a8d338
+SHA512:
+  metadata.gz: c90b5508fc1281b5f3713b87c9a980b89e9e46728db5efdd53ca782fe10393c560d78901a0b0707fcb154d6eb0320b314f4e84edaf81790e8296583210821eff
+  data.tar.gz: 979c29216afcd3a3d958f8ee6625cfb91e7bcedb47d45d75ffad5675e0b2de0a9a9ff82d9091552c1e14ebe129bc1e51917dd6fe70f0d10a7aa8d514029356bb

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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.textile

@@ -0,0 +1,51 @@
+h1. Celluloid Presence
+
+Start an instance of "ZooKeeper":http://zookeeper.apache.org/ on your server then run:
+* OSX: 
+* 
+
+<pre><code class="ruby">
+require 'rubygems'
+require 'celluloid-presence'
+
+Celluloid::Presence::ZkService.init :server => 'localhost'
+Celluloid::Presence::ZkPresence.supervise_as :presence, :service_name => :presence
+
+class Messaging
+	include Celluloid
+	include Celluloid::Notifications
+	
+	def self.finalizer
+		:finalize
+	end
+	
+	def initialize(service_name)
+		@service_name = service_name
+		subscribe("#{@service_name}_nodes", :node_update)
+	end
+	
+	def node_update(event, nodes)
+		p "\nNode list updated!"
+		nodes.each do |node|
+			p " -> #{Actor[@service_name].get(node)}"
+		end
+	end
+	
+	
+	private
+	
+	
+	def finalize
+		Actor[@service_name].terminate
+	end
+end
+
+Messaging.run(:presence)
+</code></pre>
+
+
+h2. Start using it now
+
+# Read the "Documentation":http://rubydoc.info/gems/celluloid-promise/Celluloid/Presence
+# Then @gem install celluloid-presence@
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc "Run all RSpec tests"
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => [:spec]

data/lib/celluloid-presence/presence.rb

@@ -0,0 +1,162 @@
+require 'socket'
+
+module Celluloid
+	module Presence
+		class ZkPresence
+			include Celluloid
+			include Celluloid::Notifications
+			
+			PREFIX  ||= '/coPresence'
+			NODE_PREFIX ||= 'node-'
+			
+			
+			def self.finalizer
+				:finalize
+			end
+			
+			
+			def initialize(options = {})
+				@env = options[:env] || 'production'
+				@base_path = options[:service_name].nil? ? "#{PREFIX}/#{@env}/default" : "#{PREFIX}/#{@env}/#{options[:service_name]}"
+				@base_path_sym = @base_path.to_sym
+				@node_path = nil	# This is officially set in connect_setup
+				@service_name = options[:service_name] || :default
+				@nodes = []
+		
+				if options[:node_address].nil?
+					use_ip_v4 = !options[:ip_v6]		# IP v6 or IP v4 if using the default node data
+					@node_address = proc { ip_address(use_ip_v4) }
+				else
+					node_address = options[:node_address]
+					@node_address = proc { node_address.is_a?(Proc) ? node_address.call : node_address }
+				end
+				@last_known_address = nil
+		
+				#
+				# These callbacks will be executed on a seperate thread
+				# Which is why we need to use notifications update state
+				#
+				zk.register(@base_path)
+				subscribe("zk_event_#{@base_path}", :zk_callback)
+				subscribe('zk_connected', :on_connected)
+				subscribe('zk_connecting', :on_connecting)
+				
+				on_connected if zk.connected?
+			end
+			
+			
+			#
+			# Provides the list of known nodes
+			#
+			attr_reader :nodes
+			
+		
+			#
+			# This informs us of changes to the list of base path's children
+			#
+			def zk_callback(event_name, event)
+				#p "EVENT OCUURED #{event.event_name} #{event.path}"
+				if event.node_child?	# We are only listening to child events so we only need to handle these
+					begin
+						@nodes = zk.children(@base_path, :watch => true)    # re-set watch
+						update_node_information
+					rescue ZK::Exceptions::NoNode		# Technically this shouldn't happen unless someone deleted our base path
+						on_connected if zk.connected?
+					end
+				end
+			end
+			
+			#
+			# This informs us of a new connection being established with zookeeper
+			#
+			def on_connected(event = nil)
+				address = @node_address.call
+				if @node_path.nil? or not zk.exists?(@node_path)	# Create presence node as it doesn't exist
+					#p 'node re-created'
+					@last_known_address = address
+					connect_setup
+				elsif @last_known_address != address		# Recreate existing presence node as our IP changed
+					#p 'node ip_changed, recreating'
+					zk.async.ensure(:delete, @node_path)
+					@last_known_address = address
+					connect_setup
+				else												# Else our node presence information is accurate, lets get the latest list
+					@nodes = zk.children(@base_path, :watch => true)
+				end
+				
+				update_node_information								# inform listeners of a node list update
+			end
+		
+			#
+			# This informs us that we've been disconnected from zookeeper
+			#
+			def on_connecting event
+				publish("#{@service_name}_nodes_stale")
+			end
+		
+			#
+			# Returns the value of a node
+			#
+			def get(node_id)
+				result, _ = zk.get("#{@base_path}/#{node_id}")
+				result
+			rescue ZK::Exceptions::NoNode
+			end
+			
+			#
+			# Returns the name of this node
+			#
+			def name
+				@node_path.split('/')[-1]
+			end
+		
+		
+			private
+		
+		
+			#
+			# Shortcut to the zookeeper service
+			#
+			def zk
+				Actor[:zk_service]
+			end
+			
+			#
+			# creates the presence node
+			#
+			def connect_setup
+				zk.mkdir_p @base_path
+				@node_path = zk.create "#{@base_path}/#{NODE_PREFIX}", @last_known_address, :sequence => true, :ephemeral => true
+				@nodes = zk.children @base_path, :watch => true
+			end
+		
+			#
+			# Pushes an updated node list to subscribers
+			#
+			def update_node_information
+				publish("#{@service_name}_nodes", @nodes)
+			end
+			
+			#
+			# Grabs a valid IP address
+			#
+			def ip_address(ip_v4)
+				ip = if ip_v4
+					Socket.ip_address_list.detect {|a| a.ipv4? && !a.ipv4_loopback?}
+				else
+					Socket.ip_address_list.detect {|a| !a.ipv4? && !(a.ipv6_linklocal? || a.ipv6_loopback?)}
+				end
+				return ip.ip_address unless ip.nil?
+				nil
+			end
+			
+			#
+			# On termination make sure zookeeper is updated
+			#
+			def finalize
+				zk.async.unregister(@base_path)
+				zk.async.ensure(:delete, @node_path) unless @node_path.nil?
+			end
+		end
+	end
+end

data/lib/celluloid-presence/service.rb

@@ -0,0 +1,160 @@
+require 'zk'
+
+module Celluloid
+	module Presence
+		class ZkService
+			include Celluloid
+			include Celluloid::Notifications
+			
+			DEFAULT_PORT ||= 2181
+			@@zk ||= nil				# The single zookeeper instance
+			@@registry ||= {}			# Paths we are interested in receiving events from
+			@@registry_count ||= {}		# Listener counts (for unregistering)
+			@@ensure ||= []				# Tasks we want to ensure are completed (even when disconnected)
+			@@connected ||= false		# We'll maintain our own connected state
+			
+			
+			#
+			# Optional init function to supervise this actor
+			#
+			def self.init(options)
+				ZkService.supervise_as :zk_service, options
+			end
+			
+			# Create a single connection to Zookeeper that persists through Actor crashes
+			#
+			# servers: a list of Zookeeper servers to connect to. Each server in the
+			#          list has a host/port configuration
+			def initialize(options)
+				@@zk ||= begin
+					Fanout.supervise_as :notifications_fanout if Actor[:notifications_fanout].nil?
+		
+					# Let them specify a single server instead of many
+					servers = options[:server].nil? ? options[:servers] : [options[:server]]
+					raise "no Zookeeper servers given" unless servers
+		
+					# Add the default Zookeeper port unless specified
+					servers.map! do |server|
+						if server[/:\d+$/]
+							server
+						else
+							"#{server}:#{DEFAULT_PORT}"
+						end
+					end
+		
+					ZK.new(*servers) do |zk|
+						zk.on_connecting &proc { Actor[:zk_service].async.on_connecting }
+						zk.on_connected  &proc { Actor[:zk_service].async.on_connected }
+					end
+				end.tap do |zk|
+					@@connected = zk.connected?
+				end
+			end
+			
+			#
+			# Called once a connection is made to the zookeeper cluster
+			# Runs any impending ensures before informing any subscribed actors
+			#
+			def on_connected
+				@@connected = true
+				while not @@ensure.empty?
+					func = @@ensure.shift
+					ensured func[0], *func[1]	# func[0] == function name, func[1] == arguments
+				end
+				publish('zk_connected')
+			end
+			
+			#
+			# Called on disconnect from zookeeper
+			# Might be that the zookeeper node crashed or zookeeper is down, may not effect any other connections
+			#
+			def on_connecting
+				@@connected = false
+				publish('zk_connecting')
+			end
+		
+			#
+			# Publishes any zookeeper events that have been registered
+			#
+			def event_callback(path, event)
+				publish("zk_event_#{path}", event)
+			end
+		
+			#
+			# Uses a closure to cleanly pull the zookeeper event back into the protection of celluloid
+			#
+			def register(path)
+				path = path.to_sym
+				if @@registry[path].nil?
+					callback = proc { |event| Actor[:zk_service].async.event_callback(path, event) }
+					@@registry[path] = @@zk.register(path.to_s, &callback)
+				end
+				@@registry_count[path] = (@@registry_count[path] || 0) + 1
+			end
+			
+			#
+			# unsubscribes from zookeeper events once there are no more listeners
+			#
+			def unregister(path)
+				path = path.to_sym
+				if @@registry[path]
+					@@registry_count[path] -= 1
+					if @@registry_count[path] <= 0
+						sub = @@registry.delete(path)
+						sub.unsubscribe
+						@@registry_count.delete(path)
+					end
+				end
+			end
+		
+			#
+			# Our abstracted connected status to avoid race conditions
+			#
+			def connected?
+				@@connected
+			end
+		
+			#
+			# Ensures important requests are followed through in the case of disconnect / reconnect
+			# Ignores request if the node does not exist
+			# USE SPARINGLY
+			#
+			def ensure(func, *args)
+				if connected?
+					ensured(func, *args)
+				else
+					@@ensure.push [func, args]
+				end
+			end
+		
+			
+			#
+			# Proxy the following functions
+			#
+			# Automatically creates a callable function for each command
+			#	http://blog.jayfields.com/2007/10/ruby-defining-class-methods.html
+			#	http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html
+			#
+			SAFE_OPS ||= [:get, :children, :create, :mkdir_p, :delete, :stat, :exists?, :set, :rm_rf]
+			SAFE_OPS.each do |func|
+				define_method func do |*args|
+					begin
+						@@zk.send func, *args if connected?
+					rescue Zookeeper::Exceptions::NotConnected
+					end
+				end
+			end
+		
+		
+			private
+		
+			
+			def ensured(func, *args)
+				@@zk.send func, *args
+			rescue Zookeeper::Exceptions::NotConnected
+				@@ensure << [func, args]
+			rescue ZK::Exceptions::NoNode
+			end
+		end
+	end
+end

data/lib/celluloid-presence/version.rb

@@ -0,0 +1,6 @@
+module Celluloid
+	module Presence
+		VERSION = "1.0.0"
+	end
+end
+

data/lib/celluloid-presence.rb

@@ -0,0 +1,3 @@
+require 'celluloid'
+require 'celluloid-presence/service.rb'
+require 'celluloid-presence/presence.rb'

data/lib/dcell/registries/zk_presence_adapter.rb

@@ -0,0 +1,152 @@
+require 'celluloid-presence'
+
+
+module DCell
+	module Registry
+		class ZkPresenceAdapter
+			def initialize(options)				
+				Celluloid::Presence::ZkService.init options
+				
+				@node_registry = NodeRegistry.new(options)
+				@global_registry = GlobalRegistry.new(:zk_service, options)
+			end
+			
+			
+			class NodeRegistry
+				include Celluloid
+				include Celluloid::Notifications
+				
+				def initialize(options)
+					@mutex = Mutex.new
+					@current_address = nil
+					
+					Celluloid::Presence::ZkPresence.supervise_as :dcell_presence, {
+						:service_name => :dcell_presence,
+						:node_address => proc { @mutex.synchronize { @current_address } },
+						:env => options[:env] || 'production'
+					}	
+								
+					@service_name = :dcell_presence
+					@directory = {}	# node_name => address
+					@mapping = {}	# zk_path => node_name
+					
+					subscribe("#{@service_name}_nodes", :node_update)
+					
+					@nodes = []
+					update_directory(presence.nodes)
+				end
+				
+				def get(node_id)
+					@directory[node_id]
+				end
+				
+				def nodes
+					@directory.keys
+				end
+				
+				def node_update(event, nodes)
+					update_directory(nodes)
+				end
+				
+				def set(node_id, addr)
+					@mutex.synchronize {
+						@current_address = Marshal.dump [node_id, addr]
+					}
+					presence.on_connected	# This causes an address update on zookeeper
+				end
+				
+				
+				private
+				
+				
+				def update_directory(new_list)
+					unsubscribe = @nodes - new_list		# TODO:: use sets here instead of arrays for speed
+					subscribe = new_list - @nodes
+					
+					unsubscribe.each do |node|
+						node_name = @mapping.delete(node)
+						@directory.delete(node_name)
+					end
+					
+					subscribe.each do |node|
+						value = presence.get(node)
+						if value.nil?
+							@nodes.delete value
+						else
+							begin
+								info = Marshal.load value
+								@mapping[node] = info[0]
+								@directory[info[0]] = info[1]
+							rescue
+								@nodes.delete value
+							end
+						end
+					end
+
+					@nodes = new_list
+				end
+				
+				def presence
+					::Celluloid::Actor[@service_name]
+				end
+			end
+			
+			def clear_nodes;				end		# This is now self maintaining hence no op
+			def get_node(node_id);			@node_registry.get(node_id) end
+			def nodes;						@node_registry.nodes end
+			def set_node(node_id, addr);	@node_registry.set(node_id, addr) end
+			
+			
+			
+			class GlobalRegistry
+				PREFIX  = "/dcell_global"
+				
+				def initialize(service_name, options)
+					options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+					
+					@service_name = service_name
+					@env = options['env'] || 'production'
+					@base_path = "#{PREFIX}/#{@env}"
+				end
+				
+				def get(key)
+					value, _ = zk.get "#{@base_path}/#{key}"
+					Marshal.load value
+				rescue ZK::Exceptions::NoNode
+				end
+				
+				# Set a global value
+				def set(key, value)
+					path = "#{@base_path}/#{key}"
+					string = Marshal.dump value
+				
+					zk.set path, string
+				rescue ZK::Exceptions::NoNode
+					zk.create path, string
+				end
+				
+				# The keys to all globals in the system
+				def global_keys
+					zk.children(@base_path)
+				end
+				
+				def clear
+					zk.rm_rf @base_path
+					zk.mkdir_p @base_path
+				end
+				
+				private
+				
+				def zk
+					Celluloid::Actor[@service_name]
+				end
+			end
+			
+			
+			def clear_globals;			@global_registry.clear end
+			def get_global(key);		@global_registry.get(key) end
+			def set_global(key, value);	@global_registry.set(key, value) end
+			def global_keys;			@global_registry.global_keys end
+		end
+	end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: celluloid-presence
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stephen von Takach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Node presence using ZooKeeper for celluloid services
+email:
+- steve@cotag.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/celluloid-presence/presence.rb
+- lib/celluloid-presence/service.rb
+- lib/celluloid-presence/version.rb
+- lib/celluloid-presence.rb
+- lib/dcell/registries/zk_presence_adapter.rb
+- MIT-LICENSE
+- Rakefile
+- README.textile
+homepage: https://github.com/cotag/celluloid-presence
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Node presence using ZooKeeper for celluloid services
+test_files: []