git_policy_cli/landing/mod.rs
1//! What:
2//! What the commit service does to land a commit:
3//! the serialized step,
4//! the index lock hold,
5//! preparation,
6//! replay and after-commit work.
7//! Why:
8//! The landing is the service's core and changes together.
9//!
10//! In TS you'd write (pseudocode):
11//! ```ts
12//! // landing/index.ts: one `export * from './file'` per module below.
13//! ```
14
15/// The landing location a forwarded index writer coordinates with:
16/// the real index and the registry.
17pub mod landing_location;
18
19/// Automatic maintenance decision: config record parsing and the enable and detach rules.
20pub mod maintenance_decision;
21
22/// Running automatic maintenance after a landing: the config read, then `git maintenance run --auto`.
23pub mod maintenance_run;
24
25/// The durable work-item record for asynchronous work (review, push, maintenance) left for a resident consumer.
26pub mod work_item;
27
28pub mod work_item_recovery;
29
30/// The clocks a claim's lease is judged by.
31pub mod claim_time;
32
33/// The repositories the service looks at again when a claim another instance holds may have run out.
34pub mod service_retry;
35
36/// What the user is told when the commit service cannot land a commit.
37pub mod service_messages;
38
39/// The commit service's serialized step.
40pub mod service_land;
41
42/// What the commit service's landing does once the branch has moved: index entries and conclusion state.
43pub mod service_land_copy;
44
45pub mod service_land_follow;
46
47pub mod service_land_start;
48
49/// The commit service's hold on Git's index lock across a landing.
50pub mod service_index_lock;
51
52/// The attempts and the wait of an acquisition of the index lock.
53pub mod service_index_attempts;
54
55/// The marker the service writes into the index lock and the questions asked of a marker.
56pub mod service_index_marker;
57
58/// The marker of the next batch's index lock, made and flushed while the service is idle.
59pub mod service_index_prestage;
60
61/// What an acquisition of the index lock found when it had to wait, for the service's log.
62pub mod service_index_found;
63
64/// Who a marker's holder is: the identity a process writes, and the answers a reader gives (gone, running, unknown).
65pub mod service_index_identity;
66
67/// The service's hold on a placed index lock: the check that it is still the holder's, the release and the removal.
68pub mod service_index_hold;
69
70/// Whether the index lock is still the file the holder placed, and the record of a lock that could not be settled.
71pub mod service_index_ownership;
72
73/// The staging files of the index lock.
74pub mod service_index_staging;
75
76/// How the service's marked file becomes the index lock, and the cleanup of staging files.
77pub mod service_index_placement;
78
79/// The inotify watch the wait for the index lock blocks on.
80pub mod service_index_watch;
81
82/// The preparation of a commit that the service lands, for every command line.
83pub mod service_prepare;
84
85/// Which commit command lines the commit service covers, and the message they stand for.
86pub mod service_commit_args;
87
88/// The one summary line a landed commit prints, with the abbreviated name Git would print.
89pub mod landed_summary;
90
91/// The wait of a wrapped index writer for the commit service's own hold on the index.
92pub mod service_index_wait;
93
94/// A forwarded index writer started again when the commit service took the index before its Git did.
95pub mod service_hold_retry;
96
97/// The commit command's path through the commit service.
98pub mod service_commit;
99
100/// The service's memory of when the bytes of the commits it landed were captured, per worktree.
101pub mod service_captures;
102
103/// The retry of a commit the service sent back: the captured change merged onto the branch, never prepared again from the worktree.
104pub mod service_replay;
105
106/// Which way a commit goes: through the service, set up first, or the earlier path.
107pub mod service_route;
108
109/// The message and identities of a service commit, made as native `git commit` makes them.
110pub mod service_message;
111
112/// What an amend takes from the commit it replaces: parents, message and author.
113pub mod service_amend;
114
115/// The commits real Git builds for the service: an editor, a signature, and what the service does not embed.
116pub mod service_native;
117
118/// The renewal that keeps the claims of a shared work directory from looking abandoned while their holder works.
119pub mod service_claim_renewal;
120
121/// The service's consumer of after-commit push and upkeep work.
122pub mod service_work;
123
124/// The drain of several repositories of one round, side by side and without a lock.
125pub mod service_round;
126
127/// The wrapper's side of after-commit work: records and the wake.
128pub mod service_handoff;
129
130/// Whether a worktree's head still names the branch a commit was prepared on.
131pub mod service_head;
132
133/// What a commit Git built adds to the branch, answered from the object store without starting Git.
134pub mod service_built_checks;
135
136/// How a commit headed for the service notices that its prepared content was removed before it landed.
137pub mod service_pruned;
138
139/// Where the landing's own syncs wait: queued for a background thread when the landing publishes, made before return otherwise.
140pub mod service_durable;
141
142pub mod service_land_finish;
143
144/// The removal of a stale index lock, by a rename and a second look.
145pub mod service_index_reclaim;
146
147/// The claim chain that keeps two reclaimers apart where the file system gives no `flock`.
148pub mod service_index_claim;
149
150/// Whether a new index file holds the live index's bytes.
151pub mod service_index_same;