perennial 1.2.1 → 1.2.2

data/lib/perennial/protocols/json_transport.rb

@@ -10,33 +10,28 @@ module Perennial
       def self.included(parent)
         parent.class_eval do |parent|
           is :loggable
-          
-          cattr_accessor :event_handlers
-          
           include InstanceMethods
-          extend  ClassMethods
-          
-          self.event_handlers = Hash.new { |h,k| h[k] = [] }
-          
-          # Simple built in Methods, applicable both ways.
-          on_action :exception,   :handle_exception
-          on_action :noop,        :handle_noop
-          on_action :enable_ssl,  :handle_enable_ssl
-          on_action :enabled_ssl,  :handle_enabled_ssl
-          
+          include MessageHandling
         end
       end
       
-      module InstanceMethods
+      module MessageHandling
         
-        def receive_data(data)
-          protocol_buffer.extract(data).each do |part|
-            receive_line(part)
+        def self.included(parent)
+          parent.class_eval do
+            cattr_accessor :event_handlers
+            extend  ClassMethods
+            self.event_handlers = Hash.new { |h,k| h[k] = [] }
+
+            # Simple built in Methods, applicable both ways.
+            on_action :exception,   :handle_exception
+            on_action :noop,        :handle_noop
+            on_action :enable_ssl,  :handle_enable_ssl
+            on_action :enabled_ssl,  :handle_enabled_ssl
           end
         end
         
-        def receive_line(line)
-          line.strip!
+        def receive_message(line)
           response = JSON.parse(line)
           handle_response(response)
         rescue Exception => e
@@ -44,17 +39,6 @@ module Perennial
           handle_receiving_exception(e)
         end
         
-        # Typically you'd log a backtrace
-        def handle_receiving_exception(e)
-        end
-        
-        def host_with_port
-          @host_with_port ||= begin
-            port, ip = Socket.unpack_sockaddr_in(get_peername)
-            "#{ip}:#{port}"
-          end
-        end
-        
         def message(name, data = {}, &blk)
           payload = {
             "action"  => name.to_s,
@@ -62,7 +46,7 @@ module Perennial
             "sent-at" => Time.now
           }
           payload.merge!(options_for_callback(blk))
-          send_data "#{JSON.dump(payload)}#{SEPERATOR}"
+          send_message JSON.dump(payload)
         end
         
         def reply(name, data = {}, &blk)
@@ -70,26 +54,8 @@ module Perennial
           message(name, data, &blk)
         end
         
-        def use_ssl=(value)
-          @should_use_ssl = value
-          enable_ssl if connected?
-        end
-        
-        def post_connect
-        end
-        
-        def post_init
-          if !connected? && !ssl_enabled?
-            @connected = true
-            post_connect
-          end
-        end
-        
-        def ssl_handshake_complete
-          if !connected?
-            @connected = true
-            post_connect
-          end
+        # Typically you'd log a backtrace
+        def handle_receiving_exception(e)
         end
         
         def handle_enable_ssl(data)
@@ -110,14 +76,36 @@ module Perennial
           logger.warn "Got exception from remote call of #{data["action"]}: #{data["message"]}"
         end
         
-        protected
+        def callbacks
+          @callbacks ||= {}
+        end
         
-        def should_use_ssl?
-          instance_variable_defined?(:@should_use_ssl) && @should_use_ssl
+        def connected?
+          instance_variable_defined?(:@connected) && @connected
         end
         
-        def ssl_enabled?
-          instance_variable_defined?(:@ssl_enabled) && @ssl_enabled
+        def handle_response(response)
+          return unless response.is_a?(Hash) && response.has_key?("action")
+          payload = response["payload"] || {}
+          @callback_id = response.delete("callback-id")
+          process_callback(payload)
+          process_action(response["action"], payload)
+          @callback_id = nil
+        end
+        
+        def process_action(name, data)
+          self.event_handlers[name.to_s].each do |handler|
+            if handler.respond_to?(:call)
+              instance_exec(data, &handler)
+            elsif handler.respond_to?(:handle)
+              handler.handle(data)
+            else
+              self.send(handler, data)
+            end
+          end
+        rescue Exception => e
+          reply :exception, :name => e.class.name, :message => e.message,
+                :action => name, :payload => data
         end
         
         def options_for_callback(blk)
@@ -143,50 +131,71 @@ module Perennial
           Digest::SHA256.hexdigest([base, count].compact.join("-"))
         end
         
-        def protocol_buffer
-          @protocol_buffer ||= BufferedTokenizer.new(SEPERATOR)
+        module ClassMethods
+
+          def on_action(name, handler = nil, &blk)
+            real_name = name.to_s
+            self.event_handlers[real_name] << blk     if blk.present?
+            self.event_handlers[real_name] << handler if handler.present?
+          end
+
         end
         
-        def callbacks
-          @callbacks ||= {}
+      end
+      
+      module InstanceMethods
+        
+        def receive_data(data)
+          protocol_buffer.extract(data).each do |part|
+            receive_message(part)
+          end
         end
         
-        def connected?
-          instance_variable_defined?(:@connected) && @connected
+        def send_message(line)
+          send_data "#{line}#{SEPERATOR}"
         end
         
-        def handle_response(response)
-          return unless response.is_a?(Hash) && response.has_key?("action")
-          payload = response["payload"] || {}
-          @callback_id = response.delete("callback-id")
-          process_callback(payload)
-          process_action(response["action"], payload)
-          @callback_id = nil
+        def host_with_port
+          @host_with_port ||= begin
+            port, ip = Socket.unpack_sockaddr_in(get_peername)
+            "#{ip}:#{port}"
+          end
         end
         
-        def process_action(name, data)
-          self.event_handlers[name.to_s].each do |handler|
-            if handler.respond_to?(:call)
-              instance_exec(data, &handler)
-            elsif handler.respond_to?(:handle)
-              handler.handle(data)
-            else
-              self.send(handler, data)
-            end
+        def use_ssl=(value)
+          @should_use_ssl = value
+          enable_ssl if connected?
+        end
+        
+        def post_connect
+        end
+        
+        def post_init
+          if !connected? && !ssl_enabled?
+            @connected = true
+            post_connect
           end
-        rescue Exception => e
-          reply :exception, :name => e.class.name, :message => e.message,
-                :action => name, :payload => data
         end
         
-      end
-      
-      module ClassMethods
+        def ssl_handshake_complete
+          if !connected?
+            @connected = true
+            post_connect
+          end
+        end
         
-        def on_action(name, handler = nil, &blk)
-          real_name = name.to_s
-          self.event_handlers[real_name] << blk     if blk.present?
-          self.event_handlers[real_name] << handler if handler.present?
+        protected
+        
+        def should_use_ssl?
+          instance_variable_defined?(:@should_use_ssl) && @should_use_ssl
+        end
+        
+        def ssl_enabled?
+          instance_variable_defined?(:@ssl_enabled) && @ssl_enabled
+        end
+        
+        def protocol_buffer
+          @protocol_buffer ||= BufferedTokenizer.new(SEPERATOR)
         end
         
       end

data/lib/perennial.rb

@@ -9,7 +9,7 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = [1, 2, 1]
+  VERSION = [1, 2, 2]
   
   has_library :dispatchable, :hookable, :loader, :logger, :nash,
               :loggable, :manifest, :settings, :argument_parser,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: perennial
 version: !ruby/object:Gem::Version 
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors: 
 - Darcy Laycock