reel-io 0.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b46155d8f78297c924151729c44bf1cbb654d797
+  data.tar.gz: fcdf2057bd1980f8c6be37dd418dc510ce92c12a
+SHA512:
+  metadata.gz: 10efb065e937a78f27c9af9b3fb7785d7d6ae663eae5c54df6105fa26006b6b16f9d869b2a606b7a9c96f767757de9a570e4769adc5426f086df7ef3b62dd2c0
+  data.tar.gz: 77e7c5a5c4f309e31ce4af0433fa19dd33b2e713b1582e985a18ba9b95dc6c3d108985bb1c21c936f3f149a92c50ef6f75de018e0f9f970b56e7c18da41beb3d

data/lib/reel/io.rb

@@ -0,0 +1,27 @@
+require 'forwardable'
+require 'celluloid/current'
+require 'websocket/driver'
+
+module Reel::IO
+  require 'reel/io/singletons'
+  require 'reel/io/accessors'
+  require 'reel/io/connection'
+  require 'reel/io/websocket'
+  require 'reel/io/eventsource'
+  class << self
+    extend Forwardable
+    def_delegators WebSocket, websocket?, websocket!
+    def_delegators EventSource, eventsource?, eventsource!
+    def_delegators Connection, persistent?, persistent!, :[], :[]=
+  end
+
+  class Server
+    #de TODO: Replace Reel internals with this module
+  end
+
+  class Client
+    #de TODO: Replace celluloid-websocket-client.
+    #de       Same API goes either direction.
+  end
+
+end

data/lib/reel/io/accessors.rb

