perennial 1.1.0 → 1.2.0

data/examples/json_echo_client.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'readline'
+require File.join(File.dirname(__FILE__), "..", "lib", "perennial")
+
+transport = Perennial::Protocols::PureRuby::JSONTransport.new('localhost', 43241, 10.0)
+
+input = ''
+
+loop do
+  line = Readline.readline('input> ')
+  break if line.strip.downcase == 'exit'
+  transport.write_message(:echo, 'text' => line)
+  p transport.read_message
+end

data/examples/json_echo_server.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'eventmachine'
+require File.join(File.dirname(__FILE__), "..", "lib", "perennial")
+
+module MyAwesomeApp
+
+  include Perennial
+  
+  manifest do |m, l|
+    Settings.root = __FILE__.to_pathname.dirname
+  end
+
+  class JSONEchoServer < EventMachine::Connection
+    include Perennial::Protocols::JSONTransport
+  
+    on_action :echo, :echo_data
+  
+    def echo_data(d)
+      puts "Got data: #{d.inspect}"
+      reply :echoed_back, d
+    end
+  
+  end
+  
+end
+
+EM.run do
+  puts "Starting..."
+  EM.start_server "localhost", 43241, MyAwesomeApp::JSONEchoServer
+end

data/lib/perennial/daemon.rb

@@ -118,7 +118,7 @@ module Perennial
 
       def pids_from(files)
         pids = []
-        Dir[files].each do |file|
+        Dir[files.to_s].each do |file|
           pids += File.read(file).split("\n").map { |l| l.strip.to_i(10) }
         end
         pids.uniq.select { |p| alive?(p) }

data/lib/perennial/protocols/json_transport.rb

@@ -0,0 +1,196 @@
+require 'digest/sha2'
+require 'json' unless defined?(JSON)
+
+module Perennial
+  module Protocols
+    module JSONTransport
+      
+      SEPERATOR = "\r\n".freeze
+      
+      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
+          
+        end
+      end
+      
+      module InstanceMethods
+        
+        def receive_data(data)
+          protocol_buffer.extract(data).each do |part|
+            receive_line(part)
+          end
+        end
+        
+        def receive_line(line)
+          line.strip!
+          response = JSON.parse(line)
+          handle_response(response)
+        rescue Exception => e
+          # Typically a problem parsing JSON
+          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,
+            "payload" => data,
+            "sent-at" => Time.now
+          }
+          payload.merge!(options_for_callback(blk))
+          send_data "#{JSON.dump(payload)}#{SEPERATOR}"
+        end
+        
+        def reply(name, data = {}, &blk)
+          data = data.merge("callback-id" => @callback_id) if instance_variable_defined?(:@callback_id) && @callback_id.present?
+          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
+        end
+        
+        def handle_enable_ssl(data)
+          reply :enabled_ssl
+          enable_ssl
+        end
+        
+        def handle_enabled_ssl(data)
+          enable_ssl
+        end
+        
+        # Do Nothing
+        def handle_noop(data)
+        end
+        
+        # A remote exception in the processing
+        def handle_exception(data)
+          logger.warn "Got exception from remote call of #{data["action"]}: #{data["message"]}"
+        end
+        
+        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 options_for_callback(blk)
+          return {} if blk.nil?
+          cb_id = "callback-#{self.object_id}-#{Time.now.to_f}"
+          full_id, count = nil, 0
+          while full_id.nil? || @callbacks.has_key?(full_id)
+            count += 1
+            full_id = callback_id(base, count)
+          end
+          self.callbacks[full_id] = blk
+          {"callback-id" => full_id}
+        end
+        
+        def process_callback(data)
+          if data.is_a?(Hash) && data.has_key?("callback-id")
+            callback = @callbacks.delete(data["callback-id"])
+            callback.call(self, data) if callback.present?
+          end
+        end
+        
+        def callback_id(base, count)
+          Digest::SHA256.hexdigest([base, count].compact.join("-"))
+        end
+        
+        def protocol_buffer
+          @protocol_buffer ||= BufferedTokenizer.new(SEPERATOR)
+        end
+        
+        def callbacks
+          @callbacks ||= {}
+        end
+        
+        def connected?
+          instance_variable_defined?(:@connected) && @connected
+        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
+        end
+        
+        def process_action(name, data)
+          self.event_handlers[name.to_s].each do |handler|
+            if handler.respond_to?(:call)
+              handler.call(data, self)
+            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
+        
+      end
+      
+      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
+      
+    end
+  end
+end

