tiny_thrift 1.0.0.0

data/lib/thrift/struct_union.rb

@@ -0,0 +1,192 @@
+# 
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+require 'set'
+
+module Thrift
+  module Struct_Union
+    def name_to_id(name)
+      names_to_ids = self.class.instance_variable_get(:@names_to_ids)
+      unless names_to_ids
+        names_to_ids = {}
+        struct_fields.each do |fid, field_def|
+          names_to_ids[field_def[:name]] = fid
+        end
+        self.class.instance_variable_set(:@names_to_ids, names_to_ids)
+      end
+      names_to_ids[name]
+    end
+
+    def sorted_field_ids
+      sorted_field_ids = self.class.instance_variable_get(:@sorted_field_ids)
+      unless sorted_field_ids
+        sorted_field_ids = struct_fields.keys.sort
+        self.class.instance_variable_set(:@sorted_field_ids, sorted_field_ids)
+      end
+      sorted_field_ids
+    end
+
+    def each_field
+      sorted_field_ids.each do |fid|
+        data = struct_fields[fid]
+        yield fid, data
+      end
+    end
+
+    def read_field(iprot, field = {})
+      case field[:type]
+      when Types::STRUCT
+        value = field[:class].new
+        value.read(iprot)
+      when Types::MAP
+        key_type, val_type, size = iprot.read_map_begin
+        # Skip the map contents if the declared key or value types don't match the expected ones.
+        if (size != 0 && (key_type != field[:key][:type] || val_type != field[:value][:type]))
+          size.times do
+            iprot.skip(key_type)
+            iprot.skip(val_type)
+          end
+          value = nil
+        else
+          value = {}
+          size.times do
+            k = read_field(iprot, field_info(field[:key]))
+            v = read_field(iprot, field_info(field[:value]))
+            value[k] = v
+          end
+        end
+        iprot.read_map_end
+      when Types::LIST
+        e_type, size = iprot.read_list_begin
+        # Skip the list contents if the declared element type doesn't match the expected one.
+        if (e_type != field[:element][:type])
+          size.times do
+            iprot.skip(e_type)
+          end
+          value = nil
+        else
+          value = Array.new(size) do |n|
+            read_field(iprot, field_info(field[:element]))
+          end
+        end
+        iprot.read_list_end
+      when Types::SET
+        e_type, size = iprot.read_set_begin
+        # Skip the set contents if the declared element type doesn't match the expected one.
+        if (e_type != field[:element][:type])
+          size.times do
+            iprot.skip(e_type)
+          end
+        else
+          value = Set.new
+          size.times do
+            element = read_field(iprot, field_info(field[:element]))
+            value << element
+          end
+        end
+        iprot.read_set_end
+      else
+        value = iprot.read_type(field)
+      end
+      value
+    end
+
+    def write_data(oprot, value, field)
+      if is_container? field[:type]
+        write_container(oprot, value, field)
+      else
+        oprot.write_type(field, value)
+      end
+    end
+
+    def write_container(oprot, value, field = {})
+      case field[:type]
+      when Types::MAP
+        oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
+        value.each do |k, v|
+          write_data(oprot, k, field[:key])
+          write_data(oprot, v, field[:value])
+        end
+        oprot.write_map_end
+      when Types::LIST
+        oprot.write_list_begin(field[:element][:type], value.size)
+        value.each do |elem|
+          write_data(oprot, elem, field[:element])
+        end
+        oprot.write_list_end
+      when Types::SET
+        oprot.write_set_begin(field[:element][:type], value.size)
+        value.each do |v,| # the , is to preserve compatibility with the old Hash-style sets
+          write_data(oprot, v, field[:element])
+        end
+        oprot.write_set_end
+      else
+        raise "Not a container type: #{field[:type]}"
+      end
+    end
+
+    CONTAINER_TYPES = []
+    CONTAINER_TYPES[Types::LIST] = true
+    CONTAINER_TYPES[Types::MAP] = true
+    CONTAINER_TYPES[Types::SET] = true
+    def is_container?(type)
+      CONTAINER_TYPES[type]
+    end
+
+    def field_info(field)
+      { :type => field[:type],
+        :class => field[:class],
+        :key => field[:key],
+        :value => field[:value],
+        :element => field[:element] }
+    end
+
+    def inspect_field(value, field_info)
+      if enum_class = field_info[:enum_class]
+        "#{enum_class.const_get(:VALUE_MAP)[value]} (#{value})"
+      elsif value.is_a? Hash 
+        if field_info[:type] == Types::MAP
+          map_buf = []
+          value.each do |k, v|
+            map_buf << inspect_field(k, field_info[:key]) + ": " + inspect_field(v, field_info[:value])
+          end
+          "{" + map_buf.join(", ") + "}"
+        else
+          # old-style set
+          inspect_collection(value.keys, field_info)
+        end
+      elsif value.is_a? Array
+        inspect_collection(value, field_info)
+      elsif value.is_a? Set
+        inspect_collection(value, field_info)
+      elsif value.is_a?(String) && field_info[:binary]
+        value.unpack("H*").first
+      else
+        value.inspect
+      end
+    end
+    
+    def inspect_collection(collection, field_info)
+      buf = []
+      collection.each do |k|
+        buf << inspect_field(k, field_info[:element])
+      end
+      "[" + buf.join(", ") + "]"      
+    end
+  end
+end

data/lib/thrift/thrift_native.rb

@@ -0,0 +1,24 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+begin
+  require "thrift_native"
+rescue LoadError
+  puts "Unable to load thrift_native extension. Defaulting to pure Ruby libraries."
+end

data/lib/thrift/transport/base_server_transport.rb

