tablestore-ruby-sdk 0.0.0

data/lib/tablestore/plain_buffer_crc8.rb

@@ -0,0 +1,21 @@
+require 'tablestore/crc8_auto'
+
+class PlainBufferCrc8
+  class << self
+    def crc_string(crc, bytes)
+      Digest::CRC8Auto.new.crc8(crc, bytes.to_s).checksum
+    end
+
+    def crc_int8(crc, byte)
+      Digest::CRC8Auto.new.crc8(crc, [byte].pack('C*')).checksum
+    end
+
+    def crc_int32(crc, byte)
+      Digest::CRC8Auto.new.crc8(crc, [byte].pack('i')).checksum
+    end
+
+    def crc_int64(crc, byte)
+      Digest::CRC8Auto.new.crc8(crc, [byte].pack('q')).checksum
+    end
+  end
+end

data/lib/tablestore/plain_buffer_input_stream.rb

@@ -0,0 +1,92 @@
+require 'tablestore/error'
+
+class PlainBufferInputStream
+  def initialize(data_buffer)
+    @buffer = data_buffer
+    @cur_pos = 0
+    @last_tag = 0
+  end
+
+  def is_at_end?
+    @buffer.length == @cur_pos
+  end
+
+  def read_tag
+    if is_at_end?
+      @last_tag = 0
+      return 0
+    end
+    @last_tag = read_raw_byte
+    @last_tag.ord
+  end
+
+  def check_last_tag_was(tag)
+    @last_tag.ord == tag
+  end
+
+  def get_last_tag
+    @last_tag.ord
+  end
+
+  def read_raw_byte
+    raise TableStoreClientError.new("Read raw byte encountered EOF.") if is_at_end?
+    pos = @cur_pos
+    @cur_pos += 1
+    if @buffer[pos].is_a?(Fixnum)
+      [@buffer[pos]].chr
+    else
+      @buffer[pos]
+    end
+  end
+
+  def read_raw_little_endian64
+    read_bytes(8).unpack('q<')[0]
+  end
+
+  def read_raw_little_endian32
+    read_bytes(4).unpack('i<')[0]
+  end
+
+  def read_boolean
+    read_bytes(1).unpack('C')[0] == 1
+  end
+
+  def read_double
+    read_bytes(8).unpack('q<')[0]
+  end
+
+  def read_int32
+    read_bytes(4).unpack('i<')[0]
+  end
+
+  def read_int64
+    read_bytes(8).unpack('q<')[0]
+  end
+
+  def read_bytes(size)
+    raise TableStoreClientError.new("Read bytes encountered EOF.") if @buffer.length - @cur_pos < size
+    tmp_pos = @cur_pos
+    @cur_pos += size
+    @buffer[tmp_pos, size]
+  end
+
+  def read_utf_string(size)
+    raise TableStoreClientError.new("Read bytes encountered EOF.") if @buffer.length - @cur_pos < size
+    utf_str = @buffer[@cur_pos, size]
+    @cur_pos += size
+    utf_str.encode('utf-8')   if utf_str.is_a?(String)
+    utf_str
+  end
+
+  def last_tag
+    @last_tag
+  end
+
+  def cur_pos
+    @cur_pos
+  end
+
+  def buffer
+    @buffer
+  end
+end

data/lib/tablestore/plain_buffer_output_stream.rb

@@ -0,0 +1,59 @@
+require 'tablestore/error'
+
+class PlainBufferOutputStream
+  def initialize(capacity)
+    @buffer = []
+    @capacity = capacity
+  end
+
+  def is_full?
+    @capacity <= @buffer.length
+  end
+
+  def count
+    @buffer.length
+  end
+
+  def remain
+    @capacity - count
+  end
+
+  def clear
+    @buffer.clear
+  end
+
+  def write_raw_byte(value)
+    raise TableStoreClientError.new("The buffer is full") if is_full?
+    @buffer << [value].pack("C*")
+  end
+
+  def write_raw_little_endian32(value)
+    write_bytes([value].pack("i"))
+  end
+
+  def write_raw_little_endian64(value)
+    write_bytes([value].pack("q"))
+  end
+
+  def write_double(value)
+    write_bytes([value].pack("d"))
+  end
+
+  def write_boolean(value)
+    bool_value = value ? 1 : 0
+    write_bytes([bool_value].pack("C"))
+  end
+
+  def write_bytes(value)
+    raise TableStoreClientError.new("The buffer is full.") if @buffer.length + value.length > @capacity
+    bytes = ''
+    value.to_s.each_byte do |b|
+      bytes += [b].pack("C*")
+    end
+    @buffer << bytes
+  end
+
+  def get_buffer
+    @buffer
+  end
+end

data/lib/tablestore/protocol.rb

