bson 5.0.2-java → 5.1.1-java

data/spec/shared/lib/mrss/release/candidate.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'product_data'
+
+module Mrss
+  module Release
+    class Candidate
+      # Release note section titles, by pr type
+      SECTION_TITLE = {
+        bcbreak: "Breaking Changes",
+        feature: "New Features",
+        bug: "Bug Fixes",
+      }.freeze
+
+      # GitHub labels
+      BCBREAK = 'bcbreak'
+      FEATURE = 'feature'
+      BUG = 'bug'
+      PATCH = 'patch'
+
+      def self.instance
+        @instance ||= new
+
+        yield @instance if block_given?
+
+        @instance
+      end
+
+      def product
+        @product ||= ProductData.new
+      end
+
+      def bump_version
+        product.bump_version(release_type)
+      end
+
+      def bump_version!
+        product.bump_version!(release_type)
+      end
+
+      def branch_name
+        @branch_name ||= "rc-#{product.version}"
+      end
+
+      # return a string of commit names since the last release
+      def pending_changes
+        @changes ||= begin
+                       range = product.tag_exists? ? "#{product.tag_name}.." : ""
+                       `git log --pretty=format:"%s" #{range}`
+                     end
+      end
+
+      # return a list of PR numbers since the last release
+      def pending_pr_numbers
+        @pending_pr_numbers ||= pending_changes.
+          lines.
+          map { |line| line.match(/\(#(\d+)\)$/).then { |m| m && m[1] } }.
+          compact.
+          sort.reverse
+      end
+
+      # return a JSON string of PR data
+      def pending_pr_dump
+        @pending_pr_dump ||= `gh pr list --state all --limit 256 --json number,title,labels,url,body --jq 'map(select([.number] | inside([#{pending_pr_numbers.join(',')}]))) | sort_by(.number)'`
+      end
+
+      # return a list of PR data since the last release
+      def pending_prs
+        @pending_prs ||= JSON.parse(pending_pr_dump)
+      end
+
+      # return a list of pending prs with additional attributes (summary,
+      # short title, jira issue number).
+      def decorated_prs
+        @decorated_prs ||= pending_prs.map do |pr|
+                             jira_issue, pr_title = split_pr_title(pr)
+                             summary = extract_summary(pr)
+                             type = pr_type(pr)
+                             type_code = pr_type_code(type)
+                             patch_flag = pr_patch_flag?(pr)
+
+                             pr.merge('jira' => jira_issue,
+                                      'short-title' => pr_title,
+                                      'summary' => summary,
+                                      'type' => type,
+                                      'type-code' => type_code,
+                                      'patch' => patch_flag)
+                           end
+      end
+
+      # return a hash of decorated prs grouped by :bcbreak, :feature, or :bug
+      def prs_by_type
+        @prs_by_type ||= decorated_prs.group_by { |pr| pr['type'] }
+      end
+
+      # returns 'major', 'minor', or 'patch', depending on the presence of
+      # (respectively) :bcbreak, :feature, or :bug labels.
+      #
+      # If the RELEASE environment variable is set, its value will be used
+      # directly, ignoring whatever PR labels might exist.
+      def release_type
+        @release_type ||= if ENV['RELEASE']
+                            ENV['RELEASE']
+                          elsif prs_by_type[:bcbreak]
+                            'major'
+                          elsif prs_by_type[:feature] && prs_by_type[:feature].any? { |pr| !pr['patch'] }
+                            'minor'
+                          else
+                            'patch'
+                          end
+      end
+
+      # returns the generated release notes as a string
+      def release_notes
+        @release_notes ||= release_notes_intro +
+          %i[ bcbreak feature bug ].
+            flat_map { |type| release_notes_for_type(type) }.join("\n")
+      end
+
+      private
+
+      # returns an array of strings, each string representing a single line
+      # in the release notes for the PR's of the given type.
+      def release_notes_for_type(type)
+        return [] unless prs_by_type[type]
+
+        [].tap do |lines|
+          lines << "\# #{SECTION_TITLE[type]}"
+          lines << ''
+
+          prs = prs_by_type[type]
+          summarized, unsummarized = prs.partition { |pr| pr['summary'] }
+
+          summarized.each do |pr|
+            header = [ '### ' ]
+            header << "[#{pr['jira']}](#{jira_url(pr['jira'])}) " if pr['jira']
+            header << "#{pr['short-title']} ([PR](#{pr['url']}))"
+            lines << header.join
+            lines << ''
+            lines << pr['summary']
+            lines << ''
+          end
+
+          if summarized.any? && unsummarized.any?
+            lines << ''
+            lines << [ '### Other ', SECTION_TITLE[type] ].join
+            lines << ''
+          end
+
+          unsummarized.each do |pr|
+            line = [ '* ' ]
+            line << "[#{pr['jira']}](#{jira_url(pr['jira'])}) " if pr['jira']
+            line << "#{pr['short-title']} ([PR](#{pr['url']}))"
+
+            lines << line.join
+          end
+
+          lines << ''
+        end
+      end
+
+      # returns the URL of for the given jira issue
+      def jira_url(issue)
+        "https://jira.mongodb.org/browse/#{issue}"
+      end
+
+      # assumes a pr title in the format of "JIRA-1234 PR Title (#1234)",
+      # returns a tuple of [ jira-issue, title ], where jira-issue may be
+      # blank (if no jira issue is in the title).
+      def split_pr_title(pr)
+        title = pr['title'].gsub(/\(#\d+\)/, '').strip
+
+        if title =~ /^(\w+-\d+) (.*)$/
+          [ $1, $2 ]
+        else
+          [ nil, title ]
+        end
+      end
+
+      # extracts the summary section from the pr and returns it (or returns nil
+      # if no summary section is detected)
+      def extract_summary(pr)
+        summary = []
+        accumulating = false
+        level = nil
+
+        pr['body'].lines.each do |line|
+          # a header of any level titled "summary" will begin the summary
+          if !accumulating && line =~ /^(\#+)\s+summary\s+$/i
+            accumulating = true
+            level = $1.length
+
+          # a header of any level less than or equal to the summary header's
+          # level will end the summary
+          elsif accumulating && line =~ /^\#{1,#{level}}\s+/
+            break
+
+          # otherwise, the line is part of the summary
+          elsif accumulating
+            summary << line
+          end
+        end
+
+        summary.any? ? summary.join.strip : nil
+      end
+
+      # Returns a symbol (:bcbreak, :feature, or :bug) that identifies the
+      # type of this PR that would most strongly influence what type of release
+      # it requires.
+      def pr_type(pr)
+        if pr['labels'].any? { |l| l['name'] == BCBREAK }
+          :bcbreak
+        elsif pr['labels'].any? { |l| l['name'] == FEATURE }
+          :feature
+        elsif pr['labels'].any? { |l| l['name'] == BUG }
+          :bug
+        else
+          nil
+        end
+      end
+
+      # `true` if the `patch` label is applied to the PR. This is used to
+      # indicate that a "feature" PR should be treated as a patch, for
+      # determining the release type only.
+      def pr_patch_flag?(pr)
+        pr['labels'].any? { |l| l['name'] == PATCH }
+      end
+
+      def pr_type_code(type)
+        case type
+        when :bcbreak then 'x'
+        when :feature then 'f'
+        when :bug     then 'b'
+        else '?'
+        end
+      end
+
+      def series
+        major, minor, = product.version_parts
+
+        case release_type
+        when 'minor' then 
+          "#{major}.x"
+        when 'patch' then
+          "#{major}.#{minor}.x"
+        end
+      end
+
+      # Return a string containing the markdown-formatted intro block for
+      # the release notes of this candidate.
+      def release_notes_intro
+        release_description = case release_type
+                              when 'major' then 'major release'
+                              when 'minor' then "minor release in the #{series} series"
+                              when 'patch' then "patch release in the #{series} series"
+                              end
+
+        <<~INTRO
+          The MongoDB Ruby team is pleased to announce version #{product.version} of the `#{product.package}` gem - #{product.description}. This is a new #{release_description} of #{product.name}.
+
+          Install this release using [RubyGems](https://rubygems.org/) via the command line as follows: 
+
+          ~~~
+          gem install -v #{product.version} #{product.package}
+          ~~~
+
+          Or simply add it to your `Gemfile`:
+
+          ~~~
+          gem '#{product.package}', '#{product.version}'
+          ~~~
+
+          Have any feedback? Click on through to MongoDB's JIRA and [open a new ticket](#{product.jira_project_url}) to let us know what's on your mind 🧠.
+
+        INTRO
+      end
+    end
+  end
+end

data/spec/shared/lib/mrss/release/product_data.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Mrss
+  module Release
+    class ProductData
+      FILE_PATH = 'product.yml'
+
+      def self.init!
+        if File.exist?(FILE_PATH)
+          raise "#{FILE_PATH} already exists; refusing to overwrite it"
+        end
+
+        initial_data = {
+          'name' => 'Product Name',
+          'description' => 'a very short description of the product',
+          'package' => 'product_package',
+          'jira' => 'https://url.to.jira/project',
+          'version' => { 'number' => '1.0.0',
+                         'file' => 'path/to/version.rb' }
+        }
+
+        File.write(FILE_PATH, initial_data.to_yaml)
+      end
+
+      def initialize
+        @hash = YAML.load_file(FILE_PATH)
+      end
+
+      def save_product_file!
+        File.write(FILE_PATH, @hash.to_yaml)
+      end
+
+      def rewrite_version_file!
+        version_module = File.read(version_file)
+        new_module = version_module.
+          sub(/^(\s*)(VERSION\s*=\s*).*$/) { "#{$1}#{$2}#{quoted_version}" }
+        File.write(version_file, new_module)
+      end
+
+      def version
+        @hash['version']['number']
+      end
+
+      def quoted_version
+        if version.include?("'")
+          version.inspect
+        else
+          "'#{version}'"
+        end
+      end
+
+      def version=(number)
+        @hash['version']['number'] = number
+      end
+
+      # returns an array of [ major, minor, patch, suffix ].
+      #
+      # each element will be returned as a String.
+      def version_parts
+        version.split(/\./, 4)
+      end
+
+      # bump the version according to the given release type:
+      #
+      #  'major' -> increment major component, zero the others
+      #  'minor' -> increment minor component, zero the patch
+      #  'patch' -> increment the patch component
+      def bump_version(release)
+        major, minor, patch, suffix = version_parts
+
+        case release
+        when 'major' then
+          major = major.to_i + 1
+          minor = patch = 0
+        when 'minor'
+          minor = minor.to_i + 1
+          patch = 0
+        when 'patch'
+          patch = patch.to_i + 1
+        else
+          raise ArgumentError, "invalid release type: #{release.inspect}"
+        end
+
+        self.version = [ major, minor, patch ].join('.')
+      end
+
+      # Invokes `#bump_version`, and then saves the new version to the
+      # product.yml file and to the version.rb file.
+      def bump_version!(release)
+        bump_version(release)
+        save_product_file!
+        rewrite_version_file!
+      end
+
+      def version_file
+        @hash['version']['file']
+      end
+
+      def name
+        @hash['name']
+      end
+
+      # The description is intended to be used in places where it can be
+      # appended to the end of a sentence, e.g.
+      #
+      #   "We just released #{product.name} - #{product.description}!"
+      #
+      # Markdown formatting is allowed (even expected).
+      def description
+        @hash['description']
+      end
+
+      def package
+        @hash['package']
+      end
+
+      def jira_project_url
+        @hash['jira']
+      end
+
+      def tag_name
+        "v#{version}"
+      end
+
+      def tag_exists?(tag = tag_name)
+        `git tag -l #{tag}`.strip == tag
+      end
+
+      def branch_exists?(branch)
+        `git branch -l #{branch}`.strip == branch
+      end
+
+      def base_branch
+        @base_branch ||= begin
+                           major, minor, = version_parts
+                           branch = "#{major}.#{minor}-stable"
+                           branch_exists?(branch) ? branch : 'master'
+                         end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+autoload :JSON, 'json'
+require 'open-uri'
+
+module Mrss
+  class ServerVersionRegistry
+    class Error < StandardError
+    end
+
+    class UnknownVersion < Error
+    end
+
+    class MissingDownloadUrl < Error
+    end
+
+    class BrokenDownloadUrl < Error
+    end
+
+    def initialize(desired_version, arch)
+      @desired_version, @arch = desired_version, arch.sub(/-arm$/, '')
+    end
+
+    attr_reader :desired_version, :arch
+
+    def target_arch
+      # can't use RbConfig::CONFIG["arch"] because JRuby doesn't
+      # return anything meaningful there.
+      #
+      # also, need to use `uname -a` instead of (e.g.) `uname -p`
+      # because debian (at least) does not return anything meaningful
+      # for `uname -p`.
+      uname = `uname -a`.strip
+      @target_arch ||= case uname
+        when /aarch/ then "aarch64"
+        when /x86/   then "x86_64"
+        else raise "unsupported architecture #{uname.inspect}"
+        end
+    end
+
+    def download_url
+      @download_url ||= begin
+        version, version_ok = detect_version(current_catalog)
+        if version.nil?
+          version, full_version_ok = detect_version(full_catalog)
+          version_ok ||= full_version_ok
+        end
+        if version.nil?
+          if version_ok
+            raise MissingDownloadUrl, "No downloads for version #{desired_version}"
+          else
+            raise UnknownVersion, "No version #{desired_version}"
+          end
+        end
+        dl = version['downloads'].detect do |dl|
+          dl['archive']['url'].index("enterprise-#{arch}") &&
+          dl['arch'] == target_arch
+        end
+        unless dl
+          raise MissingDownloadUrl, "No download for #{arch} for #{version['version']}"
+        end
+        url = dl['archive']['url']
+      end
+    end
+
+    private
+
+    def uri_open(*args)
+      if RUBY_VERSION < '2.5'
+        open(*args)
+      else
+        URI.open(*args)
+      end
+    end
+
+    def detect_version(catalog)
+      candidate_versions = catalog['versions'].select do |version|
+        version['version'].start_with?(desired_version) &&
+        !version['version'].include?('-')
+      end
+      version_ok = !candidate_versions.empty?
+      # Sometimes the download situation is borked and there is a release
+      # with no downloads... skip those.
+      version = candidate_versions.detect do |version|
+        !version['downloads'].empty?
+      end
+      # Allow RC releases if there isn't a GA release.
+      if version.nil?
+        candidate_versions = catalog['versions'].select do |version|
+          version['version'].start_with?(desired_version)
+        end
+        version_ok ||= !candidate_versions.empty?
+        version = candidate_versions.detect do |version|
+          !version['downloads'].empty?
+        end
+      end
+      [version, version_ok]
+    end
+
+    def current_catalog
+      @current_catalog ||= begin
+        JSON.load(uri_open('http://downloads.mongodb.org/current.json').read)
+      end
+    end
+
+    def full_catalog
+      @full_catalog ||= begin
+        JSON.load(uri_open('http://downloads.mongodb.org/full.json').read)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'singleton'
+
+module Mrss
+
+  def self.patch_mongo_for_session_registry
+
+    Mongo::Client.class_eval do
+      alias :get_session_without_tracking :get_session
+
+      def get_session(options = {})
+        get_session_without_tracking(options).tap do |session|
+          SessionRegistry.instance.register(session) if session&.materialized?
+        end
+      end
+    end
+
+    Mongo::Session.class_eval do
+      alias :end_session_without_tracking :end_session
+
+      def end_session
+        SessionRegistry.instance.unregister(self)
+        end_session_without_tracking
+      end
+
+      alias :materialize_if_needed_without_tracking :materialize_if_needed
+
+      def materialize_if_needed
+        materialize_if_needed_without_tracking.tap do
+          SessionRegistry.instance.register(self)
+        end
+      end
+    end
+  end
+end
+
+module Mrss
+  class SessionRegistry
+    include Singleton
+
+    def initialize
+      @registry = {}
+    end
+
+    def register(session)
+      @registry[session.session_id] = session if session
+    end
+
+    def unregister(session)
+      return if session.ended? || !session.materialized?
+      @registry.delete(session.session_id)
+    end
+
+    def verify_sessions_ended!
+      @registry.delete_if { |_, session| session.ended? }
+
+      unless @registry.empty?
+        sessions = @registry.map { |_, session| session }
+        raise "Session registry contains live sessions: #{sessions.join(', ')}"
+      end
+    end
+
+    def clear_registry
+      @registry = {}
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'singleton'
+
+module Mrss
+
+  def self.patch_mongo_for_session_registry
+
+    Mongo::Client.class_eval do
+      alias :get_session_without_tracking :get_session
+
+      def get_session(options = {})
+        get_session_without_tracking(options).tap do |session|
+          SessionRegistry.instance.register(session)
+        end
+      end
+    end
+
+    Mongo::Session.class_eval do
+      alias :end_session_without_tracking :end_session
+
+      def end_session
+        SessionRegistry.instance.unregister(self)
+        end_session_without_tracking
+      end
+    end
+  end
+end
+
+module Mrss
+  class SessionRegistry
+    include Singleton
+
+    def initialize
+      @registry = {}
+    end
+
+    def register(session)
+      @registry[session.session_id] = session if session
+    end
+
+    def unregister(session)
+      @registry.delete(session.session_id) unless session.ended?
+    end
+
+    def verify_sessions_ended!
+      @registry.delete_if { |_, session| session.ended? }
+
+      unless @registry.empty?
+        sessions = @registry.map { |_, session| session }
+        raise "Session registry contains live sessions: #{sessions.join(', ')}"
+      end
+    end
+
+    def clear_registry
+      @registry = {}
+    end
+  end
+end