webrick-websocket 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13e2c3b9e1af9682919f83e722d34194fc7dd442
+  data.tar.gz: ed338c06ac763cc2bb992714dcdf44c5ed077094
+SHA512:
+  metadata.gz: 1704b541060941ef57644532befe20c718ba0fb0d2f2bc8787b1113423001348e4b8da31de1cfd9fae85aa1e45e4712042729dfcb936c6b02bff0818b74ee0d7
+  data.tar.gz: 747b5dcfe41c9fd5b07ddd096cf1b1a88dd053c91b8f44098182f7b650b9f6c2232b7648ba1c3f4336e4f9d912fe538bf01383cc11944e30b6b65e06aa6cac41

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Kilobyte22
+
+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

@@ -0,0 +1,74 @@
+# Webrick::Websocket
+
+This gem allows you to use Websocket in your WEBrick web application.
+First, create a HTTPServer with websocket support:
+
+```ruby
+require 'webrick/websocket'
+server = WEBrick::Websocket::HTTPServer.new(Port: 8080, DocumentRoot: File.dirname(__FILE))
+```
+
+having that done do anything you would do with a regular WEBrick instance.
+However, you can mount a Websocket Servlet.
+ 
+```ruby
+class MyServlet < WEBrick::Websocket::Servlet
+  def select_protocol(available)
+    # method optional, if missing, it will always select first protocol.
+    # Will only be called if client actually requests a protocol
+    available.include?('myprotocol') ? 'myprotocol' : nil
+  end
+  
+  def socket_open(sock)
+    # optional
+    sock.puts 'Welcome' # send a text frame
+  def
+  
+  def socket_close(sock)
+    puts 'Poof. Socket gone.'
+  end
+  
+  def socket_text(sock, text)
+    puts "Client sent '#{text}'"
+  end
+end
+
+server.mount('/websocket', MyServlet)
+```
+
+Aaaaand lets start the server
+
+```ruby
+server.start
+```
+
+Note, that it will always use the same servlet instance for a single socket and that each socket has its own servlet instance.
+This means you can safely use instance variables inside the servlet to store the sockets state
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webrick-websocket'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webrick-websocket
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/webrick-websocket/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/webrick/httprequest_patch.rb

@@ -0,0 +1,6 @@
+require 'webrick/httprequest'
+module WEBrick
+  class HTTPRequest
+    attr_reader :socket
+  end
+end

data/lib/webrick/websocket/frame.rb

@@ -0,0 +1,101 @@
+module WEBrick
+  module Websocket
+    ## :nodoc:
+    class Frame
+      @@ops_rev = {
+          cont: 0,
+          text: 1,
+          binary: 2,
+          close: 8,
+          ping: 9,
+          pong: 10
+      }
+      @@ops = {}
+      @@ops_rev.each do |op, id|
+        @@ops[id] = op
+      end
+      attr_reader :payload, :op
+      def self.parse(socket, prev = nil)
+        Frame.new(nil).parse(socket, prev)
+      end
+
+      def initialize(op, data = '')
+        @op = op
+        @payload = data
+      end
+
+      def parse(socket, prev)
+        head = socket.read(1).unpack('C')[0]
+        @fin = head & 0b10000000 > 0
+        op = head & 0b00001111
+        @op = @@ops[op]
+        @op = prev if @op == :cont
+        head = socket.read(1).unpack('C')[0]
+        @masked = head & 0b10000000 > 0
+        len = head & 0b01111111
+        if len > 125
+          long = len == 127
+          len = socket.read(long ? 8 : 2).unpack(long ? 'Q' : 'S')[0]
+        end
+        @mask = socket.read(4).unpack('C4') if @masked
+        @payload = socket.read(len)
+        @payload = mask(@payload)
+        self
+      end
+
+      def control?
+        @@ops_rev[@op] > 7
+      end
+      def close?
+        is(:close)
+      end
+      def binary?
+        is(:binary)
+      end
+      def text?
+        is(:text)
+      end
+      def ping?
+        is(:ping)
+      end
+      def pong?
+        is(:pong)
+      end
+      def fin?
+        @fin
+      end
+
+      def write(sock)
+        head = 0b10000000 + @@ops_rev[@op]
+        puts head.to_s(2)
+        sock.write([head].pack('C'))
+        @len = @payload.length
+        lendata = if @len > 125
+          if @len > 65535
+            [127, @len].pack('CQ')
+          else
+            [126, @len].pack('CS')
+          end
+        else
+          [@len].pack('C')
+        end
+        sock.write(lendata)
+        sock.write(@payload)
+        sock.flush
+      end
+
+      private
+      def is(what)
+        @op == what
+      end
+
+      def mask(what)
+        i = -1
+        what.unpack('C*').map do |el|
+          i += 1
+          el ^ @mask[i % 4]
+        end.pack('C*')
+      end
+    end
+  end
+end

data/lib/webrick/websocket/server.rb

