ruby_volt 0.0.5

data/lib/ruby_volt/data_type/extensions.rb

@@ -0,0 +1,20 @@
+module RubyVolt
+  class DataType
+    module Extensions
+    
+      module CodeValuesHash
+        attr_reader :codes, :code_values
+
+        def inherited(child)
+          child.instance_variable_set(:@codes, Hash[@codes.map {|a| [a[0], a[1].dup]}]) if instance_variable_defined?("@codes")
+        end
+
+        def hash_codes(*arrays)
+          @codes ||= Hash[arrays]
+          @code_values ||= Hash[arrays.map(&:reverse)]
+        end
+      end
+      
+    end
+  end
+end

data/lib/ruby_volt/exceptions.rb

@@ -0,0 +1,67 @@
+module RubyVolt
+  # Local exceptions
+  
+  class SocketDialogTimeout < ::Exception
+  end
+  
+  class SendMsgTimeout < SocketDialogTimeout
+  end
+  
+  class ReadTimeout < SocketDialogTimeout
+  end
+
+  # Login Message Exceptions
+  
+  class AuthenticationRejected < ::Exception
+  end
+  
+  class TooManyConnections < ::Exception
+  end
+  
+  class TooLongToTransmitCredentials < ::Exception
+  end
+  
+  class InvalidLoginMessage < ::Exception
+  end
+  
+  class ClientDataInvalid < ::Exception
+  end
+  
+  # Procedure Call Status Codes
+  
+  class ProcedureCallException < ::Exception
+  end
+  
+  class SuccessStatusCode < ProcedureCallException
+  end
+  
+  class UserAbortStatusCode < ProcedureCallException
+  end
+  
+  class GracefulFailureStatusCode < ProcedureCallException
+  end
+  
+  class UnexpectedFailureStatusCode < ProcedureCallException
+  end
+  
+  class ConnectionLostStatusCode < ProcedureCallException
+  end
+  
+  # Serializable Exceptions
+  
+  class SerializableException < ::Exception
+  end
+  
+  class EEException < SerializableException
+    # This is a generic failure in Volt. Should indicate a failure in the serv- er and not the application code. These should not occur in normal operation.
+  end
+  
+  class SQLException < SerializableException
+    # This is the base class for all excep- tions that can occur during normal op- eration. This includes things like con- straint failures (unique, string length, not null) that are caught and handled correct by Volt.
+  end
+  
+  class ConstraintFailureException < SerializableException
+    # This is a specialization of SQLExcep- tion for constraint failures during the execution of a stored procedure.
+  end
+    
+end

data/lib/ruby_volt/helper.rb

@@ -0,0 +1,29 @@
+module RubyVolt
+  module Helper
+    
+    def self.benchmark(cycle = 1000, &block)
+      start = Time.now
+      cycle.times { yield }
+      spend = Time.now - start
+      puts "Execution time: #{spend} sec. #{(cycle/spend).round(2)} TPS."
+    end
+  
+    def self.uniq_bytes(length = 8)
+      bytes = ::String.new(:capacity => length)
+      bytes <<
+      if length > 0
+        nsec = Time.now.nsec
+        int = DataType::Integer.pack(nsec)
+        if length/2 < 4
+          int.b[-length/2..-1]
+        else
+          int
+        end
+      else
+        ::String.new
+      end
+      bytes << SecureRandom.random_bytes(length - bytes.bytesize)
+    end
+    
+  end
+end

data/lib/ruby_volt/message.rb

@@ -0,0 +1,29 @@
+module RubyVolt
+  class Message
+    attr_reader :msg, :protocol
+    
+    def initialize(*args)
+      @protocol = args[0]
+      @msg = ::String.new
+    end
+    
+    def inspect
+      to_str.dump
+    end
+    
+    def to_str
+      msg
+    end
+          
+    def wrap(&block)
+      msg << DataType::Byte.pack(protocol) # VoltDB Wire Protocol Version
+      yield(msg)
+      msg.prepend(DataType::Integer.pack(msg.bytesize)) # Message length preceded
+      self
+    end
+    
+  end
+end
+
+require 'ruby_volt/message/login_message'
+require 'ruby_volt/message/invocation_request'

data/lib/ruby_volt/message/invocation_request.rb

@@ -0,0 +1,18 @@
+module RubyVolt
+  class InvocationRequest < Message
+    
+    def initialize(*args)
+      super
+      procedure, client_data = *args[1..2]
+      raise(ClientDataInvalid, "Client data 8 bytes awaiting") if client_data.bytesize != 8
+      parameters = args[3..-1]
+      wrap do
+        msg << DataType::String.pack(procedure) # Procedure name
+        msg << [client_data].pack('a8') # Opaque client data (8 bytes)
+        msg << DataType::ParameterSet.pack(*parameters) # Parameter set
+      end
+    end
+    
+  end
+end
+  

data/lib/ruby_volt/message/login_message.rb

