mongoid 7.1.11 → 7.2.0

data/spec/shared/bin/get-mongodb-download-url

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-
-desired_version, arch = ARGV
-if arch.nil?
-  STDERR.puts "Usage: get-mongodb-download-url desired-version arch"
-  exit 1
-end
-
-$: << File.join(File.dirname(__FILE__), '../lib')
-require 'mrss/server_version_registry'
-
-begin
-  puts Mrss::ServerVersionRegistry.new(desired_version, arch).download_url
-rescue Mrss::ServerVersionRegistry::Error => exc
-  STDERR.puts "Error: #{exc}"
-  exit 2
-end

data/spec/shared/bin/s3-copy

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'aws-sdk-s3'
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: s3-copy options"
-
-  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
-    options[:region] = v
-  end
-
-  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for new files") do |v|
-    options[:params] ||= {}
-    k, v = v.split('=', 2)
-    options[:params][k.to_sym] = v
-  end
-
-  opts.on("-f", "--from=BUCKET:PATH", "Bucket name and key (or path) to copy from") do |v|
-    options[:from] = v
-  end
-
-  opts.on("-t", "--to=BUCKET:PATH", "Bucket name and key (or path) to write to (may be specified more than once)") do |v|
-    options[:to] ||= []
-    options[:to] << v
-  end
-end.parse!
-
-ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
-
-bucket, key = options.fetch(:from).split(':', 2)
-
-s3 = Aws::S3::Client.new
-
-options.fetch(:to).each do |dest|
-  STDERR.puts "Copying to #{dest}"
-  dbucket, dkey = dest.split(':', 2)
-  s3.copy_object(
-    bucket: dbucket,
-    key: dkey,
-    copy_source: "/#{bucket}/#{key}",
-    **options[:params] || {},
-  )
-end

data/spec/shared/bin/s3-upload

@@ -1,69 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'aws-sdk-s3'
-
-options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: s3-upload options"
-
-  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
-    options[:region] = v
-  end
-
-  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for S3 upload") do |v|
-    options[:params] ||= {}
-    k, v = v.split('=', 2)
-    options[:params][k.to_sym] = v
-  end
-
-  opts.on("-f", "--file=PATH", "Path to the file to upload, - to upload standard input") do |v|
-    options[:file] = v
-  end
-
-  opts.on("-w", "--write=BUCKET:PATH", "Bucket name and key (or path) to upload to") do |v|
-    options[:write] = v
-  end
-
-  opts.on("-c", "--copy=BUCKET:PATH", "Bucket name and key (or path) to copy to (may be specified more than once)") do |v|
-    options[:copy] ||= []
-    options[:copy] << v
-  end
-end.parse!
-
-ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
-
-def upload(f, options)
-  s3 = Aws::S3::Client.new
-  write = options.fetch(:write)
-  STDERR.puts "Writing #{write}"
-  bucket, key = write.split(':', 2)
-  s3.put_object(
-    body: f.read,
-    bucket: bucket,
-    key: key,
-    **options[:params] || {},
-  )
-  if copy = options[:copy]
-    copy.each do |dest|
-      STDERR.puts "Copying to #{dest}"
-      dbucket, dkey = dest.split(':', 2)
-      s3.copy_object(
-        bucket: dbucket,
-        key: dkey,
-        copy_source: "/#{bucket}/#{key}",
-        **options[:params] || {},
-      )
-    end
-  end
-end
-
-if options[:file] == '-'
-  upload(STDIN, options)
-elsif options[:file]
-  File.open(options[:file]) do |f|
-    upload(f, options)
-  end
-else
-  upload(STDIN, options)
-end

