kinetic_sdk 0.1.1

data/gems/websocket-driver-0.6.5/lib/websocket/driver/proxy.rb

@@ -0,0 +1,68 @@
+module WebSocket
+  class Driver
+
+    class Proxy
+      include EventEmitter
+
+      PORTS = {'ws' => 80, 'wss' => 443}
+
+      attr_reader :status, :headers
+
+      def initialize(client, origin, options)
+        super()
+
+        @client  = client
+        @http    = HTTP::Response.new
+        @socket  = client.instance_variable_get(:@socket)
+        @origin  = URI.parse(@socket.url)
+        @url     = URI.parse(origin)
+        @options = options
+        @state   = 0
+
+        @headers = Headers.new
+        @headers['Host'] = @origin.host + (@origin.port ? ":#{@origin.port}" : '')
+        @headers['Connection'] = 'keep-alive'
+        @headers['Proxy-Connection'] = 'keep-alive'
+
+        if @url.user
+          auth = Base64.strict_encode64([@url.user, @url.password] * ':')
+          @headers['Proxy-Authorization'] = 'Basic ' + auth
+        end
+      end
+
+      def set_header(name, value)
+        return false unless @state == 0
+        @headers[name] = value
+        true
+      end
+
+      def start
+        return false unless @state == 0
+        @state = 1
+
+        port    = @origin.port || PORTS[@origin.scheme]
+        start   = "CONNECT #{@origin.host}:#{port} HTTP/1.1"
+        headers = [start, @headers.to_s, '']
+
+        @socket.write(headers.join("\r\n"))
+        true
+      end
+
+      def parse(chunk)
+        @http.parse(chunk)
+        return unless @http.complete?
+
+        @status  = @http.code
+        @headers = Headers.new(@http.headers)
+
+        if @status == 200
+          emit(:connect, ConnectEvent.new)
+        else
+          message = "Can't establish a connection to the server at #{@socket.url}"
+          emit(:error, ProtocolError.new(message))
+        end
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/server.rb

@@ -0,0 +1,80 @@
+module WebSocket
+  class Driver
+
+    class Server < Driver
+      EVENTS = %w[open message error close]
+
+      def initialize(socket, options = {})
+        super
+        @http = HTTP::Request.new
+        @delegate = nil
+      end
+
+      def env
+        @http.complete? ? @http.env : nil
+      end
+
+      def url
+        return nil unless e = env
+
+        url  = "ws://#{e['HTTP_HOST']}"
+        url << e['PATH_INFO']
+        url << "?#{e['QUERY_STRING']}" unless e['QUERY_STRING'] == ''
+        url
+      end
+
+      %w[add_extension set_header start frame text binary ping close].each do |method|
+        define_method(method) do |*args, &block|
+          if @delegate
+            @delegate.__send__(method, *args, &block)
+          else
+            @queue << [method, args, block]
+            true
+          end
+        end
+      end
+
+      %w[protocol version].each do |method|
+        define_method(method) do
+          @delegate && @delegate.__send__(method)
+        end
+      end
+
+      def parse(chunk)
+        return @delegate.parse(chunk) if @delegate
+
+        @http.parse(chunk)
+        return fail_request('Invalid HTTP request') if @http.error?
+        return unless @http.complete?
+
+        @delegate = Driver.rack(self, @options)
+        open
+
+        EVENTS.each do |event|
+          @delegate.on(event) { |e| emit(event, e) }
+        end
+
+        emit(:connect, ConnectEvent.new)
+      end
+
+      def write(buffer)
+        @socket.write(buffer)
+      end
+
+    private
+
+      def fail_request(message)
+        emit(:error, ProtocolError.new(message))
+        emit(:close, CloseEvent.new(Hybi::ERRORS[:protocol_error], message))
+      end
+
+      def open
+        @queue.each do |method, args, block|
+          @delegate.__send__(method, *args, &block)
+        end
+        @queue = []
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/stream_reader.rb

