websocket-client 0.1.9 → 0.2.0

data/examples/simple.rb

@@ -5,22 +5,21 @@ $: << File.dirname(__FILE__) + '/../lib'
 require 'websocket_client'
 
 ## Create a disconnected client
-client = WebSocketClient.create( 'ws://localhost:8081/websockets/' ) 
+client = WebSocketClient.create( 'ws://localhost:8081/websockets/echo/' ) 
 
-  ## Set up the message handler before connecting
+## Set up the message handler before connecting
 client.on_message do |msg|
-  puts "received #{msg}"
+  puts "> received message: #{msg}"
 end
 
 ## Connect
 client.connect()
 
 ## Use the connected client
-puts "sending"
 client.send( "HOWDY-1" )
 client.send( "HOWDY-2" )
 client.send( "HOWDY-3" )
 sleep(1)
 
-## Explicit disconncet
-client.disconnect
+## Explicit disconncet and wait
+client.disconnect( true )

data/lib/websocket_client/byte_sink.rb

@@ -0,0 +1,48 @@
+
+module WebSocketClient
+
+  class ByteSink
+
+    CR = 0x0D
+    NL = 0x0A
+
+    def write_line(line)
+      line.bytes.each do |b|
+        write( b )
+      end
+      write( CR )
+      write( NL )
+    end
+
+    def flush
+    end 
+  end
+
+  class SocketByteSink < ByteSink
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def write(byte)
+      @socket.putc( byte )
+    end
+
+    def flush
+      @socket.flush
+    end
+  end 
+
+  class ArrayByteSink < ByteSink
+    def initialize()
+      @sink = []
+    end
+
+    def write(byte)
+      @sink << byte
+    end
+
+    def bytes
+      @sink
+    end
+  end
+end

data/lib/websocket_client/byte_source.rb

@@ -0,0 +1,102 @@
+
+module WebSocketClient
+
+  class ByteSource
+    def getbytes(num)
+      bytes = []
+      1.upto( num ) do
+        break if ( eof? )
+        bytes << getbyte()
+      end
+      bytes
+    end
+  end
+
+  class BufferedByteSource < ByteSource
+    def initialize(source)
+      @source = source
+      @buffer = []
+    end
+
+    def getbyte
+      return @source.getbyte if @buffer.empty?
+      @buffer.shift
+    end
+
+    def peekbyte(index=0)
+      while ( @buffer.size < (index+1) )
+        return nil if (  @source.eof? )
+        @buffer << @source.getbyte
+      end
+      return @buffer[index] 
+    end
+
+    def eof?
+      return @source.eof? if @buffer.empty?
+      false
+    end
+
+    def getline
+      line = ''
+      while ( ! eof? )
+        b = getbyte 
+        case ( b )
+          when 0x0D then # carriage-return
+            if peekbyte == 0x0A # newline
+              getbyte # consume it also
+            end
+            break
+          when 0x0A then # newline
+            break
+          else
+            line << b
+        end
+      end
+      return line
+    end
+  
+
+  end
+
+  class SocketByteSource < ByteSource
+    def initialize(socket)
+      @socket = socket
+      if ( socket.respond_to? :getbyte )
+        alias :getbyte :getbyte_19
+      else
+        alias :getbyte :getbyte_18
+      end
+    end
+
+    def getbyte_18
+      @socket.getc
+    end
+
+    def getbyte_19
+      @socket.getbyte
+    end
+
+    def eof?
+      @socket.eof?
+    end
+
+  end
+ 
+  class ArrayByteSource < ByteSource
+    def initialize(array)
+      @array = array
+      @cur = 0
+    end
+
+    def getbyte
+      b = @array[@cur]
+      @cur += 1
+      b
+    end
+
+    def eof?
+      ( @cur >= @array.size )
+    end
+
+  end
+end

data/lib/websocket_client/client.rb

@@ -1,22 +1,12 @@
 require 'socket'
 require 'uri'
-require 'websocket_client/ietf_00'
+require 'websocket_client/frame_io'
+require 'websocket_client/protocol/ietf_00'
 
 
 module WebSocketClient
 
-  DEFAULT_HANDSHAKE = Ietf00
-
-  class DebugSocket
-    def initialize(socket)
-      @socket = socket
-    end
-
-    def method_missing(method, *args)
-      puts "> #{method}(#{args.join( ', ')})"
-      @socket.__send__( method, *args )
-    end
-  end
+  DEFAULT_HANDSHAKE = Protocol::Ietf00
 
   def self.create(uri,handshake_class=WebSocketClient::DEFAULT_HANDSHAKE,&block)
     Client.new(uri, handshake_class, &block)
