hecks 3.5.0 → 3.7.0

data/lib/hecks/quality_control/cli/qa_open_pr.rb

@@ -4,6 +4,9 @@ require_relative "../../../hecks"
 # The era subsystem does not load with core (ADR 0033).
 require_relative "../../ports/persistence/plugins/era"
 require_relative "../adapters/git_pr"
+require_relative "qa_open_pr/arguments"
+require_relative "qa_open_pr/rules"
+require_relative "qa_open_pr/recording"
 
 module Hecks
   module QualityControlCli
@@ -20,6 +23,10 @@ module Hecks
     # the others, and taken for real once the PR is recorded. It is idempotent. `QA_REPO_DIR`
     # picks the checkout `git` runs in, so a spec can use a throwaway repo and a fake `gh`.
     class QaOpenPr
+      include Arguments
+      include Rules
+      include Recording
+
       EXIT_OK = 0
 
       USAGE = "usage: hecks quality_control patch.open --bug BUG#n --title \"…\" [--body \"…\"]\n       " \
@@ -56,12 +63,7 @@ module Hecks
         return EXIT_OK if options == :help
 
         @options = options
-        @git_pr = Hecks::Adapters::GitPr.new(repo_dir: @repo_dir)
-        @branch = refusing { @git_pr.branch }
-        refusing { @git_pr.assert_clean_tree! }
-        @runtime = boot_ledger
-        find_citations
-        check_rules
+        prepare
         view = open_pull_request
         record(view)
         merge_when_green(view[:number]) if dial(:AUTO_MERGE, false)
@@ -71,34 +73,14 @@ module Hecks
 
       private
 
-      def parse(argv)
-        options = {}
-        until argv.empty?
-          arg = argv.shift
-          case arg
-          when "-h", "--help"
-            puts USAGE
-            return :help
-          when "--improvement"
-            options[:improvement] = true
-          when "--bug", "--angle", "--title", "--body"
-            value = argv.shift
-            abort "#{USAGE}\n#{arg} needs a value" if value.nil? || value.empty?
-            options[arg.delete_prefix("--").to_sym] = value
-          else
-            abort "#{USAGE}\nunexpected argument: #{arg.inspect}"
-          end
-        end
-        validate(options)
-      end
-
-      def validate(options)
-        abort "#{USAGE}\n--title is required" unless options[:title]
-        abort "#{USAGE}\ngive --bug BUG#n OR --improvement, not both" if options[:bug] && options[:improvement]
-        abort "#{USAGE}\ngive --bug BUG#n or --improvement" unless options.key?(:bug) || options.key?(:improvement)
-        abort "#{USAGE}\n--angle only means something with --improvement" if options[:angle] && !options[:improvement]
-
-        options
+      # Everything that can refuse, before a PR is opened.
+      def prepare
+        @git_pr = Hecks::Adapters::GitPr.new(repo_dir: @repo_dir)
+        @branch = refusing { @git_pr.branch }
+        refusing { @git_pr.assert_clean_tree! }
+        @runtime = boot_ledger
+        find_citations
+        check_rules
       end
 
       # Every rule the adapter enforces refuses the same way: exit 1, nothing opened or recorded.
@@ -124,117 +106,28 @@ module Hecks
         ::QualityControlDials.const_get(name)
       end
 
