textus 0.54.2 → 0.55.2

data/lib/textus/gate/auth.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  class Gate
-    class Auth
-      FLOOR = {
-        put: %w[lane_writable_by raw_lane_ingest_only],
-        key_delete: %w[lane_deletable_by],
-        key_mv: %w[lane_writable_by raw_lane_ingest_only],
-        accept: %w[author_held],
-        reject: %w[author_held],
-        propose: %w[lane_writable_by raw_lane_ingest_only],
-        key_mv_prefix: %w[lane_writable_by raw_lane_ingest_only],
-        key_delete_prefix: %w[lane_writable_by raw_lane_ingest_only],
-        ingest: %w[lane_writable_by raw_write_once],
-      }.freeze
-
-      AuthContext = Struct.new(
-        :actor, :actor_caps, :lane_verb,
-        :action, :target, :envelope,
-        :mentry, :manifest,
-        keyword_init: true
-      )
-
-      def initialize(container)
-        @manifest = container.manifest
-        @schemas = container.schemas
-      end
-
-      # Command-based check (new Gate path).
-      def check!(cmd)
-        key = extract_key(cmd)
-        return unless key
-
-        evaluate_predicates(
-          action: command_to_action(cmd),
-          actor: cmd.role.to_s,
-          key: key,
-          envelope: nil,
-          extra: {},
-        )
-      end
-
-      # Backward-compatible check for inline action auth (accept, put, etc.).
-      def check_action!(action:, actor:, key:, envelope: nil, extra: {})
-        evaluate_predicates(
-          action: action.to_sym,
-          actor: actor,
-          key: key,
-          envelope: envelope,
-          extra: extra,
-        )
-      end
-
-      def self.command_to_verb
-        @command_to_verb ||= Textus::Gate::VERB_COMMAND.invert.freeze
-      end
-
-      private
-
-      def command_to_action(cmd)
-        self.class.command_to_verb.fetch(cmd.class) do
-          raise Textus::UsageError.new("unmapped command: #{cmd.class}")
-        end
-      end
-
-      def evaluate_predicates(action:, actor:, key:, envelope:, extra:)
-        mentry = @manifest.resolver.resolve(key).entry
-        lane_verb = @manifest.policy.verb_for_lane(mentry.lane.to_s)
-        actor_caps = Set.new(@manifest.data.role_caps.fetch(actor, []))
-
-        ctx = AuthContext.new(
-          actor:, actor_caps:, lane_verb:,
-          action:, target: key, envelope:,
-          mentry:, manifest: @manifest
-        )
-
-        failures = []
-        floor_preds = FLOOR.fetch(action, [])
-        rule_preds = rule_declared_predicates(action, key)
-        (floor_preds + rule_preds).uniq.each do |pred|
-          result = evaluate(pred, ctx, extra)
-          next if result[:pass]
-          raise result[:error] if result[:error]
-
-          failures << [pred, result[:reason]]
-        end
-        raise Textus::GuardFailed.new(failures) unless failures.empty?
-      end
-
-      def extract_key(cmd)
-        if cmd.respond_to?(:pending_key)
-          cmd.pending_key
-        elsif cmd.respond_to?(:key)
-          cmd.key
-        end
-      end
-
-      def rule_declared_predicates(action, key)
-        guard_map = @manifest.rules.for(key).guard
-        return [] if guard_map.nil?
-
-        Array(guard_map[action.to_s])
-      end
-
-      def evaluate(pred_name, ctx, extra)
-        case pred_name
-        when "lane_writable_by"      then evaluate_lane_writable_by(ctx)
-        when "author_held"           then evaluate_author_held(ctx)
-        when "target_is_canon"       then evaluate_target_is_canon(ctx)
-        when "etag_match"            then evaluate_etag_match(ctx, extra)
-        when "schema_valid"          then evaluate_schema_valid(ctx)
-        when "fresh_within"          then { pass: true }
-        when "raw_lane_ingest_only"  then evaluate_raw_lane_ingest_only(ctx)
-        when "raw_write_once"        then evaluate_raw_write_once(ctx)
-        when "lane_deletable_by"     then evaluate_lane_deletable_by(ctx)
-        else raise Textus::UsageError.new("unknown predicate '#{pred_name}'")
-        end
-      end
-
-      def evaluate_lane_writable_by(ctx)
-        pass = ctx.actor_caps.include?(ctx.lane_verb.to_s)
-        return { pass: true } if pass
-
-        holders = @manifest.policy.roles_with_capability(ctx.lane_verb.to_s)
-        { pass: false, error: Textus::WriteForbidden.new(ctx.mentry.key, ctx.mentry.lane, verb: ctx.lane_verb, holders:) }
-      end
-
-      def evaluate_author_held(ctx)
-        holders = @manifest.policy.roles_with_capability("author")
-        pass = holders.include?(ctx.actor.to_s)
-        reason = if pass
-                   nil
-                 elsif holders.empty?
-                   "no role holds the 'author' capability; #{ctx.action} is disabled"
-                 else
-                   "role '#{ctx.actor}' lacks the 'author' capability (held by: #{holders.join(", ")})"
-                 end
-        { pass:, reason: }
-      end
-
-      def evaluate_target_is_canon(ctx)
-        kind = @manifest.policy.declared_kind(ctx.mentry.lane.to_s)
-        pass = kind == :canon
-        { pass:, reason: pass ? nil : "target lane '#{ctx.mentry.lane}' is not canon (kind: #{kind})" }
-      end
-
-      def evaluate_etag_match(ctx, extra)
-        if_etag = extra[:if_etag]
-        return { pass: true } if if_etag.nil?
-
-        current = ctx.envelope&.etag
-        pass = current.nil? || current == if_etag
-        { pass:, error: pass ? nil : Textus::EtagMismatch.new(ctx.target, if_etag, current) }
-      end
-
-      def evaluate_schema_valid(ctx)
-        return { pass: true } unless ctx.envelope
-
-        schema_ref = ctx.mentry.schema
-        return { pass: true } unless schema_ref
-
-        schema = @schemas.fetch_or_nil(schema_ref)
-        return { pass: true } unless schema
-
-        frontmatter = ctx.envelope.meta&.dig("_meta") || ctx.envelope.meta || {}
-        begin
-          schema.validate!(frontmatter)
-          { pass: true }
-        rescue Textus::SchemaViolation => e
-          { pass: false, reason: schema_reason(e) }
-        end
-      end
-
-      def evaluate_raw_lane_ingest_only(ctx)
-        return { pass: true } unless @manifest.policy.declared_kind(ctx.mentry.lane.to_s) == :raw
-        return { pass: true } if ctx.action == :ingest
-
-        { pass: false, error: Textus::Error.new(
-          :raw_lane_ingest_only,
-          "raw lane '#{ctx.mentry.lane}' only accepts `textus ingest` — " \
-          "use that verb instead of '#{ctx.action}'",
-        ) }
-      end
-
-      def evaluate_raw_write_once(ctx)
-        path = @manifest.resolver.resolve(ctx.target).path
-        return { pass: true } unless File.exist?(path)
-
-        { pass: false, error: Textus::Error.new(
-          :raw_write_once,
-          "raw entry '#{ctx.target}' already exists; " \
-          "delete it first (`textus key-delete #{ctx.target}`), then re-ingest",
-        ) }
-      end
-
-      # Deletion authority: the lane's write capability OR the author capability.
-      # On raw-kind lanes only the author capability grants deletion (correction
-      # escape hatch); the lane's own verb (ingest) is write-only. On all other
-      # lane kinds the behaviour matches lane_writable_by — the lane's writer
-      # can delete as before.
-      def evaluate_lane_deletable_by(ctx)
-        is_raw = @manifest.policy.declared_kind(ctx.mentry.lane.to_s) == :raw
-        pass = if is_raw
-                 ctx.actor_caps.include?("author")
-               else
-                 ctx.actor_caps.include?(ctx.lane_verb.to_s) || ctx.actor_caps.include?("author")
-               end
-        return { pass: true } if pass
-
-        extra_holders = is_raw ? ["author"] : [ctx.lane_verb.to_s, "author"]
-        holders = extra_holders.flat_map { |v| @manifest.policy.roles_with_capability(v) }.uniq
-        { pass: false, error: Textus::WriteForbidden.new(ctx.mentry.key, ctx.mentry.lane,
-                                                         verb: ctx.lane_verb, holders:) }
-      end
-
-      def schema_reason(err)
-        d = err.details
-        return err.message.dup unless d.is_a?(Hash)
-        return "missing required fields: #{Array(d["missing"]).join(", ")}" if d["missing"]
-        return "field '#{d["field"]}': #{d["reason"]}" if d["field"]
-
-        err.message.dup
-      end
-    end
-  end
-end