@@ -0,0 +1,17 @@
+module RubyVolt
+  class LoginMessage < Message
+    
+    def initialize(*args)
+      super
+      servicename, username, password = *args[1..-1]
+      wrap do
+        msg << DataType::Byte.pack(protocol) if protocol > 0 # Password hash version SHA-1 / SHA-256
+        msg << DataType::String.pack(servicename) # Service name
+        msg << DataType::String.pack(username) # Username
+        msg << (protocol > 0 ? Digest::SHA2.digest(password) : Digest::SHA1.digest(password)) # Password
+      end
+    end
+    
+  end
+end
+  

data/lib/ruby_volt/meta.rb

@@ -0,0 +1,6 @@
+module RubyVolt
+  module Meta
+  end
+end
+
+require 'ruby_volt/meta/geography'

data/lib/ruby_volt/meta/geography.rb

@@ -0,0 +1,165 @@
+module RubyVolt
+  module Meta
+    module Geography
+      class Point
+        attr_reader :lng, :lat
+      
+        # The wire protocol representation is similar to the S2 representation which is used in the Execution Engine. This format is different from the Java longitude/latitude format, so some explanation is in order. In Java a point is represented by a longitude and latitude. In the wire protocol a point is represented by a three dimensional point on the unit sphere. These three dimensional points are called XYZPoints. Each dimension is a double precision IEEE floating point number. The Euclidean length of each XYZPoint must be 1.0.
+      
+        class << self
+          def from_XYZPoint(x, y, z)
+            degreesPerRadian = 180.0/Math::PI
+            lngRadians = Math.atan2(y, x)
+            latRadians = Math.atan2(z, Math.sqrt(x * x + y * y))
+            lng = (lngRadians * degreesPerRadian).round(6)
+            lat = (latRadians * degreesPerRadian).round(6)
+            new(lng, lat)
+          end
+        end
+        
+        def initialize(lng, lat)
+          raise(::ArgumentError, "Longitude must be in the range -180 ≤ longitude ≤ 180") unless lng >= -180 && lng <= 180
+          raise(::ArgumentError, "Latitude must be in the range -90 ≤ latitude ≤ 90") unless lat >= -90 && lat <= 90
+          @lng = lng
+          @lat = lat
+        end
+    
+        def to_XYZPoint
+          radiansPerDegree = (Math::PI/180.0) # A conversion factor.
+          latRadians = lat * radiansPerDegree # latitude is in degrees.
+          lngRadians = lng * radiansPerDegree # longitude is in degrees.
+          cosPhi = Math.cos(latRadians)
+          x = Math.cos(lngRadians) * cosPhi
+          y = Math.sin(lngRadians) * cosPhi
+          z = Math.sin(latRadians)
+          [x, y, z]
+        end
+      
+        def inspect
+          to_wkt
+        end
+      
+        def to_s
+          "#{lng} #{lat}"
+        end
+    
+        def to_wkt
+          "POINT(#{to_s})"
+        end
+      
+        def ==(other)
+          other.is_a?(Point) && (lng == other.lng) && (lat == other.lat)
+        end
+      
+      end
+  
+      class Ring
+        attr_reader :points
+      
+        def initialize(points = [])
+          @points = []
+          points.each {|point| add_point(point)}
+        end
+      
+        def add_point(point)
+          raise(::ArgumentError, "Point has to be represented by a pseudo container RubyVolt::Meta::Geography::Point") unless point.is_a?(Point)
+          @points << point unless @points.include?(point)
+        end
+        
+        def inspect
+          to_wkt
+        end
+        
+        def fork_reverse_points
+          Ring.new(reverse_points)
+        end
+        
+        def reverse_points!
+          @points = reverse_points
+          self
+        end
+        
+        def reverse_points
+          points[1..-1].reverse.prepend(points[0])
+        end
+        
+        def close_points
+          (points[-1] == points[0]) ? points : points + [points[0]]
+        end
+        
+        def to_s
+          "(#{close_points.join(", ")})"
+        end
+    
+        def to_wkt
+          "LINESTRING#{to_s}"
+        end
+      
+        def ==(other)
+          other.is_a?(Ring) && (points.size == other.points.size) && eval(points.map.with_index {|point, index| point == other.points[index]}.join("&&"))||true
+        end
+      
+      end
+  
+      class Polygon
+        attr_reader :rings
+      
+        # In the wire protocol the first ring is still the exterior boundary and subsequent rings are holes. However, in the wire protocol all rings, exterior and hole alike, must be counter clockwise, and the last point should not be equal to the first point.
+      
+        def initialize(rings = [])
+          @rings = []
+          rings.each {|ring| add_ring(ring)}
+        end
+      
+        def add_ring(ring)
+          raise(::ArgumentError, "LineString has to be represented by a pseudo container RubyVolt::Meta::Geography::Ring") unless ring.is_a?(Ring)
+          @rings << ring
+        end
+      
+        def holes
+          has_holes? ? rings[1..-1] : []
+        end
+      
+        def has_holes?
+          rings.size > 1
+        end
+        
+        def fork_transform_rings!
+          Polygon.new(transform_rings)
+        end
+        
+        def transform_rings!
+          @rings = transform_rings
+          self
+        end
+        
+        def transform_rings
+          # To transform a ring [from Java] representation to wire protocol representation one must:
+          # • Remove the last vertex, which is the same as the first vertex,
+          # • Transform the coordinates to XYZPoint values, and
+          # • Reverse the order of the rings from the second to the end.
+          rings.map.with_index do |ring, index|
+            index > 0 ? ring.fork_reverse_points : ring
+          end.compact
+        end
+          
+        def inspect
+          to_wkt
+        end
+      
+        def to_s
+          rings.join(", ")
+        end
+    
+        def to_wkt
+          "POLYGON(#{to_s})"
+        end
+      
+        def ==(other)
+          other.is_a?(Polygon) && (rings.size == other.rings.size) && eval(rings.map.with_index {|ring, index| ring == other.rings[index]}.join("&&"))||true
+        end
+      
+      end
+    end
+  end
+end

