cql-rb 1.0.6 → 1.1.0.pre0

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZDk1YTJjZWRjODBkYTMyNjIyYjBhYjZkN2NjYzA5MWE1YzJkNTVjMw==
-  data.tar.gz: !binary |-
-    ZjI5MjQ2Mzc1MDE3MzRjYzg4MzVjMmY5YTMyM2U4ODY0ODY4ZTg0OQ==
-SHA512:
-  metadata.gz: !binary |-
-    Y2IxNTg3NGYxOWM1MzY3ZmViYTY4MjcxNDhkNDAzZjkxMmY5MTBjYjc4YzJi
-    MDMwMjI1Y2NmZjI2OTAyNTM3ZWQ5ODk2M2YwMjNjODU5ODlkNjI5ZDUxNDk2
-    Y2NhNWZlMjk3ZWUzNTU4YzM2Y2UyZWI5M2YyODQyMjVmODczODU=
-  data.tar.gz: !binary |-
-    YjJhNDIwN2M1NTg4ZjMxMWNiYjA1NGFlMjZiMDc1ODgxZDhmMDAyZTUzZDEx
-    ZDE2OGNlZTAzN2IwNTVmNWYzNjcxYzNhNTdlNzk0Mzg3Zjk4ZDhjZjE1ZmY5
-    MjQ4NzE3NzUyNDQ5NTc5NDE5ODQ4MmE2MGZkMjIyMjlhMjk4NWQ=

data/lib/cql/io/node_connection.rb