@@ -25,59 +15,76 @@ module WebSocketClient
   class Client
     attr_reader :uri
 
+    attr_reader :source
+    attr_reader :sink
+
     def initialize(uri,handshake_class=WebSocketClient::DEFAULT_HANDSHAKE, &block)
-      @handshake_class = handshake_class
-      @socket = nil
-      @on_message_handler = nil
+      @handshake_class       = handshake_class
+      @on_message_handler    = nil
       @on_disconnect_handler = nil
-      @handler_thread = nil
-      @close_state = nil
-      case ( uri )
-        when String
-          @uri = URI.parse( uri )
-        else
-          @uri = uri
-      end
+      @handler_thread        = nil
+      @uri                   = cleanse_uri( uri )
+
       block.call( self ) if block
     end
+
+    def cleanse_uri(uri)
+      return URI.parse( uri ) if ( String === uri )
+      uri
+    end
   
     def connect(&block)
-      @socket = TCPSocket.open(uri.host, uri.port)
-      puts "> handshaking"
-      @handshake = @handshake_class.new( uri, @socket )
-      puts "> handshook"
-      
+      socket = TCPSocket.open(uri.host, uri.port)
+      @source = BufferedByteSource.new( SocketByteSource.new( socket ) )
+      @sink   = SocketByteSink.new( socket )
+      @handshake = @handshake_class.new( uri, @source, @sink )
+
+      internal_connect(source, sink)
+      run_client( &block )
+    end
+
+    def internal_connect(source, sink)
+      @frame_reader = FrameReader.new( source )
+      @frame_writer = FrameWriter.new( sink )
+    end
+
+    def run_client(&block)
+      on_connect
       start_handler
-  
       if ( block )
         begin
-          block.call( self ) 
+            block.call( self ) 
         ensure
           disconnect()
         end
       end
     end
   
-    def disconnect
-      @socket.puts 0xFF
-      @socket.putc 0x00
-      @close_state = :requested
+    def disconnect(wait_for=false)
+      @frame_writer.write_close_frame() 
+      wait_for_disconnect if wait_for
     end
   
-    def send(msg)
-      @handshake.encode_text_message( msg )
-      @socket.flush
+    def send(text)
+      @frame_writer.write_as_text_frame( text )
     end
 
-    def wait_forever()
+    def wait_for_disconnect()
       @handler_thread.join
     end
 
+    def on_connect(&block)
+      if ( block )
+        @on_connect_handler = block
+      else
+        @on_connect_handler.call() if @on_connect_handler
+      end
+    end
+
     def on_message(msg=nil,&block)
       if ( block ) 
         @on_message_handler = block
       else
-        puts "> on_message #{msg}"
         @on_message_handler.call( msg ) if @on_message_handler
       end
     end
@@ -86,59 +93,27 @@ module WebSocketClient
       if ( block )
         @on_disconnect_handler = block
       else
-        puts "> on_disconnect"
-        @on_disconnect_handler.call( msg ) if @on_disconnect_handler
+        @on_disconnect_handler.call() if @on_disconnect_handler
       end
     end
   
     def start_handler
-      @handler_thread = Thread.new(@socket) do |socket|
-        msg = ''
-        msg_state = :none
-        while ( ! socket.eof? )
-          c = nil
-          if ( socket.respond_to?( :getbyte ) )
-            c = socket.getbyte
-          else
-            c = socket.getc
-          end
-          puts "> #{c} #{c.class} #{c == 0xff}"
-          if ( c == 0x00 ) 
-            if ( msg_state == :half_closed )
-              puts "> full-closed by server"
-              socket.close
-              break
-            else
-              if ( @close_state == :half_closed )
-                socket.close
-                break
-              else
-                msg_state = :none
-              end
-            end
-          elsif ( c == 0xFF ) 
-            if ( msg_state == :none )
-              msg_state = :half_closed
-              puts "> half-closed by server"
-            else
-              if ( @close_state == :requested )
-                @close_state = :half_closed
-              else
-                on_message( msg ) 
-                msg = ''
-                msg_state = :none
-              end
-            end
-          else
-            if ( @close_state != nil )
-              @close_state = nil
-            end
-            msg_state = :in_progress
-            msg << c
-          end
+      @handler_thread = Thread.new() do
+        run_handler_loop
+      end
+    end
+
+    def run_handler_loop
+      while ( ! @frame_reader.eof? )
+        frame = @frame_reader.read_frame
+        case ( frame.type )
+          when :text
+            on_message( frame.text )
+          when :close
+            break
         end
