Function EnqueueWork

src/common/cloud_work_queue.cpp:475–523

}

void EnqueueWork(WorkItem item) {
    {
        std::lock_guard<std::mutex> lock(g_queueMutex);
        g_failedPaths.erase(item.cloudPath);
        g_failedWorkItems.erase(item.cloudPath);

        if (item.type == WorkItem::Delete) {
            ClearRecentUploadForDeleteLocked(item.cloudPath);
        } else if (item.type == WorkItem::Upload) {
            uint64_t fingerprint = FingerprintUpload(item.data);
            auto now = std::chrono::steady_clock::now();
            PruneRecentUploadFingerprintsLocked(now);

            auto recentIt = g_recentUploadFingerprints.find(item.cloudPath);
            if (!HasDeleteBarrierForPathLocked(item.cloudPath) &&
                recentIt != g_recentUploadFingerprints.end() &&
                recentIt->second.first == fingerprint) {
                LOG("[CloudStorage] Dedup: dropping recent identical upload for %s",
                    item.cloudPath.c_str());
                return;
            }

            auto indexIt = g_uploadIndex.find(item.cloudPath);
            if (indexIt != g_uploadIndex.end()) {
                WorkItem existingCopy = *indexIt->second;
                g_workQueue.erase(indexIt->second);
                g_uploadIndex.erase(indexIt);
                
                if (item.skipIfExists && !existingCopy.skipIfExists) {
                    LOG("[CloudStorage] Dedup: keeping queued authoritative upload for %s",
                        item.cloudPath.c_str());
                    g_workQueue.push_back(std::move(existingCopy));
                    g_uploadIndex[g_workQueue.back().cloudPath] = std::prev(g_workQueue.end());
                    return;
                }
                LOG("[CloudStorage] Dedup: replacing queued upload for %s (%zu -> %zu bytes)",
                    item.cloudPath.c_str(), existingCopy.data.size(), item.data.size());
                // Fall through to push new item
            }
        }

        g_workQueue.push_back(std::move(item));
        auto it = std::prev(g_workQueue.end());
        if (it->type == WorkItem::Upload) {
            g_uploadIndex[it->cloudPath] = it;
        }
    }
    g_queueCV.notify_one();
}

static bool RequeueFromWorker(WorkItem item) {
    std::lock_guard<std::mutex> lock(g_queueMutex);