Repository navigation
Issue priorities
How an item on the DittoFS project board gets its Priority. This page summarizes
#3121; if they ever differ,
docs/internals/priorities.md wins,
including its calibration table of real issues for borderline calls.
The rules are written so that a person, or an agent, can set a priority from the item's title, body, labels and board status alone. Where a rule would need judgement the text can't support, the rule gets tightened instead of being left to taste. They are tuned to where the project is now (one first use case, a lot of weight on the test suites) and will change as that changes.
Out of scope: sub-issues and issues labelled epic. They define the roadmap, so their priority is set by hand.
Draft items on the board are triaged like issues, but what they hold is not yet public (security findings above all), so their content is never copied into anything public: an issue, a comment, a commit or a PR.
| The item | What triage does |
|---|---|
has no Priority
|
sets one with the rules below |
| has one and isn't pinned | leaves it; if the rules place it elsewhere, proposes the change to a person, who decides |
| is pinned | leaves it alone and doesn't question it |
Pinning is the human override, for a priority decided for a reason the rules don't capture, or that must hold
even if the rules change. An item is pinned by the priority-pinned label, or by a line in its body starting
priority-pinned: followed by the reason (the only way for a draft, which can't carry labels).
Planned feature work (new functionality someone is building or has committed to, such as implementing a design RFC) can be placed by the rules like anything else, but the people doing the work agree its real priority and may ignore triage's.
Changing the rules doesn't rewrite the board: re-tiering is a proposal a person approves item by item.
Walk the tiers from P0 down and stop at the first match. Write one line saying which rule matched, so the next reader can disagree with the reasoning, not just the label. If nothing matches, leave it unset and ask.
-
What the issue describes decides, not how it's phrased. A
documentationlabel on "a new share inherits a deleted share's files" doesn't make it a docs issue. - "Not reproduced" doesn't lower a tier. A finding from reading the code with a concrete mechanism ranks as if reproduced; only a body showing it can't happen lowers it.
- Umbrella and audit issues (a list of findings, a tracker) take P2.
- Unsure between two tiers? Take the lower one. P0 must stay short or it stops meaning "drop everything".
P1 refers to it: Windows profile and Office containers on an SMB share backed by S3.
- Clients: Windows over SMB; any other SMB client counts too, a Linux CIFS mount included. No NFS.
- Identity: domain users from Active Directory, over Kerberos or NTLM, with domain SIDs in the files' ACLs.
- Files: one large virtual disk per user (10 to 30 GB or more), held open through one handle for a whole session.
- Writes: random, 4 KiB-aligned overwrites of data already uploaded; the file grows by writing past its end and shrinks by a truncate at sign-out.
- Scale: many users and many large files, so access control between users matters.
P0, critical (any one of):
- Data loss, corruption or unreadable data caused by what a client does (legitimate patterns, however unusual) or by a normal background process (sync, GC, eviction, compaction, restart, recovery).
- A crash, panic, deadlock, hang, an operation that fails for good, resource growth that exhausts disk or memory within days, or an outage that needs an operator to recover.
- A blocked shared gate: CI on
develop, the release build or the nightly suite can't run, passes without testing anything, or is flaky (a test passing less than 90% of the time on unchanged code). - Security reachable from the network without credentials: unauthenticated access, an authentication bypass, a privilege escalation, over any protocol.
- Denial of service without credentials, including handshakes left half-done that leave state behind.
- Denial of service by an ordinary workload: a normal user stops the service for everyone else (typically writes that outrun backpressure). Slowing down only the user or file causing the load is backpressure working, not this.
- A test with the wrong verdict, every time: it passes while the behavior is broken, or fails while it works.
P1, high (any one of):
- Anything that affects the first use case.
- Data loss with an unusual trigger: an admin action the system should have refused, or file content built to collide with an internal format.
- A silent durability failure: uploads stop and nothing reports it, though nothing is lost yet.
- Storage leaks on the remote: objects never reclaimed.
- A documented install path, or the first start, fails.
- A breaking configuration change between releases (key, variable, flag or default renamed, removed or changed).
- A regression from the previous release.
- Security that needs an authenticated client: reaching another user's data or state.
- Denial of service that needs an authenticated client sending crafted or hostile requests.
- A missing, skipped or broken test of what the first use case exercises.
- Non-conformance with POSIX, whichever protocol found it.
P2, medium:
- Wrong, missing or outdated docs under
docs/, design RFCs included (install docs that don't work are P1). - Non-conformance with a protocol spec or a design RFC that no P0 or P1 rule covers.
- Bugs and gaps that can only reach NFS clients (a wrong POSIX result found through NFS is P1).
- Security that needs more than a client (someone who can already read the bucket or log in to the host), and hardening with no known exploit.
- Test and CI gaps outside the first use case that don't block a gate.
- Investigations and spikes.
P3, low:
- Low impact: a wrong error code or message with no consequence, a race with no observable effect, cosmetic output.
- Feature requests nobody has planned.
- Test hygiene and refactors with no coverage at stake.