-        on_disconnect
       end
+      on_disconnect
     end
   
   end

data/lib/websocket_client/frame_io.rb

@@ -0,0 +1,106 @@
+
+require 'websocket_client/byte_source'
+require 'websocket_client/byte_sink'
+
+module WebSocketClient
+
+  class TextFrame
+
+    attr_accessor :text
+
+    def initialize(text)
+      @text = text
+    end
+
+    def type
+      :text
+    end
+
+    def bytes
+      [ 0x00, @text.bytes.to_a, 0xFF ].flatten
+    end
+
+  end
+
+  class CloseFrame
+    INSTANCE = CloseFrame.new.freeze
+
+    def type
+      :close
+    end
+
+    def bytes
+      [ 0xFF, 0x00 ]
+    end
+
+    private
+    def initialize()
+    end
+  end
+
+  class FrameWriter
+    attr_reader :sink
+    attr_accessor :debug
+
+    def initialize(sink,debug=false)
+      @sink = sink
+      @debug = debug
+    end
+
+    def write_close_frame()
+      write_frame( CloseFrame::INSTANCE )
+    end
+
+    def write_as_text_frame(text)
+      write_frame( TextFrame.new( text ) )
+    end
+
+    def write_frame(frame)
+      frame.bytes.each do |b|
+        @sink.write( b )
+      end
+      @sink.flush
+    end
+  end
+
+  class FrameReader
+
+    attr_reader :source
+    attr_accessor :debug
+
+    def initialize(source,debug=true)
+      @source = source
+      @debug = debug
+    end
+
+    def eof?
+      @source.eof?
+    end
+
+    def read_frame()
+      buffer = nil
+      state = :none
+      while ( ! source.eof? )
+        b = source.getbyte
+        case ( b )
+          when 0x00
+            if ( state == :half_closed )
+              return CloseFrame::INSTANCE
+            end
+            buffer = ''
+          when 0xFF
+            if ( ! buffer.nil? )
+               return TextFrame.new( buffer )
+            else
+              state = :half_closed
+            end
+          else
+            buffer << b
+        end
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/websocket_client/protocol/ietf_00.rb

@@ -0,0 +1,86 @@
+require 'socket'
+require 'uri'
+require 'digest/md5'
+
+module WebSocketClient
+  module Protocol
+    class Ietf00
+  
+      attr_reader :source
+      attr_reader :sink
+  
+      def initialize(uri, source, sink)
+        @source = source
+        @sink   = sink
+        perform_http_prolog(uri)
+      end
+
+      def perform_http_prolog(uri)
+        key1, key2, key3, solution = generate_keys()
+  
+        sink.write_line "GET #{uri.path} HTTP/1.1"
+        sink.write_line "Host: #{uri.host}"
+        sink.write_line "Connection: upgrade"
+        sink.write_line "Upgrade: websocket"
+        sink.write_line "Origin: http://#{uri.host}/"
+        sink.write_line "Sec-WebSocket-Key1: #{key1}"
+        sink.write_line "Sec-WebSocket-Key2: #{key2}"
+        sink.write_line ""
+        sink.write_line key3
+        sink.flush
+        
+        while ( ! source.eof? ) 
+          line = source.getline
+          break if ( line.strip == '' ) 
+        end
+  
+        challenge = source.getbytes( 16 ) 
+        source.getline
+  
+        if ( challenge == solution )
+          #
+        end
+      end
+  
+      def generate_keys()
+        key1 = generate_header_key
+        key2 = generate_header_key
+        key3 = generate_content_key
+        [ key1, key2, key3, solve( key1, key2, key3 ) ]
+      end
+  
+      def solve(key1, key2, key3)
+        int1 = solve_header_key( key1 )
+        int2 = solve_header_key( key2 )
+        input = int1.to_s + int2.to_s + key3
+        Digest::MD5.digest( input ).bytes.to_a
+      end
+  
+      def solve_header_key(key)
+        key_digits = key.strip.gsub( /[^0-9]/, '').to_i
+        key_spaces = key.strip.gsub( /[^ ]/, '').size
+        solution = key_digits / key_spaces
+        solution
+      end
+  
+      def generate_header_key
+        key = '' 
+        1.upto(32) do 
+          key << rand(90) + 32
+        end
+        1.upto( rand(10) + 2 ) do
+          key[rand(key.size-1)+1,1] = ' '
+        end
+        1.upto( rand(10) + 2 ) do
+          key[rand(key.size-1)+1,1] = rand(9).to_s
+        end
+        key
+      end
+  
+      def generate_content_key
+        'tacobob1'
+      end
+  
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: websocket-client
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 9
-  version: 0.1.9
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - The TorqueBox Team
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-11 00:00:00 Z
+date: 2011-06-12 00:00:00 Z
 dependencies: []
 
 description: 
