rails_grip 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 543fe29bbb33ab3fa68744043d958b0ff417561f
+  data.tar.gz: 2a4261dbe4d4fe36b271fde6391e05a8cadd9e48
+SHA512:
+  metadata.gz: 0549e500baf1100baaec263cf4725d486af5cee8dae9ecff8d83ddfa6747d72c63795ca37777f60f20c10134cf50efa637f0890658af22ccc64ff0a3f1e06b57
+  data.tar.gz: 2c365e32cd0e2b06e9410a4941f7bbea5e9bdbde563e93db0c9658ef28b144708d71134f79bb9ee12b05c9716a19d3eb23c4fea1f44ecfbf337664c84fb9c92d

data/lib/gripmiddleware.rb

@@ -0,0 +1,193 @@
+#    gripmiddleware.rb
+#    ~~~~~~~~~
+#    This module implements the GripMiddleware class.
+#    :authors: Konstantin Bokarius.
+#    :copyright: (c) 2015 by Fanout, Inc.
+#    :license: MIT, see LICENSE for more details.
+
+require 'set'
+require 'gripcontrol'
+require_relative 'websocketcontext.rb'
+require_relative 'nonwebsocketrequesterror.rb'
+
+class GripMiddleware
+  def initialize(app)  
+    @app = app  
+  end
+
+  # TODO: Add a mechanism to set to websocket-only.
+  def call(env)
+    env['grip_proxied'] = false
+    env['grip_wscontext'] = nil
+    grip_signed = false
+    grip_proxies = RailsSettings.get_grip_proxies
+    if env.key?('HTTP_GRIP_SIG') and !grip_proxies.nil?
+      grip_proxies.each do |entry|
+        if GripControl.validate_sig(env['HTTP_GRIP_SIG'], entry['key'])         
+          grip_signed = true
+          break
+        end
+      end
+    end
+    content_type = nil
+    if env.key?('CONTENT_TYPE')
+      content_type = env['CONTENT_TYPE']
+      at = content_type.index(';')
+      if !at.nil?
+        content_type = content_type[0..at-1]
+      end
+    end
+    accept_types = nil
+    if env.key?('HTTP_ACCEPT')
+      accept_types = env['HTTP_ACCEPT']
+      tmp = accept_types.split(',')
+      accept_types = []
+      tmp.each do |s|
+        accept_types.push(s.strip)
+      end
+    end
+    wscontext = nil
+    if env['REQUEST_METHOD'] == 'POST' and ((content_type == 
+        'application/websocket-events') or (!accept_types.nil? and
+        accept_types.include?('application/websocket-events')))
+      cid = nil
+      if env.key?('HTTP_CONNECTION_ID')
+        cid = env['HTTP_CONNECTION_ID']
+      end
+      meta = {}
+      env.each do |k, v|
+        if k.start_with?('HTTP_META_')
+          meta[convert_header_name(k[10..-1])] = v
+        end
+      end
+      events = nil
+      begin
+        events = GripControl.decode_websocket_events(env["rack.input"].read)
+      rescue
+        return [ 400, {}, ["Error parsing WebSocket events.\n"]]
+      end
+      wscontext = WebSocketContext.new(cid, meta, events)
+    end
+    env['grip_proxied'] = grip_signed
+    env['grip_wscontext'] = wscontext
+    begin
+      status, headers, response = @app.call(env)
+    rescue NonWebSocketRequestError => e 
+      return [400, {}, [e.message + "\n"]]
+    end
+    if !env['grip_wscontext'].nil? and status == 200
+      wscontext = env['grip_wscontext']
+      meta_remove = Set.new
+      wscontext.orig_meta.each do |k, v|
+        found = false
+        wscontext.meta.each do |nk, nv|
+          if nk.downcase == k
+            found = true
+            break
+          end
+        end
+        if !found
+          meta_remove.add(k)
+        end
+      end
+      meta_set = {}
+      wscontext.meta.each do |k, v|
+        lname = k.downcase
+        need_set = true        
+        wscontext.orig_meta.each do |ok, ov|
+          if lname == ok and v == ov
+            need_set = false
+            break
+          end
+        end
+        if need_set
+          meta_set[lname] = v
+        end
+      end
+      events = []
+      if wscontext.accepted
+        events.push(WebSocketEvent.new('OPEN'))
+      end
+      events.push(*wscontext.out_events)
+      if wscontext.closed
+        events.push(WebSocketEvent.new('CLOSE',
+            [wscontext.out_close_code].pack('S_')))
+      end
+      if response.respond_to?(:content_type)
+        response.body = GripControl.encode_websocket_events(events)
+        response.content_type = 'application/websocket-events'
+      else
+        response = [GripControl.encode_websocket_events(events)]
+      end
+      headers['Content-Type'] = 'application/websocket-events'
+      if wscontext.accepted
+				headers['Sec-WebSocket-Extensions'] = 'grip'
+      end
+      meta_remove.each do |k, v|
+		    headers['Set-Meta-' + k] = ''
+      end
+      meta_set.each do |k, v|
+		    headers['Set-Meta-' + k] = v
+      end
+    elsif !env['grip_hold'].nil?
+      if !env['grip_proxied'] and RailsSettings.get_grip_proxy_required
+        return [ 501, {}, ["Not implemented.\n"]]
+      end
+      channels = env['grip_channels']
+      prefix = RailsSettings.get_prefix
+      if prefix != ''
+        channels.each do |channel|
+          channel.name = prefix + channel.name
+        end
+      end
+      if status == 304
+        iheaders = headers.clone
+        if !iheaders.key?('Location') and response.respond_to?(:location) and
+            !response.location.nil?
+          iheaders['Location'] = response.location
+        end
+        if response.respond_to?(:body)
+          orig_body = response.body
+        else
+          orig_body = response.to_s
+        end
+        iresponse = Response.new(status, nil, iheaders, orig_body)
+        timeout = nil
+        if !env['grip_timeout'].nil?
+          timeout = env['grip_timeout']
+        end
+        if response.respond_to?(:content_type)
+          response.body = GripControl.create_hold(env['grip_hold'],
+              channels, iresponse, timeout)
+          response.content_type = 'application/grip-instruct'
+        else
+          response = [GripControl.create_hold(env['grip_hold'],
+              channels, iresponse, timeout)]
+        end
+        headers = {'Content-Type' => 'application/grip-instruct'}
+      else
+        headers['Grip-Hold'] = env['grip_hold']
+        headers['Grip-Channel'] = GripControl.create_grip_channel_header(
+            channels)
+        if !env['grip_timeout'].nil?
+          headers['Grip-Timeout'] = env['grip_timeout'].to_s
+        end
+      end
+    end
+    return [status, headers, response]
+  end
+
+  private
+
+  def convert_header_name(name)
+    out = ''
+    name.each_char do |c|
+      if c == '_'
+        out += '-'
+      else
+        out += c.downcase
+      end
+    end
+    return out
+  end
+end

