aws-crt 0.1.0.pre-x64-mingw32

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 471456c5815b1eb1b0d52caa65c48353f6564e2ebe8d8fa1c9f975d4d9de76f9
+  data.tar.gz: 821151b91caff0524fc35ce6e5da0e47eec0d7e2b197587d4389ef55c7e1a939
+SHA512:
+  metadata.gz: a88dff9be9a45de97488ab42a1e68916818a80538eb2d2138fc4d9128e2fb17c4bc825b57fef0b519599df251f5cc8b49ba085e7899b158d3caac2069f2897e5
+  data.tar.gz: 1de0ee004e15fddf9df06f62d8d86727fab30ad773dbd5551371b8a46a41cd7235be8210f7ede6558a225a513ab293eb0e18b7234caa3849deab85cfe1604c82

data/VERSION

@@ -0,0 +1 @@
+0.1.0.pre

data/lib/aws-crt.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'aws-crt/platforms'
+require_relative 'aws-crt/native'
+require_relative 'aws-crt/errors'
+require_relative 'aws-crt/managed_native'
+require_relative 'aws-crt/io'
+
+# Top level Amazon Web Services (AWS) namespace
+module Aws
+  # Top level namespace for all common runtime (CRT) functionality
+  module Crt
+    # Ensure native init() is called when gem loads
+    Aws::Crt::Native.init
+  end
+end

data/lib/aws-crt/errors.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Aws
+  module Crt
+    # Base class for CRT Errors
+    class Error < StandardError
+    end
+
+    # CRT Errors - includes utilities for mapping errors from CRT to
+    # Ruby Exceptions
+    module Errors
+      @const_set_mutex = Mutex.new
+
+      AWS_TO_RUBY_ERROR_MAP = {
+        'AWS_ERROR_INVALID_INDEX' => IndexError,
+        'AWS_ERROR_OOM' => NoMemoryError,
+        'AWS_ERROR_UNIMPLEMENTED' => NotImplementedError,
+        'AWS_ERROR_INVALID_ARGUMENT' => ArgumentError,
+        'AWS_ERROR_SYS_CALL_FAILURE' => SystemCallError,
+        'AWS_ERROR_DIVIDE_BY_ZERO' => ZeroDivisionError,
+        'AWS_ERROR_HASHTBL_ITEM_NOT_FOUND' => KeyError
+      }.freeze
+
+      def self.raise_last_error
+        error_code = Aws::Crt::Native.last_error
+        return if error_code.zero?
+
+        error_name = Aws::Crt::Native.error_name(error_code)
+        msg = Aws::Crt::Native.error_debug_str(error_code)
+        Aws::Crt::Native.reset_error
+        raise error_class(error_name), msg
+      end
+
+      # Get the error class for a given error_name
+      def self.error_class(error_name)
+        if AWS_TO_RUBY_ERROR_MAP.include? error_name
+          return AWS_TO_RUBY_ERROR_MAP[error_name]
+        end
+
+        constant = error_class_constant(error_name)
+        if error_const_set?(constant)
+          # modeled error class exist
+          # set code attribute
+          const_get(constant)
+
+        else
+          add_error_constant(constant)
+        end
+      end
+
+      # Convert an error code to an error class name/constant.
+      # This requires filtering non-safe characters from the constant
+      # name and ensuring it begins with an uppercase letter.
+      def self.error_class_constant(error_name)
+        error_name.to_s.gsub(/AWS_ERROR_/, '').split('_').map(&:capitalize).join
+      end
+
+      def self.add_error_constant(constant)
+        @const_set_mutex.synchronize do
+          # Ensure the const was not defined while blocked by the mutex
+          if error_const_set?(constant)
+            const_get(constant)
+          else
+            error_class = Class.new(Aws::Crt::Error)
+            const_set(constant, error_class)
+          end
+        end
+      end
+
+      def self.error_const_set?(constant)
+        # Purposefully not using #const_defined? as that method returns true
+        # for constants not defined directly in the current module.
+        constants.include?(constant.to_sym)
+      end
+    end
+  end
+end