data/lib/textus/gate.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  class Gate
-    VERB_COMMAND = {
-      get: Textus::Command::Get,
-      put: Textus::Command::Put,
-      propose: Textus::Command::Propose,
-      key_delete: Textus::Command::KeyDelete,
-      key_mv: Textus::Command::KeyMv,
-      accept: Textus::Command::Accept,
-      reject: Textus::Command::Reject,
-      enqueue: Textus::Command::Enqueue,
-      list: Textus::Command::List,
-      where: Textus::Command::Where,
-      uid: Textus::Command::Uid,
-      blame: Textus::Command::Blame,
-      audit: Textus::Command::Audit,
-      deps: Textus::Command::Deps,
-      rdeps: Textus::Command::Rdeps,
-      pulse: Textus::Command::Pulse,
-      rule_explain: Textus::Command::RuleExplain,
-      rule_list: Textus::Command::RuleList,
-      rule_lint: Textus::Command::RuleLint,
-      published: Textus::Command::Published,
-      schema_show: Textus::Command::SchemaShow,
-      doctor: Textus::Command::Doctor,
-      boot: Textus::Command::Boot,
-      jobs: Textus::Command::Jobs,
-      data_mv: Textus::Command::DataMv,
-      key_mv_prefix: Textus::Command::KeyMvPrefix,
-      key_delete_prefix: Textus::Command::KeyDeletePrefix,
-      drain: Textus::Command::Drain,
-      ingest: Textus::Command::Ingest,
-    }.freeze
-
-    ROUTES = {
-      Command::Get => [Textus::Action::Get],
-      Command::Put => [Textus::Action::Put],
-      Command::Propose => [Textus::Action::Propose],
-      Command::KeyDelete => [Textus::Action::KeyDelete],
-      Command::KeyMv => [Textus::Action::KeyMv],
-      Command::Accept => [Textus::Action::Accept],
-      Command::Reject => [Textus::Action::Reject],
-      Command::Enqueue => [Textus::Action::Enqueue],
-      Command::List => [Textus::Action::List],
-      Command::Where => [Textus::Action::Where],
-      Command::Uid => [Textus::Action::Uid],
-      Command::Blame => [Textus::Action::Blame],
-      Command::Audit => [Textus::Action::Audit],
-      Command::Deps => [Textus::Action::Deps],
-      Command::Rdeps => [Textus::Action::Rdeps],
-      Command::Pulse => [Textus::Action::Pulse],
-      Command::RuleExplain => [Textus::Action::RuleExplain],
-      Command::RuleList => [Textus::Action::RuleList],
-      Command::RuleLint => [Textus::Action::RuleLint],
-      Command::Published => [Textus::Action::Published],
-      Command::SchemaShow => [Textus::Action::SchemaEnvelope],
-      Command::Doctor => [Textus::Action::Doctor],
-      Command::Boot => [Textus::Action::Boot],
-      Command::Jobs => [Textus::Action::Jobs],
-      Command::DataMv => [Textus::Action::DataMv],
-      Command::KeyMvPrefix => [Textus::Action::KeyMvPrefix],
-      Command::KeyDeletePrefix => [Textus::Action::KeyDeletePrefix],
-      Command::Drain => [Textus::Action::Drain],
-      Command::Ingest => [Textus::Action::Ingest],
-    }.freeze
-
-    def initialize(container)
-      @container = container
-    end
-
-    def dispatch(cmd, correlation_id: nil)
-      cmd = normalize_propose_key(cmd, @container) if cmd.is_a?(Command::Propose)
-      action_classes = ROUTES.fetch(cmd.class) do
-        raise Textus::UsageError.new("unknown command: #{cmd.class}")
-      end
-
-      Gate::Auth.new(@container).check!(cmd)
-      call_obj = build_call(cmd, correlation_id: correlation_id)
-      results = action_classes.map { |klass| run_action(klass, cmd, @container, call_obj) }
-      results.length == 1 ? results.first : results
-    end
-
-    private
-
-    def normalize_propose_key(cmd, container)
-      return cmd if cmd.pending_key
-
-      zone = container.manifest.policy.propose_lane_for(cmd.role.to_s)
-      cmd.with(pending_key: zone ? "#{zone}.#{cmd.key}" : nil)
-    end
-
-    def run_action(klass, cmd, container, call_obj)
-      action = klass.new(**extract_kwargs(klass, cmd))
-      action.call(container:, call: call_obj)
-    end
-
-    def extract_kwargs(klass, cmd)
-      params = klass.instance_method(:initialize).parameters
-      accepts_keyrest = params.any? { |t, _| t == :keyrest }
-      param_set = params.to_set { |_t, n| n }
-      cmd.members.each_with_object({}) do |m, h|
-        next unless accepts_keyrest || param_set.include?(m)
-
-        val = cmd.public_send(m)
-        h[m] = val unless val.nil?
-      end
-    end
-
-    def build_call(cmd, correlation_id: nil)
-      dry_run = cmd.respond_to?(:dry_run) ? !cmd.dry_run.nil? : false
-      Textus::Call.build(role: cmd.role, dry_run:, correlation_id: correlation_id)
-    end
-  end
-end