data/lib/perennial/protocols/pure_ruby/json_transport.rb

@@ -0,0 +1,171 @@
+# Most of the code here, esp. the nifty code to handle protocol
+# errors is from the memcache-client gem. for the appropriate license,
+# see licenses/memcache-client.txt
+
+require 'digest/sha2'
+require 'socket'
+require 'net/protocol'
+require 'json' unless defined?(JSON)
+
+# Nasty module declaration out of the way.
+module Perennial; module Protocols; module PureRuby
+end; end; end
+
+begin
+  if defined?(JRUBY_VERSION) || (RUBY_VERSION >= '1.9')
+    require 'timeout'
+    Perennial::TimerImplementation = Timeout
+  else
+    require 'system_timer'
+    Perennial::TimerImplementation = SystemTimer
+  end
+rescue LoadError => e
+  require 'timeout'
+  Perennial::TimerImplementation = Timeout
+end
+
+class Perennial::Protocols::PureRuby::JSONTransport
+  
+  @@callbacks = {}
+  
+  RETRY_DELAY = 30.0
+  SEPERATOR   = "\r\n".freeze
+  
+  attr_reader :host, :port, :retry
+  
+  def initialize(host, port, timeout = nil)
+    @host = host
+    @port = port
+    @timeout = timeout
+  end
+  
+  def write_message(action, payload = {}, &callback)
+    # TODO: Print message.
+    message = JSON.dump({
+      "action"  => action.to_s,
+      "payload" => payload,
+      "sent-at" => Time.now
+    }.merge(callback_options(callback))) + SEPERATOR
+    with_socket { |s| s.write(message) }
+  end
+  
+  def read_message
+    with_socket do |s|
+      message = JSON.parse(s.gets.strip)
+      return false if !message.is_a?(Hash)
+      action, payload = message["action"], message["payload"]
+      return false if !action.is_a?(String)
+      payload = {} unless payload.is_a?(Hash)
+      # We have a processed callback - huzzah!
+      if payload.has_key?("callback-id")
+        callback = @@callbacks.delete(payload["callback-id"])
+        callback.call(action, payload) if callback
+      end
+      return action, payload
+    end
+  end
+  
+  def alive?
+    !!socket
+  end
+  
+  def close
+    @socket.close if @socket && !@socket.closed?
+    @socket = nil
+    @retry = nil
+  end
+  
+  protected
+  
+  def callback_options(blk)
+    return {} if blk.nil?
+    callback_id = Digest::SHA256.hexdigest("#{self.class.name}-#{Time.now.to_f}-#{rand(1_000_000_000)}")
+    @@callbacks[callback_id] = blk
+    {"callback-id" => callback_id}
+  end
+  
+  def with_socket(&blk)
+    blk.call(socket)
+  rescue SocketError, Errno::EAGAIN, Timeout::Error
+    dead!
+  rescue SystemCallError, IOError
+    retried = true
+    retry
+  end
+  
+  def dead!
+    close
+    @retry = Time.now + RETRY_DELAY
+  end
+  
+  def socket
+    return @socket if @socket and not @socket.closed?
+    @socket = nil
+    return if @retry and @retry > Time.now
+    begin
+      @socket = socket_for(@host, @port, @timeout)
+      @socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+      @retry = nil
+    rescue SocketError, SystemCallError, IOError, Timeout::Error => err
+      # TODO: Raise a connection error here
+      dead!
+    end
+    @socket
+  end
+  
+  def socket_for(host = @host, port = @port, timeout = nil)
+    socket = nil
+    if timeout
+      Perennial::TimerImplementation.timeout(timeout) do
+        socket = TCPSocket.new(host, port)
+      end
+    else
+      socket = TCPSocket.new(host, port)
+    end
+    io = BufferedIO.new(socket)
+    io.read_timeout = timeout
+    if timeout
+      secs = Integer(timeout)
+      if timeout
+        secs = Integer(timeout)
+        usecs = Integer((timeout - secs) * 1_000_000)
+        optval = [secs, usecs].pack("l_2")
+        begin
+          io.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+          io.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+        rescue Exception => ex
+          # Solaris, for one, does not like/support socket timeouts.
+        end
+      end
+    end
+    io
+  end
+  
+  class BufferedIO < Net::BufferedIO # :nodoc:
+    BUFSIZE = 1024 * 16
+
+    if RUBY_VERSION < '1.9.1'
+      def rbuf_fill
+        begin
+          @rbuf << @io.read_nonblock(BUFSIZE)
+        rescue Errno::EWOULDBLOCK
+          retry unless @read_timeout
+          if IO.select([@io], nil, nil, @read_timeout)
+            retry
+          else
+            raise Timeout::Error, 'IO timeout'
+          end
+        end
+      end
+    end
+
+    def setsockopt(*args)
+      @io.setsockopt(*args)
+    end
+
+    def gets
+      readuntil(SEPERATOR)
+    end
+  end
+  
+end