data/lib/nonwebsocketrequesterror.rb

@@ -0,0 +1,12 @@
+#    nonwebsocketrequesterror.rb
+#    ~~~~~~~~~
+#    This module implements the NonWebSocketRequestError class.
+#    :authors: Konstantin Bokarius.
+#    :copyright: (c) 2015 by Fanout, Inc.
+#    :license: MIT, see LICENSE for more details.
+
+class NonWebSocketRequestError < StandardError
+  def message
+    "This endpoint only allows WebSocket requests."
+  end
+end

data/lib/rails_grip.rb

@@ -0,0 +1,92 @@
+#    rails_grip.rb
+#    ~~~~~~~~~
+#    This module implements the RailsGrip class.
+#    :authors: Konstantin Bokarius.
+#    :copyright: (c) 2015 by Fanout, Inc.
+#    :license: MIT, see LICENSE for more details.
+
+require 'pubcontrol'
+require 'gripcontrol'
+
+require_relative 'railssettings.rb'
+require_relative 'gripmiddleware.rb'
+
+class RailsGrip
+  def self.publish(channel, formats, id=nil, prev_id=nil)
+    pub = RailsGrip.get_pubcontrol
+    pub.publish(RailsSettings.get_prefix + channel, Item.new(
+        formats, id,prev_id))
+  end
+
+  def self.publish_async(channel, formats, id=nil, prev_id=nil, callback=nil)
+    pub = RailsGrip.get_pubcontrol
+    pub.publish_async(RailsSettings.get_prefix + channel, 
+        Item.new(formats, id, prev_id), callback)
+  end
+
+  def self.set_hold_longpoll(request, channels, timeout=nil)
+    request.env['grip_hold'] = 'response'
+    request.env['grip_channels'] = RailsGrip.convert_channels(channels)
+    request.env['grip_timeout'] = timeout
+  end
+
+  def self.set_hold_stream(request, channels)
+    request.env['grip_hold'] = 'stream'
+    request.env['grip_channels'] = RailsGrip.convert_channels(channels)
+  end
+
+  def self.is_grip_proxied(request)
+    if request.env.key?('grip_proxied')
+      return request.env['grip_proxied']
+    end
+    return false
+  end
+
+  def self.get_wscontext(request)
+    if request.env.key?('grip_wscontext')
+      return request.env['grip_wscontext']
+    end
+    return nil
+  end
+
+  def self.verify_is_websocket(request)
+    if !RailsGrip.get_wscontext(request)
+      raise NonWebSocketRequestError
+    end
+  end
+
+  private
+
+  def self.get_pubcontrol
+    if Thread.current['pubcontrol'].nil?
+      pub = GripPubControl.new
+      grip_proxies = RailsSettings.get_grip_proxies
+      publish_servers = RailsSettings.get_publish_servers
+      if !grip_proxies.nil?
+        pub.apply_grip_config(grip_proxies)
+      end
+      if !publish_servers.nil?
+        pub.apply_config(publish_servers)
+      end
+      at_exit { pub.finish }
+      Thread.current['pubcontrol'] = pub
+    end
+    return Thread.current['pubcontrol']
+  end
+
+  def self.convert_channels(channels)
+    if channels.is_a?(Channel) or channels.is_a?(String)
+      channels = [channels]
+    end
+    out = []
+    channels.each do |channel|
+      if channel.is_a?(String)
+        channel = Channel.new(channel)
+      end
+      out.push(channel)
+    end
+    return out
+  end
+end
+
+require_relative 'railtie.rb' if defined? Rails::Railtie