data/lib/textus/jobs/base.rb

@@ -1,23 +0,0 @@
-module Textus
-  module Jobs
-    class Base
-      def self.inherited(subclass)
-        super
-        return unless subclass.name
-
-        TracePoint.new(:end) do |tp|
-          if tp.self == subclass
-            Textus::Jobs.register(subclass)
-            tp.disable
-          end
-        end.enable
-      end
-
-      def call(**)
-        raise NotImplementedError.new("#{self.class}#call")
-      end
-
-      def args = {}
-    end
-  end
-end

data/lib/textus/jobs/materialize.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Jobs
-    class Materialize < Base
-      TYPE = "materialize"
-
-      def initialize(key:)
-        super()
-        @key = key
-      end
-
-      def args = { key: @key }
-
-      def call(container:, call:)
-        Textus::Produce::Engine.converge(container: container, call: call, keys: [@key])
-      end
-    end
-  end
-end

data/lib/textus/jobs/plan.rb

@@ -1,9 +0,0 @@
-module Textus
-  module Jobs
-    Plan = Data.define(:steps, :warnings) do
-      def to_h
-        { "steps" => steps, "warnings" => warnings }
-      end
-    end
-  end
-end

data/lib/textus/jobs/planner.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Textus
-  module Jobs
-    class Planner
-      ACTIONS_BY_TRIGGER = {
-        "convergence" => %w[materialize sweep],
-        "entry.written" => %w[materialize],
-        "entry.deleted" => %w[materialize],
-        "entry.moved" => %w[materialize],
-        "proposal.accepted" => %w[materialize],
-        "proposal.rejected" => %w[materialize],
-      }.freeze
-
-      SCOPE_RESOLVERS = {
-        "materialize" => :producible_keys,
-        "sweep" => :lane_keys,
-      }.freeze
-
-      def self.seed(container:, queue:, role:)
-        jobs = new(container: container).plan(
-          trigger: { "type" => "convergence" },
-          role: role,
-        )
-        jobs.each { |j| queue.enqueue(j) }
-      end
-
-      def initialize(container:)
-        @container = container
-        @manifest  = container.manifest
-      end
-
-      def plan(trigger:, role:)
-        type = trigger["type"] || trigger[:type]
-        trigger["target"] || trigger[:target]
-        return [] if type.nil?
-
-        blocks_with_react = @manifest.rules.blocks.select(&:react)
-        if blocks_with_react.any?
-          plan_from_rules(blocks_with_react, type, role)
-        else
-          plan_from_defaults(type, role)
-        end
-      end
-
-      private
-
-      def plan_from_rules(blocks, type, role)
-        jobs = []
-        blocks
-          .select { |b| matches_trigger?(b.react, type) }
-          .each do |block|
-            do_action = block.react.raw["do"]
-            Array(do_action).each do |action|
-              if action == "sweep"
-                jobs << Textus::Ports::JobStore::Job.new(
-                  type: "sweep", args: { "scope" => {} }, enqueued_by: role,
-                )
-              else
-                resolver = SCOPE_RESOLVERS.fetch(action, :producible_keys)
-                keys = send(resolver, nil)
-                keys.each { |key| jobs << job(action, key, role) }
-              end
-            end
-          end
-        jobs
-      end
-
-      def plan_from_defaults(type, role)
-        actions = ACTIONS_BY_TRIGGER.fetch(type, [])
-        jobs = []
-        producible_keys(nil).each { |k| jobs << job("materialize", k, role) } if actions.include?("materialize")
-        if actions.include?("sweep")
-          jobs << Textus::Ports::JobStore::Job.new(
-            type: "sweep", args: { "scope" => {} }, enqueued_by: role,
-          )
-        end
-        jobs
-      end
-
-      def matches_trigger?(react, type)
-        on = react.raw["on"]
-        Array(on).include?(type)
-      end
-
-      def job(type, key, enqueued_by)
-        Textus::Ports::JobStore::Job.new(type: type, args: { "key" => key }, enqueued_by: enqueued_by)
-      end
-
-      def producible_keys(_target)
-        @manifest.data.entries
-                 .select { |e| !e.publish_tree.nil? || !e.publish_to.empty? }
-                 .map(&:key)
-      end
-
-      def lane_keys(_target)
-        @manifest.data.entries.map(&:key)
-      end
-    end
-  end
-end

