Luce packages
LuceLuce BaseLuciaOS

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