Hai bài trước có chung một giả định dễ chịu: làm lại một việc là miễn phí. Ở
bài về hàng đợi, một job lấy danh
sách file bị treo thì cứ đưa về PENDING và làm lại — đọc thêm một lần chẳng hại
gì. Dịch hai lần cũng ra cùng một đoạn văn.
Gửi đi thì khác. Tạo một GitHub Release hai lần, post vào Slack hai lần, hay gửi email cho một nghìn người hai lần đều không miễn phí. Và khi worker dừng giữa chừng một lời gọi, nó không thể biết provider đã làm hay chưa.
ADR-0020 ghi lại đúng câu hỏi đó trước khi ReleaseFlow có tính năng phân phối đầu tiên. Bài này, cũng là bài cuối của chuỗi, kể câu trả lời.
Một câu hỏi không ai trả lời được
Hình dung ReleaseFlow gửi note của một release vào Slack. Request đã đi, rồi kết nối đứt trước khi có phản hồi. Slack đã đăng tin nhắn chưa?
Có thể rồi, có thể chưa. Không ai biết — kể cả ReleaseFlow. Nếu ghi lần gửi đó là
FAILED rồi tự thử lại, kênh Slack có thể nhận hai tin nhắn. Nếu ghi là
SUCCEEDED, có thể không ai nhận được gì mà không ai hay.
Nên ReleaseFlow không chọn bên nào. "Không biết" được ghi đúng là "không biết":
/**
* How one delivery ended. {@code UNKNOWN} means the provider may have accepted it:
* nothing may repeat such an Action without a person saying so.
*/
record ActionResult(ExecutionStatus outcome, String externalReference, String errorCode) {
// ...
}
Một lần gửi kết thúc ở một trong sáu trạng thái: PENDING, RUNNING,
SUCCEEDED, FAILED, UNKNOWN và CANCELLED. UNKNOWN không phải một kiểu
lỗi. Nó là một trạng thái riêng, với một luật riêng: không gì được tự gửi lại nó.
FAILED hay UNKNOWN: ranh giới nằm ở đâu
Câu hỏi để phân loại rất đơn giản: provider có chắc chắn chưa làm gì không?
Đây là phần xử lý phản hồi trong SlackActionExecutor:
} catch (RestClientResponseException exception) {
int status = exception.getStatusCode().value();
if (exception.getStatusCode().is5xxServerError()) {
// Slack may have posted the message before it failed to answer.
log.warn("Slack answered HTTP {} for the note of release {}.", status, command.releaseId());
return ActionResult.unknown(ActionResult.OUTCOME_UNKNOWN);
}
log.warn("Slack refused the note of release {} with HTTP {}.", command.releaseId(), status);
return ActionResult.failed(REJECTED);
} catch (RestClientException exception) {
// Slack may have posted the message before the connection failed.
log.warn("Could not reach Slack with the note of release {}.", command.releaseId());
return ActionResult.unknown(ActionResult.OUTCOME_UNKNOWN);
}
-
4xx nghĩa là Slack đã đọc request và từ chối nó — URL sai, webhook đã bị thu hồi. Chắc chắn không có gì được đăng, nên đó là
FAILED. -
5xx nghĩa là phía Slack có sự cố, nhưng sự cố có thể xảy ra sau khi tin nhắn đã được đăng. Đó là
UNKNOWN. -
Kết nối đứt — timeout, mạng rớt — cũng là
UNKNOWN, vì request có thể đã tới nơi.
ReleaseFlow không tự follow redirect khi gửi. Một phản hồi redirect nghĩa là
note chưa đi đâu cả, nên nó là FAILED, không phải UNKNOWN.
Cùng một câu hỏi đó cho ra những ranh giới hơi khác nhau ở từng provider:
-
Với email, lỗi khi soạn thư là
FAILED— chưa có gì rời khỏi ReleaseFlow. Nhưng khi SMTP không xác nhận lần gửi thì làUNKNOWN, vì máy chủ có thể đã nhận thư cho một vài người nhận, hoặc tất cả. -
Zendesk cần hai lời gọi: lấy access token, rồi tạo bài viết. Lời gọi thứ nhất không bao giờ cho ra
UNKNOWN— chưa có gì được đăng, nên thử lại sau không thể tạo bản trùng. Lời gọi thứ hai thì có. Kể cả khi Zendesk trả 2xx mà phản hồi không nêu được bài viết nào, kết quả vẫn làUNKNOWN: không ai nói chắc được bài viết có tồn tại hay không.
Worker chết thì thành UNKNOWN, không thành PENDING
Hàng đợi gửi dùng đúng khuôn FOR UPDATE SKIP LOCKED của bài 2. Nhưng ở khâu
thu hồi job bị treo, nó làm điều ngược lại.
Ở bài 2, job lấy danh sách file treo quá mười phút thì quay về PENDING. Ở đây,
một lần gửi bị treo quá năm phút sẽ trở thành UNKNOWN:
/**
* Deliveries cannot be repeated safely, so an Action whose worker stopped is never
* released back to PENDING: it becomes UNKNOWN and waits for a person.
*/
@Query(value = """
SELECT id FROM automation_action_runs
WHERE status = 'RUNNING' AND claimed_at < :staleBefore
FOR UPDATE SKIP LOCKED
""", nativeQuery = true)
List<UUID> findStaleRunningIds(@Param("staleBefore") Instant staleBefore);
Worker gọi markUnknown cho từng lần gửi tìm được, và cập nhật lại trạng thái
của cả lượt chạy. Cùng một hàng đợi, cùng một cách nhận job, nhưng quyết định
ngược nhau — vì cái giá của việc làm lại khác nhau. Mình thấy đây là bài học lớn
nhất của cả chuỗi: không có chính sách retry nào đúng cho mọi việc. Phải hỏi
riêng từng việc: làm lại nó thì mất gì?
Thêm một luật nữa: các action trong một rule chạy theo thứ tự, và action đầu tiên
kết thúc ở FAILED hoặc UNKNOWN sẽ dừng mọi action phía sau nó. Không ai muốn
note được gửi tới Slack khi chưa rõ GitHub Release đã có hay chưa.
Chỉ người mới được quyết định gửi lại
Một lượt chạy FAILED có thể chạy lại thoải mái: chắc chắn chưa có gì được gửi.
Một lượt chạy UNKNOWN thì phải có người xác nhận rằng gửi hai lần là chấp nhận
được:
public AutomationRunView retry(UUID organizationId, UUID runId, boolean confirmUnknown) {
AutomationRun run = find(organizationId, runId);
if (run.getStatus() == ExecutionStatus.UNKNOWN && !confirmUnknown) {
throw AutomationConflictException.unknownNeedsConfirmation();
}
// ...
}
Thiếu xác nhận, API trả 409 automation_unknown_needs_confirmation. Trên giao
diện, nút Chạy lại đi kèm một ô bắt buộc tick: "Việc này có thể gửi hai lần".
Chạy lại chỉ đặt lại đúng action đầu tiên bị dừng, cùng những action phía sau đang chờ nó. Action đã thành công không bao giờ bị lặp lại.
Trước khi bấm, người vận hành có thể làm điều mà ReleaseFlow không làm được: mở kênh Slack hay Help Center ra xem tin nhắn hoặc bài viết đã có chưa.
Khi provider cho phép hỏi lại: GitHub Release
Với GitHub Release thì ReleaseFlow tự trả lời được câu hỏi "lần trước đã gửi chưa?", vì một release có thể được đọc lại theo tag. Mỗi lần gửi ghi một marker mang ID của chính nó vào cuối body:
private static String marker(UUID actionRunId) {
return "<!-- releaseflow-action:" + actionRunId + " -->";
}
Trước khi tạo, executor đọc release theo tag:
// A release this Action Run wrote is the delivery; anything else is somebody's work.
private static ActionResult reconcile(GitHubRelease release, String marker) {
String body = release.body() == null ? "" : release.body();
return body.contains(marker)
? ActionResult.succeeded(release.htmlUrl())
: ActionResult.failed(RELEASE_CONFLICT);
}
-
Chưa có release nào với tag đó: tạo mới, kèm marker.
-
Đã có, và body chứa marker của chính lần gửi này: đó là lần gửi trước, đã thành công. Kết quả là
SUCCEEDED, không tạo thêm gì. -
Đã có, nhưng là của người khác:
FAILEDvớigithub_release_conflict. ReleaseFlow không bao giờ ghi đè release do người khác tạo. -
Ai đó tạo đúng tag đó giữa lúc đọc và lúc tạo: đọc lại rồi xét như trên.
Lần chạy lại một action UNKNOWN của GitHub Release nhờ vậy an toàn: nếu lần
trước đã tới nơi, lần này chỉ nhận ra nó.
Không phải provider nào cũng cho làm vậy. Trang Confluence cũng mang một comment
HTML nêu tên lượt chạy đã viết ra nó, nhưng ReleaseFlow không đọc lại trang đó.
Nên một lần gửi tới Notion hay Confluence không được xác nhận vẫn là UNKNOWN
cho tới khi có người chấp nhận một trang thứ hai.
Phân phối không bao giờ chặn một release
Còn một chỗ dễ gửi trùng — hoặc tệ hơn — nằm ngay lúc publish. Bản cũ của dự án tạo các lượt chạy ngay trong transaction publish. Một rule trỏ tới một audience thiếu note là ném exception, và việc publish bị rollback theo. ADR-0020 viết: một release đã sẵn sàng publish không phải là chỗ để phát hiện ai đó gõ sai URL Slack.
ReleaseFlow bây giờ chỉ ghi đúng một dòng outbox khi publish:
@EventListener
void onReleasePublished(ReleasePublished event) {
if (jobRepository.existsByReleaseId(event.releaseId())) {
return;
}
jobRepository.save(new AutomationPublishJob(
UUID.randomUUID(),
event.organizationId(),
event.projectId(),
event.releaseId(),
clock.instant().truncatedTo(ChronoUnit.MICROS)
));
}
Listener này không tìm rule, không đọc note, không gọi gì ra ngoài. Sau khi
transaction commit, AutomationWorker mới biến dòng đó thành các lượt chạy. Một
rule không thực hiện được sẽ thành một action FAILED trong lịch sử, chẳng hạn
release_note_missing, chứ không phải một release không publish được.
Chống trùng ở phía vào
Gửi trùng không chỉ đến từ việc retry. Nó còn đến từ việc kích hoạt hai lần. Hai unique index trong migration V22 chặn chuyện đó:
-- A publication fires each matching Rule once, and a repeated manual request is the
-- same Run rather than a second delivery.
CREATE UNIQUE INDEX automation_runs_published_once
ON automation_runs (rule_id, release_id)
WHERE trigger_type = 'RELEASE_PUBLISHED';
CREATE UNIQUE INDEX automation_runs_request_once
ON automation_runs (rule_id, request_id)
WHERE request_id IS NOT NULL;
Mỗi rule chỉ chạy một lần cho một lần publish. Form chạy tay mang sẵn một
request ID, nên bấm nút hai lần hay trình duyệt gửi lại form đều trả về đúng
lượt chạy cũ. Hệ
thống khác gọi vào bằng webhook có chữ ký cũng vậy: header
X-ReleaseFlow-Delivery là một UUID được giữ nguyên khi retry, nên một webhook
được gửi lại không tạo ra lượt chạy thứ hai.
Đánh đổi, nói thẳng
-
UNKNOWNcần người xử lý. Một sự cố mạng có thể để lại vài lượt chạy chờ người vận hành mở ra, kiểm tra, rồi quyết định. Đó là việc thêm, và mình chấp nhận nó. -
Mình chọn "có thể thiếu một lần gửi, nhưng người sẽ biết", thay vì "có thể gửi hai lần mà không ai biết". Một release note bị thiếu thì gửi bù được. Một email đã tới một nghìn hộp thư hai lần thì không rút lại được.
-
Lịch sử chạy ít chi tiết. Lỗi chỉ được lưu bằng mã cố định, như
execution_outcome_unknownhaygithub_release_conflict, không bao giờ bằng message của provider hay của exception — để không có gì lạ lọt vào giao diện. Muốn biết thêm, chẳng hạn mã HTTP mà Slack trả về, người vận hành phải xem log của ứng dụng.
Khép lại chuỗi bài
Bốn bài, ba quyết định kỹ thuật, và nhìn lại thì chúng có chung một tinh thần:
-
Hàng đợi trên PostgreSQL — máy làm lại những gì làm lại được, và không bao giờ âm thầm bỏ qua một việc;
-
AI gợi ý, con người quyết định — máy soạn nháp, rule và con người giữ quyền quyết định;
-
và bài này — khi máy không chắc, nó nói là không chắc, và để người quyết.
Đó cũng chính là ý của bình luận Reddit ở bài đầu tiên: automation cho phần lặp lại, AI cho phần viết, còn con người review và quyết định.
Cảm ơn bạn đã đọc tới đây. Code của ReleaseFlow nằm trong
repo trên GitHub, tài liệu ở
trang docs, và các quyết định
trong bài này được ghi ở ADR-0020. Nếu bạn dùng thử và gặp một lần gửi UNKNOWN
— hoặc bất cứ vấn đề gì khác — hãy mở một
Discussion trên
GitHub.