aws-crt 0.1.5-arm64-darwin

data/lib/aws-crt/http/headers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Aws
+  module Crt
+    # High level Ruby abstractions for CRT HTTP functionality
+    module Http
+      # HTTP Headers
+      class Headers
+        include Aws::Crt::ManagedNative
+        native_destroy Aws::Crt::Native.method(
+          :http_headers_release
+        )
+
+        def initialize(headers = {})
+          blob = StringBlob.encode(headers.flatten)
+          blob_ptr = FFI::MemoryPointer.new(:char, blob.length)
+          blob_ptr.write_array_of_char(blob)
+
+          manage_native do
+            Aws::Crt::Native.http_headers_new_from_blob(blob_ptr, blob.length)
+          end
+        end
+
+        def to_blob_strings
+          buf_out = Aws::Crt::Native::CrtBuf.new
+          Aws::Crt::Native.http_headers_to_blob(native, buf_out)
+          StringBlob.decode(buf_out.to_blob)
+        end
+      end
+    end
+  end
+end

data/lib/aws-crt/http/message.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Aws
+  module Crt
+    # High level Ruby abstractions for CRT HTTP functionality
+    module Http
+      # HTTP Message (request)
+      class Message
+        include Aws::Crt::ManagedNative
+        native_destroy Aws::Crt::Native.method(
+          :http_message_release
+        )
+
+        def initialize(method, path, headers = {})
+          strings = [method, path] +
+                    headers.flatten
+          blob = StringBlob.encode(strings)
+          blob_ptr = FFI::MemoryPointer.new(:char, blob.length)
+          blob_ptr.write_array_of_char(blob)
+
+          manage_native do
+            Aws::Crt::Native.http_message_new_from_blob(blob_ptr, blob.length)
+          end
+        end
+
+        def to_blob_strings
+          buf_out = Aws::Crt::Native::CrtBuf.new
+          Aws::Crt::Native.http_message_to_blob(native, buf_out)
+          StringBlob.decode(buf_out.to_blob)
+        end
+
+        def headers
+          blob_strings = to_blob_strings
+          # blob_strings must have at least 2 element and must have
+          # pairs of header/values
+          if blob_strings.length < 2 ||
+             blob_strings.length.odd?
+            raise Aws::Crt::Errors::Error,
+                  'Invalid blob_string for HTTP Message'
+          end
+          blob_strings[2..blob_strings.length].each_slice(2).to_h
+        end
+
+        def method
+          to_blob_strings[0]
+        end
+
+        def path
+          to_blob_strings[1]
+        end
+      end
+    end
+  end
+end

