ruby_volt 0.0.5

data/lib/ruby_volt/connection.rb

@@ -0,0 +1,150 @@
+require 'ruby_volt/message'
+require 'ruby_volt/response'
+
+module RubyVolt
+  class Connection
+    attr_reader :host, :port, :socket, :login_data
+    
+    def initialize(base, host, port, username, password)
+      @host, @port = host, port
+      @mutex = Mutex.new # Semaphore
+      @opaque = Helper.uniq_bytes(8)
+      define_singleton_method :base do
+        base
+      end
+      define_singleton_method :login! do
+        request = LoginMessage.new(login_protocol, servicename, username, password)
+        response_msg = dialog!(request, connect_timeout)
+        response = LoginResponse.new(response_msg).unpack!
+        @login_data = response.data
+        if logged_in?
+          puts "=== VoltDB wired [#{host}:#{port}]: connection_id=#{login_data[:connection_id]}" if logged_in?
+        end
+      end
+      establish!
+    end
+    
+    def login_protocol
+      base.login_protocol
+    end
+    
+    def procedure_protocol
+      base.procedure_protocol
+    end
+    
+    def servicename
+      base.servicename
+    end
+    
+    def connect_timeout
+      base.connect_timeout
+    end
+    
+    def procedure_timeout
+      base.procedure_timeout
+    end
+    
+    def inspect
+      "#<#{self.class.name} [#{host}:#{port}]: server_host_id=#{login_data[:server_host_id]} connection_id=#{login_data[:connection_id]} login_protocol=#{login_protocol} procedure_protocol=#{procedure_protocol}>"
+    end
+    
+    def establish!
+      close!
+      attempts = 0
+      begin
+        @socket = ::Socket.tcp(host, port, nil, nil, {:connect_timeout => connect_timeout})
+      rescue ::SystemCallError => e
+        warn "#{e.class}: #{e}. Reinitializing connection..." unless attempts > 0
+        attempts += 1
+        retry
+      else
+        login!
+      end
+    end
+    
+    def socket_open?
+      socket && !socket.closed?
+    end
+    
+    def close!
+      @login_data = nil
+      if socket
+        begin
+          socket.close
+        rescue
+        ensure
+          @socket = nil
+        end
+      end
+    end
+    
+    def require_login!
+      establish! unless logged_in?
+    end
+    
+    def logged_in?
+      login_data && login_data[:auth_result] == 0
+    end
+    
+    def unavailable?
+      !logged_in?||!socket_open?
+    end
+    
+    def available?
+      !unavailable?
+    end
+    
+    def call_procedure(procedure, client_data = @opaque, *parameters)
+      # The procedure invocation request contains the procedure to be called by name, and the serialized parameters to the procedure. The message also includes an opaque 8 byte client data value which will be returned with the response, and can be used by the client to correlate requests with responses.
+      @mutex.synchronize do
+        require_login!
+        request = InvocationRequest.new(procedure_protocol, procedure, client_data, *parameters)
+        dialog!(request, procedure_timeout) # Byte string
+      end
+    end
+    
+    def ping
+      call_procedure("@Ping")
+    end
+    
+    def benchmark(cycle = 1000)
+      Helper.benchmark(cycle) {ping} # call @Ping - system stored procedure
+    end
+    
+    private
+    
+    def dialog!(request, timeout = nil)
+      begin
+        socket.read(socket.nread) if socket_open? && socket.nread > 0 # Flush data waiting to be read
+        socket.send(request.msg, 0) # Starting dialog
+        io_select(:read, ReadTimeout, timeout) do # Waiting socket to be readable
+          length = DataType::Integer.unpack(socket) # Unpacking 32-bit integer of message length
+          readmsg(length) # Receiving message body
+        end
+      rescue ::SystemCallError, SocketDialogTimeout, ConnectionLostStatusCode => e
+        warn "#{e.class}: #{e}."
+        establish! unless request.is_a?(LoginMessage)
+        retry
+      end
+    end
+    
+    def readmsg(length)
+      msg = ::String.new(:capacity => length)
+      socket.read(length, msg) # Reading message body
+      ReadPartial.new(msg)
+    end
+    
+    def io_select(action, exception_class, timeout = DEFAULT_TIMEOUT, &block)
+      ready = case action
+      when :read then IO.select([socket], nil, nil, timeout) # ready for read
+      when :send then IO.select(nil, [socket], nil, timeout) # ready for write
+      when :exception then IO.select(nil, nil, [socket], timeout) # ready for exceptions
+      end
+      # 1) IO.select takes a set of sockets and waits until it's possible to read or write with them (or if error happens). It returns sockets event happened with.
+      # 2) array contains sockets that are checked for events. In your case you specify only sockets for reading.
+      # 3) IO.select returns an array of arrays of sockets. Element 0 contains sockets you can read from, element 1 - sockets you can write to and element 2 - sockets with errors.
+      ready ? yield : raise(exception_class, "#{timeout} sec data #{action} timed out")
+    end
+    
+  end
+end