-      def find_citations
-        @bug = @angle = nil
-        if @options[:bug]
-          @bug = ::QualityControl::Bug.find(@options[:bug])
-          abort "refused: no such bug #{@options[:bug].inspect}" unless @bug
-        end
-        return unless @options[:angle]
-
-        @angle = ::QualityControl::Angle.find(@options[:angle])
-        abort "refused: no such angle #{@options[:angle].inspect}" unless @angle
-      end
-
-      # What a refused `given` says to do next, by the rule's own wording; nothing for a rule it
-      # does not know.
-      def hint_for(rule)
-        case rule
-        when "the bug is fixed"
-          " (#{@bug.id} is #{@bug.status.inspect} — dispatch investigate and fix first " \
-          "(hecks run qa/bluebook fix id=#{@bug.id} reference.value=#{@bug.id} commit.value=<sha>))"
-        when "the angle is under investigation"
-          " (#{@angle.id} is #{@angle.status.inspect} — dispatch angle.investigate first, so the lead " \
-          "reads as picked up before something is built from it)"
-        when "the branch is one this practice recognises as its own"
-          " (the branch is #{@branch.inspect}; a PR this practice opens is on a branch it can recognise " \
-          "as its own)"
-        when "the day's cap is not spent"
-          " (QualityControlDials::PR_CAP_PER_DAY is #{dial(:PR_CAP_PER_DAY, 0)} — leave this as an open " \
-          "Bug/Angle and open it tomorrow, or raise the dial in qa/settings.yml)"
-        else ""
-        end
-      end
-
-      # Asks the ledger whether `verb` would take these facts, without recording anything. The
-      # number is one no record holds yet, so the dry run reaches the `given`s rather than
-      # `AlreadyExists`.
-      def refuse_unless_ledger_takes(verb, **facts)
-        @runtime.dry_run?(verb, **facts)
-      rescue Hecks::Runtime::GivenNotMet => e
-        hint = hint_for(e.message.split(" — ", 2).last)
-        abort "refused: #{e.message}#{hint} — a dry run of #{verb}, so nothing was opened or recorded"
-      end
-
-      def next_number(aggregate)
-        query("#{aggregate}.All").map { |row| row[:number][:value] }.max.to_i + 1
-      end
-
-      def check_rules
-        recorded = { url: { value: "https://github.com/pull/0" }, title: { value: @options[:title] },
-                     branch: { value: @branch }, now: { value: Time.now.to_i } }
-        if @bug
-          commit = @bug.commit.to_h[:value].to_s
-          refuse_unless_ledger_takes("QualityControl::Patch.Open",
-                                     bug: @bug.id, number: { value: next_number("Patch") },
-                                     commit: { value: commit.match?(SHA_PATTERN) ? commit : PLACEHOLDER_COMMIT },
-                                     **recorded)
-        else
-          refuse_unless_ledger_takes("QualityControl::Improvement.Open",
-                                     **(@angle ? { angle: @angle.id } : {}),
-                                     number: { value: next_number("Improvement") }, **recorded)
+      # @return [Hash] `gh`'s view of the PR, opened here when the branch had none
+      def open_pull_request
+        view = existing_or_new_pull_request
+        sha = view[:headRefOid].to_s
+        unless sha.match?(SHA_PATTERN)
+          abort "refused: gh reports head #{sha.inspect} for ##{view[:number]}, which does not look like a sha"
         end
-        check_daily_cap
-        check_ancestry
-      end
-
-      # The record of the UTC day the clock reads: `DailyQuota.Today` fills the day from the clock.
-      def todays_quota = query("DailyQuota.Today").first
-
-      # A day with no record has spent nothing, so only an opened day can refuse.
-      def check_daily_cap
-        cap = dial(:PR_CAP_PER_DAY, 0)
-        quota = todays_quota
-        return unless cap.positive? && quota
-
-        refuse_unless_ledger_takes("QualityControl::DailyQuota.Take", today: quota[:today], cap: { value: cap })
-      end
-
-      # Counts the PR just recorded against the day, opening the day's record on its first.
-      def take_daily_slot
-        row = todays_quota
-        quota = row ? ::QualityControl::DailyQuota.find(row[:today][:value]) : ::QualityControl::DailyQuota.open!
-        quota.take!(cap: { value: dial(:PR_CAP_PER_DAY, 0) })
-      end
-
-      def check_ancestry
-        return unless @bug
 
-        commit = @bug.commit.to_h[:value].to_s
-        abort "refused: #{@bug.id} carries no commit" unless commit.match?(SHA_PATTERN)
-
-        refusing do
-          @git_pr.assert_ancestor!(commit: commit, owner: @bug.id)
-          @git_pr.assert_pushed!(branch: @branch, commit: commit, owner: @bug.id)
-        end
+        check_pr_head(sha)
+        view
       end
 
