db_worker_thread.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef KICAD_DB_WORKER_THREAD_H
#define KICAD_DB_WORKER_THREAD_H
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <thread>
#include <vector>
 
#include <database/database_backend.h>
 
struct DB_WORKER_CORE;
struct DB_WORKER_STATE;
 

class DB_JOB_CONTEXT
{
public:
    static constexpr size_t BATCH_ROWS = 512;
    static constexpr size_t MAX_QUEUED_BATCHES = 4;

    bool Emit( std::vector<DB_VALUE>&& aRow );

    bool Flush();

    bool Cancelled() const;
 
private:
    friend struct DB_WORKER_CORE;
 
    explicit DB_JOB_CONTEXT( DB_WORKER_CORE& aCore ) : m_core( aCore ) {}
 
    bool pushBatch();
 
    DB_WORKER_CORE&                    m_core;
    std::vector<std::vector<DB_VALUE>> m_pending;
};
 

class DB_WORKER_THREAD
{
public:
    static constexpr size_t MAX_ABANDONED = 2;

    DB_WORKER_THREAD( std::string aSourceKey, std::function<bool()> aThreadInit = nullptr,
                      std::function<void()> aThreadExit = nullptr, bool aPumpMessages = false,
                      std::function<void()> aOnAbandon = nullptr );

    ~DB_WORKER_THREAD();

    enum class OUTCOME
    {
        OK,
        TIMED_OUT,   
        TOO_LATE,    
        REFUSED,     
        UNAVAILABLE  
    };
 
    DB_WORKER_THREAD( const DB_WORKER_THREAD& ) = delete;
    DB_WORKER_THREAD& operator=( const DB_WORKER_THREAD& ) = delete;

    template <typename R>
    std::optional<R> Run( std::function<R( DB_JOB_CONTEXT& )> aJob, std::chrono::milliseconds aBound,
                          const DB_ROW_SINK* aSink )
    {
        auto result = std::make_shared<std::optional<R>>();
 
        auto wrapped = [job = std::move( aJob ), result]( DB_JOB_CONTEXT& aContext )
                       {
                           *result = job( aContext );
                       };
 
        if( !runJob( std::move( wrapped ), aBound, aSink, false ) )
            return std::nullopt;
 
        return std::move( *result );
    }

    bool RunCleanup( std::function<void()> aCleanup, std::chrono::milliseconds aBound );

    bool IsHealthy() const;

    bool HasLiveThread() const;
 
    OUTCOME LastOutcome() const { return *m_outcome; }

    static bool OnWorkerThread();

    void SetShutdownBound( std::chrono::milliseconds aBound ) { m_shutdownBound = aBound; }

    static std::string SourceKeyFor( const std::string& aPath );

    static std::string SourceKeyFor( const std::string& aPath, bool aWindowsPath );

    static std::string NormalizePath( const std::string& aPath, bool aWindowsPath );

    static std::chrono::milliseconds CallerBound( int aTimeoutSeconds );
 
private:
    bool runJob( std::function<void( DB_JOB_CONTEXT& )> aJob, std::chrono::milliseconds aBound,
                 const DB_ROW_SINK* aSink, bool aCleanup );
 
    std::string m_key;
    bool        m_pumpMessages;
 
    std::chrono::milliseconds m_shutdownBound{ std::chrono::seconds( 30 ) };
    std::shared_ptr<OUTCOME>  m_outcome = std::make_shared<OUTCOME>( OUTCOME::OK );
 
    // Everything a caller still waiting in admission touches lives here, so destroying the worker cannot free it
    std::shared_ptr<DB_WORKER_STATE> m_state;
};
 
#endif // KICAD_DB_WORKER_THREAD_H