wires-cluster 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 52d376216621589ebc6244e42f99969ca1762986
+  data.tar.gz: b55d81e07aebad4eaf6e31e0440cffe8596aec4d
+SHA512:
+  metadata.gz: 7456c1ac652e1dcd87e0768c90d09f531cf023a608846274421083376be8367136259cdb29e4aee9387609e0a8fcbd187e7444a077d48f4c208b3ab7de6f16e0
+  data.tar.gz: 23a1faf0eaab0db74c549c6df870ce64e79dcb8c83966f85279c62107f9b02eb07f09c88728fcebae0a98d161f6f0a7211b19f5596a52236f65da32266fa1d74

data/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) 2013 : Joe McIlvain
+All rights reserved.

data/lib/wires/cluster.rb

@@ -0,0 +1,78 @@
+
+require 'wires'
+require "#{File.dirname __FILE__}/cluster/udp"
+require "#{File.dirname __FILE__}/cluster/json"
+
+
+module Wires
+  module Cluster
+    PORT  = 4567
+    GROUP = "224.0.1.33"
+    
+    class << self
+    
+      # Block indefinitely while receiving messages
+      def listen!
+        listen
+        @rx_thread.join
+      end
+      
+      # Start the UDP receiving thread (or stop it, if action==:stop)
+      def listen(action=:start)
+        case action
+        when :start
+          @rx ||= UDP::RX.new GROUP, PORT
+          raise IOError, "Probably firewalled..." unless @rx.test!
+          @rx_thread ||= Thread.new { _rx_loop }
+        when :stop
+          @rx_thread.kill; @rx_thread = nil
+          @rx.close;       @rx        = nil
+        end
+      end
+      
+      # Enable UDP sending of fired events (or disable, if action==:stop)
+      def spout(action=:start)
+        case action
+        when :start
+          @tx ||= UDP::TX.new GROUP, PORT
+          @tx_proc = Wires::Channel.after_fire(true) do |e,c|
+            @tx.puts JSON.dump [e,c] unless e.cluster_source
+          end
+        when :stop
+          Wires::Channel.remove_hook :@after_fire, @tx_proc
+          @tx.close; @tx = nil
+        end
+      end
+      
+      # Loop through incoming messages and deploy valid firable events
+      def _rx_loop
+        ongoing = {}
+        loop do
+          msg = @rx.gets
+          ongoing[msg.source] ||= ''
+          ongoing[msg.source]  += msg
+          
+          begin
+            data = _load_json(ongoing[msg.source])
+            if (data[0].is_a? Event) and (data[1].is_a? Channel)
+              event, chan = data
+              event.instance_variable_set(:@cluster_source, msg.source)
+              Convenience::fire *data
+            end
+            ongoing[msg.source] = nil
+          rescue JSON::MissingTailError
+          rescue JSON::ParserError
+            ongoing[msg.source] = nil
+          end
+          
+        end
+      end; private :_rx_loop
+      
+    end
+    
+  end
+end
+
+class Wires::Event
+  attr_reader :cluster_source
+end

data/lib/wires/cluster/json.rb

@@ -0,0 +1,99 @@
+
+# For now, must require in this order
+# to avoid active_support wrecking json/add/core
+require 'active_support/json'
+require 'json/add/core'
+
+# Add for reference when parsing for incomplete packets
+require 'json/pure/parser'
+
+
+# Define default JSON behavior for objects as UnserializableObject
+class Object
+  def as_json(opt=nil)
+    UnserializableObject.new.as_json
+  end
+  
+  def self.json_create(data)
+    UnserializableObject.new
+  end
+end
+
+# A placeholder object to alert the JSON receiver that 
+# the intended object has no defined serialization scheme
+class UnserializableObject
+  def to_s; '<UnserializableObject>'; end
+  def inspect; to_s; end
+  
+  def as_json(opt=nil)
+    { json_class:self.class.name }
+  end
+  
+  def self.json_create(data)
+    self.new
+  end
+end
+
+
+# Define a serialization scheme for Wires Events
+class Wires::Event
+  def as_json(*serialization_args)
+    { json_class: self.class.name,
+      args: [*@args, **@kwargs] }
+  end
+  
+  def self.json_create(data)
+    self.new(*data['args'])
+  end
+end
+
+# Define a serialization scheme for Wires Channels
+class Wires::Channel
+  def as_json(*serialization_args)
+    { json_class: self.class.name,
+      name:       @name }
+  end
+  
+  def self.json_create(data)
+    self.new(data['name'])
+  end
+end
+
+
+# Add JSON-related functions to Wires::Cluster
+module Wires
+  module Cluster
+    class << self
+      
+      # Perform rudimentary JSON verification to make sure str is not 
+      #   a partial payload due to missing or yet-to-come packets,
+      #   then actually load in the JSON objects and return them
+      def _load_json(str)
+        ref_parser = JSON::Pure::Parser
+        
+        # Ignore json comments and strings for open/close count verification
+        stripped_str = str.gsub(ref_parser::IGNORE, '')
+                        .gsub(ref_parser::STRING, '')
+        
+        # Missing tail if any quote symbols remain after string purge
+        raise JSON::MissingTailError if stripped_str.match /(?<!\\)"/
+        
+        # Make sure open/close symbol counts match
+        [[ref_parser::OBJECT_OPEN, ref_parser::OBJECT_CLOSE],
+         [ref_parser::ARRAY_OPEN,  ref_parser::ARRAY_CLOSE]].each do |a, z|
+          case (stripped_str.scan(a).size) <=> (stripped_str.scan(z).size)
+          when  1; raise JSON::MissingTailError
+          when -1; raise JSON::MissingHeadError
+          end
+        end
+        
+        # Try to load objects from the string and return the result
+        JSON.load(str)
+      end; private :_load_json
+      
+    end
+  end
+end
+
+class JSON::MissingTailError < JSON::ParserError; end
+class JSON::MissingHeadError < JSON::ParserError; end