data/lib/aws-crt/io.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Aws
+  module Crt
+    # High level Ruby abstractions for CRT IO functionality
+    module IO
+      # A collection of event-loops.
+      # An event-loop is a thread for doing async work, such as I/O.
+      # Classes that need to do async work will ask the EventLoopGroup
+      # for an event-loop to use.
+      class EventLoopGroup
+        include Aws::Crt::ManagedNative
+        native_destroy Aws::Crt::Native.method(:event_loop_group_release)
+
+        def initialize(max_threads = nil)
+          unless max_threads.nil? ||
+                 (max_threads.is_a?(Integer) && max_threads.positive?)
+            raise ArgumentError, 'max_threads must be nil or positive Integer'
+          end
+
+          # Ruby uses nil to request default values, native code uses 0
+          max_threads = 0 if max_threads.nil?
+
+          manage_native do
+            Aws::Crt::Native.event_loop_group_new(max_threads)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aws-crt/managed_native.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Aws
+  module Crt
+    # A mixin module for generic managed native functionality
+    # Example:
+    #
+    #   class C
+    #     include Aws::Crt::ManagedNative
+    #     native_destroy Aws::Crt::Native.method(:test_struct_destroy)
+    #
+    #     def initialize
+    #       manage_native { Aws::Crt::Native::test_struct_new() }
+    #     end
+    #
+    #     def use_native
+    #       Aws::Crt::Native::test_method(native) #use that getter for native
+    #     end
+    #   end
+    module ManagedNative
+      def self.included(sub_class)
+        sub_class.extend(ClassMethods)
+      end
+
+      # expects a block that returns a :pointer to the native resource
+      # that this class manages
+      def manage_native(&block)
+        # check that a destructor has been registered
+        unless self.class.instance_variable_get('@destructor')
+          raise 'No native destructor registered.  use native_destroy to ' \
+                  'set the method used to cleanup the native object this ' \
+                  'class manages.'
+        end
+        native = block.call
+        @native = FFI::AutoPointer.new(native, self.class.method(:on_release))
+      end
+
+      # @param [Boolean] safe (true) - raise an exception if the native object
+      #   is not set (has been freed or never created)
+      # @return [FFI:Pointer]
+      def native(safe: true)
+        raise '@native is unset or has been freed.' if safe && !@native
+
+        @native
+      end
+
+      # @return [Boolean]
+      def native_set?
+        !!@native
+      end
+
+      # Immediately release this instance's attachment to the underlying
+      # resources, without waiting for the garbage collector.
+      # Note that underlying resources will remain alive until nothing
+      # else is using them.
+      def release
+        return unless @native
+
+        @native.free
+        @native = nil
+      end
+
+      # ClassMethods for ManagedNative
+      module ClassMethods
+        # Register the method used to cleanup the native object this class
+        # manages.  Must be a method, use object.method(:method_name).
+        #
+        # Example:
+        #  native_destroy Aws::Crt::Native.method(:test_release)
+        def native_destroy(destructor)
+          unless destructor.is_a?(Method)
+            raise ArgumentError, 'destructor must be a Method. ' \
+              'Use object.method(:method_name)'
+          end
+          @destructor = destructor
+        end
+
+        # Do not call directly
+        # method passed to FFI Autopointer to call the destructor
+        def on_release(native)
+          @destructor.call(native)
+        end
+      end
+    end
+  end
+end