-      # @return [Hash] `gh`'s view of the PR, opened here when the branch had none
-      def open_pull_request
+      def existing_or_new_pull_request
         view = refusing { @git_pr.open_pull_request(@branch) }
         if view
           puts "PR ##{view[:number]} already open for #{@branch} — not re-creating"
-        else
-          create_pull_request
-          view = refusing { @git_pr.open_pull_request(@branch) }
-          abort "gh pr create returned, but gh pr view #{@branch} shows no open PR — record nothing" unless view
-        end
-        sha = view[:headRefOid].to_s
-        unless sha.match?(SHA_PATTERN)
-          abort "refused: gh reports head #{sha.inspect} for ##{view[:number]}, which does not look like a sha"
+          return view
         end
 
-        check_pr_head(sha)
+        create_pull_request
+        view = refusing { @git_pr.open_pull_request(@branch) }
+        abort "gh pr create returned, but gh pr view #{@branch} shows no open PR — record nothing" unless view
         view
       end
 
@@ -246,75 +139,23 @@ module Hecks
       end
 
       def create_pull_request
-        # The body names the ledger record so the PR and the ledger point at each other.
-        cited = if @bug then "Fixes #{@bug.id}."
-                elsif @angle then "Builds #{@angle.id}."
-                else "Deliberate work, no Bug or Angle behind it."
-                end
-        body = @options[:body] ||
-               "#{cited}\n\nOpened by hecks quality_control patch.open and recorded in the QualityControl ledger."
-        begin
-          @git_pr.create_pull_request(branch: @branch, title: @options[:title], body: body,
-                                      draft: dial(:DRAFT_ONLY, false))
-        rescue Hecks::Adapters::GitPr::CommandFailed => e
-          abort e.message
-        end
-      end
-
-      def record(view)
-        number = view[:number]
-        sha = view[:headRefOid].to_s
-        now = Time.now.to_i
-        if @bug
-          record_patch(view, number, sha, now)
-        else
-          record_improvement(view, number, sha, now)
-        end
+        @git_pr.create_pull_request(branch: @branch, title: @options[:title], body: pull_request_body,
+                                    draft: dial(:DRAFT_ONLY, false))
+      rescue Hecks::Adapters::GitPr::CommandFailed => e
+        abort e.message
       end
 
-      def record_patch(view, number, sha, now)
-        if query("Patch.All").map { |row| row[:number][:value] }.include?(number)
-          puts "Patch ##{number} already recorded — not re-recording"
-          return
-        end
-
-        ::QualityControl::Patch.open!(
-          bug: @bug.id, number: { value: number }, url: { value: view[:url] },
-          branch: { value: view[:headRefName] }, commit: { value: sha }, title: { value: view[:title] },
-          now: { value: now }
-        )
-        take_daily_slot
-        puts "recorded Patch ##{number} for #{@bug.id} at #{sha[0, 7]}"
+      # The body names the ledger record so the PR and the ledger point at each other.
+      def pull_request_body
+        @options[:body] ||
+          "#{cited_record}\n\nOpened by hecks quality_control patch.open and recorded in the QualityControl ledger."
       end
 
-      def record_improvement(view, number, sha, now)
-        existing = ::QualityControl::Improvement.find(number)
-        if existing && existing.status != "opened"
-          puts "Improvement ##{number} already recorded (#{existing.status}) — not re-recording"
-          return
-        end
-
-        # A run that stopped between `open!` and `land!` leaves the record `opened`: finish it.
-        unless existing
-          ::QualityControl::Improvement.open!(
-            **(@angle ? { angle: @angle.id } : {}),
-            number: { value: number }, url: { value: view[:url] },
-            branch: { value: view[:headRefName] }, title: { value: view[:title] },
-            now: { value: now }
-          )
-          take_daily_slot
-        end
-        ::QualityControl::Improvement.find(number).land!(number: { value: number }, commit: { value: sha })
-        puts "recorded Improvement ##{number}#{" for #{@angle.id}" if @angle}, landed at #{sha[0, 7]}"
-      end
+      def cited_record
+        return "Fixes #{@bug.id}." if @bug
+        return "Builds #{@angle.id}." if @angle
 
