lukasandClaude Opus 5.5
609e7c58f9
Sending: a send the server could not take (unreachable, timeout, 4xx) is no
longer failed at once. It waits in Scheduled ("retrying") and is tried again
after 1, 2, 5, 10, 30 min, then hourly, for 24 hours — on the server, so it
works with the browser closed. A permanent refusal (5xx, wrong password) is
"failed" at once, with the server's reason. GET /outbox lists both;
POST /outbox/{id}/retry (Retry now) and /cancel (Edit, Delete) act on them,
and they are left out of Drafts. Mail delivered but not filed in Sent now
counts as sent, and a conditional claim keeps two jobs from sending one
message twice. The app says when a send failed and when it finally went.
Actions: arq retries a job only on Retry, never on a plain exception, so the
"retry x5, then revert" for flags and moves never happened. Flag, move,
archive, restore, delete and empty-folder jobs now raise Retry while the
server is unreachable (~24 hours of growing gaps), skip a change a later one
replaced, stop at the first connection failure instead of 20 s per message,
and delete/empty keep the rows until the server has the messages gone.
Account health: 3 failed connections in a row mark an account unreachable
(amber in the sidebar and Settings, cleared on the next success); 3 refused
sign-ins stop its syncing as auth_failed until the password is entered
again, so the provider does not lock the account. Sync loops back off 30 s
doubling to 10 min and log one line per expected failure; a refused
connection fails at once with its reason (the connect task is kept), and a
silently dead IDLE connection is noticed within ~11 min instead of ~29.
Also: the empty reading pane is clipped to its width when dragged very
narrow; tests no longer leave live accounts and outbox rows in the database.
Migration 0021: outbox attempts / next_attempt_at / retry_until, accounts
sync_error / sync_error_since.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
110 lines
3.8 KiB
Python
110 lines
3.8 KiB
Python
"""Draft persistence and the send/undo flow (SPEC §6.5)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import uuid
|
|
from datetime import UTC, datetime, timedelta
|
|
|
|
from sqlalchemy import ColumnElement, exists, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.config import get_settings
|
|
from app.models import Account, Draft, Mailbox, Message, Outbox
|
|
from app.outbox.schemas import DraftIn
|
|
|
|
|
|
class DraftError(Exception):
|
|
"""Draft could not be created/updated (e.g. account not owned)."""
|
|
|
|
|
|
async def delete_mirrored_draft_row(
|
|
session: AsyncSession, *, account_id: uuid.UUID, imap_uid: int
|
|
) -> None:
|
|
"""Delete the DB row for a draft that was mirrored into the IMAP Drafts folder.
|
|
|
|
The server copy is expunged separately (send_job / remove_imap_draft_job).
|
|
Without also dropping this row the draft resurfaces in ``list_remote_drafts``
|
|
as an "other client" draft once its local ``drafts`` row is gone — until the
|
|
next Drafts poll would catch the expunge. Used on both send and discard.
|
|
"""
|
|
mirror = await session.scalar(
|
|
select(Message)
|
|
.join(Mailbox, Mailbox.id == Message.mailbox_id)
|
|
.where(
|
|
Message.account_id == account_id,
|
|
Message.uid == imap_uid,
|
|
Mailbox.special_use == "drafts",
|
|
)
|
|
)
|
|
if mirror is not None:
|
|
await session.delete(mirror)
|
|
|
|
|
|
async def upsert_draft(
|
|
session: AsyncSession, *, user_id: uuid.UUID, body: DraftIn, draft_id: uuid.UUID | None
|
|
) -> Draft:
|
|
"""Create or update a draft owned by ``user_id``."""
|
|
account = await session.scalar(
|
|
select(Account).where(Account.id == body.account_id, Account.user_id == user_id)
|
|
)
|
|
if account is None:
|
|
raise DraftError("account not found")
|
|
|
|
payload = body.payload.model_dump(mode="json")
|
|
if draft_id is None:
|
|
draft = Draft(
|
|
user_id=user_id,
|
|
account_id=body.account_id,
|
|
thread_id=body.thread_id,
|
|
reply_to_message_id=body.reply_to_message_id,
|
|
kind=body.kind,
|
|
payload=payload,
|
|
)
|
|
session.add(draft)
|
|
else:
|
|
fetched = await session.scalar(
|
|
select(Draft).where(Draft.id == draft_id, Draft.user_id == user_id)
|
|
)
|
|
if fetched is None:
|
|
raise DraftError("draft not found")
|
|
draft = fetched
|
|
draft.account_id = body.account_id
|
|
draft.thread_id = body.thread_id
|
|
draft.reply_to_message_id = body.reply_to_message_id
|
|
draft.kind = body.kind
|
|
draft.payload = payload
|
|
draft.updated_at = datetime.now(UTC)
|
|
await session.flush()
|
|
return draft
|
|
|
|
|
|
# A draft with one of these sends is in flight — or waiting in Scheduled for a
|
|
# retry — so it is not listed (or counted) in Drafts.
|
|
OUTBOX_ACTIVE = ("undo_window", "sending", "retrying", "failed")
|
|
|
|
|
|
def not_being_sent() -> ColumnElement[bool]:
|
|
"""SQL condition: this Draft row has no send in flight or waiting."""
|
|
return ~exists().where(Outbox.draft_id == Draft.id, Outbox.state.in_(OUTBOX_ACTIVE))
|
|
|
|
|
|
async def create_outbox(session: AsyncSession, *, user_id: uuid.UUID, draft: Draft) -> Outbox:
|
|
"""Create an outbox row in the undo window for a draft."""
|
|
send_after = datetime.now(UTC) + timedelta(seconds=get_settings().undo_seconds)
|
|
outbox = Outbox(user_id=user_id, draft_id=draft.id, state="undo_window", send_after=send_after)
|
|
session.add(outbox)
|
|
await session.flush()
|
|
return outbox
|
|
|
|
|
|
async def cancel_outbox(session: AsyncSession, *, user_id: uuid.UUID, outbox_id: uuid.UUID) -> bool:
|
|
"""Cancel a send if still in the undo window. Returns False if too late/unknown."""
|
|
outbox = await session.scalar(
|
|
select(Outbox).where(Outbox.id == outbox_id, Outbox.user_id == user_id)
|
|
)
|
|
if outbox is None or outbox.state != "undo_window":
|
|
return False
|
|
outbox.state = "cancelled"
|
|
await session.flush()
|
|
return True
|