mysql2-lambda 0.5.3.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38c8414b5b084f3948f948ade30837b9f3816d25ba28cb215128288fc27fa291
+  data.tar.gz: 7b7d8a1d824e51fac74545c36e0df03e0985efa16887d059aacf7e55ddd850e9
+SHA512:
+  metadata.gz: c1cfa0090917c725c234471eb5a7f045fafd29f0ef2c45886cf587fc8d9c759d1c9420e9a40d2a0aa27faa215d3ea71d47cdd268fbfe144bb75f7ce27fc4eb00
+  data.tar.gz: 5cb9c06c7c24ed58b564361a8d3893d21512012f6abe3aaacd33b040f161cb9ce8483d1f3def6b5431dc71d584b6251c4a69e2097161fd3e7d326d48b3ec00b8

data/CHANGELOG.md

@@ -0,0 +1 @@
+Changes are maintained under [Releases](https://github.com/brianmario/mysql2/releases)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Brian Lopez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+
+# Lamby MySQL Layer
+
+Installs dependencies for [customink/foundry](https://github.com/customink/foundry) on Lambda.
+
+## Usage
+
+* Clone or fork this repository.
+* Make sure you have Docker or AWS CLI installed.
+* Run `./bin/deploy` or `./bin/deploy-${stage}` scripts.
+
+From there you simply use the arn in your AWS SAM `template.yaml` file.
+
+## Dependencies
+
+...
+
+## Layer Size
+
+In `/opt/lib64/mysql`
+
+```
+lrwxrwxrwx 1 root      17 Jul  2 00:49 libmysqlclient_r.so -> libmysqlclient.so
+lrwxrwxrwx 1 root      20 Jul  2 00:49 libmysqlclient.so -> libmysqlclient.so.18
+lrwxrwxrwx 1 root      24 Jul  2 00:49 libmysqlclient.so.18 -> libmysqlclient.so.18.0.0
+-rwxr-xr-x 1 root 2983624 Dec  3  2018 libmysqlclient.so.18.0.0
+```
+
+
+## Methodology
+
+We used the `lambci/lambda:build-ruby2.5` Docker image from the [docker-lambda](https://github.com/lambci/docker-lambda) project.

data/lib/mysql2.rb

@@ -0,0 +1,86 @@
+require 'date'
+require 'bigdecimal'
+
+# Load libmysql.dll before requiring mysql2/mysql2.so
+# This gives a chance to be flexible about the load path
+# Or to bomb out with a clear error message instead of a linker crash
+if RUBY_PLATFORM =~ /mswin|mingw/
+  dll_path = if ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
+    # If this environment variable is set, it overrides any other paths
+    # The user is advised to use backslashes not forward slashes
+    ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
+  elsif File.exist?(File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)))
+    # Use vendor/libmysql.dll if it exists, convert slashes for Win32 LoadLibrary
+    File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__))
+  elsif defined?(RubyInstaller)
+    # RubyInstaller-2.4+ native build doesn't need DLL preloading
+  else
+    # This will use default / system library paths
+    'libmysql.dll'
+  end
+
+  if dll_path
+    require 'fiddle'
+    kernel32 = Fiddle.dlopen 'kernel32'
+    load_library = Fiddle::Function.new(
+      kernel32['LoadLibraryW'], [Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT,
+    )
+    if load_library.call(dll_path.encode('utf-16le')).zero?
+      abort "Failed to load libmysql.dll from #{dll_path}"
+    end
+  end
+end
+
+require 'mysql2/version' unless defined? Mysql2::VERSION
+require 'mysql2/error'
+require 'mysql2/mysql2'
+require 'mysql2/result'
+require 'mysql2/client'
+require 'mysql2/field'
+require 'mysql2/statement'
+
+# = Mysql2
+#
+# A modern, simple and very fast Mysql library for Ruby - binding to libmysql
+module Mysql2
+end
+
+if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3.1"
+  begin
+    require 'active_record/connection_adapters/mysql2_adapter'
+  rescue LoadError
+    warn "============= WARNING FROM mysql2 ============="
+    warn "This version of mysql2 (#{Mysql2::VERSION}) doesn't ship with the ActiveRecord adapter."
+    warn "In Rails version 3.1.0 and up, the mysql2 ActiveRecord adapter is included with rails."
+    warn "If you want to use the mysql2 gem with Rails <= 3.0.x, please use the latest mysql2 in the 0.2.x series."
+    warn "============= END WARNING FROM mysql2 ============="
+  end
+end
+
+# For holding utility methods
+module Mysql2
+  module Util
+    #
+    # Rekey a string-keyed hash with equivalent symbols.
+    #
+    def self.key_hash_as_symbols(hash)
+      return nil unless hash
+      Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
+
+    #
+    # In Mysql2::Client#query and Mysql2::Statement#execute,
+    # Thread#handle_interrupt is used to prevent Timeout#timeout
+    # from interrupting query execution.
+    #
+    # Timeout::ExitException was removed in Ruby 2.3.0, 2.2.3, and 2.1.8,
+    # but is present in earlier 2.1.x and 2.2.x, so we provide a shim.
+    #
+    require 'timeout'
+    TIMEOUT_ERROR_CLASS = if defined?(::Timeout::ExitException)
+      ::Timeout::ExitException
+    else
+      ::Timeout::Error
+    end
+  end
+end

data/lib/mysql2/client.rb

@@ -0,0 +1,155 @@
+module Mysql2
+  class Client
+    attr_reader :query_options, :read_timeout
+
+    def self.default_query_options
+      @default_query_options ||= {
+        as: :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
+        async: false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
+        cast_booleans: false,        # cast tinyint(1) fields as true/false in ruby
+        symbolize_keys: false,       # return field names as symbols instead of strings
+        database_timezone: :local,   # timezone Mysql2 will assume datetime objects are stored in
+        application_timezone: nil,   # timezone Mysql2 will convert to before handing the object back to the caller
+        cache_rows: true,            # tells Mysql2 to use its internal row cache for results
+        connect_flags: REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION | CONNECT_ATTRS,
+        cast: true,
+        default_file: nil,
+        default_group: nil,
+      }
+    end
+
+    def initialize(opts = {})
+      raise Mysql2::Error, "Options parameter must be a Hash" unless opts.is_a? Hash
+      opts = Mysql2::Util.key_hash_as_symbols(opts)
+      @read_timeout = nil
+      @query_options = self.class.default_query_options.dup
+      @query_options.merge! opts
+
+      initialize_ext
+
+      # Set default connect_timeout to avoid unlimited retries from signal interruption
+      opts[:connect_timeout] = 120 unless opts.key?(:connect_timeout)
+
+      # TODO: stricter validation rather than silent massaging
+      %i[reconnect connect_timeout local_infile read_timeout write_timeout default_file default_group secure_auth init_command automatic_close enable_cleartext_plugin default_auth].each do |key|
+        next unless opts.key?(key)
+        case key
+        when :reconnect, :local_infile, :secure_auth, :automatic_close, :enable_cleartext_plugin
+          send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
+        when :connect_timeout, :read_timeout, :write_timeout
+          send(:"#{key}=", Integer(opts[key])) unless opts[key].nil?
+        else
+          send(:"#{key}=", opts[key])
+        end
+      end
+
+      # force the encoding to utf8
+      self.charset_name = opts[:encoding] || 'utf8'
+
+      ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
+      ssl_set(*ssl_options) if ssl_options.any? || opts.key?(:sslverify)
+      self.ssl_mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
+
+      flags = case opts[:flags]
+      when Array
+        parse_flags_array(opts[:flags], @query_options[:connect_flags])
+      when String
+        parse_flags_array(opts[:flags].split(' '), @query_options[:connect_flags])
+      when Integer
+        @query_options[:connect_flags] | opts[:flags]
+      else
+        @query_options[:connect_flags]
+      end
+
+      # SSL verify is a connection flag rather than a mysql_ssl_set option
+      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify]
+
+      if %i[user pass hostname dbname db sock].any? { |k| @query_options.key?(k) }
+        warn "============= WARNING FROM mysql2 ============="
+        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock are deprecated and will be removed at some point in the future."
+        warn "Instead, please use :username, :password, :host, :port, :database, :socket, :flags for the options."
+        warn "============= END WARNING FROM mysql2 ========="
+      end
+
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+      host     = opts[:host] || opts[:hostname]
+      port     = opts[:port]
+      database = opts[:database] || opts[:dbname] || opts[:db]
+      socket   = opts[:socket] || opts[:sock]
+
+      # Correct the data types before passing these values down to the C level
+      user = user.to_s unless user.nil?
+      pass = pass.to_s unless pass.nil?
+      host = host.to_s unless host.nil?
+      port = port.to_i unless port.nil?
+      database = database.to_s unless database.nil?
+      socket = socket.to_s unless socket.nil?
+      conn_attrs = parse_connect_attrs(opts[:connect_attrs])
+
+      connect user, pass, host, port, database, socket, flags, conn_attrs
+    end
+
+    def parse_ssl_mode(mode)
+      m = mode.to_s.upcase
+      if m.start_with?('SSL_MODE_')
+        return Mysql2::Client.const_get(m) if Mysql2::Client.const_defined?(m)
+      else
+        x = 'SSL_MODE_' + m
+        return Mysql2::Client.const_get(x) if Mysql2::Client.const_defined?(x)
+      end
+      warn "Unknown MySQL ssl_mode flag: #{mode}"
+    end
+
+    def parse_flags_array(flags, initial = 0)
+      flags.reduce(initial) do |memo, f|
+        fneg = f.start_with?('-') ? f[1..-1] : nil
+        if fneg && fneg =~ /^\w+$/ && Mysql2::Client.const_defined?(fneg)
+          memo & ~ Mysql2::Client.const_get(fneg)
+        elsif f && f =~ /^\w+$/ && Mysql2::Client.const_defined?(f)
+          memo | Mysql2::Client.const_get(f)
+        else
+          warn "Unknown MySQL connection flag: '#{f}'"
+          memo
+        end
+      end
+    end
+
+    # Set default program_name in performance_schema.session_connect_attrs
+    # and performance_schema.session_account_connect_attrs
+    def parse_connect_attrs(conn_attrs)
+      return {} if Mysql2::Client::CONNECT_ATTRS.zero?
+      conn_attrs ||= {}
+      conn_attrs[:program_name] ||= $PROGRAM_NAME
+      conn_attrs.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = value.to_s
+      end
+    end
+
+    def query(sql, options = {})
+      Thread.handle_interrupt(::Mysql2::Util::TIMEOUT_ERROR_CLASS => :never) do
+        _query(sql, @query_options.merge(options))
+      end
+    end
+
+    def query_info
+      info = query_info_string
+      return {} unless info
+      info_hash = {}
+      info.split.each_slice(2) { |s| info_hash[s[0].downcase.delete(':').to_sym] = s[1].to_i }
+      info_hash
+    end
+
+    def info
+      self.class.info
+    end
+
+    class << self
+      private
+
+      def local_offset
+        ::Time.local(2010).utc_offset.to_r / 86400
+      end
+    end
+  end
+end