data/lib/ruby_volt/read_partial.rb

@@ -0,0 +1,23 @@
+module RubyVolt
+  class ReadPartial
+    def initialize(bytes)
+      @bytes = bytes
+    end
+    
+    def inspect
+      "<#{self.class.name}: bytes=#{@bytes.bytesize}>"
+    end
+    
+    def nread
+      @bytes.bytesize
+    end
+    
+    def read(num)
+      exp = @bytes.byteslice(0, num)
+      @bytes.delete_prefix!(exp)
+      exp
+    end
+    
+    alias_method :recv, :read
+  end
+end

data/lib/ruby_volt/response.rb

@@ -0,0 +1,24 @@
+module RubyVolt
+  class Response
+    attr_reader :bytes, :data
+    
+    def initialize(*args)
+      @bytes = case args[0]
+      when ::IO, ReadPartial then args[0]
+      else ReadPartial.new(args[0]) # Partial reader
+      end
+      @data = {}
+    end
+    
+    def wrap(&block)
+      # data[:length] = DataType::Integer.unpack(bytes) # Message length
+      data[:protocol] = DataType::Byte.unpack(bytes) # Protocol version
+      yield
+      self
+    end
+    
+  end
+end
+
+require 'ruby_volt/response/login_response'
+require 'ruby_volt/response/invocation_response'

data/lib/ruby_volt/response/invocation_response.rb

@@ -0,0 +1,64 @@
+module RubyVolt
+  class InvocationResponse < Response
+    attr_reader :result
+
+    # An invocation response contains the results of the server's attempt to execute the stored procedure. The response includes optional fields and the first byte after the header is used to indicate which optional fields are present. The status string, application status string, and serializable exception are all optional fields. Bit 7 indicates the presence of a serializable exception, bit 6 indicates the presence of a status string, and bit 8 indicates the presence of an app status string. The serializable exception that can be included in some responses is currently not a part of the wire protocol. The exception length value should be used to skip exceptions if they are present. The status string is used to return any human readable information the server or stored procedure wants to return with the response. The app status code and app status string can be set by application code from within stored procedures and is returned with the response.
+    
+    def unpack!(&block)
+      wrap do
+        data[:client_data] = bytes.read(8).unpack1('a8')
+    
+        presentFields = DataType::Byte.unpack(bytes)
+        data[:present_fields] = presentFields
+    
+        data[:status] = DataType::ProcedureCallStatusCode.unpack(bytes) # Status
+
+        if presentFields & (1 << 5) != 0 # Bit 6 indicates the presence of a status string
+          data[:status_string] = DataType::String.unpack(bytes) # Status string
+        end
+      
+        data[:app_status] = DataType::Byte.unpack(bytes) # App status
+      
+        if presentFields & (1 << 7) != 0 # Bit 8 indicates the presence of an app status string
+          data[:app_status_string] = DataType::String.unpack(bytes) # App status string
+        end
+      
+        data[:cluster_round_trip_time] = DataType::Integer.unpack(bytes) # Cluster round trip time
+      
+        if presentFields & (1 << 6) != 0 # Bit 7 indicates the presence of a serializable exception
+          data[:serialized_exception] = DataType::SerializableException.unpack(bytes) # Serialized exception
+        end
+
+        if data[:status] != SuccessStatusCode
+          raise(data[:status], data[:status_string])
+        end
+      
+        if data[:serialized_exception]
+          raise(*data[:serialized_exception])
+        end
+
+        result_count = DataType::Short.unpack(bytes) # Result count
+                  
+        # VoltTables data
+        @result = result_count.times.map do |index|
+          table_info = DataType::VoltTable.unpack_table_info(bytes) # Total Table Length, Table Metadata Length, Status Code
+          columns = DataType::VoltTable.unpack_columns(bytes) # Columns data
+          volt_table = VoltTable.new(index, *table_info, columns)
+
+          # Rows data
+          DataType::VoltTable.unpack_rows(columns, bytes) do |row|
+            if block_given?
+              yield(data, volt_table, row)
+            else
+              volt_table.add_struct(row)
+            end
+          end
+          
+          volt_table
+        end
+      end
+      
+    end
+          
+  end
+end