data/lib/textus/jobs/retention.rb

@@ -1,48 +0,0 @@
-require "fileutils"
-
-module Textus
-  module Jobs
-    class Retention
-      def initialize(container:, call:)
-        @container = container
-        @call = call
-      end
-
-      def call(rows)
-        out = { dropped: [], archived: [], failed: [] }
-        rows.each do |row|
-          key = row["key"]
-          begin
-            case row["action"]
-            when "drop"
-              delete(key)
-              out[:dropped] << key
-            when "archive"
-              archive_leaf(row)
-              delete(key)
-              out[:archived] << key
-            end
-          rescue Textus::Error => e
-            out[:failed] << { "key" => key, "error" => e.message }
-          end
-        end
-        out
-      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
-
-      def delete(key)
-        Textus::Action::KeyDelete.new(key: key).call(container: @container, call: @call)
-      end
-    end
-  end
-end

data/lib/textus/jobs/sweep.rb

@@ -1,27 +0,0 @@
-module Textus
-  module Jobs
-    class Sweep < Base
-      REQUIRED_ROLE = Textus::Role::AUTOMATION
-      TYPE = "sweep"
-
-      def initialize(scope: nil, key: nil)
-        super()
-        @scope = scope || {}
-        @key   = key
-      end
-
-      def args = { scope: @scope, key: @key }.compact
-
-      def call(container:, call:)
-        prefix = @key || (@scope.is_a?(Hash) ? @scope["prefix"] : nil)
-        lane   = @scope.is_a?(Hash) ? @scope["lane"] : nil
-        rows = Textus::Core::Retention::Sweep.new(
-          manifest: container.manifest,
-          file_stat: Textus::Ports::Storage::FileStat.new,
-          clock: Textus::Ports::Clock.new,
-        ).call(prefix: prefix, lane: lane)
-        Textus::Jobs::Retention.new(container: container, call: call).call(rows)
-      end
-    end
-  end
-end

