Class: Eco::API::UseCases::GraphQL::Samples::Pages::Template::Deploy::Loop

Inherits:
Object
  • Object
show all
Defined in:
lib/eco/api/usecases/graphql/samples/pages/template/deploy/loop.rb

Overview

Deploy → verify → monitor orchestration (Phase 5).

Ties the four offline-safe pieces into one pass:

1. APPLY   — hand a gem `Diff::Deploy` plan to the `Applier` (dry-run by DEFAULT; live only
           behind an explicit `commit: true` + executor).
2. DRIFT   — re-read the target and run a pre/post self-version diff, then compare the applied
           delta to the intended delta (`DriftReport`). Reports drift honestly.
3. VERIFY  — run the post-deploy template doc through a `Verifier` (ecoportal-qa when present,
           else the null verifier).
4. MONITOR — optional sync-readiness scan of a register subset against the post-deploy template.

Everything is OFFLINE against fixtures. The two seams that would touch a live API — applying the batch and re-reading the target — are injected as callables, so specs (and dry-runs) drive them with fixtures and a RecordingExecutor:

loop = Deploy::Loop.new(
plan:       gem_deploy_plan,
intended:   source_version_diff,        # the diff the plan was built from
pre_doc:    target_before_doc,          # the target template BEFORE apply
reread:     -> { recording_executor.doc } # how to fetch the target AFTER apply (post-deploy doc)
)
result = loop.run(commit: false, executor: recording_executor, entries: register_entries)

result.applied            # => Applier::Outcome
result.drift              # => DriftReport (nil if pre_doc/reread not supplied)
result.verdict            # => Verifier::Verdict
result.sync_readiness     # => SyncReadiness (nil if no entries)
result.ok?                # => apply not blocked && drift match && verify pass
result.report             # => aggregate human summary

Defined Under Namespace

Classes: Result

Instance Method Summary collapse

Constructor Details

#initialize(plan:, intended: nil, pre_doc: nil, reread: nil, target: nil, verifier: nil, diff_builder: nil) ⇒ Loop

Returns a new instance of Loop.

Parameters:

  • plan (Ecoportal::API::GraphQL::Diff::Deploy) —

    the gem deploy plan.

  • intended (#changes, nil) (defaults to: nil) —

    the source diff the plan was built from (for drift check).

  • pre_doc (Hash, nil) (defaults to: nil) —

    the target template doc BEFORE apply (for drift check).

  • reread (#call, nil) (defaults to: nil) —

    returns the target template doc AFTER apply (for drift + verify).

  • target (#id, nil) (defaults to: nil) —

    the target model, forwarded to the Applier for a live apply.

  • verifier (Verifier, nil) (defaults to: nil) —

    injected verifier; defaults to Verifier.default.

  • diff_builder (#call, nil) (defaults to: nil) —

    diff_builder.call(pre_doc, post_doc) returns the applied self-version diff (must expose #changes). Defaults to the gem's Diff::VersionDiff — which lives in the (currently unreleased) gem Diff module, so it is resolved LAZILY at drift time, never at load. Injectable so offline callers/specs can supply their own diff builder.



95
96
97
98
99
100
101
102
103
104
 
# File 'lib/eco/api/usecases/graphql/samples/pages/template/deploy/loop.rb', line 95

def initialize(plan:, intended: nil, pre_doc: nil, reread: nil, target: nil, verifier: nil,
               diff_builder: nil)
  @plan         = plan
  @intended     = intended
  @pre_doc      = pre_doc
  @reread       = reread
  @target       = target
  @verifier     = verifier || Verifier.default
  @diff_builder = diff_builder
end

Instance Method Details

#run(commit: false, executor: nil, allow_partial: false, entries: nil) ⇒ Result

Run the full pass.

Parameters:

  • commit (Boolean) (defaults to: false) —

    false = dry-run (default). true = live apply.

  • executor (#execute_workflow_commands, nil) (defaults to: nil) —

    the mutation facade (live) or a RecordingExecutor (offline). Required for both commit AND for an offline drift check (the RecordingExecutor replays the batch to produce the post-deploy doc).

  • allow_partial (Boolean) (defaults to: false) —

    forwarded to the Applier / gem plan.

  • entries (Array, nil) (defaults to: nil) —

    register subset for the sync-readiness monitor (optional).

Returns:



115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/eco/api/usecases/graphql/samples/pages/template/deploy/loop.rb', line 115

def run(commit: false, executor: nil, allow_partial: false, entries: nil)
  applied = Applier.new(@plan, target: @target).apply(
    commit: commit, executor: executor, allow_partial: allow_partial
  )

  post_doc = applied.skipped_reason.nil? ? reread_post_doc : nil
  drift    = build_drift(post_doc)
  verdict  = post_doc ? @verifier.verify(post_doc) : nil
  monitor  = build_monitor(post_doc, entries)

  Result.new(applied: applied, drift: drift, verdict: verdict, sync_readiness: monitor)
end