data/lib/wires/cluster/udp.rb

@@ -0,0 +1,115 @@
+
+require 'socket'
+require 'ipaddr'
+
+module Wires
+  module Cluster
+    module UDP
+      
+      class << self;  attr_accessor :max_length;  end
+      self.max_length = 1024 # default max payload length
+      
+      class Xceiver
+        attr_reader :group, :port, :socket, :local_ip, :local_port
+        
+        def self.new(*args)
+          if (self.class==Xceiver)
+            raise TypeError, "#{self.class} is an 'abstract class' only."\
+                             "  Inherit it; don't instantiate it!"; end
+          super
+        end
+        
+        def initialize(group, port, **kwargs)
+          @group = group
+          @port  = port
+          kwargs.each_pair { |k,v| instance_variable_set("@#{k}".to_sym, v) }
+          open
+        end
+        
+        def open
+          @socket.close if @socket
+          @socket = UDPSocket.new
+          configure
+          @local_ip = Socket.ip_address_list.detect{|intf| intf.ipv4_private?}
+          @local_port = @socket.addr[1]
+          return @socket
+        ensure
+          @finalizer ||= ObjectSpace.define_finalizer self, Proc.new { close }
+        end
+        
+        def close
+          @socket.close if @socket
+          @socket = nil
+        end
+      end
+      
+      
+      class TX < Xceiver
+        def configure
+          # Set up for multicasting
+          @socket.setsockopt Socket::IPPROTO_IP,
+                             Socket::IP_MULTICAST_TTL,
+                             [1].pack('i')
+          # Bind to any available port
+          @socket.bind "0.0.0.0", (@bind_port or 0)
+        end
+        
+        def puts(m)
+          max = UDP.max_length
+          if m.size > max
+            self.puts m[0...max]
+            self.puts m[max...m.size]
+          else
+            @socket.send(m, 0, @group, @port)
+            m
+          end
+        end
+      end
+      
+      
+      class RX < Xceiver
+        def configure
+          # Add membership to the multicast group
+          @socket.setsockopt Socket::IPPROTO_IP,
+                             Socket::IP_ADD_MEMBERSHIP,
+                             IPAddr.new(@group).hton + IPAddr.new("0.0.0.0").hton
+          # Don't prevent future listening peers on the same machine
+          @socket.setsockopt(Socket::SOL_SOCKET,
+                             Socket::SO_REUSEADDR,
+                             [1].pack('i')) unless @selfish
+          # Bind the socket to the specified port or any open port on the machine
+          @socket.bind Socket::INADDR_ANY, @port
+        end
+        
+        def gets
+          msg, addrinfo = @socket.recvfrom(UDP.max_length)
+          msg.instance_variable_set :@source, addrinfo[3].to_s+':'+addrinfo[1].to_s
+          class << msg;  attr_reader :source;  end
+          msg
+        end
+        
+        def test!(message="#{self}.test!")
+          tx = UDP::TX.new @group, @port
+          rx = self
+          
+          outer_thread = Thread.current
+          passed = false
+          thr = Thread.new do
+            rx.gets
+            passed = true
+            outer_thread.wakeup
+          end
+          Thread.pass
+          
+          tx.puts message
+          sleep 1 if thr.status
+          thr.kill
+          tx.close
+          
+          passed
+        end
+      end
+      
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: wires-cluster
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Joe McIlvain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: wires
+  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: json
+  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: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: wires-test
+  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'
+- !ruby/object:Gem::Dependency
+  name: jemc-reporter
+  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: Wires extension gem for firing and receiving events between Ruby processes
+  with UDP multicasts.
+email: joe.eli.mac@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wires/cluster/udp.rb
+- lib/wires/cluster/json.rb
+- lib/wires/cluster.rb
+- LICENSE
+homepage: https://github.com/jemc/wires-cluster/
+licenses:
+- 'Copyright (c) Joe McIlvain. All rights reserved '
+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.3
+signing_key: 
+specification_version: 4
+summary: wires-cluster
+test_files: []