@@ -0,0 +1,55 @@
+module WebSocket
+  class Driver
+
+    class StreamReader
+      # Try to minimise the number of reallocations done:
+      MINIMUM_AUTOMATIC_PRUNE_OFFSET = 128
+
+      def initialize
+        @buffer = String.new('').force_encoding(BINARY)
+        @offset = 0
+      end
+
+      def put(chunk)
+        return unless chunk and chunk.bytesize > 0
+        @buffer << chunk.force_encoding(BINARY)
+      end
+
+      # Read bytes from the data:
+      def read(length)
+        return nil if (@offset + length) > @buffer.bytesize
+
+        chunk = @buffer.byteslice(@offset, length)
+        @offset += chunk.bytesize
+
+        prune if @offset > MINIMUM_AUTOMATIC_PRUNE_OFFSET
+
+        return chunk
+      end
+
+      def each_byte
+        prune
+
+        @buffer.each_byte do |octet|
+          @offset += 1
+          yield octet
+        end
+      end
+
+    private
+
+      def prune
+        buffer_size = @buffer.bytesize
+
+        if @offset > buffer_size
+          @buffer = String.new('').force_encoding(BINARY)
+        else
+          @buffer = @buffer.byteslice(@offset, buffer_size - @offset)
+        end
+
+        @offset = 0
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver.rb

@@ -0,0 +1,199 @@
+# Protocol references:
+#
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+require 'base64'
+require 'digest/md5'
+require 'digest/sha1'
+require 'securerandom'
+require 'set'
+require 'stringio'
+require 'uri'
+require 'websocket/extensions'
+
+module WebSocket
+  autoload :HTTP, File.expand_path('../http', __FILE__)
+
+  class Driver
+
+    root = File.expand_path('../driver', __FILE__)
+
+    begin
+      # Load C native extension
+      require 'websocket_mask'
+    rescue LoadError
+      # Fall back to pure-Ruby implementation
+      require 'websocket/mask'
+    end
+
+
+    if RUBY_PLATFORM =~ /java/
+      require 'jruby'
+      com.jcoglan.websocket.WebsocketMaskService.new.basicLoad(JRuby.runtime)
+    end
+
+    unless Mask.respond_to?(:mask)
+      def Mask.mask(payload, mask)
+        @instance ||= new
+        @instance.mask(payload, mask)
+      end
+    end
+
+    MAX_LENGTH = 0x3ffffff
+    STATES     = [:connecting, :open, :closing, :closed]
+
+    BINARY  = 'ASCII-8BIT'
+    UNICODE = 'UTF-8'
+
+    ConnectEvent = Struct.new(nil)
+    OpenEvent    = Struct.new(nil)
+    MessageEvent = Struct.new(:data)
+    CloseEvent   = Struct.new(:code, :reason)
+
+    ProtocolError      = Class.new(StandardError)
+    URIError           = Class.new(ArgumentError)
+    ConfigurationError = Class.new(ArgumentError)
+
+    autoload :Client,       root + '/client'
+    autoload :Draft75,      root + '/draft75'
+    autoload :Draft76,      root + '/draft76'
+    autoload :EventEmitter, root + '/event_emitter'
+    autoload :Headers,      root + '/headers'
+    autoload :Hybi,         root + '/hybi'
+    autoload :Proxy,        root + '/proxy'
+    autoload :Server,       root + '/server'
+    autoload :StreamReader, root + '/stream_reader'
+
+    include EventEmitter
+    attr_reader :protocol, :ready_state
+
+    def initialize(socket, options = {})
+      super()
+      Driver.validate_options(options, [:max_length, :masking, :require_masking, :protocols])
+
+      @socket      = socket
+      @reader      = StreamReader.new
+      @options     = options
+      @max_length  = options[:max_length] || MAX_LENGTH
+      @headers     = Headers.new
+      @queue       = []
+      @ready_state = 0
+    end
+
+    def state
+      return nil unless @ready_state >= 0
+      STATES[@ready_state]
+    end
+
+    def add_extension(extension)
+      false
+    end
+
+    def set_header(name, value)
+      return false unless @ready_state <= 0
+      @headers[name] = value
+      true
+    end
+
+    def start
+      return false unless @ready_state == 0
+      response = handshake_response
+      return false unless response
+      @socket.write(response)
+      open unless @stage == -1
+      true
+    end
+
+    def text(message)
+      message = message.encode(UNICODE) unless message.encoding.name == UNICODE
+      frame(message, :text)
+    end
+
+    def binary(message)
+      false
+    end
+
+    def ping(*args)
+      false
+    end
+
+    def pong(*args)
+      false
+    end
+
+    def close(reason = nil, code = nil)
+      return false unless @ready_state == 1
+      @ready_state = 3
+      emit(:close, CloseEvent.new(nil, nil))
+      true
+    end
+
+  private
+
+    def open
+      @ready_state = 1
+      @queue.each { |message| frame(*message) }
+      @queue = []
+      emit(:open, OpenEvent.new)
+    end
+
+    def queue(message)
+      @queue << message
+      true
+    end
+
+    def self.client(socket, options = {})
+      Client.new(socket, options.merge(:masking => true))
+    end
+
+    def self.server(socket, options = {})
+      Server.new(socket, options.merge(:require_masking => true))
+    end
+
+    def self.rack(socket, options = {})
+      env = socket.env
+      if env['HTTP_SEC_WEBSOCKET_VERSION']
+        Hybi.new(socket, options.merge(:require_masking => true))
+      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
+        Draft76.new(socket, options)
+      else
+        Draft75.new(socket, options)
+      end
+    end
+
+    def self.encode(string, encoding = nil)
+      case string
+        when Array then
+          string = string.pack('C*')
+          encoding ||= BINARY
+        when String then
+          encoding ||= UNICODE
+      end
+      unless string.encoding.name == encoding
+        string = string.dup if string.frozen?
+        string.force_encoding(encoding)
+      end
+      string.valid_encoding? ? string : nil
+    end
+
+    def self.validate_options(options, valid_keys)
+      options.keys.each do |key|
+        unless valid_keys.include?(key)
+          raise ConfigurationError, "Unrecognized option: #{key.inspect}"
+        end
+      end
+    end
+
+    def self.websocket?(env)
+      connection = env['HTTP_CONNECTION'] || ''
+      upgrade    = env['HTTP_UPGRADE']    || ''
+
+      env['REQUEST_METHOD'] == 'GET' and
+      connection.downcase.split(/ *, */).include?('upgrade') and
+      upgrade.downcase == 'websocket'
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/http/headers.rb