data/lib/textus/jobs/worker.rb

@@ -1,67 +0,0 @@
-module Textus
-  module Jobs
-    class Worker
-      Summary = Struct.new(:completed, :failed, keyword_init: true)
-
-      def self.for(container:, queue:)
-        new(queue: queue, container: container,
-            lease_ttl: container.manifest.data.worker_config[:lease_ttl])
-      end
-
-      def initialize(queue:, container:, lease_ttl: 60)
-        @queue     = queue
-        @container = container
-        @lease_ttl = lease_ttl
-      end
-
-      def drain(worker_id: "drain-#{Process.pid}")
-        completed = 0
-        failed    = 0
-        loop do
-          leased = @queue.lease(worker_id: worker_id, lease_ttl: @lease_ttl)
-          break unless leased
-
-          case run_one(leased)
-          when :completed     then completed += 1
-          when :dead_lettered then failed += 1
-          end
-        end
-        Summary.new(completed: completed, failed: failed)
-      end
-
-      def drain_pool(pool: 4)
-        summaries = []
-        mutex     = Mutex.new
-        threads   = Array.new(pool) do |i|
-          Thread.new do
-            s = drain(worker_id: "pool-#{Process.pid}-#{i}")
-            mutex.synchronize { summaries << s }
-          end
-        end
-        threads.each(&:join)
-        Summary.new(completed: summaries.sum(&:completed), failed: summaries.sum(&:failed))
-      end
-
-      private
-
-      def run_one(leased)
-        job    = leased.job
-        klass  = Textus::Jobs.fetch(job.type)
-        action = if klass.instance_method(:initialize).parameters.any?
-                   klass.new(**job.args.transform_keys(&:to_sym))
-                 else
-                   klass.new
-                 end
-        call   = Textus::Call.build(
-          role: job.enqueued_by || Textus::Role::AUTOMATION,
-          correlation_id: SecureRandom.uuid,
-        )
-        action.call(container: @container, call: call)
-        @queue.ack(leased)
-        :completed
-      rescue StandardError => e
-        @queue.fail(leased, error: e.message)
-      end
-    end
-  end
-end