data/lib/aws-crt/native.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'ffi'
+module Aws
+  module Crt
+    # FFI Bindings to native CRT functions
+    module Native
+      extend FFI::Library
+
+      ffi_lib [crt_bin_path(local_platform), 'libaws-crt']
+
+      # aws_byte_cursor binding
+      class ByteCursor < FFI::Struct
+        layout :len, :size_t,
+               :ptr, :pointer
+
+        def to_s
+          return unless (self[:len]).positive? && !(self[:ptr]).null?
+
+          self[:ptr].read_string(self[:len])
+        end
+      end
+
+      # Managed PropertyList Struct (for outputs)
+      class PropertyList < FFI::ManagedStruct
+        layout :len, :size_t,
+               :names, :pointer,
+               :values, :pointer
+
+        def props
+          return nil if to_ptr.null?
+
+          return {} unless (self[:len]).positive?
+
+          out = {}
+          names_p = self[:names].get_array_of_pointer(0, self[:len])
+          values_p = self[:values].get_array_of_pointer(0, self[:len])
+          names_p.zip(values_p).each do |name_p, value_p|
+            out[name_p.read_string.dup] = value_p.read_string.dup
+          end
+          out
+        end
+
+        def self.release(ptr)
+          Aws::Crt::Native.aws_crt_property_list_release(ptr)
+        end
+      end
+
+      # Given a ruby hash (string -> string), return two native arrays:
+      # char** (:pointer) AND a list of all of the FFI::MemoryPointers
+      # that must be kept around to avoid GC
+      def self.hash_to_native_arrays(hash)
+        key_array, keys_p = array_to_native(hash.keys)
+        value_array, values_p = array_to_native(hash.values)
+        [key_array, value_array, keys_p + values_p]
+      end
+
+      # Given a ruby array of strings, return a native array: char** and
+      # the FFI::MemoryPointers (these need to be pined for the length the
+      # native memory will be used to avoid GC)
+      def self.array_to_native(array)
+        native = FFI::MemoryPointer.new(:pointer, array.size)
+        pointers = array.map do |s|
+          FFI::MemoryPointer.from_string(s.to_s)
+        end
+        native.write_array_of_pointer(pointers)
+        [native, pointers]
+      end
+
+      # Extends FFI::attach_function
+      #
+      # 1. Allows us to only supply the aws_crt C name and removes
+      #     the aws_crt.
+      # 2. Wraps the call in an error-raise checker (unless options[:raise]
+      #   = false)
+      # 3. Creates a bang method that does not do automatic error checking.
+      def self.attach_function(c_name, params, returns, options = {})
+        ruby_name = c_name.to_s.sub(/aws_crt_/, '').to_sym
+        raise_errors = options.fetch(:raise, true)
+        options.delete(:raise)
+        unless raise_errors
+          return super(ruby_name, c_name, params, returns, options)
+        end
+
+        bang_name = "#{ruby_name}!"
+
+        super(ruby_name, c_name, params, returns, options)
+        alias_method(bang_name, ruby_name)
+
+        define_method(ruby_name) do |*args, &block|
+          res = public_send(bang_name, *args, &block)
+          # functions that return void cannot fail
+          return unless res
+
+          # for functions that return int, non-zero indicates failure
+          Errors.raise_last_error if res.is_a?(Integer) && res != 0
+
+          # for functions that return pointer, NULL indicates failure
+          Errors.raise_last_error if res.is_a?(FFI::Pointer) && res.null?
+
+          res
+        end
+
+        module_function ruby_name
+        module_function bang_name
+      end
+
+      # Core API
+      attach_function :aws_crt_init, [], :void, raise: false
+      attach_function :aws_crt_last_error, [], :int, raise: false
+      attach_function :aws_crt_error_str, [:int], :string, raise: false
+      attach_function :aws_crt_error_name, [:int], :string, raise: false
+      attach_function :aws_crt_error_debug_str, [:int], :string, raise: false
+      attach_function :aws_crt_reset_error, [], :void, raise: false
+
+      attach_function :aws_crt_thread_join_all_managed, [], :int
+
+      # IO API
+      attach_function :aws_crt_event_loop_group_new, [:uint16], :pointer
+      attach_function :aws_crt_event_loop_group_release, [:pointer], :void
+
+      # Auth API
+      attach_function :aws_crt_credentials_new, %i[string string string uint64], :pointer
+      attach_function :aws_crt_credentials_release, [:pointer], :void
+      attach_function :aws_crt_credentials_get_access_key_id, [:pointer], ByteCursor.by_value
+      attach_function :aws_crt_credentials_get_secret_access_key, [:pointer], ByteCursor.by_value
+      attach_function :aws_crt_credentials_get_session_token, [:pointer], ByteCursor.by_value
+      attach_function :aws_crt_credentials_get_expiration_timepoint_seconds, [:pointer], :uint64
+
+      enum :signing_algorithm, %i[sigv4 sigv4a]
+      enum :signature_type, %i[http_request_headers http_request_query_params
+                               http_request_chunk http_request_event]
+      enum :signed_body_header_type, %i[sbht_none sbht_content_sha256]
+      callback :should_sign_header_fn, [ByteCursor.by_ref, :pointer], :bool
+      attach_function :aws_crt_signing_config_new, %i[signing_algorithm signature_type string string string uint64 pointer signed_body_header_type should_sign_header_fn bool bool bool uint64], :pointer
+      attach_function :aws_crt_signing_config_release, [:pointer], :void
+      attach_function :aws_crt_signing_config_is_signing_synchronous, [:pointer], :bool, raise: false
+
+      attach_function :aws_crt_signable_new, [], :pointer
+      attach_function :aws_crt_signable_release, [:pointer], :void
+      attach_function :aws_crt_signable_set_property, %i[pointer string string], :int
+      attach_function :aws_crt_signable_get_property, %i[pointer string], :string, raise: false
+      attach_function :aws_crt_signable_append_property_list, %i[pointer string string string], :int
+      attach_function :aws_crt_signable_set_property_list, %i[pointer string size_t pointer pointer], :int
+
+      callback :signing_complete_fn, %i[pointer int pointer], :void
+      attach_function :aws_crt_sign_request_synchronous, %i[pointer pointer signing_complete_fn], :int
+      attach_function :aws_crt_verify_sigv4a_signing, %i[pointer pointer string string string string], :int
+
+      attach_function :aws_crt_signing_result_get_property, %i[pointer string], :string, raise: false
+      attach_function :aws_crt_signing_result_get_property_list, %i[pointer string], PropertyList.by_ref, raise: false
+      attach_function :aws_crt_property_list_release, %i[pointer], :void
+
+      # Internal testing API
+      attach_function :aws_crt_test_error, [:int], :int
+      attach_function :aws_crt_test_pointer_error, [], :pointer
+    end
+  end
+end

