RubyGems - thin-em-websocket-gmalette - Versions diffs - 0.0.1 - Mend

thin-em-websocket-gmalette 0.0.1

Files changed (12) hide show

checksums.yaml +7 -0
data/.gitignore +18 -0
data/Gemfile +4 -0
data/LICENSE +26 -0
data/README.md +29 -0
data/Rakefile +2 -0
data/examples/Gemfile +1 -0
data/examples/config.ru +38 -0
data/lib/thin-em-websocket.rb +282 -0
data/lib/thin-em-websocket/version.rb +5 -0
data/thin-em-websocket.gemspec +21 -0
metadata +95 -0

checksums.yaml ADDED

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e56114ee23b9f4aba27e061eb7f9c850c225510
+  data.tar.gz: f15eb765178e22d51559af04e72f6cdd5c8bb51f
+SHA512:
+  metadata.gz: 945be7f0b09249e287eed6be7adeaca7b6f0f6165f6397a1c5d21f0f752e0a20993bd1e308cfb107291b559df194590f3d6d1ffd57fa7ceb045275273d158517
+  data.tar.gz: 1b94b5351db6402683a36ee0280f967bf4e1e4e1c6d7da99501a95e056802298393325d65c98dc9ed56ba2ea06c549b85e5f25e56263849e449d5f8bd125c0a9

data/.gitignore ADDED

@@ -0,0 +1,18 @@
+*.swp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile ADDED

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in thin-em-websocket.gemspec
+gemspec

data/LICENSE ADDED

@@ -0,0 +1,26 @@
+Copyright (c) 2012 Sam Saffron
+portions from em-websocket
+Copyright (c) 2009 Ilya Grigorik
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED

@@ -0,0 +1,29 @@
+# Thin::Em::Websocket
+Thin support for the em-websocket gem
+## Installation
+Add this line to your application's Gemfile:
+    gem 'thin-em-websocket'
+And then execute:
+    $ bundle
+Or install it yourself as:
+    $ gem install thin-em-websocket
+## Usage
+## Contributing
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile ADDED

	@@ -0,0 +1,2 @@
1	+ #!/usr/bin/env rake
2	+ require "bundler/gem_tasks"

data/examples/Gemfile ADDED

	@@ -0,0 +1 @@
1	+ gem 'thin-em-websocket', :path => '../'

data/examples/config.ru ADDED

@@ -0,0 +1,38 @@
+require 'thin-em-websocket'
+echo = lambda do |env|
+  connection = env['em.connection']
+  if connection && connection.websocket?
+    puts "upgrading web socket"
+    begin
+      connection.upgrade_websocket
+    rescue => e
+      p "#{e}"
+      e.backtrace.each do |b|
+        p b
+      end
+    end
+    connection.onmessage { |m|
+      puts "GOT #{m}"
+      connection.send(m)
+      puts "SEND #{m}"
+    }
+    return Thin::Connection::AsyncResponse
+  end
+  [200, {"Content-Type" => "text/html"}, [<<-HTML
+    <html>
+    <body>
+      <script>
+        socket = new WebSocket("ws://" + document.location.hostname + ":" + (document.location.port || 80) + "/ws");
+        socket.onerror = function(m){ alert("error: " + m); };
+        socket.onopen = function() { alert("connected"); socket.send("hello world") };
+        socket.onmessage = function(msg) { alert(msg.data); }
+      </script>
+    </body>
+    </html>
+HTML
+  ]]
+end
+run echo

data/lib/thin-em-websocket.rb ADDED