@@ -0,0 +1,55 @@
+module Reel::IO::Accessors
+  HEADERS = {
+    'HTTP_ORIGIN'                   => 'Origin',
+    'HTTP_SEC_WEBSOCKET_KEY'        => 'Sec-WebSocket-Key',
+    'HTTP_SEC_WEBSOCKET_KEY1'       => 'Sec-WebSocket-Key1',
+    'HTTP_SEC_WEBSOCKET_KEY2'       => 'Sec-WebSocket-Key2',
+    'HTTP_SEC_WEBSOCKET_EXTENSIONS' => 'Sec-WebSocket-Extensions',
+    'HTTP_SEC_WEBSOCKET_PROTOCOL'   => 'Sec-WebSocket-Protocol',
+    'HTTP_SEC_WEBSOCKET_VERSION'    => 'Sec-WebSocket-Version'
+  }.freeze
+
+  PORTABLE_HASH = Hash.new do |hash, key|
+    if key
+      result = hash.keys.find {|k| "#{k}" =~ /#{key}/i}
+      result = hash[HEADERS[key]] unless result
+      hash[result]
+    end
+  end
+
+  def context(env={})
+    @options = env.delete(:options) || {} unless @context
+    @context ||= PORTABLE_HASH.merge(env)
+  end
+
+  def url
+    @url ||= "#{(secure?) ? 'wss' : 'ws'}://#{context[:HTTP_HOST]}#{context[:REQUEST_URI]}"
+  end  
+
+  HEADERS = {
+    'HTTP_ORIGIN'                   => 'Origin',
+    'HTTP_SEC_WEBSOCKET_KEY'        => 'Sec-WebSocket-Key',
+    'HTTP_SEC_WEBSOCKET_KEY1'       => 'Sec-WebSocket-Key1',
+    'HTTP_SEC_WEBSOCKET_KEY2'       => 'Sec-WebSocket-Key2',
+    'HTTP_SEC_WEBSOCKET_EXTENSIONS' => 'Sec-WebSocket-Extensions',
+    'HTTP_SEC_WEBSOCKET_PROTOCOL'   => 'Sec-WebSocket-Protocol',
+    'HTTP_SEC_WEBSOCKET_VERSION'    => 'Sec-WebSocket-Version'
+  }.freeze
+
+  PORTABLE_HASH = Hash.new do |hash, key|
+    if key
+      result = hash.keys.find {|k| "#{k}" =~ /#{key}/i}
+      result = hash[HEADERS[key]] unless result
+      hash[result]
+    end
+  end
+
+  def context(env={})
+    @options = env.delete(:options) || {} unless @context
+    @context ||= PORTABLE_HASH.merge(env)
+  end
+
+  def url
+    @url ||= "#{(secure?) ? 'wss' : 'ws'}://#{context[:HTTP_HOST]}#{context[:REQUEST_URI]}"
+  end
+end

data/lib/reel/io/connection.rb

@@ -0,0 +1,95 @@
+class Reel::IO::Connection
+
+  def websocket?
+    self.class == Reel::IO::WebSocket
+  end
+
+  def eventsource?
+    self.class == Reel::IO::EventSource
+  end
+
+  extend Reel::IO::Singletons::Connection
+
+  include Celluloid
+  include Reel::IO::Accessors
+  include Reel::IO::Streamers
+  extend Forwardable
+
+  attr_reader :io, :url
+  alias :env :context
+  alias :socket :io
+
+  def initialize
+    @polling = @options.fetch(:polling, :perpetual)
+    @autostart = @options.fetch(:autostart, true) #de Only if there are emitters:
+    @emitters = @options.fetch(:emitters, {})
+    @message_buffer = []
+    @driver.on(:message) do |message|
+      @message_buffer.push(message.data)
+    end
+    @driver.on(:close) do
+      @io.close
+    end
+    @driver.start
+
+    @io ||= begin
+      context_suffixed(:hijack).call
+      context_suffixed(:hijack_io)
+    end
+
+    @io = Celluloid::IO::TCPSocket.new(@io)
+
+    if @emitters.any?
+      @emitters.each { |type, proc|
+        @driver.on(type, proc)
+      }
+      run if @autostart
+    end
+  end
+
+  attr_reader :socket
+  def_delegators :@io, :addr, :peeraddr
+  def_delegators :@driver, :ping, :on
+
+  def secure?
+    @secure ||= (@url && @url.start_with?('wss://')) ||
+                @context['HTTP_PORT'] == 443 ||
+                @context['HTTPS'] == true ||
+                @contex.select { |k,v| k.downcase.end_with?("scheme") && v.downcase == 'https' } > 0 ||
+  end
+
+  def closed?
+    @io.closed?
+  end
+
+  def close
+    @driver.close
+    @io.close
+  rescue
+  end
+
+  def context_suffixed(*key)
+    return key.find { |k| context_suffixed(k) } unless key.one?
+    key = "#{key.first}".downcase
+    context.find { |k, v| "#{k}".end_with?(key) && v }
+  end
+
+  def cancel_timer!
+    @timer && @timer.cancel
+  end
+
+  def server?
+    @mode == :server
+  end
+
+  def client?
+    @mode == :client
+  end
+
+  [:message, :error, :close, :ping, :pong].each do |meth|
+    define_method "on_#{meth}" do |&proc|
+      @driver.send(:on, meth, &proc)
+    end
+  end
+
+end

data/lib/reel/io/eventsource.rb

@@ -0,0 +1,6 @@
+class Reel::IO::WebSocket < Reel::IO::Connection
+  extend Reel::IO::Singletons::EventSource
+
+  #de TODO: Port Faye::EventSource
+
+end

data/lib/reel/io/singletons.rb

@@ -0,0 +1,73 @@
+module Reel::IO::Singletons
+
+  module WebSocket
+    def websocket!(env, io=nil)
+      Reel::IO::WebSocket.new(env, io)      
+    end
+    alias :[]= :websocket!
+    alias :[] :websocket!
+
+    def websocket?(env)
+      return false unless env['REQUEST_METHOD'] == 'GET'
+      connection, upgrade = Reel::IO::Singletons::Connection.header(env, :connection,  :upgrade)
+      connection.downcase.split(/ *, */).include?('upgrade') and
+      upgrade.downcase == 'websocket'
+    end
+  end
+
+  module EventSource
+    def eventsource!(env, io=nil)
+      Reel::IO::EventSource.new(env, io)      
+    end
+    alias :[]= :eventsource!
+    alias :[] :eventsource!
+    def eventsource?(env)
+      return false unless env['REQUEST_METHOD'] == 'GET'
+      Reel::IO::Singletons::Connection.header(env, :accept)
+        .downcase.split(/\s*,\s*/)
+        .include?('text/event-stream')
+    end
+  end
+
+  module Connection
+
+    extend Forwardable
+    def_delegators Reel::IO::WebSocket,
+                   :websocket!,
+                   :websocket?
+
+    def_delegators Reel::IO::EventSource,
+                   :eventsource!,
+                   :eventsource?
+
+    def []=(env)
+      persistent!(env)
+    end
+
+    def []=(env, io)
+      persistent!(env, io)
+    end
+
+    def persistent!(env, io=nil)
+      return unless persistent?(env)
+      return websocket!(env, io) if websocket?(env)
+      eventsource!(env, io)
+    end
+    def :connection! :persistent!
+    def :channel! :persistent!
+
+    def persistent?(env)
+      websocket?(env) || eventsource?(env)
+    end
+
+    def header(env, *key)
+      if key.length > 1
+        return key.map { |k| header(env, k) }
+      else
+        key = key.first
+      end
+      [ "HTTP_#{key}".upcase, "#{key}".capitalize ].find { |k| !env[k].nil? } || ''
+    end
+  end
+
+end

data/lib/reel/io/streamers.rb

@@ -0,0 +1,65 @@
+module Reel::IO::Streamers
+
+  def run
+    (polling?) ? async.reading! || async.read && read_every(@polling)
+  end
+
+  alias :run! :run
+  alias :poll :run
+  alias :poll! :run
+  alias :start :run
+  alias :start! :run
+  alias :go :run
+  alias :go! :run
+
+  def reading!
+    loop {
+      read
+    }
+  end
+
+  def perpetual?
+    @polling == :perpetual
+  end
+
+  def write(msg)
+    if msg.is_a? String
+      @driver.text(msg)
+    elsif msg.is_a? Array
+      @driver.binary(msg)
+    else
+      raise "Can only send byte array or string over driver."
+    end
+  rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+    cancel_timer!
+    raise SocketError, "error writing to socket"
+  rescue
+    cancel_timer!
+    raise
+  end
+  alias_method :<<, :write
+
+  def read
+    while @message_buffer.empty?
+      buffer = @io.readpartial(Connection::BUFFER_SIZE)
+      @driver.parse(buffer)
+    end
+    @message_buffer.shift
+  end
+
+  def read_every(n, unit = :s)
+    cancel_timer! # only one timer allowed per stream
+    seconds = case unit.to_s
+    when /\Am/
+      n * 60
+    when /\Ah/
+      n * 3600
+    else
+      n
+    end
+    @timer = every(seconds) { read }
+  end
+  alias read_interval  read_every
+  alias read_frequency read_every
+
+end

data/lib/reel/io/websocket.rb

@@ -0,0 +1,39 @@
+class Reel::IO::WebSocket < Reel::IO::Connection
+
+  extend Reel::IO::Singletons::WebSocket
+
+  def initialize(*args)
+    if args.last.respond_to? :to_io
+      @mode = :server
+      @io = args.pop
+    end
+
+    if args.first.is_a? Hash
+      env = args.shift
+      @url = env.delete(:connect)
+    elsif args.first.is_a? String
+      @mode = :client
+      @url = args.shift
+    end
+
+    raise ArgumentError unless args.empty? && (env.is_a?(Hash) || @url.is_a?(String) && !@url.empty?)
+    @mode ||= (@url) ? :client : :server
+    context(env)
+
+    @driver = if server?
+      if context[:HTTP_SEC_WEBSOCKET_VERSION]
+        ::WebSocket::Hybi.new(Celluloid::Actor.curent, @options.merge(require_masking: true))
+      elsif context[:HTTP_SEC_WEBSOCKET_KEY1]
+        ::WebSocket::Draft76.new(Celluloid::Actor.curent, @options)
+      else
+        ::WebSocket::Draft75.new(Celluloid::Actor.curent, @options)
+      end
+    else
+      ::WebSocket::Client.new(Celluloid::Actor.current, @options.merge(masking: true))
+    end
+
+    super()
+  rescue EOFError
+    close
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: reel-io
+version: !ruby/object:Gem::Version
+  version: 0.0.0.pre
+platform: ruby
+authors:
+- digitalextremist //
+- Tony Arcieri
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+  name: websocket-driver
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  name: celluloid
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.16.5.pre0
+  name: celluloid-io
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.16.5.pre0
+description: Evented WebSockets and Server Side Events for Ruby, using Celluloid::IO and WebSocket::Driver.
+email:
+- code@extremist.digital
+- tony.arcieri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/reel/io.rb
+- lib/reel/io/accessors.rb
+- lib/reel/io/connection.rb
+- lib/reel/io/eventsource.rb
+- lib/reel/io/singletons.rb
+- lib/reel/io/streamers.rb
+- lib/reel/io/websocket.rb
+homepage: https://github.com/celluloid/reel-io
+licenses:
+- MIT
+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: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: Simple, non-blocking persistent I/O for HTTP/S servers.
+test_files: []