data/lib/aws-crt/platforms.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Maps OS name to crt binary name.
+OS_BINARIES = {
+  'darwin' => 'libaws-crt.dylib',
+  'linux' => 'libaws-crt.so',
+  'mingw32' => 'aws-crt.dll'
+}.freeze
+
+DEFAULT_BINARY = 'libaws-crt.so'
+
+# @return [String] returns Gem::Platform style name for the current system
+# similar to Gem::Platform.local but will return systems host os/cpu
+# for Jruby
+def local_platform
+  Gem::Platform.new(host_string)
+end
+
+# @return [String] return the file name for the CRT library for the platform
+def crt_bin_name(platform)
+  OS_BINARIES[platform.os] || DEFAULT_BINARY
+end
+
+# @return [String] return the directory of the CRT library for the platform
+def crt_bin_dir(platform)
+  File.expand_path("../../bin/#{platform.cpu}", File.dirname(__FILE__))
+end
+
+# @return [String] return the path to the CRT library for the platform
+def crt_bin_path(platform)
+  File.expand_path(crt_bin_name(platform), crt_bin_dir(platform))
+end
+
+# @return [String] generate a string that be used with Gem::Platform
+def host_string
+  "#{host_cpu}-#{host_os}"
+end
+
+# @return [String] host cpu, even on jruby
+def host_cpu
+  case RbConfig::CONFIG['host_cpu']
+  when /86_64/
+    'x86_64'
+  when /86/
+    'x86'
+  else
+    RbConfig::CONFIG['host_cpu']
+  end
+end
+
+# @return [String] host os, even on jruby
+def host_os
+  case RbConfig::CONFIG['host_os']
+  when /darwin/
+    'darwin'
+  when /linux/
+    'linux'
+  when /mingw|mswin/
+    'mingw32'
+  else
+    RbConfig::CONFIG['host_os']
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: aws-crt
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+platform: x64-mingw32
+authors:
+- Amazon Web Services
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- bin/x64/aws-crt.dll
+- lib/aws-crt.rb
+- lib/aws-crt/errors.rb
+- lib/aws-crt/io.rb
+- lib/aws-crt/managed_native.rb
+- lib/aws-crt/native.rb
+- lib/aws-crt/platforms.rb
+homepage: https://github.com/awslabs/aws-crt-ruby
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: AWS SDK for Ruby - Common Run Time
+test_files: []