Worker.hpp

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <array>
#include <atomic>
#include <mutex>
#include <queue>
 
// Project includes
#include "sinks/Sink.hpp"
#include <dfx-core/Node.hpp>
#include <dfx-core/messages/Message.hpp>
#include <dfx-fdwatch/PollerFd.hpp>
#include <dfx-fdwatch/EPollPoller.hpp>
#include <dfx-fdwatch/Timer.hpp>
#include <dfx-utilities/UUIDGenerator.hpp>
 
namespace dfx::Pcapng
{
class Worker
{
public:
    enum SinkIndex : std::size_t
    {
        File, 
        Pipe, 
        Tcp,  
 
        Count 
    };
 
public:
    struct SinkData
    {
        SinkPtr sink;

        std::atomic_bool isNew{false};
    };

    struct QueueData
    {
        Core::MessagePtr message;
        Utils::UUID      uuid{};

        std::string      nodeName;
        Core::Node::Id   nodeId = 0;

        std::string      portName;
        Core::Port::Id   portId = 0;
        Core::Port::Mode portMode;

        uint32_t counter = 1;
        uint8_t timeoutCounter = 10; // Multiple of 100 ms
    };
 
public:
    explicit Worker(bool getHwAndOsInfo);

    ~Worker();

    void setFileSink(SinkPtr fileSink);

    void setPipeSink(SinkPtr pipeSink);

    void setTcpSink(SinkPtr tcpSink);

    void pushData(QueueData data);

    void exec(std::stop_token stopToken);
 
public:
    void setUserAppInfo(std::string info);

    void clearHwAndOsInfo() noexcept;
 
private:
    void _onCleanupTimerTimeout();
    void _onQueueDataReady();
    void _handleNewSink(SinkPtr & sink);
 
    void _sinkWriteData(std::vector<uint8_t> const & data);
 
private:
    // Destroy the poller last
    FdWatch::EPollPoller _poller;
 
    std::queue<QueueData> _queue;
    std::mutex _mutexQueue;
 
    std::array<SinkData, SinkIndex::Count> _sinkDatas;
    std::mutex _mutexSink;
 
    std::string _userAppInfo;
    std::string _hardwareInfo;
    std::string _osInfo;
 
private:
    std::unordered_map<Utils::UUID, QueueData> _pendingData;
 
private:
    FdWatch::PollerFd _eventfd;
    FdWatch::Timer _cleanupTimer;
};
} // !namespace dfx::Pcapng