@@ -0,0 +1,282 @@
+# much of the code here is lifted from https://github.com/igrigorik/em-websocket/blob/master/lib/em-websocket/connection.rb
+require "thin-em-websocket/version"
+require "em-websocket"
+module ThinEM
+  module Websocket
+  end
+end
+# connection SHIM, so we only override minimal amounts of thin
+class ThinEM::Websocket::Connection
+  attr_writer :max_frame_size
+  # define WebSocket callbacks
+  def onopen(&blk);     @onopen = blk;    end
+  def onclose(&blk);    @onclose = blk;   end
+  def onerror(&blk);    @onerror = blk;   end
+  def onmessage(&blk);  @onmessage = blk; end
+  def onping(&blk);     @onping = blk;    end
+  def onpong(&blk);     @onpong = blk;    end
+  def trigger_on_message(msg)
+    @onmessage.call(msg) if @onmessage
+  end
+  def trigger_on_open
+    @onopen.call if @onopen
+  end
+  def trigger_on_close
+    @onclose.call if @onclose
+  end
+  def trigger_on_ping(data)
+    @onping.call(data) if @onping
+  end
+  def trigger_on_pong(data)
+    @onpong.call(data) if @onpong
+  end
+  def trigger_on_error(reason)
+    return false unless @onerror
+    @onerror.call(reason)
+    true
+  end
+  def initialize(connection)
+    @connection = connection
+    @logger = Class.new do
+      def error(m); end
+      def warn(m); end
+      def debug(m); end
+      def info(m); end
+    end.new
+  end
+  def logger=(logger)
+    @logger = logger
+  end
+  def websocket?
+    true
+  end
+  def upgrade_websocket
+    return if @handler
+    @handler = EM::WebSocket::HandlerFactory.build(self, @connection.ws_buffer, false, nil)
+    unless @handler
+      # see: https://github.com/learnboost/socket.io/commit/9982232032771574ceb68e2bccee4e43fd5af887#diff-0
+      # hixie-76 behind HAProxy gets a bit messy, we need to send the header first to unblock the stream
+      if !@sent_upgrade && @connection.ws_buffer =~ /sec-websocket-key1/i
+        @logger.info("WebSocket: attempting hixie 76 hack")
+        fake_buffer = @connection.ws_buffer.dup
+        fake_buffer << "12345678"
+        (header, remains) = fake_buffer.split("\r\n\r\n", 2)
+        fake_handler = EM::WebSocket::HandlerFactory.build(self, fake_buffer, false, nil)
+        @handshake_76_without_verify = fake_handler.handshake[0..-17]
+        send_data(@handshake_76_without_verify)
+        @sent_upgrade = true
+      end
+    end
+    @connection.set_comm_inactivity_timeout(0) if @handler
+    @handler.run if @handler
+  end
+  def upgraded?
+    !@handler.nil?
+  end
+  def pending_upgrade?
+    @handler.nil? && @sent_upgrade
+  end
+  # Cache encodings since it's moderately expensive to look them up each time
+  ENCODING_SUPPORTED = "string".respond_to?(:force_encoding)
+  UTF8 = Encoding.find("UTF-8") if ENCODING_SUPPORTED
+  BINARY = Encoding.find("BINARY") if ENCODING_SUPPORTED
+  def send_data(data)
+    if @sent_upgrade && !@upgrade_stripped
+      # strip it
+      raise EventMachine::WebSocket::HandshakeError if @handshake_76_without_verify != data[0..@handshake_76_without_verify.length-1]
+      data = data[@handshake_76_without_verify.length..-1]
+      @upgrade_stripped = true
+    end
+    @connection.send_data(data)
+  end
+  def receive_data(data)
+    begin
+      @logger.info("Got Socket Data (l: #{data.length})")
+      @handler.receive_data(data)
+    rescue EventMachine::WebSocket::HandshakeError => e
+      @logger.warn("Web Socket Failed to handshake")
+      trigger_on_error(e)
+      # Errors during the handshake require the connection to be aborted
+      abort
+    rescue EventMachine::WebSocket::WSProtocolError => e
+      @logger.warn("Web Socket Protocol Error")
+      trigger_on_error(e)
+      close_websocket_private(e.code)
+    rescue => e
+        # These are application errors - raise unless onerror defined
+      trigger_on_error(e) || raise(e)
+      # There is no code defined for application errors, so use 3000
+      # (which is reserved for frameworks)
+      close_websocket_private(3000)
+    end
+  end
+  # Send a WebSocket text frame.
+  #
+  # A WebSocketError may be raised if the connection is in an opening or a
+  # closing state, or if the passed in data is not valid UTF-8
+  #
+  def send(data)
+    # If we're using Ruby 1.9, be pedantic about encodings
+    if ENCODING_SUPPORTED
+      # Also accept ascii only data in other encodings for convenience
+      unless (data.encoding == UTF8 && data.valid_encoding?) || data.ascii_only?
+        raise WebSocketError, "Data sent to WebSocket must be valid UTF-8 but was #{data.encoding} (valid: #{data.valid_encoding?})"
+      end
+      # This labels the encoding as binary so that it can be combined with
+      # the BINARY framing
+      data.force_encoding(BINARY)
+    else
+      # TODO: Check that data is valid UTF-8
+    end
+    if @handler
+      @handler.send_text_frame(data)
+    else
+      raise WebSocketError, "Cannot send data before onopen callback"
+    end
+    # Revert data back to the original encoding (which we assume is UTF-8)
+    # Doing this to avoid duping the string - there may be a better way
+    data.force_encoding(UTF8) if ENCODING_SUPPORTED
+    return nil
+  end
+  # Send a ping to the client. The client must respond with a pong.
+  #
+  # In the case that the client is running a WebSocket draft < 01, false
+  # is returned since ping & pong are not supported
+  #
+  def ping(body = '')
+    if @handler
+      @handler.pingable? ? @handler.send_frame(:ping, body) && true : false
+    else
+      raise WebSocketError, "Cannot ping before onopen callback"
+    end
+  end
+  # Send an unsolicited pong message, as allowed by the protocol. The
+  # client is not expected to respond to this message.
+  #
+  # em-websocket automatically takes care of sending pong replies to
+  # incoming ping messages, as the protocol demands.
+  #
+  def pong(body = '')
+    if @handler
+      @handler.pingable? ? @handler.send_frame(:pong, body) && true : false
+    else
+      raise WebSocketError, "Cannot ping before onopen callback"
+    end
+  end
+  # Test whether the connection is pingable (i.e. the WebSocket draft in
+  # use is >= 01)
+  def pingable?
+    if @handler
+      @handler.pingable?
+    else
+      raise WebSocketError, "Cannot test whether pingable before onopen callback"
+    end
+  end
+  def state
+    @handler ? @handler.state : :handshake
+  end
+  # Returns the maximum frame size which this connection is configured to
+  # accept. This can be set globally or on a per connection basis, and
+  # defaults to a value of 10MB if not set.
+  #
+  # The behaviour when a too large frame is received varies by protocol,
+  # but in the newest protocols the connection will be closed with the
+  # correct close code (1009) immediately after receiving the frame header
+  #
+  def max_frame_size
+    @max_frame_size || EventMachine::WebSocket.max_frame_size
+  end
+  def close_connection_after_writing()
+    @connection.close_connection_after_writing()
+  end
+  private
+  # As definited in draft 06 7.2.2, some failures require that the server
+  # abort the websocket connection rather than close cleanly
+  def abort
+    @connection.close_connection
+  end
+  def close_websocket_private(code, body = nil)
+    if @handler
+      @handler.close_websocket(code, body)
+    else
+      # The handshake hasn't completed - should be safe to terminate
+      abort
+    end
+  end
+end
+class Thin::Connection
+  # based off https://github.com/faye/faye-websocket-ruby/blob/master/lib/faye/adapters/thin.rb
+  # and code in em-websocket
+  alias :thin_process      :process
+  alias :thin_receive_data :receive_data
+  attr_reader :ws_buffer
+  def process
+    if websocket? && !@request.env['em.connection']
+      @socket_connection = ThinEM::Websocket::Connection.new(self)
+      @request.env['em.connection'] = @socket_connection
+      @response.persistent!
+    end
+    thin_process
+  end
+  def receive_data(data)
+    if @socket_connection && @socket_connection.upgraded?
+      @socket_connection.receive_data(data)
+    else
+      @ws_buffer ||= ""
+      @ws_buffer << data unless @ws_buffer == false
+      @ws_buffer = false if @ws_buffer.length > 10000 # some sane cutoff so we dont have too much data in memory
+      @socket_connection.upgrade_websocket if @socket_connection && @socket_connection.pending_upgrade?
+      thin_receive_data(data)
+    end
+  end
+  def websocket?
+    return @websocket unless @websocket == nil
+    env = @request.env
+    @websocket =
+      env['REQUEST_METHOD'] == 'GET' and
+      env['HTTP_CONNECTION'] and
+      env['HTTP_CONNECTION'].split(/\s*,\s*/).include?('Upgrade') and
+      env['HTTP_UPGRADE'].downcase == 'websocket'
+  end
+end