data/lib/mysql2/console.rb

@@ -0,0 +1,5 @@
+# Loaded by script/console. Land helpers here.
+
+Pry.config.prompt = lambda do |context, *|
+  "[mysql2] #{context}> "
+end

data/lib/mysql2/em.rb

@@ -0,0 +1,53 @@
+require 'eventmachine'
+require 'mysql2'
+
+module Mysql2
+  module EM
+    class Client < ::Mysql2::Client
+      module Watcher
+        def initialize(client, deferable)
+          @client = client
+          @deferable = deferable
+          @is_watching = true
+        end
+
+        def notify_readable
+          detach
+          begin
+            result = @client.async_result
+          rescue StandardError => e
+            @deferable.fail(e)
+          else
+            @deferable.succeed(result)
+          end
+        end
+
+        def watching?
+          @is_watching
+        end
+
+        def unbind
+          @is_watching = false
+        end
+      end
+
+      def close(*args)
+        @watch.detach if @watch && @watch.watching?
+
+        super(*args)
+      end
+
+      def query(sql, opts = {})
+        if ::EM.reactor_running?
+          super(sql, opts.merge(async: true))
+          deferable = ::EM::DefaultDeferrable.new
+          @watch = ::EM.watch(socket, Watcher, self, deferable)
+          @watch.notify_readable = true
+          deferable
+        else
+          super(sql, opts)
+        end
+      end
+    end
+  end
+end