@@ -0,0 +1,161 @@
+require 'base64'
+
+class OTSProtocol
+  $api_version = '2015-12-31'
+  $user_agent = 'table-store-ruby'
+
+  encoder_class = OTSProtoBufferEncoder.new
+  decoder_class = OTSProtoBufferDecoder.new
+
+  $api_list = [
+      'CreateTable',
+      'ListTable',
+      'DeleteTable',
+      'DescribeTable',
+      'UpdateTable',
+      'GetRow',
+      'PutRow',
+      'UpdateRow',
+      'DeleteRow',
+      'BatchGetRow',
+      'BatchWriteRow',
+      'GetRange'
+  ]
+
+  def initialize(user_id, user_key, sts_token, instance_name, encoding, logger)
+    @user_id = user_id
+    @user_key = user_key
+    @sts_token = sts_token
+    @instance_name = instance_name
+    @encoding = encoding
+    @encoder = encoder_class(encoding)
+    @decoder = decoder_class(encoding)
+    @logger = logger
+  end
+
+  def make_headers_string(headers)
+    headers.map{|k,v| "#{k.downcase}:#{v.strip}" if k.include?('x-ots-') and k != 'x-ots-signature'}.sort.join('\n')
+  end
+
+  def call_signature_method(signature_string)
+    salt = Digest::SHA1.digest(signature_string)
+    Base64.encode64(HMAC::SHA1.digest(UserSecret, salt)).strip
+  end
+
+  def make_request_signature(query, headers)
+    signature_string = query + '\n' + 'POST' + '\n\n'
+
+    headers_string = make_headers_string(headers)
+    signature_string += headers_string + '\n'
+    call_signature_method(signature_string)
+  end
+
+  def make_headers(body, query)
+    md5 = Base64.encode64(Digest::MD5.new.digest(body)).gsub(/\n/, '')
+    date = Time.now.strftime('%Y-%m-%dT%H:%M:%S.000Z')
+
+    headers = {
+      'x-ots-date': date,
+      'x-ots-apiversion': $api_version,
+      'x-ots-accesskeyid': @user_id,
+      'x-ots-instancename': @instance_name,
+      'x-ots-contentmd5': md5,
+    }
+
+    headers['x-ots-ststoken'] = @sts_token if @sts_token.present?
+
+    signature = make_request_signature(query, headers)
+    headers['x-ots-signature'] = signature
+    headers['User-Agent'] = $user_agent
+    headers
+  end
+
+  def make_response_signature(query, headers)
+    uri = query
+    headers_string = make_headers_string(headers)
+
+    signature_string = headers_string + '\n' + uri
+    signature = call_signature_method(signature_string)
+    signature
+  end
+
+  def check_headers(headers, body, status=nil)
+      # check the response headers and process response body if needed.
+
+      header_names = [
+          'x-ots-contentmd5',
+          'x-ots-requestid',
+          'x-ots-date',
+          'x-ots-contenttype',
+      ]
+
+    if status >= 200 and status < 300
+      header_names.each do |name|
+        raise TableStoreClientError.new("#{name} is missing in response header.") unless headers.include?name
+
+        if headers.include?'x-ots-contentmd5'
+          md5 = Base64.encode64(Digest::MD5.new.digest(body)).gsub(/\n/, '')
+        end
+        raise TableStoreClientError.new('MD5 mismatch in response.')  if md5 != headers['x-ots-contentmd5']
+      end
+    end
+  end
+
+  def check_authorization(query, headers, status=nil)
+    auth = headers.get('authorization')
+    if auth.nil?
+      if status >= 200 and status < 300
+        raise TableStoreClientError.new('"Authorization" is missing in response header.')
+      else
+        return
+      end
+    end
+    # 1, check authorization
+    unless auth.include?('OTS ')
+      raise TableStoreClientError.new('Invalid Authorization in response.')
+    end
+    # 2, check accessid
+    access_id, signature = auth[4..-1].split(':')
+    if access_id != self.user_id
+      raise TableStoreClientError.new('Invalid accesskeyid in response.')
+    end
+    # 3, check signature
+    # decode the byte type
+    if signature != make_response_signature(query, headers)
+      raise TableStoreClientError.new('Invalid signature in response.')
+    end
+  end
+
+  def make_request(api_name)
+    raise TableStoreClientError("API #{api_name} is not supported.") if $api_list.exclude?api_name
+    body = encoder.encode_request(api_name, *args)
+    query = '/' + api_name
+    headers = make_headers(body, query)
+    return query, headers, body
+  end
+
+  def get_request_id_string(headers)
+    request_id = headers.get('x-ots-requestid')
+    request_id = ""  if request_id.nil?
+    request_id
+  end
+
+  def parse_response(api_name, status, headers, body)
+    raise TableStoreClientError.new("API #{api_name} is not supported.") unless api_list.include?(api_name)
+    begin
+      hash, proto = decoder.decode_response(api_name, body)
+    rescue => e
+      request_id = get_request_id_string(headers)
+      error_message = "Response format is invalid, #{e}, RequestID: #{request_id}, " \
+                "HTTP status: #{status}, Body: #{body}."
+      self.logger.error(error_message)
+      raise TableStoreClientError.new(error_message, status)
+    end
+    hash
+  end
+
+  # def handle_error(api_name, query, status, reason, headers, body)
+  #
+  # end
+
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: tablestore-ruby-sdk
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- seveninches
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: digest-crc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: os
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A simple tablestore gem
+email: lijinghao333@aliyun.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/consts.rb
+- lib/protobuf/ots.proto
+- lib/protobuf/ots_filiter.proto
+- lib/protobuf/ots_filiter_pb.rb
+- lib/protobuf/ots_pb.rb
+- lib/tablestore-ruby-sdk.rb
+- lib/tablestore/connection.rb
+- lib/tablestore/crc8_auto.rb
+- lib/tablestore/error.rb
+- lib/tablestore/main.rb
+- lib/tablestore/metadata.rb
+- lib/tablestore/ots.rb
+- lib/tablestore/plain_buffer_coded_input_stream.rb
+- lib/tablestore/plain_buffer_coded_output_stream.rb
+- lib/tablestore/plain_buffer_crc8.rb
+- lib/tablestore/plain_buffer_input_stream.rb
+- lib/tablestore/plain_buffer_output_stream.rb
+- lib/tablestore/protocol.rb
+homepage: http://rubygems.org/gems/tablestore-ruby-sdk
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: tablestore
+test_files: []