RubyGems - kinetic_sdk - Versions diffs - 5.0.19 → 5.0.20 - Mend

kinetic_sdk 5.0.19 → 5.0.20

Files changed (661) hide show

data/gems/websocket-driver-0.6.5/lib/websocket/driver/hybi.rb DELETED Viewed

@@ -1,406 +0,0 @@
-module WebSocket
-  class Driver
-    class Hybi < Driver
-      root = File.expand_path('../hybi', __FILE__)
-      autoload :Frame,   root + '/frame'
-      autoload :Message, root + '/message'
-      def self.generate_accept(key)
-        Base64.strict_encode64(Digest::SHA1.digest(key + GUID))
-      end
-      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-      BYTE       = 0b11111111
-      FIN = MASK = 0b10000000
-      RSV1       = 0b01000000
-      RSV2       = 0b00100000
-      RSV3       = 0b00010000
-      OPCODE     = 0b00001111
-      LENGTH     = 0b01111111
-      OPCODES = {
-        :continuation => 0,
-        :text         => 1,
-        :binary       => 2,
-        :close        => 8,
-        :ping         => 9,
-        :pong         => 10
-      }
-      OPCODE_CODES    = OPCODES.values
-      MESSAGE_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
-      OPENING_OPCODES = OPCODES.values_at(:text, :binary)
-      ERRORS = {
-        :normal_closure       => 1000,
-        :going_away           => 1001,
-        :protocol_error       => 1002,
-        :unacceptable         => 1003,
-        :encoding_error       => 1007,
-        :policy_violation     => 1008,
-        :too_large            => 1009,
-        :extension_error      => 1010,
-        :unexpected_condition => 1011
-      }
-      ERROR_CODES        = ERRORS.values
-      DEFAULT_ERROR_CODE = 1000
-      MIN_RESERVED_ERROR = 3000
-      MAX_RESERVED_ERROR = 4999
-      PACK_FORMATS = {2 => 'n', 8 => 'Q>'}
-      def initialize(socket, options = {})
-        super
-        @extensions      = ::WebSocket::Extensions.new
-        @stage           = 0
-        @masking         = options[:masking]
-        @protocols       = options[:protocols] || []
-        @protocols       = @protocols.strip.split(/ *, */) if String === @protocols
-        @require_masking = options[:require_masking]
-        @ping_callbacks  = {}
-        @frame = @message = nil
-        return unless @socket.respond_to?(:env)
-        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
-        protos  = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
-        @headers['Upgrade']              = 'websocket'
-        @headers['Connection']           = 'Upgrade'
-        @headers['Sec-WebSocket-Accept'] = Hybi.generate_accept(sec_key)
-        if protos = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
-          protos = protos.split(/ *, */) if String === protos
-          @protocol = protos.find { |p| @protocols.include?(p) }
-          @headers['Sec-WebSocket-Protocol'] = @protocol if @protocol
-        end
-      end
-      def version
-        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
-      end
-      def add_extension(extension)
-        @extensions.add(extension)
-        true
-      end
-      def parse(chunk)
-        @reader.put(chunk)
-        buffer = true
-        while buffer
-          case @stage
-            when 0 then
-              buffer = @reader.read(1)
-              parse_opcode(buffer.getbyte(0)) if buffer
-            when 1 then
-              buffer = @reader.read(1)
-              parse_length(buffer.getbyte(0)) if buffer
-            when 2 then
-              buffer = @reader.read(@frame.length_bytes)
-              parse_extended_length(buffer) if buffer
-            when 3 then
-              buffer = @reader.read(4)
-              if buffer
-                @stage = 4
-                @frame.masking_key = buffer
-              end
-            when 4 then
-              buffer = @reader.read(@frame.length)
-              if buffer
-                @stage = 0
-                emit_frame(buffer)
-              end
-            else
-              buffer = nil
-          end
-        end
-      end
-      def binary(message)
-        frame(message, :binary)
-      end
-      def ping(message = '', &callback)
-        @ping_callbacks[message] = callback if callback
-        frame(message, :ping)
-      end
-      def pong(message = '')
-        frame(message, :pong)
-      end
-      def close(reason = nil, code = nil)
-        reason ||= ''
-        code   ||= ERRORS[:normal_closure]
-        if @ready_state <= 0
-          @ready_state = 3
-          emit(:close, CloseEvent.new(code, reason))
-          true
-        elsif @ready_state == 1
-          frame(reason, :close, code)
-          @ready_state = 2
-          true
-        else
-          false
-        end
-      end
-      def frame(buffer, type = nil, code = nil)
-        return queue([buffer, type, code]) if @ready_state <= 0
-        return false unless @ready_state == 1
-        message = Message.new
-        frame   = Frame.new
-        is_text = String === buffer
-        message.rsv1   = message.rsv2 = message.rsv3 = false
-        message.opcode = OPCODES[type || (is_text ? :text : :binary)]
-        payload = is_text ? buffer.bytes.to_a : buffer
-        payload = [code].pack(PACK_FORMATS[2]).bytes.to_a + payload if code
-        message.data = payload.pack('C*')
-        if MESSAGE_OPCODES.include?(message.opcode)
-          message = @extensions.process_outgoing_message(message)
-        end
-        frame.final       = true
-        frame.rsv1        = message.rsv1
-        frame.rsv2        = message.rsv2
-        frame.rsv3        = message.rsv3
-        frame.opcode      = message.opcode
-        frame.masked      = !!@masking
-        frame.masking_key = SecureRandom.random_bytes(4) if frame.masked
-        frame.length      = message.data.bytesize
-        frame.payload     = message.data
-        send_frame(frame)
-        true
-      rescue ::WebSocket::Extensions::ExtensionError => error
-        fail(:extension_error, error.message)
-      end
-    private
-      def send_frame(frame)
-        length = frame.length
-        buffer = []
-        masked = frame.masked ? MASK : 0
-        buffer[0] = (frame.final ? FIN : 0) |
-                    (frame.rsv1 ? RSV1 : 0) |
-                    (frame.rsv2 ? RSV2 : 0) |
-                    (frame.rsv3 ? RSV3 : 0) |
-                    frame.opcode
-        if length <= 125
-          buffer[1] = masked | length
-        elsif length <= 65535
-          buffer[1] = masked | 126
-          buffer[2..3] = [length].pack(PACK_FORMATS[2]).bytes.to_a
-        else
-          buffer[1] = masked | 127
-          buffer[2..9] = [length].pack(PACK_FORMATS[8]).bytes.to_a
-        end
-        if frame.masked
-          buffer.concat(frame.masking_key.bytes.to_a)
-          buffer.concat(Mask.mask(frame.payload, frame.masking_key).bytes.to_a)
-        else
-          buffer.concat(frame.payload.bytes.to_a)
-        end
-        @socket.write(buffer.pack('C*'))
-      end
-      def handshake_response
-        begin
-          extensions = @extensions.generate_response(@socket.env['HTTP_SEC_WEBSOCKET_EXTENSIONS'])
-        rescue => error
-          fail(:protocol_error, error.message)
-          return nil
-        end
-        @headers['Sec-WebSocket-Extensions'] = extensions if extensions
-        start   = 'HTTP/1.1 101 Switching Protocols'
-        headers = [start, @headers.to_s, '']
-        headers.join("\r\n")
-      end
-      def shutdown(code, reason, error = false)
-        @frame = @message = nil
-        @stage = 5
-        @extensions.close
-        frame(reason, :close, code) if @ready_state < 2
-        @ready_state = 3
-        emit(:error, ProtocolError.new(reason)) if error
-        emit(:close, CloseEvent.new(code, reason))
-      end
-      def fail(type, message)
-        return if @ready_state > 1
-        shutdown(ERRORS[type], message, true)
-      end
-      def parse_opcode(octet)
-        rsvs = [RSV1, RSV2, RSV3].map { |rsv| (octet & rsv) == rsv }
-        @frame = Frame.new
-        @frame.final  = (octet & FIN) == FIN
-        @frame.rsv1   = rsvs[0]
-        @frame.rsv2   = rsvs[1]
-        @frame.rsv3   = rsvs[2]
-        @frame.opcode = (octet & OPCODE)
-        @stage = 1
-        unless @extensions.valid_frame_rsv?(@frame)
-          return fail(:protocol_error,
-              "One or more reserved bits are on: reserved1 = #{@frame.rsv1 ? 1 : 0}" +
-              ", reserved2 = #{@frame.rsv2 ? 1 : 0 }" +
-              ", reserved3 = #{@frame.rsv3 ? 1 : 0 }")
-        end
-        unless OPCODES.values.include?(@frame.opcode)
-          return fail(:protocol_error, "Unrecognized frame opcode: #{@frame.opcode}")
-        end
-        unless MESSAGE_OPCODES.include?(@frame.opcode) or @frame.final
-          return fail(:protocol_error, "Received fragmented control frame: opcode = #{@frame.opcode}")
-        end
-        if @message and OPENING_OPCODES.include?(@frame.opcode)
-          return fail(:protocol_error, 'Received new data frame but previous continuous frame is unfinished')
-        end
-      end
-      def parse_length(octet)
-        @frame.masked = (octet & MASK) == MASK
-        @frame.length = (octet & LENGTH)
-        if @frame.length >= 0 and @frame.length <= 125
-          @stage = @frame.masked ? 3 : 4
-          return unless check_frame_length
-        else
-          @stage = 2
-          @frame.length_bytes = (@frame.length == 126) ? 2 : 8
-        end
-        if @require_masking and not @frame.masked
-          return fail(:unacceptable, 'Received unmasked frame but masking is required')
-        end
-      end
-      def parse_extended_length(buffer)
-        @frame.length = buffer.unpack(PACK_FORMATS[buffer.bytesize]).first
-        @stage = @frame.masked ? 3 : 4
-        unless MESSAGE_OPCODES.include?(@frame.opcode) or @frame.length <= 125
-          return fail(:protocol_error, "Received control frame having too long payload: #{@frame.length}")
-        end
-        return unless check_frame_length
-      end
-      def check_frame_length
-        length = @message ? @message.data.bytesize : 0
-        if length + @frame.length > @max_length
-          fail(:too_large, 'WebSocket frame length too large')
-          false
-        else
-          true
-        end
-      end
-      def emit_frame(buffer)
-        frame    = @frame
-        opcode   = frame.opcode
-        payload  = frame.payload = Mask.mask(buffer, @frame.masking_key)
-        bytesize = payload.bytesize
-        bytes    = payload.bytes.to_a
-        @frame = nil
-        case opcode
-          when OPCODES[:continuation] then
-            return fail(:protocol_error, 'Received unexpected continuation frame') unless @message
-            @message << frame
-          when OPCODES[:text], OPCODES[:binary] then
-            @message = Message.new
-            @message << frame
-          when OPCODES[:close] then
-            code   = (bytesize >= 2) ? payload.unpack(PACK_FORMATS[2]).first : nil
-            reason = (bytesize > 2)  ? Driver.encode(bytes[2..-1] || [], UNICODE) : nil
-            unless (bytesize == 0) or
-                   (code && code >= MIN_RESERVED_ERROR && code <= MAX_RESERVED_ERROR) or
-                   ERROR_CODES.include?(code)
-              code = ERRORS[:protocol_error]
-            end
-            if bytesize > 125 or (bytesize > 2 and reason.nil?)
-              code = ERRORS[:protocol_error]
-            end
-            shutdown(code || DEFAULT_ERROR_CODE, reason || '')
-          when OPCODES[:ping] then
-            frame(payload, :pong)
-          when OPCODES[:pong] then
-            message = Driver.encode(payload, UNICODE)
-            callback = @ping_callbacks[message]
-            @ping_callbacks.delete(message)
-            callback.call if callback
-        end
-        emit_message if frame.final and MESSAGE_OPCODES.include?(opcode)
-      end
-      def emit_message
-        message  = @extensions.process_incoming_message(@message)
-        @message = nil
-        payload = message.data
-        case message.opcode
-          when OPCODES[:text] then
-            payload = Driver.encode(payload, UNICODE)
-          when OPCODES[:binary]
-            payload = payload.bytes.to_a
-        end
-        if payload
-          emit(:message, MessageEvent.new(payload))
-        else
-          fail(:encoding_error, 'Could not decode a text frame as UTF-8')
-        end
-      rescue ::WebSocket::Extensions::ExtensionError => error
-        fail(:extension_error, error.message)
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-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 DELETED Viewed

@@ -1,80 +0,0 @@
-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 DELETED Viewed

@@ -1,55 +0,0 @@
-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