-      def merge_when_green(number)
-        begin
-          @git_pr.merge_when_green(number)
-        rescue Hecks::Adapters::GitPr::CommandFailed => e
-          abort "recorded, but #{e.message}"
-        end
-        puts "auto-merge queued for ##{number} (QualityControlDials::AUTO_MERGE)"
+        "Deliberate work, no Bug or Angle behind it."
       end
     end
   end

data/lib/hecks/quality_control/cli/qa_postgres_migrate/copying.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaPostgresMigrate
+      # The copy step of `sweep.migrate_ledger_from_heki`: one `save` per Heki id into the
+      # repository the domain binds today, sorted into migrated, skipped and refused.
+      module Copying
+        private
+
+        # @return [Array<Array<String>>] the ids migrated, skipped and refused
+        def copy(candidates, registry, heki_dir, force)
+          buckets = { migrated: [], skipped: [], conflicts: [] }
+          candidates.each { |candidate| copy_candidate(candidate, registry, heki_dir, force, buckets) }
+          buckets.values_at(:migrated, :skipped, :conflicts)
+        end
+
+        def copy_candidate(candidate, registry, heki_dir, force, buckets)
+          aggregate = candidate[:aggregate]
+          # Guarded like a factory-built repository so a Heki store decodes through the state codec.
+          source = Hecks::Ports::Persistence::CodecBoundary.guard!(
+            Hecks::Adapters::Heki.new(aggregate: aggregate, settings: { dir: heki_dir }, root: nil)
+          )
+          dest = registry.repository(candidate[:domain_name], aggregate)
+          source.all.each do |instance|
+            buckets[copy_instance(dest, instance, force)] << "#{aggregate.storage_name}/#{instance.id}"
+          end
+        end
+
+        # @return [Symbol] the bucket the instance falls in: `:migrated`, `:skipped` or `:conflicts`
+        def copy_instance(dest, instance, force)
+          existing = dest.find(instance.id)
+          if existing.nil?
+            dest.save(instance) if force
+            :migrated
+          elsif self.class.canonical(existing.state) == self.class.canonical(instance.state)
+            :skipped
+          else
+            :conflicts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_postgres_migrate/reporting.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaPostgresMigrate
+      # The report `sweep.migrate_ledger_from_heki` prints once the copy is done.
+      module Reporting
+        private
+
+        def report(force, migrated, skipped, conflicts)
+          label = force ? "MIGRATED" : "WOULD MIGRATE"
+          migrated.each { |id| @out.puts "#{label} #{id}" }
+          skipped.each { |id| @out.puts "SKIP #{id}: destination already holds the identical state" }
+          conflicts.each { |id| @err.puts refusal(id) }
+          @out.puts "" unless [migrated, skipped, conflicts].all?(&:empty?)
+          report_summary(force, migrated, skipped, conflicts)
+        end
+
+        def refusal(id)
+          "REFUSED #{id}: the destination already holds a DIFFERENT state for this id — " \
+            "not overwritten, --force or not. Resolve by hand (compare the two states, decide " \
+            "which is authoritative) before migrating this id again."
+        end
+
+        def report_summary(force, migrated, skipped, conflicts)
+          @out.puts "#{force ? "migrated" : "would migrate"} #{migrated.size}, skipped #{skipped.size} " \
+                    "(already caught up), refused #{conflicts.size} (conflicting data)"
+          @out.puts "re-run with --force to apply" unless force || migrated.empty?
+        end
+      end
+    end
+  end
+end

data/lib/hecks/quality_control/cli/qa_postgres_migrate.rb

@@ -4,6 +4,8 @@ require_relative "../../../hecks"
 # The era subsystem does not load with core; a `PostgresEra` domain needs it (ADR 0033).
 require_relative "../../ports/persistence/plugins/era"
 require_relative "../../adapters/driven/heki"