data/spec/shared/lib/mrss/cluster_config.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-# ClusterConfig requires ClientRegistry class provided by the host project.
-
-require 'singleton'
-
-module Mrss
-  class ClusterConfig
-    include Singleton
-    include RSpec::Core::Pending
-
-    def single_server?
-      determine_cluster_config
-      @single_server
-    end
-
-    def sharded_ish?
-      determine_cluster_config
-      @topology == :sharded || @topology == :load_balanced
-    end
-
-    def replica_set_name
-      determine_cluster_config
-      @replica_set_name
-    end
-
-    def server_version
-      determine_cluster_config
-      @server_version
-    end
-
-    def enterprise?
-      determine_cluster_config
-      @enterprise
-    end
-
-    def short_server_version
-      server_version.split('.')[0..1].join('.')
-    end
-
-    def fcv
-      determine_cluster_config
-      @fcv
-    end
-
-    # Per https://jira.mongodb.org/browse/SERVER-39052, working with FCV
-    # in sharded topologies is annoying. Also, FCV doesn't exist in servers
-    # less than 3.4. This method returns FCV on 3.4+ servers when in single
-    # or RS topologies, and otherwise returns the major.minor server version.
-    def fcv_ish
-      if server_version.nil?
-        raise "Deployment server version not known - check that connection to deployment succeeded"
-      end
-
-      if server_version >= '3.4' && !sharded_ish?
-        fcv
-      else
-        if short_server_version == '4.1'
-          '4.2'
-        else
-          short_server_version
-        end
-      end
-    end
-
-    # @return [ Mongo::Address ] The address of the primary in the deployment.
-    def primary_address
-      determine_cluster_config
-      @primary_address
-    end
-
-    def primary_address_str
-      determine_cluster_config
-      @primary_address.seed
-    end
-
-    def primary_address_host
-      both = primary_address_str
-      both.split(':').first
-    end
-
-    def primary_address_port
-      both = primary_address_str
-      both.split(':')[1] || 27017
-    end
-
-    def primary_description
-      determine_cluster_config
-      @primary_description
-    end
-
-    def server_parameters
-      determine_cluster_config
-      @server_parameters
-    end
-
-    # Try running a command on the admin database to see if the mongod was
-    # started with auth.
-    def auth_enabled?
-      if @auth_enabled.nil?
-        @auth_enabled = begin
-          basic_client.use(:admin).command(getCmdLineOpts: 1).first["argv"].include?("--auth")
-        rescue => e
-          e.message =~ /(not authorized)|(unauthorized)|(no users authenticated)|(requires authentication)/
-        end
-      end
-      @auth_enabled
-    end
-
-    def topology
-      determine_cluster_config
-      @topology
-    end
-
-    def storage_engine
-      @storage_engine ||= begin
-        # 2.6 does not have wired tiger
-        if short_server_version == '2.6'
-          :mmapv1
-        else
-          client = ClientRegistry.instance.global_client('root_authorized')
-          if sharded_ish?
-            shards = client.use(:admin).command(listShards: 1).first
-            if shards['shards'].empty?
-              raise 'Shards are empty'
-            end
-            shard = shards['shards'].first
-            address_str = shard['host'].sub(/^.*\//, '').sub(/,.*/, '')
-            client = ClusterTools.instance.direct_client(address_str,
-              SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options).merge(connect: :direct))
-          end
-          rv = client.use(:admin).command(serverStatus: 1).first
-          rv = rv['storageEngine']['name']
-          rv_map = {
-            'wiredTiger' => :wired_tiger,
-            'mmapv1' => :mmapv1,
-          }
-          rv_map[rv] || rv
-        end
-      end
-    end
-
-    # This method returns an alternate address for connecting to the configured
-    # deployment. For example, if the replica set is configured with nodes at
-    # of localhost:27017 and so on, this method will return 127.0.0.:27017.
-    #
-    # Note that the "alternate" refers to replica set configuration, not the
-    # addresses specified in test suite configuration. If the deployment topology
-    # is not a replica set, "alternate" refers to test suite configuration as
-    # this is the only configuration available.
-    def alternate_address
-      @alternate_address ||= begin
-        address = primary_address_host
-        str = case address
-        when '127.0.0.1'
-          'localhost'
-        when /^(\d+\.){3}\d+$/
-          skip 'This test requires a hostname or 127.0.0.1 as address'
-        else
-          # We don't know if mongod is listening on ipv4 or ipv6, in principle.
-          # Our tests use ipv4, so hardcode that for now.
-          # To support both we need to try both addresses which will make this
-          # test more complicated.
-          #
-          # JRuby chokes on primary_address_port as the port (e.g. 27017).
-          # Since the port does not actually matter, use a common port like 80.
-          resolved_address = Addrinfo.getaddrinfo(address, 80, Socket::PF_INET).first.ip_address
-          if resolved_address.include?(':')
-            "[#{resolved_address}]"
-          else
-            resolved_address
-          end
-        end + ":#{primary_address_port}"
-        Mongo::Address.new(str)
-      end
-    end
-
-    private
-
-    def determine_cluster_config
-      return if @primary_address
-
-      # Run all commands to figure out the cluster configuration from the same
-      # client. This is somewhat wasteful when running a single test, but reduces
-      # test runtime for the suite overall because all commands are sent on the
-      # same connection rather than each command connecting to the cluster by
-      # itself.
-      client = ClientRegistry.instance.global_client('root_authorized')
-
-      primary = client.cluster.next_primary
-      @primary_address = primary.address
-      @primary_description = primary.description
-      @replica_set_name = client.cluster.topology.replica_set_name
-
-      @topology ||= begin
-        topology = client.cluster.topology.class.name.sub(/.*::/, '')
-        topology = topology.gsub(/([A-Z])/) { |match| '_' + match.downcase }.sub(/^_/, '')
-        if topology =~ /^replica_set/
-          topology = 'replica_set'
-        end
-        topology.to_sym
-      end
-
-      @single_server = client.cluster.servers_list.length == 1
-
-      build_info = client.database.command(buildInfo: 1).first
-
-      @server_version = build_info['version']
-      @enterprise = build_info['modules'] && build_info['modules'].include?('enterprise')
-
-      @server_parameters = client.use(:admin).command(getParameter: '*').first
-
-      if !sharded_ish? && short_server_version >= '3.4'
-        rv = @server_parameters['featureCompatibilityVersion']
-        @fcv = rv['version'] || rv
-      end
-    end
-
-    def basic_client
-      # Do not cache the result here so that if the client gets closed,
-      # client registry reconnects it in subsequent tests
-      ClientRegistry.instance.global_client('basic')
-    end
-  end
-end