data/lib/railssettings.rb

@@ -0,0 +1,36 @@
+#    railssettings.rb
+#    ~~~~~~~~~
+#    This module implements the RailsSettings class.
+#    :authors: Konstantin Bokarius.
+#    :copyright: (c) 2015 by Fanout, Inc.
+#    :license: MIT, see LICENSE for more details.
+
+class RailsSettings
+  def self.get_prefix
+    if Rails.application.config.respond_to?(:grip_prefix)
+      return Rails.application.config.grip_prefix
+    end
+    return ''
+  end
+
+  def self.get_grip_proxies
+    if Rails.application.config.respond_to?(:grip_proxies)
+      return Rails.application.config.grip_proxies
+    end
+    return nil
+  end
+
+  def self.get_publish_servers
+    if Rails.application.config.respond_to?(:publish_servers)
+      return Rails.application.config.publish_servers
+    end
+    return nil
+  end
+
+  def self.get_grip_proxy_required
+    if Rails.application.config.respond_to?(:grip_proxy_required)
+      return Rails.application.config.grip_proxy_required
+    end
+    return false
+  end
+end

data/lib/railtie.rb

@@ -0,0 +1,12 @@
+#    railtie.rb
+#    ~~~~~~~~~
+#    This module implements the Railtie class.
+#    :authors: Konstantin Bokarius.
+#    :copyright: (c) 2015 by Fanout, Inc.
+#    :license: MIT, see LICENSE for more details.
+
+class Railtie < Rails::Railtie
+  initializer "rails_grip.configure_rails_initialization" do
+    Rails.application.middleware.use GripMiddleware
+  end
+end