+require_relative "qa_postgres_migrate/copying"
+require_relative "qa_postgres_migrate/reporting"
 
 module Hecks
   module QualityControlCli
@@ -20,6 +22,9 @@ module Hecks
     # `<storage_name>.heki` file in the Heki directory are considered; trailing names (`hecks_name`
     # or `storage_name`) narrow further.
     class QaPostgresMigrate
+      include Copying
+      include Reporting
+
       USAGE = "usage: hecks quality_control migrate_ledger_from_heki <domain_dir> <heki_data_dir> " \
               "[aggregate_name ...] [--force]"
 
@@ -47,27 +52,11 @@ module Hecks
       def call(argv)
         argv = argv.dup
         force = argv.delete("--force")
-        domain_dir = argv.shift
-        return usage("no domain directory given") if domain_dir.nil?
-        return usage("no such domain directory #{domain_dir.inspect}") unless Dir.exist?(domain_dir)
-
-        heki_dir = argv.shift
-        return usage("no Heki data directory given") if heki_dir.nil?
-        return usage("no such Heki data directory #{heki_dir.inspect}") unless Dir.exist?(heki_dir)
-
-        heki_dir = File.expand_path(heki_dir)
-        registry = Hecks.boot(domain_dir).registry
-        candidates = candidates_in(registry, heki_dir, argv)
-        if candidates.empty?
-          @out.puts "hecks quality_control migrate_ledger_from_heki: no aggregate matched " \
-                    "#{argv.empty? ? '(any)' : argv.inspect} with a " \
-                    "corresponding .heki file under #{heki_dir}"
-          return 0
-        end
-
-        migrated, skipped, conflicts = copy(candidates, registry, heki_dir, force)
-        report(force, migrated, skipped, conflicts)
-        conflicts.empty? ? 0 : 1
+        domain_dir = directory_argument(argv.shift, "domain directory")
+        heki_dir = File.expand_path(directory_argument(argv.shift, "Heki data directory"))
+        migrate(domain_dir, heki_dir, argv, force)
+      rescue UsageError => e
+        usage(e.message)
       end
 
       # Deep comparison independent of key type and hash order; only array order is meaningful.
@@ -88,6 +77,33 @@ module Hecks
 
       private
 
+      # Raised for a wrong command line; `call` answers it with the usage line and status 1.
+      class UsageError < StandardError; end
+
+      def directory_argument(value, name)
+        raise UsageError, "no #{name} given" if value.nil?
+        raise UsageError, "no such #{name} #{value.inspect}" unless Dir.exist?(value)
+
+        value
+      end
+
+      def migrate(domain_dir, heki_dir, names, force)
+        registry = Hecks.boot(domain_dir).registry
+        candidates = candidates_in(registry, heki_dir, names)
+        return report_no_match(names, heki_dir) if candidates.empty?
+
+        migrated, skipped, conflicts = copy(candidates, registry, heki_dir, force)
+        report(force, migrated, skipped, conflicts)
+        conflicts.empty? ? 0 : 1
+      end
+
+      def report_no_match(names, heki_dir)
+        @out.puts "hecks quality_control migrate_ledger_from_heki: no aggregate matched " \
+                  "#{names.empty? ? "(any)" : names.inspect} with a " \
+                  "corresponding .heki file under #{heki_dir}"
+        0
+      end
+
       def usage(message)
         @err.puts "hecks quality_control migrate_ledger_from_heki: #{message}"
         @err.puts USAGE
@@ -107,48 +123,6 @@ module Hecks
           end
         end
       end