data/lib/ruby_volt/data_type.rb

@@ -0,0 +1,50 @@
+module RubyVolt
+  class DataType
+    class << self
+      def voltDataType(val) # Ruby data type => Wire::DataType conversion
+        case val
+        when ::Array then Array
+        when NilClass then Null # Byte::NULL_INDICATOR
+        when ::Integer then
+          case val.bit_length
+          when (0..7) then Byte
+          when (8..15) then Short
+          when (16..31) then Integer
+          else
+            Long if val.bit_length >= 32
+          end
+        when ::Float then Float
+        when ::String then
+          val.encoding.name == "UTF-8" ? String : Varbinary # See "sometext".encoding
+        when ::Time then Timestamp
+        when ::BigDecimal then Decimal
+        when Meta::Geography::Point then GeographyPoint
+        when Meta::Geography::Polygon then Geography
+        end
+      end
+    
+      def classifyDataType(val)
+        case val
+        when Class then val if val < DataType
+        when ::String, ::Symbol then
+          begin
+            DataType.const_get(val)
+          rescue
+            nil
+          end
+        end
+      end
+    
+      def testpacking(*vals)
+        unpack(ReadPartial.new(pack(*vals)))
+      end
+    end
+    
+  end
+end
+
+require 'ruby_volt/data_type/extensions'
+require 'ruby_volt/data_type/basic'
+require 'ruby_volt/data_type/compound'
+require 'ruby_volt/data_type/complex'
+require 'ruby_volt/data_type/app_data_type'

data/lib/ruby_volt/data_type/app_data_type.rb

@@ -0,0 +1,24 @@
+module RubyVolt
+  class DataType
+    class AppDataType < Byte
+      extend Extensions::CodeValuesHash
+      
+      class << self
+        def pack(val)
+          val = val.is_a?(::Integer) ? val : code_values[val]
+          super(val)
+        end
+      
+        def unpack(bytes)
+          if unpacked = super(bytes)
+            codes[unpacked]
+          end
+        end
+      end
+      
+    end
+  end
+end
+
+require 'ruby_volt/data_type/app_data_type/procedure_call_status_code'
+require 'ruby_volt/data_type/app_data_type/wire_type_info'

data/lib/ruby_volt/data_type/app_data_type/procedure_call_status_code.rb

@@ -0,0 +1,14 @@
+module RubyVolt
+  class DataType
+    class ProcedureCallStatusCode < AppDataType
+      hash_codes [1, SuccessStatusCode], # SUCCESS
+                 [-1, UserAbortStatusCode], # USER_ABORT
+                 [-2, GracefulFailureStatusCode], # GRACEFUL_FAILURE
+                 [-3, UnexpectedFailureStatusCode], # UNEXPECTED_FAILURE
+                 [-4, ConnectionLostStatusCode] # CONNECTION_LOST
+                 
+
+     
+    end
+  end
+end

data/lib/ruby_volt/data_type/app_data_type/wire_type_info.rb

@@ -0,0 +1,22 @@
+module RubyVolt
+  class DataType
+    class WireTypeInfo < AppDataType
+      hash_codes [-99, Array], # ARRAY
+                 [1, Null], # NULL
+                 [3, Byte], # TINYINT
+                 [4, Short], # SMALLINT
+                 [5, Integer], # INTEGER
+                 [6, Long], # BIGINT
+                 [8, Float], # FLOAT
+                 [9, String], # STRING
+                 [11, Timestamp], # TIMESTAMP
+                 [22, Decimal], # DECIMAL
+                 [25, Varbinary], # VARBINARY
+                 [26, GeographyPoint], # GEOGRAPHY_POINT
+                 [27, Geography] # GEOGRAPHY
+      
+
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic.rb

@@ -0,0 +1,36 @@
+module RubyVolt
+  class DataType
+    class Basic < self
+      
+      class << self
+        def intToBytes(length, value)
+          bitlength = length*8
+          div = nil
+          x = [[32, 'N'], [16, 'n'], [8, 'C']].find {|a| (div = bitlength.divmod(a[0])) && div[0] != 0 && div[1] == 0}
+          b = (2**x[0])-1
+          ([value & b] + (2..div[0]).map {|i| (value >> x[0]*(i-1)) & b}).reverse.pack(x[1]*div[0])
+        end
+      
+        def bytesToInt(length, bytes) # bytes = array of 8-bit unsigned
+          bytes = bytes.unpack("C#{length}")
+          most_significant_bit = 1 << 7
+          negative = (bytes[0] & most_significant_bit) != 0
+          unscaled_value = -(bytes[0] & most_significant_bit) << length*8-8
+          # Clear the highest bit
+          # Unleash the powers of the butterfly
+          bytes[0] &= ~most_significant_bit
+          # Get the 2's complement
+          (0..length-1).each {|i| unscaled_value += bytes[i] << ((length-1 - i) * 8)}
+          unscaled_value * -1 if negative
+          unscaled_value
+        end
+      end
+      
+    end
+  end
+end
+
+require 'ruby_volt/data_type/basic/fixed_size'
+require 'ruby_volt/data_type/basic/varbinary'
+require 'ruby_volt/data_type/basic/string'
+require 'ruby_volt/data_type/basic/geography'