@@ -1,209 +0,0 @@
-# encoding: utf-8
-
-require 'socket'
-
-
-module Cql
-  module Io
-    # @private
-    class NodeConnection
-      def initialize(*args)
-        @host, @port, @connection_timeout = args
-        @connected_future = Future.new
-        @io = nil
-        @addrinfo = nil
-        @write_buffer = ByteBuffer.new
-        @read_buffer = ByteBuffer.new
-        @current_frame = Protocol::ResponseFrame.new(@read_buffer)
-        @response_tasks = [nil] * 128
-        @event_listeners = Hash.new { |h, k| h[k] = [] }
-      end
-
-      def open
-        @connection_started_at = Time.now
-        begin
-          addrinfo = Socket.getaddrinfo(@host, @port, Socket::AF_INET, Socket::SOCK_STREAM)
-          _, port, _, ip, address_family, socket_type = addrinfo.first
-          @sockaddr = Socket.sockaddr_in(port, ip)
-          @io = Socket.new(address_family, socket_type, 0)
-          @io.connect_nonblock(@sockaddr)
-        rescue Errno::EINPROGRESS
-          # NOTE not connected yet, this is expected
-        rescue SystemCallError, SocketError => e
-          fail_connection!(e)
-        end
-        @connected_future
-      end
-
-      def connection_id
-        self.object_id
-      end
-
-      def to_io
-        @io
-      end
-
-      def on_event(&listener)
-        @event_listeners[:event] << listener
-      end
-
-      def on_close(&listener)
-        @event_listeners[:close] << listener
-      end
-
-      def connected?
-        @io && !connecting?
-      end
-
-      def connecting?
-        @io && !(@connected_future.complete? || @connected_future.failed?)
-      end
-
-      def closed?
-        @io.nil? && !connecting?
-      end
-
-      def has_capacity?
-        !!next_stream_id && connected?
-      end
-
-      def can_write?
-        @io && (!@write_buffer.empty? || connecting?)
-      end
-
-      def handle_read
-        new_bytes = @io.read_nonblock(2**16)
-        @current_frame << new_bytes
-        while @current_frame.complete?
-          stream_id = @current_frame.stream_id
-          if stream_id == EVENT_STREAM_ID
-            @event_listeners[:event].each { |listener| listener.call(@current_frame.body) }
-          elsif @response_tasks[stream_id]
-            @response_tasks[stream_id].complete!([@current_frame.body, connection_id])
-            @response_tasks[stream_id] = nil
-          else
-            # TODO dropping the request on the floor here, but we didn't send it
-          end
-          @current_frame = Protocol::ResponseFrame.new(@read_buffer)
-        end
-      rescue => e
-        force_close(e)
-      end
-
-      def perform_request(request, future)
-        stream_id = next_stream_id
-        request.encode_frame(stream_id, @write_buffer)
-        @response_tasks[stream_id] = future
-      rescue => e
-        case e
-        when CqlError
-          error = e
-        else
-          error = IoError.new(e.message)
-          error.set_backtrace(e.backtrace)
-        end
-        @response_tasks.delete(stream_id)
-        future.fail!(error)
-      end
-
-      def handle_write
-        if connecting?
-          handle_connecting
-        else
-          if !@write_buffer.empty?
-            bytes_written = @io.write_nonblock(@write_buffer.cheap_peek)
-            @write_buffer.discard(bytes_written)
-          end
-        end
-      rescue => e
-        force_close(e)
-      end
-
-      def handle_connecting
-        if connecting_timed_out?
-          fail_connection!(ConnectionTimeoutError.new("Could not connect to #{@host}:#{@port} within #{@connection_timeout}s"))
-        else
-          @io.connect_nonblock(@sockaddr)
-          succeed_connection!
-        end
-      rescue Errno::EALREADY, Errno::EINPROGRESS
-        # NOTE still not connected
-      rescue Errno::EISCONN
-        succeed_connection!
-      rescue SystemCallError, SocketError => e
-        fail_connection!(e)
-      end
-
-      def close
-        if @io
-          begin
-            @io.close
-          rescue SystemCallError
-            # NOTE nothing to do, it wasn't open
-          end
-          if connecting?
-            succeed_connection!
-          end
-          @io = nil
-          @event_listeners[:close].each { |listener| listener.call(self) }
-        end
-      end
-
-      def to_s
-        state = begin
-          if connected? then 'connected'
-          elsif connecting? then 'connecting'
-          else 'not connected'
-          end
-        end
-        %<NodeConnection(#{@host}:#{@port}, #{state})>
-      end
-
-      private
-
-      EVENT_STREAM_ID = -1
-
-      def connecting_timed_out?
-        (Time.now - @connection_started_at) > @connection_timeout
-      end
-
-      def succeed_connection!
-        @connected_future.complete!(connection_id)
-      end
-
-      def fail_connection!(e)
-        case e
-        when ConnectionError
-          error = e
-        else
-          message = "Could not connect to #{@host}:#{@port}: #{e.message} (#{e.class.name})"
-          error = ConnectionError.new(message)
-          error.set_backtrace(e.backtrace)
-        end
-        @connected_future.fail!(error)
-        force_close(error)
-      end
-
-      def force_close(e)
-        case e
-        when CqlError
-          error = e
-        else
-          error = IoError.new(e.message)
-          error.set_backtrace(e.backtrace)
-        end
-        @response_tasks.each do |listener|
-          listener.fail!(error) if listener
-        end
-        close
-      end
-
-      def next_stream_id
-        @response_tasks.each_with_index do |task, index|
-          return index if task.nil?
-        end
-        nil
-      end
-    end
-  end
-end

data/spec/cql/protocol/type_converter_spec.rb

@@ -1,52 +0,0 @@
-# encoding: ascii-8bit
-
-require 'spec_helper'
-
-
-module Cql
-  module Protocol
-    describe TypeConverter do
-      let :converter do
-        described_class.new
-      end
-
-      let :buffer do
-        ''
-      end
-
-      TYPES = [:ascii, :bigint, :blob, :boolean, :counter, :decimal, :double, :float, :inet, :int, :text, :varchar, :timestamp, :timeuuid, :uuid, :varint].freeze
-
-      describe '#to_bytes' do
-        context 'when encoding normal value' do
-          TYPES.each do |type|
-            it "encodes a null #{type.upcase}" do
-              converter.to_bytes(buffer, type, nil, 4).should == "\xff\xff\xff\xff"
-            end
-          end
-
-          it 'encodes a null LIST' do
-            converter.to_bytes(buffer, [:list, :int], nil, 4).should == "\xff\xff\xff\xff"
-          end
-
-          it 'encodes a null MAP' do
-            converter.to_bytes(buffer, [:map, :text, :text], nil, 4).should == "\xff\xff\xff\xff"
-
-          end
-
-          it 'encodes a null SET' do
-            converter.to_bytes(buffer, [:set, :uuid], nil, 4).should == "\xff\xff\xff\xff"
-
-          end
-        end
-
-        context 'when encoding collection values' do
-          TYPES.each do |type|
-            it "encodes a null #{type.upcase}" do
-              converter.to_bytes(buffer, type, nil, 2).should == "\xff\xff"
-            end
-          end
-        end
-      end
-    end
-  end
-end