data/lib/perennial/protocols/pure_ruby.rb

@@ -0,0 +1,7 @@
+module Perennial
+  module Protocols
+    module PureRuby
+      autoload :JSONTransport, 'perennial/protocols/pure_ruby/json_transport'
+    end
+  end
+end

data/lib/perennial/protocols.rb

@@ -0,0 +1,6 @@
+module Perennial
+  module Protocols
+    autoload :JSONTransport, 'perennial/protocols/json_transport'
+    autoload :PureRuby,      'perennial/protocols/pure_ruby'
+  end
+end

data/lib/perennial/settings.rb

@@ -23,7 +23,7 @@ module Perennial
       end
       
       def root=(path)
-        @@root = File.expand_path(path.to_str)
+        @@root = File.expand_path(path.respond_to?(:to_path) ? path.to_path : path.to_str)
       end
       
       def root

data/lib/perennial.rb

@@ -9,12 +9,12 @@ require 'perennial/exceptions'
 
 module Perennial
   
-  VERSION = [1, 1, 0]
+  VERSION = [1, 2, 0]
   
   has_library :dispatchable, :hookable, :loader, :logger, :nash,
               :loggable, :manifest, :settings, :argument_parser,
               :option_parser, :application, :generator, :daemon,
-              :delegateable, :reloading
+              :delegateable, :reloading, :protocols
   
   def self.included(parent)
     parent.extend(Manifest::Mixin)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: perennial
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Darcy Laycock
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-07 00:00:00 +08:00
+date: 2010-01-02 00:00:00 +08:00
 default_executable: perennial
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -76,6 +76,10 @@ files:
 - lib/perennial/manifest.rb
 - lib/perennial/nash.rb
 - lib/perennial/option_parser.rb
+- lib/perennial/protocols.rb
+- lib/perennial/protocols/json_transport.rb
+- lib/perennial/protocols/pure_ruby.rb
+- lib/perennial/protocols/pure_ruby/json_transport.rb
 - lib/perennial/reloading.rb
 - lib/perennial/settings.rb
 - templates/application.erb
@@ -127,3 +131,5 @@ test_files:
 - test/reloading_test.rb
 - test/settings_test.rb
 - test/test_helper.rb
+- examples/json_echo_client.rb
+- examples/json_echo_server.rb