data/lib/thin-em-websocket/version.rb ADDED

@@ -0,0 +1,5 @@
+module ThinEM
+  module Websocket
+    VERSION = "0.0.1"
+  end
+end

data/thin-em-websocket.gemspec ADDED

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/thin-em-websocket/version', __FILE__)
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sam Saffron"]
+  gem.email         = ["sam.saffron@gmail.com"]
+  gem.description   = %q{thin support for em-websocket}
+  gem.summary       = %q{thin support for em-websocket}
+  gem.homepage      = ""
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "thin-em-websocket-gmalette"
+  gem.require_paths = ["lib"]
+  gem.version       = ThinEM::Websocket::VERSION
+  gem.add_dependency('em-websocket', '>= 0.3.8')
+  gem.add_dependency('thin', '>= 1.4.1')
+  gem.add_development_dependency('rake')
+end

metadata ADDED

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: thin-em-websocket-gmalette
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sam Saffron
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.8
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !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'
+description: thin support for em-websocket
+email:
+- sam.saffron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- examples/Gemfile
+- examples/config.ru
+- lib/thin-em-websocket.rb
+- lib/thin-em-websocket/version.rb
+- thin-em-websocket.gemspec
+homepage: ''
+licenses: []
+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.2.2
+signing_key:
+specification_version: 4
+summary: thin support for em-websocket
+test_files: []