em-websocket-request 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/em-ws-request/vendor/web-socket-ruby"]
+	path = lib/em-ws-request/vendor/web-socket-ruby
+	url = git@github.com:rykov/web-socket-ruby.git

data/Gemfile

@@ -0,0 +1,9 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in em-websocket-request.gemspec
+gemspec
+
+group :development do
+  gem "rspec", "~> 2.6.0"
+  gem "em-websocket", "~> 0.3.1"
+end

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/em-websocket-request.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/em-ws-request/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Michael Rykov"]
+  gem.email         = ["mrykov@gmail.com"]
+  gem.description   = %q{EventMachine WebSocket client}
+  gem.summary       = %q{EventMachine WebSocket client}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "em-websocket-request"
+  gem.require_paths = ["lib"]
+  gem.version       = EventMachine::WS_REQUEST_VERSION
+
+  gem.add_runtime_dependency 'em-http-request', '~> 1.0.0'
+end

data/lib/em-websocket-request.rb

@@ -0,0 +1,16 @@
+require 'em-http-request'
+require "em-ws-request/version"
+require "em-ws-request/client"
+require "em-ws-request/wrapper"
+
+module EventMachine
+  class WebsocketRequest < HttpRequest
+    def self.new(uri, options={})
+      connopt = HttpConnectionOptions.new(uri, options)
+      c = WebsocketConnection.new
+      c.connopts = connopt
+      c.uri = uri
+      c
+    end
+  end
+end

data/lib/em-ws-request/client.rb

@@ -0,0 +1,87 @@
+module EventMachine
+  class WebsocketConnection < HttpConnection
+    def setup_request(method, options = {}, c = nil)
+      c ||= WebsocketClient.new(self, HttpClientOptions.new(@uri, options, method))
+      @deferred ? activate_connection(c) : finalize_request(c)
+      c
+    end
+
+    def post_init
+      super
+      @p.on_message_complete = proc do
+        if not client.continue?
+          if client.state == :websocket
+            client.state = :stream
+          else
+            client.state = :finished
+            client.on_request_complete
+          end
+        end
+      end
+    end
+
+    def receive_data(data)
+      if client.state == :stream
+        client.receive(data)
+      else
+        super(data)
+      end
+    end
+  end
+
+  class WebsocketClient < HttpClient
+    PROTOCOL_VERSION = '8'
+
+    def initialize(conn, options)
+      super(conn, options)
+      @wswrapper = WebSocketWrapper.new(self, PROTOCOL_VERSION)
+    end
+
+    def send(data, frame_type = :text)
+      @connection = @conn
+      if state == :stream || state == :websocket # FIXME
+        @wswrapper.send_frame(frame_type, data)
+      end
+    end
+
+    def send_data(data)
+      @conn.send_data(data)
+    end
+
+    def receive(data)
+      out = @wswrapper.receive(data)
+      @stream.call(out) if @stream
+    end
+
+    def websocket?
+      @req.uri.scheme == 'ws' || @req.uri.scheme == 'wss'
+    end
+
+    def build_request
+      head = super
+      if websocket?
+        head.delete_if { |k, v| !%w(host).include?(k) }
+        head['upgrade'] = 'websocket'
+        head['connection'] = 'Upgrade'
+        head['origin'] = @req.uri.host
+        head['Sec-WebSocket-Key'] = 'dGhlIHNhbXBsZSBub25jZQ=='
+        head['Sec-WebSocket-Version'] = PROTOCOL_VERSION
+      end
+      head
+    end
+
+    def parse_response_header(header, version, status)
+      super
+      if websocket?
+        p [:parse_response_header, :WEBSOCKET]
+        if @response_header.status == 101
+          @state = :websocket
+          succeed
+        else
+          fail "websocket handshake failed"
+        end
+      end
+    end
+  end
+end
+

data/lib/em-ws-request/version.rb

@@ -0,0 +1,3 @@
+module EventMachine
+  WS_REQUEST_VERSION = "0.0.1"
+end

data/lib/em-ws-request/wrapper.rb