@@ -0,0 +1,37 @@
+# encoding: ascii-8bit
+# 
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# 
+
+module Thrift
+  class BaseServerTransport
+    def listen
+      raise NotImplementedError
+    end
+
+    def accept
+      raise NotImplementedError
+    end
+      
+    def close; nil; end
+
+    def closed?
+      raise NotImplementedError
+    end
+  end
+end

data/lib/thrift/transport/base_transport.rb

@@ -0,0 +1,109 @@
+# encoding: ascii-8bit
+# 
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# 
+
+module Thrift
+  class TransportException < Exception
+    UNKNOWN = 0
+    NOT_OPEN = 1
+    ALREADY_OPEN = 2
+    TIMED_OUT = 3
+    END_OF_FILE = 4
+
+    attr_reader :type
+
+    def initialize(type=UNKNOWN, message=nil)
+      super(message)
+      @type = type
+    end
+  end
+
+  module TransportUtils
+    # Deprecated: Use Thrift::Bytes instead
+    def self.get_string_byte(string, index)
+      Bytes.get_string_byte(string, index)
+    end
+
+    # Deprecated: Use Thrift::Bytes instead
+    def self.set_string_byte(string, index, byte)
+      Bytes.set_string_byte(string, index, byte)
+    end
+  end
+
+  class BaseTransport
+    def open?; end
+    
+    def open; end
+
+    def close; end
+
+    # Reads a number of bytes from the transports. In Ruby 1.9+, the String returned will have a BINARY (aka ASCII8BIT) encoding.
+    #
+    # sz - The number of bytes to read from the transport.
+    #
+    # Returns a String acting as a byte buffer.
+    def read(sz)
+      raise NotImplementedError
+    end
+
+    # Returns an unsigned byte as a Fixnum in the range (0..255).
+    def read_byte
+      buf = read_all(1)
+      return Bytes.get_string_byte(buf, 0)
+    end
+
+    # Reads size bytes and copies them into buffer[0..size].
+    def read_into_buffer(buffer, size)
+      tmp = read_all(size)
+      i = 0
+      tmp.each_byte do |byte|
+        Bytes.set_string_byte(buffer, i, byte)
+        i += 1
+      end
+      i
+    end
+
+    def read_all(size)
+      return Bytes.empty_byte_buffer if size <= 0
+      buf = read(size)
+      while (buf.length < size)
+        chunk = read(size - buf.length)
+        buf << chunk
+      end
+    
+      buf
+    end
+
+    # Writes the byte buffer to the transport. In Ruby 1.9+, the buffer will be forced into BINARY encoding.
+    #
+    # buf - A String acting as a byte buffer.
+    #
+    # Returns nothing.
+    def write(buf); end
+    alias_method :<<, :write
+
+    def flush; end
+  end
+  
+  class BaseTransportFactory
+    def get_transport(trans)
+      return trans
+    end
+  end
+end

data/lib/thrift/transport/buffered_transport.rb

@@ -0,0 +1,114 @@
+# encoding: ascii-8bit
+# 
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+module Thrift
+  class BufferedTransport < BaseTransport
+    DEFAULT_BUFFER = 4096
+    
+    def initialize(transport)
+      @transport = transport
+      @wbuf = Bytes.empty_byte_buffer
+      @rbuf = Bytes.empty_byte_buffer
+      @index = 0
+    end
+
+    def open?
+      return @transport.open?
+    end
+
+    def open
+      @transport.open
+    end
+
+    def close
+      flush
+      @transport.close
+    end
+
+    def read(sz)
+      @index += sz
+      ret = @rbuf.slice(@index - sz, sz) || Bytes.empty_byte_buffer
+
+      if ret.length == 0
+        @rbuf = @transport.read([sz, DEFAULT_BUFFER].max)
+        @index = sz
+        ret = @rbuf.slice(0, sz) || Bytes.empty_byte_buffer
+      end
+
+      ret
+    end
+
+    def read_byte
+      # If the read buffer is exhausted, try to read up to DEFAULT_BUFFER more bytes into it.
+      if @index >= @rbuf.size
+        @rbuf = @transport.read(DEFAULT_BUFFER)
+        @index = 0
+      end
+
+      # The read buffer has some data now, read a single byte. Using get_string_byte() avoids
+      # allocating a temp string of size 1 unnecessarily.
+      @index += 1
+      return Bytes.get_string_byte(@rbuf, @index - 1)
+    end
+
+    # Reads a number of bytes from the transport into the buffer passed.
+    #
+    # buffer - The String (byte buffer) to write data to; this is assumed to have a BINARY encoding.
+    # size   - The number of bytes to read from the transport and write to the buffer.
+    #
+    # Returns the number of bytes read.
+    def read_into_buffer(buffer, size)
+      i = 0
+      while i < size
+        # If the read buffer is exhausted, try to read up to DEFAULT_BUFFER more bytes into it.
+        if @index >= @rbuf.size
+          @rbuf = @transport.read(DEFAULT_BUFFER)
+          @index = 0
+        end
+
+        # The read buffer has some data now, so copy bytes over to the output buffer.
+        byte = Bytes.get_string_byte(@rbuf, @index)
+        Bytes.set_string_byte(buffer, i, byte)
+        @index += 1
+        i += 1
+      end
+      i
+    end
+
+    def write(buf)
+      @wbuf << Bytes.force_binary_encoding(buf)
+    end
+
+    def flush
+      unless @wbuf.empty?
+        @transport.write(@wbuf)
+        @wbuf = Bytes.empty_byte_buffer
+      end
+      
+      @transport.flush
+    end
+  end
+
+  class BufferedTransportFactory < BaseTransportFactory
+    def get_transport(transport)
+      return BufferedTransport.new(transport)
+    end
+  end
+end