@@ -0,0 +1,112 @@
+module WebSocket
+  module HTTP
+
+    module Headers
+      MAX_LINE_LENGTH = 4096
+      CR = 0x0D
+      LF = 0x0A
+
+      # RFC 2616 grammar rules:
+      #
+      #       CHAR           = <any US-ASCII character (octets 0 - 127)>
+      #
+      #       CTL            = <any US-ASCII control character
+      #                        (octets 0 - 31) and DEL (127)>
+      #
+      #       SP             = <US-ASCII SP, space (32)>
+      #
+      #       HT             = <US-ASCII HT, horizontal-tab (9)>
+      #
+      #       token          = 1*<any CHAR except CTLs or separators>
+      #
+      #       separators     = "(" | ")" | "<" | ">" | "@"
+      #                      | "," | ";" | ":" | "\" | <">
+      #                      | "/" | "[" | "]" | "?" | "="
+      #                      | "{" | "}" | SP | HT
+      #
+      # Or, as redefined in RFC 7230:
+      #
+      #       token          = 1*tchar
+      #
+      #       tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+      #                      / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+      #                      / DIGIT / ALPHA
+      #                      ; any VCHAR, except delimiters
+
+      HEADER_LINE = /^([!#\$%&'\*\+\-\.\^_`\|~0-9a-z]+):\s*([\x20-\x7e]*?)\s*$/i
+
+      attr_reader :headers
+
+      def initialize
+        @buffer  = []
+        @env     = {}
+        @headers = {}
+        @stage   = 0
+      end
+
+      def complete?
+        @stage == 2
+      end
+
+      def error?
+        @stage == -1
+      end
+
+      def parse(chunk)
+        chunk.each_byte do |octet|
+          if octet == LF and @stage < 2
+            @buffer.pop if @buffer.last == CR
+            if @buffer.empty?
+              complete if @stage == 1
+            else
+              result = case @stage
+                       when 0 then start_line(string_buffer)
+                       when 1 then header_line(string_buffer)
+                       end
+
+              if result
+                @stage = 1
+              else
+                error
+              end
+            end
+            @buffer = []
+          else
+            @buffer << octet if @stage >= 0
+            error if @stage < 2 and @buffer.size > MAX_LINE_LENGTH
+          end
+        end
+        @env['rack.input'] = StringIO.new(string_buffer)
+      end
+
+    private
+
+      def complete
+        @stage = 2
+      end
+
+      def error
+        @stage = -1
+      end
+
+      def header_line(line)
+        return false unless parsed = line.scan(HEADER_LINE).first
+
+        key   = HTTP.normalize_header(parsed[0])
+        value = parsed[1].strip
+
+        if @headers.has_key?(key)
+          @headers[key] << ', ' << value
+        else
+          @headers[key] = value
+        end
+        true
+      end
+
+      def string_buffer
+        @buffer.pack('C*')
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/http/request.rb

@@ -0,0 +1,45 @@
+module WebSocket
+  module HTTP
+
+    class Request
+      include Headers
+
+      REQUEST_LINE     = /^(OPTIONS|GET|HEAD|POST|PUT|DELETE|TRACE|CONNECT) ([\x21-\x7e]+) (HTTP\/[0-9]+\.[0-9]+)$/
+      REQUEST_TARGET   = /^(.*?)(\?(.*))?$/
+      RESERVED_HEADERS = %w[content-length content-type]
+
+      attr_reader :env
+
+    private
+
+      def start_line(line)
+        return false unless parsed = line.scan(REQUEST_LINE).first
+
+        target = parsed[1].scan(REQUEST_TARGET).first
+
+        @env = {
+          'REQUEST_METHOD' => parsed[0],
+          'SCRIPT_NAME'    => '',
+          'PATH_INFO'      => target[0],
+          'QUERY_STRING'   => target[2] || ''
+        }
+        true
+      end
+
+      def complete
+        super
+        @headers.each do |name, value|
+          rack_name = name.upcase.gsub(/-/, '_')
+          rack_name = "HTTP_#{rack_name}" unless RESERVED_HEADERS.include?(name)
+          @env[rack_name] = value
+        end
+        if host = @env['HTTP_HOST']
+          uri = URI.parse("http://#{host}")
+          @env['SERVER_NAME'] = uri.host
+          @env['SERVER_PORT'] = uri.port.to_s
+        end
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/http/response.rb

@@ -0,0 +1,29 @@
+module WebSocket
+  module HTTP
+
+    class Response
+      include Headers
+
+      STATUS_LINE = /^(HTTP\/[0-9]+\.[0-9]+) ([0-9]{3}) ([\x20-\x7e]+)$/
+
+      attr_reader :code
+
+      def [](name)
+        @headers[HTTP.normalize_header(name)]
+      end
+
+      def body
+        @buffer.pack('C*')
+      end
+
+    private
+
+      def start_line(line)
+        return false unless parsed = line.scan(STATUS_LINE).first
+        @code = parsed[1].to_i
+        true
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/http.rb

@@ -0,0 +1,15 @@
+module WebSocket
+  module HTTP
+
+    root = File.expand_path('../http', __FILE__)
+
+    autoload :Headers,  root + '/headers'
+    autoload :Request,  root + '/request'
+    autoload :Response, root + '/response'
+
+    def self.normalize_header(name)
+      name.to_s.strip.downcase.gsub(/^http_/, '').gsub(/_/, '-')
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/mask.rb

@@ -0,0 +1,14 @@
+module WebSocket
+  module Mask
+    def self.mask(payload, mask)
+      return payload if mask.nil? || payload.empty?
+
+      payload.tap do |result|
+        payload.bytesize.times do |i|
+          result.setbyte(i, payload.getbyte(i) ^ mask.getbyte(i % 4))
+        end
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/websocket_mask.rb

@@ -0,0 +1,2 @@
+# Load C native extension
+require "websocket-driver/websocket_mask"