data/lib/mysql2/error.rb

@@ -0,0 +1,100 @@
+module Mysql2
+  class Error < StandardError
+    ENCODE_OPTS = {
+      undef: :replace,
+      invalid: :replace,
+      replace: '?'.freeze,
+    }.freeze
+
+    ConnectionError = Class.new(Error)
+    TimeoutError = Class.new(Error)
+
+    CODES = {
+      1205 => TimeoutError, # ER_LOCK_WAIT_TIMEOUT
+
+      1044 => ConnectionError, # ER_DBACCESS_DENIED_ERROR
+      1045 => ConnectionError, # ER_ACCESS_DENIED_ERROR
+      1152 => ConnectionError, # ER_ABORTING_CONNECTION
+      1153 => ConnectionError, # ER_NET_PACKET_TOO_LARGE
+      1154 => ConnectionError, # ER_NET_READ_ERROR_FROM_PIPE
+      1155 => ConnectionError, # ER_NET_FCNTL_ERROR
+      1156 => ConnectionError, # ER_NET_PACKETS_OUT_OF_ORDER
+      1157 => ConnectionError, # ER_NET_UNCOMPRESS_ERROR
+      1158 => ConnectionError, # ER_NET_READ_ERROR
+      1159 => ConnectionError, # ER_NET_READ_INTERRUPTED
+      1160 => ConnectionError, # ER_NET_ERROR_ON_WRITE
+      1161 => ConnectionError, # ER_NET_WRITE_INTERRUPTED
+
+      2001 => ConnectionError, # CR_SOCKET_CREATE_ERROR
+      2002 => ConnectionError, # CR_CONNECTION_ERROR
+      2003 => ConnectionError, # CR_CONN_HOST_ERROR
+      2004 => ConnectionError, # CR_IPSOCK_ERROR
+      2005 => ConnectionError, # CR_UNKNOWN_HOST
+      2006 => ConnectionError, # CR_SERVER_GONE_ERROR
+      2007 => ConnectionError, # CR_VERSION_ERROR
+      2009 => ConnectionError, # CR_WRONG_HOST_INFO
+      2012 => ConnectionError, # CR_SERVER_HANDSHAKE_ERR
+      2013 => ConnectionError, # CR_SERVER_LOST
+      2020 => ConnectionError, # CR_NET_PACKET_TOO_LARGE
+      2026 => ConnectionError, # CR_SSL_CONNECTION_ERROR
+      2027 => ConnectionError, # CR_MALFORMED_PACKET
+      2047 => ConnectionError, # CR_CONN_UNKNOW_PROTOCOL
+      2048 => ConnectionError, # CR_INVALID_CONN_HANDLE
+      2049 => ConnectionError, # CR_UNUSED_1
+    }.freeze
+
+    attr_reader :error_number, :sql_state
+
+    # Mysql gem compatibility
+    alias errno error_number
+    alias error message
+
+    def initialize(msg, server_version = nil, error_number = nil, sql_state = nil)
+      @server_version = server_version
+      @error_number = error_number
+      @sql_state = sql_state ? sql_state.encode(**ENCODE_OPTS) : nil
+
+      super(clean_message(msg))
+    end
+
+    def self.new_with_args(msg, server_version, error_number, sql_state)
+      error_class = CODES.fetch(error_number, self)
+      error_class.new(msg, server_version, error_number, sql_state)
+    end
+
+    private
+
+    # In MySQL 5.5+ error messages are always constructed server-side as UTF-8
+    # then returned in the encoding set by the `character_set_results` system
+    # variable.
+    #
+    # See http://dev.mysql.com/doc/refman/5.5/en/charset-errors.html for
+    # more context.
+    #
+    # Before MySQL 5.5 error message template strings are in whatever encoding
+    # is associated with the error message language.
+    # See http://dev.mysql.com/doc/refman/5.1/en/error-message-language.html
+    # for more information.
+    #
+    # The issue is that the user-data inserted in the message could potentially
+    # be in any encoding MySQL supports and is insert into the latin1, euckr or
+    # koi8r string raw. Meaning there's a high probability the string will be
+    # corrupt encoding-wise.
+    #
+    # See http://dev.mysql.com/doc/refman/5.1/en/charset-errors.html for
+    # more information.
+    #
+    # So in an attempt to make sure the error message string is always in a valid
+    # encoding, we'll assume UTF-8 and clean the string of anything that's not a
+    # valid UTF-8 character.
+    #
+    # Returns a valid UTF-8 string.
+    def clean_message(message)
+      if @server_version && @server_version > 50500
+        message.encode(**ENCODE_OPTS)
+      else
+        message.encode(Encoding::UTF_8, **ENCODE_OPTS)
+      end
+    end
+  end
+end