@@ -27,8 +27,11 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/websocket_client/byte_sink.rb
+- lib/websocket_client/byte_source.rb
 - lib/websocket_client/client.rb
-- lib/websocket_client/ietf_00.rb
+- lib/websocket_client/frame_io.rb
+- lib/websocket_client/protocol/ietf_00.rb
 - lib/websocket_client.rb
 - examples/simple.rb
 - examples/with_block.rb

data/lib/websocket_client/ietf_00.rb

@@ -1,123 +0,0 @@
-require 'socket'
-require 'uri'
-require 'digest/md5'
-
-module WebSocketClient
-
-  class Ietf00
-
-    def initialize(uri, socket)
-      puts "initialize for #{socket}"
-      @socket = socket
-      key1, key2, key3, solution = generate_keys()
-
-      puts "> sending prolog"
-      @socket.puts "GET #{uri.path} HTTP/1.1"
-      @socket.puts "Host: #{uri.host}"
-      @socket.puts "Connection: upgrade"
-      @socket.puts "Upgrade: websocket"
-      @socket.puts "Origin: http://#{uri.host}/"
-      @socket.puts "Sec-WebSocket-Version: 8"
-      @socket.puts "Sec-WebSocket-Key1: #{key1}"
-      @socket.puts "Sec-WebSocket-Key2: #{key2}"
-      @socket.puts ""
-      @socket.print key3
-      @socket.puts ""
-      @socket.flush
-      
-      while ( ! @socket.eof? ) 
-        line = readline( socket )
-        puts ">> #{line}"
-        break if ( line.strip == '' ) 
-      end
-
-      begin
-      challenge = @socket.read( 16 ) 
-      puts "Challenge: #{challenge}"
-      readline( @socket )
-      puts "read"
-      rescue Exception=>e
-        puts e.message
-        puts e.backtrace
-      end
-
-      puts "> challenge-response #{challenge}"
-      if ( challenge == solution )
-        puts "success!"
-      end
-      #dump 'solution', solution
-      #dump 'challenge', challenge
-    end
-
-    def readline(socket)
-      line = ''
-      while ( ! socket.eof? )
-        if ( socket.respond_to? :getbyte )
-          c = socket.getbyte
-        else
-          c = socket.getc
-        end
-        puts "> #{c} #{c.class} #{c == '\n'}"
-
-        line << c
-
-        if ( c == 10 )
-          break
-        end
-      end
-      line
-    end
-
-    def encode_text_message(msg)
-      @socket.putc 0x00
-      @socket.print msg
-      @socket.putc 0xFF
-      @socket.flush
-    end
-
-    def generate_keys()
-      key1 = generate_header_key
-      key2 = generate_header_key
-      key3 = generate_content_key
-      [ key1, key2, key3, solve( key1, key2, key3 ) ]
-    end
-
-    def solve(key1, key2, key3)
-      int1 = solve_header_key( key1 )
-      int2 = solve_header_key( key2 )
-      input = int1.to_s + int2.to_s + key3
-      Digest::MD5.digest( input )
-    end
-
-    def solve_header_key(key)
-      key_digits = key.strip.gsub( /[^0-9]/, '').to_i
-      key_spaces = key.strip.gsub( /[^ ]/, '').size
-      solution = key_digits / key_spaces
-      solution
-    end
-
-    def generate_header_key
-      key = '' 
-      1.upto(32) do 
-        key << rand(90) + 32
-      end
-      1.upto( rand(10) + 2 ) do
-        key[rand(key.size-1)+1,1] = ' '
-      end
-      1.upto( rand(10) + 2 ) do
-        key[rand(key.size-1)+1,1] = rand(9).to_s
-      end
-      key
-    end
-
-    def generate_content_key
-      key = []
-      'tacobob1'.each_byte do |byte|
-        key << byte
-      end
-      key.pack('cccccccc')
-    end
-
-  end
-
-end