Method ThreadMain

src/daemon/cloud_tunnel.cpp:796–912

}

void CloudTunnel::ThreadMain() {
    pthread_setname_np(pthread_self(), "cloud-tunnel");
    // Exponential backoff for reconnect attempts. Caps at 60s so a flaky
    // network or temporary cloud outage does not keep the journal at the
    // previous 1-attempt-per-second cadence (which on a host with broken
    // IPv6 + AF_UNSPEC produced ~30k log lines/day for nothing). Reset
    // only after the link has been *up* for kBackoffResetThreshold so a
    // pathological connect-then-immediately-disconnect loop still backs
    // off instead of hot-spinning at 1Hz.
    using Clock = std::chrono::steady_clock;
    constexpr auto kBackoffMin = std::chrono::seconds(1);
    constexpr auto kBackoffMax = std::chrono::seconds(60);
    constexpr auto kBackoffResetThreshold = std::chrono::seconds(30);
    auto backoff = kBackoffMin;
    auto bump_backoff = [&]() {
        backoff = std::min(backoff * 2, kBackoffMax);
    };
    // Sleep `delay` but wake early on shutdown so SIGTERM doesn't have
    // to wait out a full 60s slot during the backoff phase.
    auto interruptible_sleep = [this](std::chrono::seconds delay) {
        const auto deadline = Clock::now() + delay;
        while (running_ && Clock::now() < deadline) {
            const auto remaining = std::chrono::duration_cast<std::chrono::milliseconds>(
                deadline - Clock::now());
            const auto slice = std::min<std::chrono::milliseconds>(
                remaining, std::chrono::milliseconds(200));
            std::this_thread::sleep_for(slice);
        }
    };

    while (running_) {
        // Refresh the token snapshot at the top of each connect attempt so
        // a successful pair (which writes device.token mid-session) takes
        // effect on the very next reconnect without a daemon restart.
        {
            std::lock_guard<std::mutex> lock(pair_mu_);
            device_token_ = LoadDeviceToken(config_.data_dir);
            if (device_token_.empty()) {
                if (pair_code_.empty()) pair_code_ = GeneratePairCode();
            } else {
                pair_code_.clear();
            }
        }

        std::string error;
        if (!Connect(&error)) {
            std::cerr << "cloud tunnel connect failed: " << error
                      << " (retrying in " << backoff.count() << "s)\n";
            interruptible_sleep(backoff);
            bump_backoff();
            continue;
        }

        const auto connected_at = Clock::now();
        std::cerr << "cloud tunnel connected as " << host_id_ << "\n";
        SendJson(HelloPayload());
        // Once the WS upgrade succeeds and we know we still need pairing,
        // surface the URL so an operator running `curl ... | sh` sees it