data/lib/ruby_volt/data_type/basic/fixed_size.rb

@@ -0,0 +1,26 @@
+module RubyVolt
+  class DataType
+    class FixedSize < Basic
+      
+      class << self
+        def pack(val)
+          val ||= self::NULL_INDICATOR
+          [val].pack(self::DIRECTIVE)
+        end
+  
+        def unpack(bytes)
+          unpacked = bytes.read(self::LENGTH).unpack1(self::DIRECTIVE)
+          unpacked unless unpacked == self::NULL_INDICATOR
+        end
+      end
+      
+    end
+  end
+end
+
+require 'ruby_volt/data_type/basic/fixed_size/integer_type'
+require 'ruby_volt/data_type/basic/fixed_size/float'
+require 'ruby_volt/data_type/basic/fixed_size/geography_point'
+require 'ruby_volt/data_type/basic/fixed_size/timestamp' # Date
+require 'ruby_volt/data_type/basic/fixed_size/decimal'
+require 'ruby_volt/data_type/basic/fixed_size/null'

data/lib/ruby_volt/data_type/basic/fixed_size/decimal.rb

@@ -0,0 +1,45 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module RubyVolt
+  class DataType
+    class Decimal < FixedSize
+      DIRECTIVE = 'C16'
+      NULL_INDICATOR = -170141183460469231731687303715884105728 # SQL NULL indicator for object type serializations
+      LENGTH = 16
+      PRECISION = 38
+      SCALE = 12
+      
+      class << self
+        def pack(val)
+          ((val == self::NULL_INDICATOR) || val.nil?) ? intToBytes(self::LENGTH, self::NULL_INDICATOR) : serialize(val)
+        end
+  
+        def unpack(bytes)
+          if (unscaled = bytesToInt(self::LENGTH, bytes.read(self::LENGTH))) && (unscaled != self::NULL_INDICATOR)
+            unscaled = unscaled.to_s
+            scaled = unscaled.insert(unscaled.size - self::SCALE, ".")
+            BigDecimal(scaled)
+          end
+        end
+      
+        def serialize(val)
+          num = case val
+          when BigDecimal then val
+          else val.to_d
+          end
+          sign, digits, base, exponent = *num.split
+          scale = digits.size - exponent
+          precision = digits.size
+          raise(::ArgumentError, "Scale of this decimal is #{scale} and the max is #{self::SCALE}") if scale > self::SCALE
+          rest = precision - scale
+          raise(::ArgumentError, "Precision to the left of the decimal point is #{rest} and the max is #{self::PRECISION-self::SCALE}") if rest > 26
+          scale_factor = self::SCALE - scale
+          unscaled_int = sign * digits.to_i * base ** scale_factor # Unscaled integer
+          intToBytes(self::LENGTH, unscaled_int)
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/float.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class Float < FixedSize
+      DIRECTIVE = 'G'
+      LENGTH = 8
+      NULL_INDICATOR = -1.7E308 # SQL NULL indicator for object type serializations
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/geography_point.rb

@@ -0,0 +1,28 @@
+module RubyVolt
+  class DataType
+    class GeographyPoint < FixedSize
+      DIRECTIVE = "G2"
+      LENGTH = 16
+      
+      class << self
+        def pack(point)
+          # A GeographyPointValue's wire protocol representation is simply two double precision numbers in sequence. The first is the longitude, and must be in the range -180 ≤ longitude ≤ 180. The second is the latitude, and must be in the range -90 ≤ latitude ≤ 90. The null GeographyPoint value has longitude and latitude both equal to 360.0.
+          if point.nil?
+            lng, lat = 360.0, 360.0
+          else
+            lng, lat = point.lng, point.lat
+          end
+          [lng, lat].pack(self::DIRECTIVE)
+        end
+      
+        def unpack(bytes)
+          lng, lat = *bytes.read(self::LENGTH).unpack(self::DIRECTIVE)
+          if (lng != 360.0) && (lat != 360.0)
+            Meta::Geography::Point.new(lng, lat)
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type.rb

@@ -0,0 +1,20 @@
+module RubyVolt
+  class DataType
+    class IntegerType < FixedSize
+      # Reserved class
+      
+      class << self
+      end
+      
+    end
+  end
+end
+
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/byte'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/u_byte'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/short'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/u_short'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/integer'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/u_integer'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/long'
+require 'ruby_volt/data_type/basic/fixed_size/integer_type/u_long'

data/lib/ruby_volt/data_type/basic/fixed_size/integer_type/byte.rb

@@ -0,0 +1,9 @@
+module RubyVolt
+  class DataType
+    class Byte < IntegerType
+      DIRECTIVE = 'c'
+      LENGTH = 1
+      NULL_INDICATOR = -128 # SQL NULL indicator for object type serializations
+    end
+  end
+end