data/lib/websocketcontext.rb

@@ -0,0 +1,107 @@
+#    websocketcontext.rb
+#    ~~~~~~~~~
+#    This module implements the WebSocketContext class.
+#    :authors: Konstantin Bokarius.
+#    :copyright: (c) 2015 by Fanout, Inc.
+#    :license: MIT, see LICENSE for more details.
+
+require 'gripcontrol'
+
+class WebSocketContext
+  attr_accessor :orig_meta
+  attr_accessor :meta
+  attr_accessor :accepted
+  attr_accessor :out_events
+  attr_accessor :closed
+  attr_accessor :out_close_code
+  attr_accessor :close_code
+
+  def initialize(id, meta, in_events)
+    @id = id
+    @in_events = in_events
+    @read_index = 0
+    @accepted = false
+    @close_code = nil
+    @closed = false
+    @out_close_code = nil
+    @out_events = []
+    @orig_meta = meta
+    @meta = Marshal.load(Marshal.dump(meta))
+  end
+
+  def is_opening
+    return (!@in_events.nil? and @in_events.length > 0 and 
+        @in_events[0].type == 'OPEN')
+  end
+
+  def accept
+    @accepted = true
+  end
+
+  def close(code=nil)
+    @closed = true
+    if !code.nil?
+      @out_close_code = code
+    else
+      @out_close_code = 0
+    end
+  end
+
+  def can_recv
+    for n in @read_index..@in_events.length-1 do
+      if ['TEXT', 'BINARY', 'CLOSE', 'DISCONNECT'].include?(
+          @in_events[n].type)
+        return true
+      end
+    end
+    return false
+  end
+
+  def recv
+    e = nil
+    while e.nil? and @read_index < @in_events.length do
+      if ['TEXT', 'BINARY', 'CLOSE', 'DISCONNECT'].include?(
+          @in_events[@read_index].type)
+        e = @in_events[@read_index]
+      elsif @in_events[@read_index].type == 'PING'
+        @out_events.push(WebSocketEvent.new('PONG'))
+      end
+      @read_index += 1
+    end
+    if e.nil?
+      raise 'read from empty buffer'
+    end
+    if e.type == 'TEXT' or e.type == 'BINARY'
+      return e.content
+    elsif e.type == 'CLOSE'
+      if !e.content.nil? and e.content.length == 2
+        @close_code = e.content.unpack('S_')[0]
+      end
+      return nil
+    else
+      raise 'client disconnected unexpectedly'
+    end
+  end
+
+  def send(message)
+    @out_events.push(WebSocketEvent.new('TEXT', 'm:' + message))
+  end
+
+  def send_control(message)
+    @out_events.push(WebSocketEvent.new('TEXT', 'c:' + message))
+  end
+
+  def subscribe(channel)
+    send_control(GripControl.websocket_control_message(
+        RailsSettings.get_prefix + 'subscribe', {'channel' => channel}))
+  end
+
+  def unsubscribe(channel)
+    send_control(GripControl.websocket_control_message(
+        RailsSettings.get_prefix + 'unsubscribe', {'channel' => channel}))
+  end
+
+  def detach(channel)
+    send_control(GripControl.websocket_control_message('detach'))
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: rails_grip
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Konstantin Bokarius
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gripcontrol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A Ruby on Rails convenience library for working with GRIP proxies.
+email: bokarius@comcast.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/gripmiddleware.rb
+- lib/nonwebsocketrequesterror.rb
+- lib/rails_grip.rb
+- lib/railssettings.rb
+- lib/railtie.rb
+- lib/websocketcontext.rb
+homepage: https://github.com/fanout/rails-grip
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: GRIP library for Ruby on Rails
+test_files: []