-
-      def copy(candidates, registry, heki_dir, force)
-        migrated = []
-        skipped = []
-        conflicts = []
-        candidates.each do |candidate|
-          aggregate = candidate[:aggregate]
-          # Guarded like a factory-built repository so a Heki store decodes through the state codec.
-          source = Hecks::Ports::Persistence::CodecBoundary.guard!(
-            Hecks::Adapters::Heki.new(aggregate: aggregate, settings: { dir: heki_dir }, root: nil)
-          )
-          dest = registry.repository(candidate[:domain_name], aggregate)
-          source.all.each do |instance|
-            name = "#{aggregate.storage_name}/#{instance.id}"
-            existing = dest.find(instance.id)
-            if existing.nil?
-              dest.save(instance) if force
-              migrated << name
-            elsif self.class.canonical(existing.state) == self.class.canonical(instance.state)
-              skipped << name
-            else
-              conflicts << name
-            end
-          end
-        end
-        [migrated, skipped, conflicts]
-      end
-
-      def report(force, migrated, skipped, conflicts)
-        label = force ? "MIGRATED" : "WOULD MIGRATE"
-        migrated.each { |id| @out.puts "#{label} #{id}" }
-        skipped.each { |id| @out.puts "SKIP #{id}: destination already holds the identical state" }
-        conflicts.each do |id|
-          @err.puts "REFUSED #{id}: the destination already holds a DIFFERENT state for this id — " \
-                    "not overwritten, --force or not. Resolve by hand (compare the two states, decide " \
-                    "which is authoritative) before migrating this id again."
-        end
-        @out.puts "" unless migrated.empty? && skipped.empty? && conflicts.empty?
-        @out.puts "#{force ? 'migrated' : 'would migrate'} #{migrated.size}, skipped #{skipped.size} " \
-                  "(already caught up), refused #{conflicts.size} (conflicting data)"
-        @out.puts "re-run with --force to apply" unless force || migrated.empty?
-      end
     end
   end
 end

data/lib/hecks/quality_control/cli/qa_postgres_role/ownership.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hecks
+  module QualityControlCli
+    class QaPostgresRole
+      # What `sweep.create_ledger_role` hands to the role inside the database: the `public` schema,
+      # its relations and its functions.
+      module Ownership
+        private
+
+        def take_contents(database, role, done)
+          db = PG.connect(dbname: database)
+          quoted_role = db.quote_ident(role)
+          take_schema(db, role, quoted_role, done)
+          take_relations(db, role, quoted_role, done)
+          take_functions(db, role, quoted_role, done)
+          db.close
+        end
+
+        def take_schema(db, role, quoted_role, done)
+          schema_owner = db.exec("SELECT pg_get_userbyid(nspowner) AS owner FROM pg_namespace WHERE nspname = 'public'")
+          return unless schema_owner.ntuples.positive? && schema_owner[0]["owner"] != role
+
+          db.exec("ALTER SCHEMA public OWNER TO #{quoted_role}")
+          done << "schema public: owner #{schema_owner[0]["owner"]} -> #{role}"
+        end
+
+        # relkind: r table, p partitioned table, S sequence, v view, m matview.
+        def take_relations(db, role, quoted_role, done)
+          relations = db.exec_params(<<~SQL, [role])
+            SELECT c.relname, c.relkind, pg_get_userbyid(c.relowner) AS owner
+            FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE n.nspname = 'public' AND c.relkind IN ('r', 'p', 'S', 'v', 'm') AND pg_get_userbyid(c.relowner) <> $1
+            ORDER BY c.relkind, c.relname
+          SQL
+          relations.each do |row|
+            db.exec("ALTER #{KINDS.fetch(row["relkind"])} #{db.quote_ident(row["relname"])} OWNER TO #{quoted_role}")
+          end
+          done << "#{relations.ntuples} relation(s) in public -> #{role}" if relations.ntuples.positive?
+        end
+
+        def take_functions(db, role, quoted_role, done)
+          functions = db.exec_params(<<~SQL, [role])
+            SELECT p.proname, pg_get_function_identity_arguments(p.oid) AS args
+            FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace
+            WHERE n.nspname = 'public' AND pg_get_userbyid(p.proowner) <> $1
+            ORDER BY p.proname
+          SQL
+          functions.each do |row|
+            db.exec("ALTER FUNCTION #{db.quote_ident(row["proname"])}(#{row["args"]}) OWNER TO #{quoted_role}")
+          end
+          done << "#{functions.ntuples} function(s) in public -> #{role}" if functions.ntuples.positive?
+        end
+      end
+    end
+  end
+end