git_repo_mixin.h

Go to the documentation of this file.

// 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 GIT_REPO_MIXIN_H
#define GIT_REPO_MIXIN_H
 
#include "kicad_git_common.h"
#include "kicad_git_errors.h"
#include "kigit_failure.h"
#include "git_progress.h"
#include <import_export.h>
 
class APIEXPORT KIGIT_REPO_MIXIN: public KIGIT_ERRORS, public GIT_PROGRESS
{
public:
    KIGIT_REPO_MIXIN( KIGIT_COMMON* aCommon ) :
            m_common( aCommon ),
            m_cancelToken( KIGIT_COMMON::NewCancelToken() )
    {
        // Ensure m_common is initialized
        wxASSERT( aCommon != nullptr );
    }
 
    virtual ~KIGIT_REPO_MIXIN()
    {
        // Non-owning, don't delete
    }

    std::vector<wxString> GetProjectDirs()
    {
        return m_common->GetProjectDirs();
    }

    git_repository* GetRepo() const
    {
        return m_common->GetRepo();
    }

 
    KIGIT_COMMON* GetCommon() const
    {
        return m_common;
    }

    void ResetNextKey() { m_common->ResetNextKey(); }

    wxString GetNextPublicKey()
    {
        return m_common->GetNextPublicKey();
    }

    KIGIT_COMMON::GIT_CONN_TYPE GetConnType() const
    {
        return m_common->GetConnType();
    }

    wxString GetUsername() const
    {
        return m_common->GetUsername();
    }

    void SetUsername( const wxString& aUsername )
    {
        m_common->SetUsername( aUsername );
    }

    void SetPassword( const wxString& aPassword )
    {
        m_common->SetPassword( aPassword );
    }

    void SetSSHKey( const wxString& aSSHKey )
    {
        m_common->SetSSHKey( aSSHKey );
    }

    wxString GetRemotename() const
    {
        return m_common->GetRemotename();
    }

    wxString GetProjectDir() const
    {
        return m_common->GetProjectDir();
    }

    std::atomic<unsigned>& TestedTypes() { return m_common->TestedTypes(); }
 
    void UpdateProgress( int aCurrent, int aTotal, const wxString& aMessage ) override
    {
        // The transfer callbacks poll this token and abort on their next tick.
        if( !ReportProgress( aCurrent, aTotal, aMessage ) )
            CancelThisOperation();
    }

    void SetCancelToken( const KIGIT_COMMON::CANCEL_TOKEN& aToken )
    {
        if( aToken )
            m_cancelToken = aToken;
    }
 
    const KIGIT_COMMON::CANCEL_TOKEN& CancelToken() const { return m_cancelToken; }

    void SetWaitForActionLock( bool aWait ) { m_waitForActionLock = aWait; }

    void SetActionLockWait( std::chrono::milliseconds aWait ) { m_actionLockWait = aWait; }
 
    std::unique_lock<std::mutex> GetActionLock() const
    {
        if( m_waitForActionLock )
            return m_common->LockAction();
 
        if( m_actionLockWait.count() > 0 )
            return m_common->TryLockActionFor( m_actionLockWait );
 
        return m_common->TryLockAction();
    }

    std::optional<KIGIT::HOST_KEY_FAILURE> GetHostKeyFailure() const { return m_hostKeyFailure; }
    void SetHostKeyFailure( const KIGIT::HOST_KEY_FAILURE& aFailure ) { m_hostKeyFailure = aFailure; }
    void ClearHostKeyFailure() { m_hostKeyFailure.reset(); }
 
    void            SetHostKeyRefusal( const wxString& aReason ) { m_hostKeyRefusal = aReason; }

    void ResetTransferState()
    {
        TestedTypes() = 0;
        ResetNextKey();
        ClearHostKeyFailure();
        m_hostKeyRefusal.clear();
        m_authAttempt = KIGIT_AUTH_ATTEMPT();
        m_serverMessage.clear();
        m_pendingSideband.clear();
        m_skippingServerLine = false;
        m_pushRefusal.clear();
        m_authFailed = false;
        m_failureKind.reset();
    }
 
    KIGIT_AUTH_ATTEMPT&       AuthAttempt() { return m_authAttempt; }

    bool WasAuthFailure() const { return m_authFailed; }
    void SetAuthFailure() { m_authFailed = true; }

    void ReceiveSideband( const char* aData, size_t aLength );
 
    void            SetPushRefusal( const wxString& aStatus );

    KIGIT_FAILURE_REPORT ReportTransferFailure( const KIGIT_ERROR_INFO& aError, KIGIT_OPERATION aOperation,
                                                const wxString& aRemoteName );

    std::optional<KIGIT_FAILURE> GetFailureKind() const { return m_failureKind; }
 
    bool IsThisOperationCancelled() const { return m_cancelToken->load(); }
 
    void CancelThisOperation() { m_cancelToken->store( true ); }
 
 
private:
    void addServerLine( const wxString& aLine );
 
    KIGIT_COMMON*              m_common;
    KIGIT_COMMON::CANCEL_TOKEN m_cancelToken;
    bool                       m_waitForActionLock = false;
    std::chrono::milliseconds  m_actionLockWait{ 0 };
 
    std::optional<KIGIT::HOST_KEY_FAILURE> m_hostKeyFailure;
    wxString                               m_hostKeyRefusal;
    KIGIT_AUTH_ATTEMPT                     m_authAttempt;
    bool                                   m_authFailed = false;
    wxString                               m_serverMessage;
    std::string                            m_pendingSideband;
    bool                                   m_skippingServerLine = false;
    wxString                               m_pushRefusal;
    std::optional<KIGIT_FAILURE>           m_failureKind;
};
 
 
#endif // GIT_REPO_MIXIN_H