dymokomi/luced-message
Source of release 0.5.0
0.5.0 / src / mail_sync / folders.lucb
#==============================================================================================
#
# mail_sync/folders - Listing and syncing folders, fetching bodies
#
#==============================================================================================
extend Engine:
# mark: syncing ==============================================================================
## List the folders and bring every one up to date.
func sync_all() -> !:
self.wants_full_sync = false
self.last_full_sync = time.now()
self.post("status", b"Checking for mail")
try self.list_folders()
for at in 0..<self.folders.length():
if self.room.stopped():
return
try self.sync_folder(at)
# A command the window is waiting on goes before the remaining folders.
var command: Buffer
defer command.destroy()
while try self.room.take(&command):
try self.handle(command.view())
try self.save_folders()
self.post("folders")
self.post("status", b"")
## Learn the folders, INBOX first, and store the list.
func list_folders() -> !:
let mailboxes = try self.session.list()
self.folders.clear()
self.folder_text.destroy()
var key: Buffer
defer key.destroy()
# INBOX first: it is what the user looks at.
for pass in 0..<2:
for mailbox in mailboxes:
let inbox = imap.same(mailbox.path, b"INBOX")
if (pass == 0) != inbox or mailbox.is(imap.MailboxFlags.no_select):
continue
key.clear()
try put_key(mailbox.path, &key)
try self.folders.append(Folder(path = try self.folder_text.keep_text(mailbox.path), name = try self.folder_text.keep_text(mailbox.name.bytes),
delimiter = mailbox.delimiter, flags = (u32)mailbox.flags, key = try self.folder_text.keep_text(key.view())))
try self.save_folders()
self.post("folders")
## Store the folder list in the account's identity, dropping folders that are gone.
func save_folders() -> !:
var batch = try mail_db.Batch.begin(self.store, self.account.id)
defer batch.close()
var kept: TextPool
defer kept.destroy()
var paths: List[str]
defer paths.destroy()
var element: Buffer
defer element.destroy()
for order in 0..<self.folders.length():
let folder = self.folders.at(order)
try batch.put_folder(&folder, order)
element.clear()
try element.put(b"/f")
try element.put_text(folder.key)
try paths.append(try kept.keep_text(element.view()))
try batch.remove_others(paths.view())
try batch.commit()
## Bring folder number `at` up to date.
func sync_folder(at: usize) -> !:
let folder = self.folders.at(at)
let path = folder.path.bytes
var identity: Buffer
defer identity.destroy()
try mail_db.folder_identity(self.account.id, folder.key.bytes, &identity)
var ledger = try mail_db.read_ledger(self.store, identity.text())
defer ledger.close()
let state = try self.select(path)
var batch = try mail_db.Batch.begin(self.store, identity.text())
defer batch.close()
var changed = false
if ledger.uid_validity != state.uid_validity or (state.exists == 0 and ledger.uids.length() > 0):
# A new UIDVALIDITY makes every held UID stale; an empty folder holds nothing.
for uid in ledger.uids.view():
try batch.remove(uid)
ledger.clear()
elif ledger.uids.length() > 0:
# Flags of the messages held, and which are gone.
try self.refresh_flags(&ledger, &batch)
# New messages: their headers, newest batches first.
if state.exists > 0 and (state.uid_next == 0 or state.uid_next > ledger.last_uid() + 1):
changed = try self.fetch_new(path, &ledger, &batch) or changed
if ledger.uid_validity != state.uid_validity or ledger.uid_next != state.uid_next:
ledger.uid_validity = state.uid_validity
ledger.uid_next = state.uid_next
try batch.put_state(state.uid_validity, state.uid_next, ledger.modseq)
if imap.same(path, b"INBOX"):
try self.prefetch(path, &ledger, &batch)
changed = batch.count > 0 or changed
try batch.commit()
if changed:
try mail_db.bake(self.store, identity.text())
self.post("folder", path)
var updated = folder
updated.total = (u32)ledger.uids.length()
updated.unseen = ledger.unseen()
self.folders.set(at, updated)
## Update every held message's flags and drop the ones the server no longer has.
func refresh_flags(ledger: mail_db.Ledger*, batch: mail_db.Batch*) -> !:
var set: Buffer
defer set.destroy()
try set.put(b"1:")
try set.put_number((i64)ledger.last_uid())
let records = try self.session.fetch(set.text(), "(UID FLAGS)")
var seen: List[bool]
defer seen.destroy()
while seen.length() < ledger.uids.length():
try seen.append(false)
for record in records:
if let at = ledger.find(record.uid):
seen.set(at, true)
if record.has_flags and ledger.flags.at(at) != (u16)record.flags:
ledger.flags.set(at, (u16)record.flags)
try batch.set_flags(record.uid, (u16)record.flags)
var at = ledger.uids.length()
while at > 0:
at -= 1
if not seen.at(at):
try batch.remove(ledger.uids.at(at))
ledger.uids.remove(at)
ledger.flags.remove(at)
## Fetch the headers of messages newer than the folder holds, committing each batch
## so the window shows them as they come. Whether any arrived.
func fetch_new(path: const u8[], ledger: mail_db.Ledger*, batch: mail_db.Batch*) -> bool!:
var criteria: Buffer
defer criteria.destroy()
try criteria.put(b"UID ")
try criteria.put_number((i64)ledger.last_uid() + 1)
try criteria.put(b":*")
let found = try self.session.search(criteria.text())
var uids: List[u32]
defer uids.destroy()
for uid in found:
if uid > ledger.last_uid():
try uids.append(uid)
var end = uids.length()
let any = end > 0
while end > 0:
let start = end - batch_size if end > batch_size else 0
var set: Buffer
defer set.destroy()
try imap.write_set(uids.view()[start..<end], &set)
let records = try self.session.fetch_headers((str)set.view(), summary_fields)
var text: TextPool
defer text.destroy()
for record in records:
let row = try summarize(&record, &text)
try batch.put_row(&row)
try ledger.put(row.uid, row.flags)
try batch.flush()
self.post("folder", path)
end = start
if self.room.has_command() or self.room.stopped():
# The rest arrives on the next sync; the window's command goes first.
self.wants_full_sync = true
return any
return any
## Fetch INBOX's newest bodies that are not in the store yet.
func prefetch(path: const u8[], ledger: mail_db.Ledger*, batch: mail_db.Batch*) -> !:
var fetched: usize = 0
var at = ledger.uids.length()
while at > 0 and fetched < prefetch_count:
at -= 1
if self.room.has_command() or self.room.stopped():
break
if ledger.bodies.at(at):
continue
let uid = ledger.uids.at(at)
if try self.store_body(uid, batch):
ledger.bodies.set(at, true)
# Each body is its own commit: bodies are large, and a frame holds
# references, not payloads, but a commit stays one message's worth.
try batch.flush()
fetched += 1
## Fetch message `uid` of the selected folder into the store, with the preview and
## attachment mark its row shows. Whether the server had it.
func store_body(uid: u32, batch: mail_db.Batch*) -> bool!:
let data = try self.session.fetch_message(uid)
if data.length == 0:
return false
try batch.set_raw(uid, data)
var message = try mime.Message.read(data)
defer message.close()
try batch.set_body_summary(uid, try message.preview(), try message.attachment_count() > 0)
return true
## Fetch message `uid` of folder `path` for the window, which waits for it.
func fetch_body(path: const u8[], uid: u32) -> !:
var identity: Buffer
defer identity.destroy()
try self.folder_identity_of(path, &identity)
if not try mail_db.has_body(self.store, identity.text(), uid):
_ = try self.select(path)
var batch = try mail_db.Batch.begin(self.store, identity.text())
defer batch.close()
_ = try self.store_body(uid, &batch)
let changed = batch.count > 0
try batch.commit()
if changed:
self.post("folder", path)
var number: Buffer
defer number.destroy()
try number.put_number((i64)uid)
self.post("body", path, number.view())
## The row a message list needs from a fetched header, its text kept in `text`.
func summarize(record: const imap.Fetched*, text: TextPool*) -> Row!:
var message = try mime.Message.read(record.header)
defer message.close()
let sender = try message.address_line("From", short = true)
let date = message.date_seconds()
return Row(uid = record.uid, flags = (u16)record.flags, date = date if date != 0 else record.internal_date,
size = (u32)record.size, attachment = try message.part_type(0) == "multipart/mixed",
sender = try text.keep_text(sender.bytes), subject = try text.keep_text((try message.subject()).bytes),
message_id = try text.keep_text((try message.message_id()).bytes),
in_reply_to = try text.keep_text((try message.in_reply_to()).bytes), preview = "")
## The UIDs of sequence set `text` (`4:7,9`) onto `out`.
func read_set(text: const u8[], out: List[u32]*) -> !:
var index: usize = 0
while index < text.length:
var first: u32 = 0
while index < text.length and text[index] >= '0' and text[index] <= '9':
first = first * 10 + (u32)(text[index] - '0')
index += 1
var last = first
if index < text.length and text[index] == ':':
index += 1
last = 0
while index < text.length and text[index] >= '0' and text[index] <= '9':
last = last * 10 + (u32)(text[index] - '0')
index += 1
var value = first
while value <= last and value - first < 100000:
try out.append(value)
value += 1
index += 1