@@ -0,0 +1,51 @@
+require 'digest/sha1'
+require 'webrick/websocket/socket'
+require 'webrick/websocket/servlet'
+
+module WEBrick
+  module Websocket
+    ##
+    # A HTTP Server with Websocket Support
+    class HTTPServer < WEBrick::HTTPServer
+      def initialize(*args, &block)
+        super(*args, &block)
+      end
+
+      ## :nodoc:
+      def service(req, res)
+        if req.unparsed_uri == "*"
+          if req.request_method == "OPTIONS"
+            do_OPTIONS(req, res)
+            raise HTTPStatus::OK
+          end
+          raise HTTPStatus::NotFound, "`#{req.unparsed_uri}' not found."
+        end
+
+        servlet, options, script_name, path_info = search_servlet(req.path)
+        raise HTTPStatus::NotFound, "`#{req.path}' not found." unless servlet
+        req.script_name = script_name
+        req.path_info = path_info
+        si = servlet.get_instance(self, *options)
+        @logger.debug(format("%s is invoked.", si.class.name))
+        if req['upgrade'] == 'websocket' && si.is_a?(Servlet)
+          req.header.each do |k, v|
+            puts "#{k} -> #{v}"
+          end
+          res.status = 101
+          key = req['Sec-WebSocket-Key']
+          res['Sec-WebSocket-Accept'] = Digest::SHA1.base64digest(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+          res['Sec-WebSocket-Protocol'] = si.select_protocol(req['Sec-WebSocket-Protocol']).split(/[ ,\t]+/) if req['Sec-WebSocket-Protocol']
+          res['upgrade'] = 'websocket'
+          res.setup_header
+          res.instance_variable_get(:@header)['connection'] = 'upgrade'
+          res.send_header(req.socket)
+          sock = WEBrick::Websocket::Socket.new(req.socket, si, @logger)
+          sock.run
+          res.request_line = nil
+        else
+          si.service(req, res)
+        end
+      end
+    end
+  end
+end

data/lib/webrick/websocket/servlet.rb

@@ -0,0 +1,9 @@
+module WEBrick
+  module Websocket
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      def select_protocol(input)
+        input.first
+      end
+    end
+  end
+end

data/lib/webrick/websocket/socket.rb

@@ -0,0 +1,78 @@
+require 'webrick/websocket/frame'
+
+module WEBrick
+  module Websocket
+    class Socket
+      def initialize(sock, handler, logger)
+        @prev = nil
+        @sock = sock
+        @handler = handler
+        @open = true
+        @logger = logger
+        handle(:open)
+      end
+
+      def puts(data)
+        send_frame(Frame.new(:text, data))
+      end
+
+      def close
+        handle(:close)
+        if @open
+          @open = false
+          send_frame(Frame.new(:close))
+        end
+      end
+
+      def send_frame(frame)
+        @logger.debug("Websocket Frame Sent: #{frame.op.to_s}(#{frame.payload.length} Bytes)")
+        if frame.close? && @open
+          close
+        else
+          frame.write(@sock)
+        end
+      end
+
+      def run
+        handle_packet while @open
+      end
+
+      private
+
+      def handle_packet
+        payload = ''
+        while @open
+          frame = read_frame
+          @prev = frame.op
+          if frame.control?
+            case @prev
+              when :ping
+                send_frame(Frame.new(:pong))
+              when :close
+                @open = false
+                close
+            end
+          else
+            payload += frame.payload
+            break if frame.fin?
+          end
+        end
+        return unless @open
+        handle(@prev, payload)
+        handle(:data, @prev, payload)
+      end
+
+      def handle(op, *args)
+        cb = 'socket_' + op.to_s
+        @logger.debug("Websocket Callback: #{@handler.class.name}##{cb}")
+        @handler.send(cb, self, *args) if @handler.respond_to?(cb)
+      end
+
+      def read_frame
+        f = Frame.parse(@sock, @prev)
+        @logger.debug("Websocket Frame Received: #{f.op.to_s}(#{f.payload.length} Bytes)")
+        f
+      end
+    end
+  end
+end

data/lib/webrick/websocket/version.rb

@@ -0,0 +1,5 @@
+module WEBrick
+  module Websocket
+    VERSION = '0.0.1'
+  end
+end

data/lib/webrick/websocket.rb

@@ -0,0 +1,10 @@
+require 'webrick/websocket/version'
+require 'webrick'
+require 'webrick/httprequest_patch'
+require 'webrick/websocket/server'
+
+module WEBrick
+  module Websocket
+
+  end
+end

data/testrun/jquery-websocket.js

@@ -0,0 +1,45 @@
+/*
+ * jQuery Web Sockets Plugin v0.0.1
+ * http://code.google.com/p/jquery-websocket/
+ *
+ * This document is licensed as free software under the terms of the
+ * MIT License: http://www.opensource.org/licenses/mit-license.php
+ *
+ * Copyright (c) 2010 by shootaroo (Shotaro Tsubouchi).
+ */
+(function($){
+    $.extend({
+        websocketSettings: {
+            open: function(){},
+            close: function(){},
+            message: function(){},
+            options: {},
+            events: {}
+        },
+        websocket: function(url, s) {
+            var ws = WebSocket ? new WebSocket( url ) : {
+                send: function(m){ return false },
+                close: function(){}
+            };
+            $(ws)
+                .bind('open', $.websocketSettings.open)
+                .bind('close', $.websocketSettings.close)
+                .bind('message', $.websocketSettings.message)
+                .bind('message', function(e){
+                    var m = $.parseJSON(e.originalEvent.data);
+                    var h = $.websocketSettings.events[m.type];
+                    if (h) h.call(this, m);
+                });
+            ws._settings = $.extend($.websocketSettings, s);
+            ws._send = ws.send;
+            ws.send = function(type, data) {
+                var m = {type: type};
+                m = $.extend(true, m, $.extend(true, {}, $.websocketSettings.options, m));
+                if (data) m['data'] = data;
+                return this._send(JSON.stringify(m));
+            };
+            $(window).unload(function(){ ws.close(); ws = null });
+            return ws;
+        }
+    });
+})(jQuery);