data/lib/mysql2/field.rb

@@ -0,0 +1,3 @@
+module Mysql2
+  Field = Struct.new(:name, :type)
+end

data/lib/mysql2/result.rb

@@ -0,0 +1,7 @@
+module Mysql2
+  class Result
+    attr_reader :server_flags
+
+    include Enumerable
+  end
+end

data/lib/mysql2/statement.rb

@@ -0,0 +1,11 @@
+module Mysql2
+  class Statement
+    include Enumerable
+
+    def execute(*args, **kwargs)
+      Thread.handle_interrupt(::Mysql2::Util::TIMEOUT_ERROR_CLASS => :never) do
+        _execute(*args, **kwargs)
+      end
+    end
+  end
+end

data/lib/mysql2/version.rb

@@ -0,0 +1,3 @@
+module Mysql2
+  VERSION = "0.5.3".freeze
+end

data/mysql2-lambda.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = 'mysql2-lambda'
+  s.version = '0.5.3.alpha1'
+  s.authors = ['Ken Collins']
+  s.license = "MIT"
+  s.email = ['kcollins@customink.com']
+  s.homepage = 'https://github.com/customink/mysql2-lambda'
+  s.rdoc_options = ['--charset=UTF-8']
+  s.summary = 'Precompiled Mysql2 gem for AWS Lambda using MariaDB.'
+  s.metadata = {
+    'bug_tracker_uri'   => "#{s.homepage}/issues",
+    'changelog_uri'     => "#{s.homepage}/releases/tag/#{s.version}",
+    'homepage_uri'      => s.homepage,
+    'source_code_uri'   => "#{s.homepage}/tree/#{s.version}",
+  }
+  s.required_ruby_version = '>= 2.5.5'
+  s.files = Dir.glob('./**/*')
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: mysql2-lambda
+version: !ruby/object:Gem::Version
+  version: 0.5.3.alpha1
+platform: ruby
+authors:
+- Ken Collins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-04 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- kcollins@customink.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./CHANGELOG.md"
+- "./LICENSE"
+- "./README.md"
+- "./lib/mysql2.rb"
+- "./lib/mysql2/client.rb"
+- "./lib/mysql2/console.rb"
+- "./lib/mysql2/em.rb"
+- "./lib/mysql2/error.rb"
+- "./lib/mysql2/field.rb"
+- "./lib/mysql2/mysql2.so"
+- "./lib/mysql2/result.rb"
+- "./lib/mysql2/statement.rb"
+- "./lib/mysql2/version.rb"
+- "./mysql2-lambda.gemspec"
+homepage: https://github.com/customink/mysql2-lambda
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/customink/mysql2-lambda/issues
+  changelog_uri: https://github.com/customink/mysql2-lambda/releases/tag/0.5.3.alpha1
+  homepage_uri: https://github.com/customink/mysql2-lambda
+  source_code_uri: https://github.com/customink/mysql2-lambda/tree/0.5.3.alpha1
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.5
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Precompiled Mysql2 gem for AWS Lambda using MariaDB.
+test_files: []