textus 0.47.1 → 0.49.0

data/lib/textus/maintenance/migrate.rb

@@ -1,65 +0,0 @@
-require "yaml"
-
-module Textus
-  module Maintenance
-    # Loads a YAML migration plan and dispatches each op to the
-    # appropriate Maintenance use case. Concatenates resulting Plans.
-    class Migrate
-      extend Textus::Contract::DSL
-
-      verb     :migrate
-      summary  "Run a YAML migration plan (multi-op)."
-      surfaces :cli, :mcp
-      arg :plan_yaml, String, required: true, positional: true, source: :file,
-                              description: "path to the YAML migration plan (zone_mv, key_mv_prefix, key_delete_prefix ops run in order)"
-      arg :dry_run, :boolean, default: false,
-                              description: "when true, returns the planned ops without applying them; " \
-                                           "defaults to false, so omitting it runs the migration immediately"
-      view { |v, _i| v.to_h }
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-      end
-
-      def call(plan_yaml, dry_run: false)
-        raw = YAML.safe_load(plan_yaml, permitted_classes: [Symbol], aliases: false)
-        raise UsageError.new("migration plan must be a YAML mapping") unless raw.is_a?(Hash)
-
-        ops = Array(raw["operations"])
-        all_steps = []
-        warnings = []
-
-        ops.each do |op_hash|
-          op_name = op_hash["op"]
-          sub_plan = invoke_op(op_name, op_hash, dry_run: dry_run)
-          all_steps.concat(sub_plan.steps)
-          warnings.concat(sub_plan.warnings)
-        end
-
-        Plan.new(steps: all_steps, warnings: warnings)
-      end
-
-      private
-
-      def invoke_op(op_name, op_hash, dry_run:)
-        klass = op_class(op_name)
-        inputs = op_hash.except("op").transform_keys(&:to_sym).merge(dry_run: dry_run)
-        # Each op now carries positional args (from/to, from_prefix/to_prefix,
-        # prefix); split the YAML fields into (positional, keyword) via the op's
-        # own contract so we call its #call signature correctly (ADR 0066/0068).
-        args, kwargs = Textus::Contract::Binder.bind(klass.contract, inputs)
-        klass.new(container: @container, call: @call).call(*args, **kwargs)
-      end
-
-      def op_class(op_name)
-        case op_name
-        when "key_mv_prefix"     then KeyMvPrefix
-        when "key_delete_prefix" then KeyDeletePrefix
-        when "zone_mv"           then ZoneMv
-        else raise UsageError.new("unknown op: #{op_name}")
-        end
-      end
-    end
-  end
-end

data/lib/textus/read/retainable.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Read
-    class Retainable
-      def initialize(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
-        @manifest = container.manifest
-      end
-
-      def call(prefix: nil, zone: nil)
-        Textus::Domain::Retention.new(
-          manifest: @manifest,
-          file_stat: Textus::Ports::Storage::FileStat.new,
-          clock: Textus::Ports::Clock,
-        ).call(prefix: prefix, zone: zone)
-      end
-    end
-  end
-end

data/lib/textus/read/stale.rb

@@ -1,17 +0,0 @@
-module Textus
-  module Read
-    class Stale
-      def initialize(container:, call: nil) # rubocop:disable Lint/UnusedMethodArgument
-        @manifest = container.manifest
-      end
-
-      def call(prefix: nil, zone: nil)
-        Textus::Domain::Staleness.new(
-          manifest: @manifest,
-          file_stat: Textus::Ports::Storage::FileStat.new,
-          clock: Textus::Ports::Clock,
-        ).call(prefix: prefix, zone: zone)
-      end
-    end
-  end
-end

data/lib/textus/write/fetch_all.rb

@@ -1,53 +0,0 @@
-module Textus
-  module Write
-    class FetchAll
-      extend Textus::Contract::DSL
-
-      verb     :fetch_all
-      summary  "Fetch all stale quarantine entries, optionally scoped by zone/prefix."
-      surfaces :cli, :mcp
-      cli      "fetch all"
-      arg :prefix, String, description: "only refresh stale entries whose key starts with this dotted prefix"
-      arg :zone,   String, description: "only refresh stale entries in this quarantine zone (see `pulse` stale list)"
-
-      def initialize(container:, call:)
-        @container    = container
-        @call         = call
-      end
-
-      def call(prefix: nil, zone: nil)
-        worker = Textus::Write::FetchWorker.new(
-          container: @container, call: @call,
-        )
-
-        stale_rows = Textus::Read::Stale.new(container: @container, call: @call).call(prefix: prefix, zone: zone)
-        fetched = []
-        failed = []
-        skipped = []
-
-        stale_rows.each do |row|
-          key = row["key"] || row[:key]
-          reason = row["reason"] || row[:reason]
-          if reason.to_s.match?(/ttl exceeded|never fetched/)
-            begin
-              worker.run(key)
-              fetched << key
-            rescue Textus::Error => e
-              failed << { "key" => key, "error" => e.message }
-            end
-          else
-            skipped << { "key" => key, "reason" => reason }
-          end
-        end
-
-        {
-          "protocol" => Textus::PROTOCOL,
-          "ok" => failed.empty?,
-          "fetched" => fetched,
-          "failed" => failed,
-          "skipped" => skipped,
-        }
-      end
-    end
-  end
-end

data/lib/textus/write/retention_sweep.rb

@@ -1,64 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Write
-    # Applies retention actions reported by Read::Retainable. `expire` deletes
-    # the leaf through the role gate; `archive` copies it to
-    # <root>/archive/<relative-path> first, then deletes. Rows whose zone the
-    # caller's role cannot write surface in `failed` rather than aborting.
-    class RetentionSweep
-      extend Textus::Contract::DSL
-
-      verb     :retain
-      summary  "Apply each entry's retention policy; prune expired versions."
-      surfaces :cli
-      cli      "retain"
-      arg :prefix, String, description: "restrict to keys starting with this dotted prefix"
-      arg :zone,   String, description: "restrict to entries in this zone"
-
-      def initialize(container:, call:)
-        @container = container
-        @call      = call
-      end
-
-      def call(prefix: nil, zone: nil)
-        rows = Textus::Read::Retainable.new(container: @container, call: @call)
-                                       .call(prefix: prefix, zone: zone)
-        delete_op = Textus::Write::Delete.new(container: @container, call: @call)
-        expired   = []
-        archived  = []
-        failed    = []
-
-        rows.each do |row|
-          key = row["key"]
-          begin
-            archive_leaf(row) if row["action"] == "archive"
-            delete_op.call(key)
-            (row["action"] == "archive" ? archived : expired) << key
-          rescue Textus::Error => e
-            failed << { "key" => key, "error" => e.message }
-          end
-        end
-
-        {
-          "protocol" => Textus::PROTOCOL,
-          "ok" => failed.empty?,
-          "expired" => expired,
-          "archived" => archived,
-          "failed" => failed,
-        }
-      end
-
-      private
-
-      def archive_leaf(row)
-        src  = row["path"]
-        root = @container.root.to_s
-        rel  = src.delete_prefix("#{root}/")
-        dest = File.join(root, "archive", rel)
-        FileUtils.mkdir_p(File.dirname(dest))
-        FileUtils.cp(src, dest)
-      end
-    end
-  end
-end