data/spec/shared/lib/mrss/docker_runner.rb

@@ -1,271 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'optparse'
-require 'erb'
-autoload :Dotenv, 'dotenv'
-
-module Mrss
-  autoload :ServerVersionRegistry, 'mrss/server_version_registry'
-
-  class DockerRunner
-    def initialize(**opts)
-      # These options are required:
-      opts.fetch(:image_tag)
-      opts.fetch(:dockerfile_path)
-      opts.fetch(:default_script)
-      opts.fetch(:project_lib_subdir)
-
-      @options = opts
-    end
-
-    attr_reader :options
-
-    def run
-      process_arguments
-      unless @options[:exec_only]
-        create_dockerfile
-        create_image
-      end
-      if @options[:mongo_only]
-        run_deployment
-      else
-        run_tests
-      end
-    end
-
-    private
-
-    def process_arguments
-      #@options = {}
-      OptionParser.new do |opts|
-        opts.banner = "Usage: test-on-docker [-d distro] [evergreen_key=value ...]"
-
-        opts.on("-a", "--add-env=PATH", "Load environment variables from PATH in .env format") do |path|
-          @options[:extra_env] ||= {}
-          unless File.exist?(path)
-            raise "-a option references nonexistent file #{path}"
-          end
-          Dotenv.parse(path).each do |k, v|
-            @options[:extra_env][k] = v
-          end
-        end
-
-        opts.on("-d", "--distro=DISTRO", "Distro to use") do |v|
-          @options[:distro] = v
-        end
-
-        opts.on('-e', '--exec-only', 'Execute tests using existing Dockerfile (for offline user)') do |v|
-          @options[:exec_only] = v
-        end
-
-        opts.on('-m', '--mongo-only=PORT', 'Start the MongoDB deployment and expose it to host on ports starting with PORT') do |v|
-          @options[:mongo_only] = v.to_i
-        end
-
-        opts.on('-p', '--preload', 'Preload Ruby toolchain and server binaries in docker') do |v|
-          @options[:preload] = v
-        end
-
-        opts.on('-s', '--script=SCRIPT', 'Test script to invoke') do |v|
-          @options[:script] = v
-        end
-
-        opts.on('-i', '--interactive', 'Interactive mode - disable per-test timeouts') do |v|
-          @options[:interactive] = v
-        end
-      end.parse!
-
-      @env = Hash[ARGV.map do |arg|
-        arg.split('=', 2)
-      end]
-
-      @env['RVM_RUBY'] ||= 'ruby-2.7'
-      unless ruby =~ /^j?ruby-/
-        raise "RVM_RUBY option is not in expected format: #{ruby}"
-      end
-
-      @env['MONGODB_VERSION'] ||= '4.4'
-    end
-
-    def create_dockerfile
-      template_path = File.join(File.dirname(__FILE__), '../../share/Dockerfile.erb')
-      result = ERB.new(File.read(template_path)).result(binding)
-      File.open(dockerfile_path, 'w') do |f|
-        f << result
-      end
-    end
-
-    def image_tag
-      options.fetch(:image_tag)
-    end
-
-    def dockerfile_path
-      options.fetch(:dockerfile_path)
-    end
-
-    def create_image
-      run_command(['docker', 'build',
-        '-t', image_tag,
-        '-f', dockerfile_path,
-        '.'])
-    end
-
-    BASE_TEST_COMMAND = %w(docker run --rm -i --tmpfs /tmpfs:exec).freeze
-
-    def run_tests
-      run_command(BASE_TEST_COMMAND + tty_arg + extra_env + [image_tag] +
-        script.split(/\s+/))
-    end
-
-    def run_deployment
-      run_command(BASE_TEST_COMMAND + tty_arg + extra_env + [
-        '-e', %q`TEST_CMD=watch -x bash -c "ps awwxu |egrep 'mongo|ocsp'"`,
-        '-e', 'BIND_ALL=true',
-      ] + port_forwards + [image_tag] + script.split(/\s+/))
-    end
-
-    def tty_arg
-      tty = File.open('/dev/stdin') do |f|
-        f.isatty
-      end
-      if tty
-        %w(-t --init)
-      else
-        []
-      end
-    end
-
-    def extra_env
-      if @options[:extra_env]
-        @options[:extra_env].map do |k, v|
-          # Here the value must not be escaped
-          ['-e', "#{k}=#{v}"]
-        end.flatten
-      else
-        []
-      end
-    end
-
-    def port_forwards
-      args = (0...num_exposed_ports).map do |i|
-        host_port = @options[:mongo_only] + i
-        container_port = 27017 + i
-        ['-p', "#{host_port}:#{container_port}"]
-      end.flatten
-
-      if @env['OCSP_ALGORITHM'] && !@env['OCSP_VERIFIER']
-        args += %w(-p 8100:8100)
-      end
-
-      args
-    end
-
-    def run_command(cmd)
-      if pid = fork
-        Process.wait(pid)
-        unless $?.exitstatus == 0
-          raise "Process exited with code #{$?.exitstatus}"
-        end
-      else
-        exec(*cmd)
-      end
-    end
-
-    def distro
-      @options[:distro] || 'ubuntu1604'
-    end
-
-    BASE_IMAGES = {
-      'debian81' => 'debian:jessie',
-      'debian92' => 'debian:stretch',
-      'debian10' => 'debian:buster',
-      'ubuntu1404' => 'ubuntu:trusty',
-      'ubuntu1604' => 'ubuntu:xenial',
-      'ubuntu1804' => 'ubuntu:bionic',
-      'ubuntu2004' => 'ubuntu:focal',
-      'rhel62' => 'centos:6',
-      'rhel70' => 'centos:7',
-    }.freeze
-
-    def base_image
-      BASE_IMAGES[distro] or raise "Unknown distro: #{distro}"
-    end
-
-    def ruby
-      @env['RVM_RUBY']
-    end
-
-    def ruby_head?
-      ruby == 'ruby-head'
-    end
-
-    def system_ruby?
-      %w(1 true yes).include?(@env['SYSTEM_RUBY']&.downcase)
-    end
-
-    def server_version
-      @env['MONGODB_VERSION']
-    end
-
-    def script
-      @options[:script] || options.fetch(:default_script)
-    end
-
-    def debian?
-      distro =~ /debian|ubuntu/
-    end
-
-    def preload?
-      !!@options[:preload]
-    end
-
-    def interactive?
-      !!@options[:interactive]
-    end
-
-    def project_lib_subdir
-      options.fetch(:project_lib_subdir)
-    end
-
-    def server_download_url
-      @server_download_url ||= ServerVersionRegistry.new(server_version, distro).download_url
-    end
-
-    def libmongocrypt_path
-      case distro
-      when /ubuntu1604/
-        "./ubuntu1604/nocrypto/lib64/libmongocrypt.so"
-      when /ubuntu1804/
-        "./ubuntu1804-64/nocrypto/lib64/libmongocrypt.so"
-      when /debian92/
-        "./debian92/nocrypto/lib64/libmongocrypt.so"
-      else
-        raise "This script does not support running FLE tests on #{distro}. Use ubuntu1604, ubuntu1804 or debian92 instead"
-      end
-    end
-
-    def expose?
-      !!@options[:mongo_only]
-    end
-
-    def fle?
-      %w(1 true yes).include?(@env['FLE']&.downcase)
-    end
-
-    def num_exposed_ports
-      case @env['TOPOLOGY'] || 'standalone'
-      when 'standalone'
-        1
-      when 'replica-set'
-        3
-      when 'sharded-cluster'
-        if @env['SINGLE_MONGOS']
-          1
-        else
-          2
-        end
-      end
-    end
-  end
-end