RubyGems - sinatra-websocket - Versions diffs - 0.1.0 - Mend

sinatra-websocket 0.1.0

Files changed (6) hide show

data/README.md +90 -0
data/lib/sinatra-websocket.rb +115 -0
data/lib/sinatra-websocket/ext/sinatra/request.rb +23 -0
data/lib/sinatra-websocket/ext/thin/connection.rb +76 -0
data/lib/sinatra-websocket/version.rb +4 -0
metadata +97 -0

data/README.md ADDED

@@ -0,0 +1,90 @@
+# SinatraWebsocket
+Makes it easy to upgrade any request to a websocket connection.
+SinatraWebsocket is a fork of [Skinny](https://github.com/sj26/skinny) merged with [Rack WebSocket](https://github.com/igrigorik/em-websocket). It provides helpers methods to detect if an request is a WebSocket request and defer to an EM::WebSocket::Connection.
+## Put this in your pipe ...
+```ruby
+require 'sinatra'
+require 'sinatra-websocket'
+set :server, 'thin'
+set :sockets, []
+get '/' do
+  if !request.websocket?
+    erb :index
+  else
+    request.websocket do |ws|
+      ws.onopen do
+        ws.send("Hello World!")
+        settings.sockets << ws
+      end
+      ws.onmessage do |msg|
+        EM.next_tick { settings.sockets.each{|s| s.send(msg) } }
+      end
+      ws.onclose do
+        warn("wetbsocket closed")
+        settings.sockets.delete(ws)
+      end
+    end
+  end
+end
+__END__
+@@ index
+<html>
+  <body>
+     <h1>Simple Echo & Chat Server</h1>
+     <form id="form">
+       <input type="text" id="input" value="send a message"></input>
+     </form>
+     <div id="msgs"></div>
+  </body>
+  <script type="text/javascript">
+    window.onload = function(){
+      (function(){
+        var show = function(el){
+          return function(msg){ el.innerHTML = msg + '<br />' + el.innerHTML; }
+        }(document.getElementById('msgs'));
+        var ws       = new WebSocket('ws://' + window.location.host + window.location.pathname);
+        ws.onopen    = function()  { show('websocket opened'); };
+        ws.onclose   = function()  { show('websocket closed'); }
+        ws.onmessage = function(m) { show('websocket message: ' +  m.data); };
+        var sender = function(f){
+          var input     = document.getElementById('input');
+          input.onclick = function(){ input.value = "" };
+          f.onsubmit    = function(){
+            ws.send(input.value);
+            input.value = "send a message";
+            return false;
+          }
+        }(document.getElementById('form'));
+      })();
+    }
+  </script>
+</html>
+```
+## And Smoke It
+```
+ruby echo.rb
+```
+## Copyright
+Copyright (c) 2012 Caleb Crane.
+Portions of this software are Copyright (c) Bernard Potocki <bernard.potocki@imanel.org> and Samuel Cochran.
+See License.txt for more details.

data/lib/sinatra-websocket.rb ADDED

@@ -0,0 +1,115 @@
+require 'thin'
+require 'em-websocket'
+require 'sinatra-websocket/ext/thin/connection'
+require 'sinatra-websocket/ext/sinatra/request'
+module SinatraWebsocket
+  class Connection < ::EventMachine::WebSocket::Connection
+    class << self
+      def from_env(env, options = {})
+        socket      = env[Thin::Request::ASYNC_CALLBACK].receiver
+        request    = request_from_env(env)
+        connection = Connection.new(env, socket, :debug => options[:debug])
+        yield(connection) if block_given?
+        connection.dispatch(request) ? async_response : failure_response
+      end
+      #######
+      # Taken from WebSocket Rack
+      # https://github.com/imanel/websocket-rack
+      #######
+      # Parse Rack env to em-websocket-compatible format
+      # this probably should be moved to Base in future
+      def request_from_env(env)
+        request = {}
+        request['path']   = env['REQUEST_URI'].to_s
+        request['method'] = env['REQUEST_METHOD']
+        request['query']  = env['QUERY_STRING'].to_s
+        request['Body']   = env['rack.input'].read
+        env.each do |key, value|
+          if key.match(/HTTP_(.+)/)
+            request[$1.downcase.gsub('_','-')] ||= value
+          end
+        end
+        request
+      end
+      # Standard async response
+      def async_response
+        [-1, {}, []]
+      end
+      # Standard 400 response
+      def failure_response
+        [ 400, {'Content-Type' => 'text/plain'}, [ 'Bad request' ] ]
+      end
+    end # class << self
+    #########################
+    ### EventMachine part ###
+    #########################
+    # Overwrite new from EventMachine
+    # we need to skip standard procedure called
+    # when socket is created - this is just a stub
+    def self.new(*args)
+      instance = allocate
+      instance.__send__(:initialize, *args)
+      instance
+    end
+    # Overwrite send_data from EventMachine
+    # delegate send_data to rack server
+    def send_data(*args)
+      EM.next_tick do
+        @socket.send_data(*args)
+      end
+    end
+    # Overwrite close_connection from EventMachine
+    # delegate close_connection to rack server
+    def close_connection(*args)
+      EM.next_tick do
+        @socket.close_connection(*args)
+      end
+    end
+    #########################
+    ### EM-WebSocket part ###
+    #########################
+    # Overwrite initialize from em-websocket
+    # set all standard options and disable
+    # EM connection inactivity timeout
+    def initialize(app, socket, options = {})
+      @app     = app
+      @socket  = socket
+      @options = options
+      @debug   = options[:debug] || false
+      @ssl     = socket.backend.respond_to?(:ssl?) && socket.backend.ssl?
+      socket.websocket = self
+      socket.comm_inactivity_timeout = 0
+      debug [:initialize]
+    end
+    # Overwrite dispath from em-websocket
+    # we already have request headers parsed so
+    # we can skip it and call build_with_request
+    def dispatch(data)
+      return false if data.nil?
+      debug [:inbound_headers, data]
+      @handler = EventMachine::WebSocket::HandlerFactory.build_with_request(self, data, data['Body'], @ssl, @debug)
+      unless @handler
+        # The whole header has not been received yet.
+        return false
+      end
+      @handler.run
+      return true
+    end
+  end
+end # module::SinatraWebSocket

data/lib/sinatra-websocket/ext/sinatra/request.rb ADDED

@@ -0,0 +1,23 @@
+module SinatraWebsocket
+  module Ext
+    module Sinatra
+      module Request
+        # Taken from skinny https://github.com/sj26/skinny and updated to support Firefox
+        def websocket?
+          env['HTTP_CONNECTION'].split(',').map(&:strip).map(&:downcase).include?('upgrade') &&
+            env['HTTP_UPGRADE'].downcase == 'websocket'
+        end
+        # Taken from skinny https://github.com/sj26/skinny
+        def websocket(options={}, &blk)
+          env['skinny.websocket'] ||= begin
+            raise RuntimeError, "Not a WebSocket request" unless websocket?
+            SinatraWebsocket::Connection.from_env(env, options, &blk)
+          end
+        end
+      end
+    end # module::Sinatra
+  end # module::Ext
+end # module::SinatraWebsocket
+defined?(Sinatra) && Sinatra::Request.send(:include, SinatraWebsocket::Ext::Sinatra::Request)

data/lib/sinatra-websocket/ext/thin/connection.rb ADDED

@@ -0,0 +1,76 @@
+module SinatraWebsocket
+  module Ext
+    module Thin
+      module Connection
+        def self.included(base)
+          base.class_eval do
+            alias :receive_data_without_websocket :receive_data
+            alias :receive_data :receive_data_with_websocket
+            alias :unbind_without_websocket :unbind
+            alias :unbind :unbind_with_websocket
+            alias :receive_data_without_flash_policy_file :receive_data
+            alias :receive_data :receive_data_with_flash_policy_file
+            alias :pre_process_without_websocket :pre_process
+            alias :pre_process :pre_process_with_websocket
+          end
+        end
+        attr_accessor :websocket
+        # Set 'async.connection' Rack env
+        def pre_process_with_websocket
+          @request.env['async.connection'] = self
+          pre_process_without_websocket
+        end
+        # Is this connection WebSocket?
+        def websocket?
+          !self.websocket.nil?
+        end
+        # Skip default receive_data if this is
+        # WebSocket connection
+        def receive_data_with_websocket(data)
+          if self.websocket?
+            self.websocket.receive_data(data)
+          else
+            receive_data_without_websocket(data)
+          end
+        end
+        # Skip standard unbind it this is
+        # WebSocket connection
+        def unbind_with_websocket
+          if self.websocket?
+            self.websocket.unbind
+          else
+            unbind_without_websocket
+          end
+        end
+        # Send flash policy file if requested
+        def receive_data_with_flash_policy_file(data)
+          # thin require data to be proper http request - in it's not
+          # then @request.parse raises exception and data isn't parsed
+          # by futher methods. Here we only check if it is flash
+          # policy file request ("<policy-file-request/>\000") and
+          # if so then flash policy file is returned. if not then
+          # rest of request is handled.
+          if (data == "<policy-file-request/>\000")
+            file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
+            # ignore errors - we will close this anyway
+            send_data(file) rescue nil
+            close_connection_after_writing
+          else
+            receive_data_without_flash_policy_file(data)
+          end
+        end
+      end # module::Connection
+    end # module::Thin
+  end # module::Ext
+end # module::SinatraWebsocket
+defined?(Thin) && Thin::Connection.send(:include, SinatraWebsocket::Ext::Thin::Connection)

data/lib/sinatra-websocket/version.rb ADDED

@@ -0,0 +1,4 @@
+module SinatraWebsocket
+  VERSION = '0.1.0'
+end

metadata ADDED

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-websocket
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease:
+platform: ruby
+authors:
+- Caleb Crane
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.6
+description: Makes it easy to upgrade any request to a websocket connection in Sinatra
+email: sinatra-websocket@simulacre.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sinatra-websocket/ext/sinatra/request.rb
+- lib/sinatra-websocket/ext/thin/connection.rb
+- lib/sinatra-websocket/version.rb
+- lib/sinatra-websocket.rb
+- README.md
+homepage: http://github.com/simulacre/sinatra-websocket
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.21
+signing_key:
+specification_version: 3
+summary: Simple, upgradable WebSockets for Sinatra.
+test_files: []