@@ -0,0 +1,46 @@
+require "em-ws-request/vendor/web-socket-ruby/lib/web_socket"
+
+module EventMachine
+  class WebSocketWrapper < ::WebSocket
+    def initialize(client, version)
+      @handshaked = true
+      @client = client
+      @web_socket_version = version
+    end
+
+    def send_frame(type, data)
+      opcode = type_to_opcode(type)
+      super(opcode, data, true)
+    end
+
+    def write(data)
+      @client.send_data(data)
+    end
+
+    def receive(data)
+      @incoming_data = data
+      super()
+    end
+
+    def read(num_bytes)
+      str = @incoming_data.slice(0, num_bytes)
+      @incoming_data = @incoming_data[num_bytes..-1]
+      return str
+    end
+
+  private
+    FRAME_TYPES = {
+      :continuation => 0,
+      :text => 1,
+      :binary => 2,
+      :close => 8,
+      :ping => 9,
+      :pong => 10,
+    }
+
+    def type_to_opcode(frame_type)
+      FRAME_TYPES[frame_type] || raise("Unknown frame type")
+    end
+  end
+end
+

data/spec/websocket_spec.rb

@@ -0,0 +1,86 @@
+require 'em-websocket'
+require 'em-websocket-request'
+
+describe EventMachine::WebsocketRequest do
+
+  context "websocket connection" do
+    # Spec: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-55
+    #
+    # ws.onopen     = http.callback
+    # ws.onmessage  = http.stream { |msg| }
+    # ws.errback    = no connection
+    #
+
+    it "should invoke errback on failed upgrade" do
+      EventMachine.run {
+        http = EventMachine::WebsocketRequest.new('ws://127.0.0.1:8090/').get :timeout => 0
+
+        http.callback { failed(http) }
+        http.errback {
+          http.response_header.status.should == 0
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should complete websocket handshake and transfer data from client to server and back" do
+      EventMachine.run {
+        MSG = "hello bi-directional data exchange"
+
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8085, :debug => true) do |ws|
+          ws.onopen { p [:OPENED_WS, ws]}
+          ws.onmessage {|msg| ws.send msg}
+          ws.onerror {|e| p [:WS_ERROR, e]}
+          ws.onclose { p [:WS_CLOSE, ws]}
+        end
+
+        http = EventMachine::WebsocketRequest.new('ws://127.0.0.1:8085/').get :keepalive => true
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 101
+          http.response_header['CONNECTION'].should match(/Upgrade/)
+          http.response_header['UPGRADE'].should match(/websocket/)
+
+          # push should only be invoked after handshake is complete
+          http.send(MSG)
+        }
+
+        http.stream { |chunk|
+          chunk.should == MSG
+          EventMachine.stop
+        }
+      }
+    end
+
+    # parser eats up the trailign data
+    # [:receive, "HTTP/1.1 101 Web Socket Protocol Handshake\r\nUpgrade: WebSocket\r\nConnection: Upgrade\r\nWebSocket-Origin: 127.0.0.1\r\nWebSocket-Location: ws://127.0.0.1:8085/\r\n\r\n\x001\xFF\x002\xFF", :keep_alive?, "#<HTTP::Parser:0x0000010132d000>"]
+
+    xit "should split multiple messages from websocket server into separate stream callbacks" do
+      EM.run do
+        messages = %w[1 2]
+        recieved = []
+
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8085) do |ws|
+          ws.onopen {
+            ws.send messages[0]
+            ws.send messages[1]
+          }
+        end
+
+        EventMachine.add_timer(0.1) do
+          http = EventMachine::WebsocketRequest.new('ws://127.0.0.1:8085/').get :keepalive => true
+          http.errback { failed(http) }
+          http.callback { http.response_header.status.should == 101; p 'WS CONNECTED' }
+          http.stream {|msg|
+            p ['GOT MSG ', msg]
+            msg.should == messages[recieved.size]
+            recieved.push msg
+            p [:MULTI_MESAGE, recieved]
+
+            EventMachine.stop if recieved.size == messages.size
+          }
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: em-websocket-request
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Michael Rykov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: &70329779717660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70329779717660
+description: EventMachine WebSocket client
+email:
+- mrykov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- Gemfile
+- Rakefile
+- em-websocket-request.gemspec
+- lib/em-websocket-request.rb
+- lib/em-ws-request/client.rb
+- lib/em-ws-request/version.rb
+- lib/em-ws-request/wrapper.rb
+- spec/websocket_spec.rb
+homepage: ''
+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.11
+signing_key: 
+specification_version: 3
+summary: EventMachine WebSocket client
+test_files:
+- spec/websocket_spec.rb