data/lib/aws-crt/io/event_loop_group.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Aws
+  module Crt
+    # High level Ruby abstractions for CRT IO functionality
+    module IO
+      # Options for an EventLoopGroup
+      class EventLoopGroupOptions
+        include Aws::Crt::ManagedNative
+        native_destroy Aws::Crt::Native.method(
+          :event_loop_group_options_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_options_new
+          end
+
+          Aws::Crt::Native.event_loop_group_options_set_max_threads(@native,
+                                                                    max_threads)
+        end
+      end
+
+      # 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)
+          @options = EventLoopGroupOptions.new(max_threads)
+
+          manage_native do
+            Aws::Crt::Native.event_loop_group_new(@options.native)
+          end
+          Aws::Crt::Native.event_loop_group_acquire(@native)
+        end
+      end
+    end
+  end
+end

data/lib/aws-crt/managed_native.rb

@@ -0,0 +1,87 @@
+# 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,222 @@
+# 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-ffi']
+
+      # Warning, when used as an output structure
+      # the memory in ptr needs to be manually destructed!
+      class CrtBuf < FFI::Struct
+        layout :ptr, :pointer,
+               :len, :size_t
+
+        def to_blob
+          return unless (self[:len]).positive? && !(self[:ptr]).null?
+
+          self[:ptr].read_array_of_char(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_clean_up, [], :void
+      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, [:uint64], :int
+
+      # Core Memory Management
+      attach_function :aws_crt_mem_release, [:pointer], :void, raise: false
+      attach_function :aws_crt_mem_bytes, [], :uint64, raise: false
+      attach_function :aws_crt_mem_count, [], :uint64, raise: false
+      attach_function :aws_crt_mem_dump, [], :void, raise: false
+
+      typedef :pointer, :blob
+
+      # IO API
+      typedef :pointer, :event_loop_group_options_ptr
+      attach_function :aws_crt_event_loop_group_options_new, [], :event_loop_group_options_ptr
+      attach_function :aws_crt_event_loop_group_options_release, [:event_loop_group_options_ptr], :void
+      attach_function :aws_crt_event_loop_group_options_set_max_threads, %i[event_loop_group_options_ptr uint16], :void
+
+      typedef :pointer, :event_loop_group_ptr
+      attach_function :aws_crt_event_loop_group_new, [:event_loop_group_options_ptr], :pointer
+      attach_function :aws_crt_event_loop_group_acquire, [:event_loop_group_ptr], :event_loop_group_ptr
+      attach_function :aws_crt_event_loop_group_release, [:event_loop_group_ptr], :void
+
+      # HTTP API
+      typedef :pointer, :headers_ptr
+      attach_function :aws_crt_http_headers_new_from_blob, %i[blob size_t], :headers_ptr
+      attach_function :aws_crt_http_headers_to_blob, [:headers_ptr, CrtBuf], :void
+      attach_function :aws_crt_http_headers_release, [:headers_ptr], :void
+
+      typedef :pointer, :http_message_ptr
+      attach_function :aws_crt_http_message_new_from_blob, %i[blob size_t], :http_message_ptr
+      attach_function :aws_crt_http_message_to_blob, [:http_message_ptr, CrtBuf], :void
+      attach_function :aws_crt_http_message_release, [:http_message_ptr], :void
+
+      # Auth API
+      typedef :pointer, :credentials_options_ptr
+      attach_function :aws_crt_credentials_options_new, [], :credentials_options_ptr
+      attach_function :aws_crt_credentials_options_release, [:credentials_options_ptr], :void
+      attach_function :aws_crt_credentials_options_set_access_key_id, %i[credentials_options_ptr string size_t], :void
+      attach_function :aws_crt_credentials_options_set_secret_access_key, %i[credentials_options_ptr string size_t], :void
+      attach_function :aws_crt_credentials_options_set_session_token, %i[credentials_options_ptr string size_t], :void
+      attach_function :aws_crt_credentials_options_set_expiration_timepoint_seconds, %i[credentials_options_ptr uint64], :void
+
+      typedef :pointer, :credentials_ptr
+      attach_function :aws_crt_credentials_new, [:credentials_options_ptr], :credentials_ptr
+      attach_function :aws_crt_credentials_acquire, [:credentials_ptr], :credentials_ptr
+      attach_function :aws_crt_credentials_release, [:credentials_ptr], :void
+
+      typedef :pointer, :credentials_provider_ptr
+      attach_function :aws_crt_credentials_provider_acquire, [:credentials_provider_ptr], :credentials_provider_ptr
+      attach_function :aws_crt_credentials_provider_release, [:credentials_provider_ptr], :void
+
+      typedef :pointer, :static_cred_provider_options_ptr
+      attach_function :aws_crt_credentials_provider_static_options_new, [], :static_cred_provider_options_ptr
+      attach_function :aws_crt_credentials_provider_static_options_release, [:static_cred_provider_options_ptr], :void
+      attach_function :aws_crt_credentials_provider_static_options_set_access_key_id, %i[static_cred_provider_options_ptr string size_t], :void
+      attach_function :aws_crt_credentials_provider_static_options_set_secret_access_key, %i[static_cred_provider_options_ptr string size_t], :void
+      attach_function :aws_crt_credentials_provider_static_options_set_session_token, %i[static_cred_provider_options_ptr string size_t], :void
+
+      attach_function :aws_crt_credentials_provider_static_new, [:static_cred_provider_options_ptr], :credentials_provider_ptr
+
+      enum :signing_algorithm, %i[sigv4 sigv4a]
+      enum :signature_type, %i[
+        http_request_headers http_request_query_params
+        http_request_chunk http_request_event
+        canonical_request_headers canonical_request_query_params
+      ]
+      enum :signed_body_header_type, %i[sbht_none sbht_content_sha256]
+
+      typedef :pointer, :signing_config_ptr
+      callback :should_sign_header_fn, %i[pointer size_t pointer], :bool
+      attach_function :aws_crt_signing_config_aws_new, [], :signing_config_ptr
+      attach_function :aws_crt_signing_config_aws_release, [:signing_config_ptr], :void
+      attach_function :aws_crt_signing_config_aws_validate, [:signing_config_ptr], :bool
+      attach_function :aws_crt_signing_config_aws_set_algorithm, %i[signing_config_ptr signing_algorithm], :void
+      attach_function :aws_crt_signing_config_aws_set_signature_type, %i[signing_config_ptr signature_type], :void
+      attach_function :aws_crt_signing_config_aws_set_credentials_provider, %i[signing_config_ptr credentials_provider_ptr], :void
+      attach_function :aws_crt_signing_config_aws_set_region, %i[signing_config_ptr string size_t], :void
+      attach_function :aws_crt_signing_config_aws_set_service, %i[signing_config_ptr string size_t], :void
+      attach_function :aws_crt_signing_config_aws_set_use_double_uri_encode, %i[signing_config_ptr bool], :void
+      attach_function :aws_crt_signing_config_aws_set_should_normalize_uri_path, %i[signing_config_ptr bool], :void
+      attach_function :aws_crt_signing_config_aws_set_omit_session_token, %i[signing_config_ptr bool], :void
+      attach_function :aws_crt_signing_config_aws_set_signed_body_value, %i[signing_config_ptr string size_t], :void
+      attach_function :aws_crt_signing_config_aws_set_signed_body_header_type, %i[signing_config_ptr signed_body_header_type], :void
+      attach_function :aws_crt_signing_config_aws_set_expiration_in_seconds, %i[signing_config_ptr uint64], :void
+      attach_function :aws_crt_signing_config_aws_set_date, %i[signing_config_ptr uint64], :void
+      attach_function :aws_crt_signing_config_aws_set_should_sign_header_fn, %i[signing_config_ptr should_sign_header_fn], :void
+
+      typedef :pointer, :signable_ptr
+      attach_function :aws_crt_signable_new_from_http_request, [:http_message_ptr], :signable_ptr
+      attach_function :aws_crt_signable_release, [:signable_ptr], :void
+
+      typedef :pointer, :user_data_ptr
+      typedef :pointer, :signing_result_ptr
+
+      callback :signing_complete_fn, %i[signing_result_ptr int user_data_ptr], :void
+      attach_function :aws_crt_sign_request_aws, %i[signable_ptr signing_config_ptr signing_complete_fn user_data_ptr], :int
+      attach_function :aws_crt_signing_result_apply_to_http_request, %i[signing_result_ptr http_message_ptr], :int
+
+      # Checksums
+      attach_function :aws_crt_crc32, %i[pointer size_t uint32], :uint32, raise: false
+      attach_function :aws_crt_crc32c, %i[pointer size_t uint32], :uint32, raise: false
+
+      # Internal testing API
+      attach_function :aws_crt_test_error, [:int], :int
+    end
+  end
+end

data/lib/aws-crt/platforms.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Maps OS name to crt binary name.
+OS_BINARIES = {
+  'darwin' => 'libaws-crt-ffi.dylib',
+  'linux' => 'libaws-crt-ffi.so',
+  'mingw32' => 'aws-crt-ffi.dll'
+}.freeze
+
+DEFAULT_BINARY = 'libaws-crt-ffi.so'
+
+# @return [Gem::Platform] similar to Gem::Platform.local but will return
+# host os/cpu for Jruby
+def local_platform
+  Gem::Platform.new(host_string)
+end
+
+# @return [Gem::Platform] return Gem::Platform for host os with target cpu
+def target_platform(cpu)
+  Gem::Platform.new(target_string(cpu))
+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 can be used with Gem::Platform
+def host_string
+  target_string(host_cpu)
+end
+
+# @return [String] generate a string that can be used with Gem::Platform
+def target_string(cpu)
+  "#{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

data/lib/aws-crt/string_blob.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+module Aws
+  module Crt
+    # module for CRT Blob utility methods
+    # CRT encodes lists of strings as [length, str*]
+    # using null padded, unsigned long
+    module StringBlob
+      # Encode an array of strings into
+      # a buffer (blob)
+      # @param strings [Array<String>]
+      # @return buffer (Array<char>)
+      def self.encode(strings)
+        buffer = StringIO.new
+        strings.each do |s|
+          e = s.to_s.unpack('c*')
+          buffer << [e.length].pack('N')
+          buffer << (e).pack('c*')
+        end
+        buffer.string.unpack('c*')
+      end
+
+      # Decode a blob (StringBlob)/Buffer into
+      # an array of strings
+      # @param buffer - array of chars (buffer)
+      # @return strings
+      def self.decode(buffer)
+        strings = []
+        i = 0
+        while i < buffer.size
+          len = buffer[i, 4].pack('c*').unpack1('N')
+          strings << (buffer[i + 4, len].pack('c*'))
+                     .force_encoding(Encoding::UTF_8)
+          i += len + 4
+        end
+        strings
+      end
+    end
+  end
+end

data/lib/aws-crt.rb

@@ -0,0 +1,29 @@
+# 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/string_blob'
+
+require_relative 'aws-crt/io/event_loop_group'
+require_relative 'aws-crt/http/headers'
+require_relative 'aws-crt/http/message'
+
+require_relative 'aws-crt/auth/credentials'
+require_relative 'aws-crt/auth/static_credentials_provider'
+require_relative 'aws-crt/auth/signing_config'
+require_relative 'aws-crt/auth/signable'
+require_relative 'aws-crt/auth/signer'
+require_relative 'aws-crt/checksums/crc'
+
+# Top level Amazon Web Services (AWS) namespace
+module Aws
+  # Common runtime bindings
+  module Crt
+    GEM_VERSION = File.read(File.expand_path('../VERSION', __dir__)).strip
+
+    # Ensure native init() is called when gem loads
+    Aws::Crt::Native.init
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: aws-crt
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: arm64-darwin
+authors:
+- Amazon Web Services
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-05-18 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:
+- CHANGELOG.md
+- LICENSE.txt
+- VERSION
+- bin/arm64/libaws-crt-ffi.dylib
+- lib/aws-crt.rb
+- lib/aws-crt/auth/credentials.rb
+- lib/aws-crt/auth/signable.rb
+- lib/aws-crt/auth/signer.rb
+- lib/aws-crt/auth/signing_config.rb
+- lib/aws-crt/auth/static_credentials_provider.rb
+- lib/aws-crt/checksums/crc.rb
+- lib/aws-crt/errors.rb
+- lib/aws-crt/http/headers.rb
+- lib/aws-crt/http/message.rb
+- lib/aws-crt/io/event_loop_group.rb
+- lib/aws-crt/managed_native.rb
+- lib/aws-crt/native.rb
+- lib/aws-crt/platforms.rb
+- lib/aws-crt/string_blob.rb
+homepage: https://github.com/awslabs/aws-crt-ruby
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/awslabs/aws-crt-ruby/tree/main/gems/aws-crt
+  changelog_uri: https://github.com/awslabs/aws-crt-ruby/tree/main/gems/aws-crt/CHANGELOG.md
+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: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: AWS SDK for Ruby - Common Run Time
+test_files: []