Client.h

Go to the documentation of this file.

/*
    This file is part of cpp-ethereum.

    cpp-ethereum 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.

    cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once

#include "Block.h"
#include "BlockChain.h"
#include "BlockChainImporter.h"
#include "ClientBase.h"
#include "CommonNet.h"
#include "StateImporter.h"
#include "WarpCapability.h"
#include <libdevcore/Common.h>
#include <libdevcore/CommonIO.h>
#include <libdevcore/Guards.h>
#include <libdevcore/Worker.h>
#include <libethcore/SealEngine.h>
#include <libp2p/Common.h>
#include <array>
#include <atomic>
#include <condition_variable>
#include <list>
#include <mutex>
#include <queue>
#include <string>
#include <thread>

#include <boost/filesystem/path.hpp>


namespace dev
{
namespace eth
{

class Client;
class DownloadMan;
class EthereumCapability;

enum ClientWorkState
{
    Active = 0,
    Deleting,
    Deleted
};

struct ActivityReport
{
    unsigned ticks = 0;
    std::chrono::system_clock::time_point since = std::chrono::system_clock::now();
};

std::ostream& operator<<(std::ostream& _out, ActivityReport const& _r);

class Client: public ClientBase, protected Worker
{
public:
    Client(ChainParams const& _params, int _networkID, p2p::Host& _host,
        std::shared_ptr<GasPricer> _gpForAdoption,
        boost::filesystem::path const& _dbPath = boost::filesystem::path(),
        boost::filesystem::path const& _snapshotPath = boost::filesystem::path(),
        WithExisting _forceAction = WithExisting::Trust,
        TransactionQueue::Limits const& _l = TransactionQueue::Limits{1024, 1024});
    virtual ~Client();

    ChainParams const& chainParams() const { return bc().chainParams(); }

    void setGasPricer(std::shared_ptr<GasPricer> _gp) { m_gp = _gp; }
    std::shared_ptr<GasPricer> gasPricer() const { return m_gp; }

    h256 submitTransaction(TransactionSkeleton const& _t, Secret const& _secret) override;
    
    h256 importTransaction(Transaction const& _t) override;

    ExecutionResult call(Address const& _secret, u256 _value, Address _dest, bytes const& _data, u256 _gas, u256 _gasPrice, BlockNumber _blockNumber, FudgeFactor _ff = FudgeFactor::Strict) override;

    void flushTransactions() override;

    Transactions pending() const override;

    ImportResult queueBlock(bytes const& _block, bool _isSafe = false);

    u256 gasLimitRemaining() const override { return m_postSeal.gasLimitRemaining(); }
    u256 gasBidPrice() const override { return m_gp->bid(); }

    // [PRIVATE API - only relevant for base clients, not available in general]
    dev::eth::Block block(h256 const& _blockHash, PopulationStatistics* o_stats) const;

    dev::eth::Block postState() const { ReadGuard l(x_postSeal); return m_postSeal; }
    BlockChain const& blockChain() const { return bc(); }
    BlockQueueStatus blockQueueStatus() const { return m_bq.status(); }
    SyncStatus syncStatus() const override;
    TransactionSkeleton populateTransactionWithDefaults(TransactionSkeleton const& _t) const override;
    BlockQueue const& blockQueue() const { return m_bq; }
    OverlayDB const& stateDB() const { return m_stateDB; }
    TransactionQueue::Status transactionQueueStatus() const { return m_tq.status(); }
    TransactionQueue::Limits transactionQueueLimits() const { return m_tq.limits(); }

    std::tuple<ImportRoute, bool, unsigned> syncQueue(unsigned _max = 1);

    // Sealing stuff:
    // Note: "mining"/"miner" is deprecated. Use "sealing"/"sealer".

    Address author() const override { ReadGuard l(x_preSeal); return m_preSeal.author(); }
    void setAuthor(Address const& _us) override
    {
        DEV_WRITE_GUARDED(x_preSeal)
            m_preSeal.setAuthor(_us);
        restartMining();
    }

    strings sealers() const { return sealEngine()->sealers(); }
    std::string sealer() const { return sealEngine()->sealer(); }
    void setSealer(std::string const& _id) { sealEngine()->setSealer(_id); if (wouldSeal()) startSealing(); }
    bytes sealOption(std::string const& _name) const { return sealEngine()->option(_name); }
    bool setSealOption(std::string const& _name, bytes const& _value) { auto ret = sealEngine()->setOption(_name, _value); if (wouldSeal()) startSealing(); return ret; }

    void startSealing() override;
    void stopSealing() override { m_wouldSeal = false; }
    bool wouldSeal() const override { return m_wouldSeal; }

    bool isSyncing() const override;
    bool isMajorSyncing() const override;

    u256 networkId() const override;
    void setNetworkId(u256 const& _n) override;

    SealEngineFace* sealEngine() const override { return bc().sealEngine(); }

    // Debug stuff:

    DownloadMan const* downloadMan() const;
    void clearPending();
    void killChain() { reopenChain(WithExisting::Kill); }
    void reopenChain(ChainParams const& _p, WithExisting _we = WithExisting::Trust);
    void reopenChain(WithExisting _we);
    void retryUnknown() { m_bq.retryAllUnknown(); }
    ActivityReport activityReport() { ActivityReport ret; std::swap(m_report, ret); return ret; }
    void setExtraData(bytes const& _extraData) { m_extraData = _extraData; }
    void rewind(unsigned _n);
    void rescue() { bc().rescue(m_stateDB); }

    std::unique_ptr<StateImporterFace> createStateImporter() { return dev::eth::createStateImporter(m_stateDB); }
    std::unique_ptr<BlockChainImporterFace> createBlockChainImporter() { return dev::eth::createBlockChainImporter(m_bc); }

    void executeInMainThread(std::function<void()> const& _function);

    Block block(h256 const& _block) const override;
    using ClientBase::block;

    void startWorking() { Worker::startWorking(); };

    Handler<bytes const&> setOnBlockSealed(std::function<void(bytes const&)> _handler)
    {
        return m_onBlockSealed.add(_handler);
    }
    Handler<h256s const&, h256s const&> setOnChainChanged(
        std::function<void(h256s const&, h256s const&)> _handler)
    {
        return m_onChainChanged.add(_handler);
    }


protected:
    void init(p2p::Host& _extNet, boost::filesystem::path const& _dbPath,
        boost::filesystem::path const& _snapshotPath, WithExisting _forceAction, u256 _networkId);

    BlockChain& bc() override { return m_bc; }
    BlockChain const& bc() const override { return m_bc; }

    Block preSeal() const override { ReadGuard l(x_preSeal); return m_preSeal; }
    Block postSeal() const override { ReadGuard l(x_postSeal); return m_postSeal; }
    void prepareForTransaction() override;

    void appendFromNewPending(TransactionReceipt const& _receipt, h256Hash& io_changed, h256 _sha3);

    void appendFromBlock(h256 const& _blockHash, BlockPolarity _polarity, h256Hash& io_changed);

    void noteChanged(h256Hash const& _filters);

    virtual bool submitSealed(bytes const& _s);

protected:
    void startedWorking() override;

    void doWork(bool _doWait);
    void doWork() override { doWork(true); }

    void doneWorking() override;

    void rejigSealing();

    void onDeadBlocks(h256s const& _blocks, h256Hash& io_changed);

    virtual void onNewBlocks(h256s const& _blocks, h256Hash& io_changed);

    void resyncStateFromChain();
    void restartMining();

    void resetState();

    void onChainChanged(ImportRoute const& _ir);

    void syncBlockQueue();

    void syncTransactionQueue();

    void onTransactionQueueReady() { m_syncTransactionQueue = true; m_signalled.notify_all(); }

    void onBlockQueueReady() { m_syncBlockQueue = true; m_signalled.notify_all(); }

    void onPostStateChanged();

    void checkWatchGarbage();

    void tick();

    void onBadBlock(Exception& _ex) const;

    void callQueuedFunctions();

    BlockChain m_bc;                        
    BlockQueue m_bq;                        
    TransactionQueue m_tq;                  

    std::shared_ptr<GasPricer> m_gp;        

    OverlayDB m_stateDB;                    
    mutable SharedMutex x_preSeal;          
    Block m_preSeal;                        
    mutable SharedMutex x_postSeal;         
    Block m_postSeal;                       
    mutable SharedMutex x_working;          
    Block m_working;                        
    BlockHeader m_sealingInfo;              
    bool remoteActive() const;              
    std::atomic<bool> m_remoteWorking = { false };          
    std::atomic<bool> m_needStateReset = { false };         
    std::chrono::system_clock::time_point m_lastGetWork;    

    std::weak_ptr<EthereumCapability> m_host;
    std::weak_ptr<WarpCapability> m_warpHost;

    std::condition_variable m_signalled;
    Mutex x_signalled;

    Handler<> m_tqReady;
    Handler<h256 const&> m_tqReplaced;
    Handler<> m_bqReady;

    std::atomic<bool> m_wouldSeal = { false };               
    bool m_wouldButShouldnot = false;       

    mutable std::chrono::system_clock::time_point m_lastGarbageCollection;
    mutable std::chrono::system_clock::time_point m_lastTick = std::chrono::system_clock::now();

    unsigned m_syncAmount = 50;             

    ActivityReport m_report;

    SharedMutex x_functionQueue;
    std::queue<std::function<void()>> m_functionQueue;  

    std::atomic<bool> m_syncTransactionQueue = {false};
    std::atomic<bool> m_syncBlockQueue = {false};

    bytes m_extraData;

    Signal<bytes const&> m_onBlockSealed;        

    Signal<h256s const&, h256s const&> m_onChainChanged;

    Logger m_logger{createLogger(VerbosityInfo, "client")};
    Logger m_loggerDetail{createLogger(VerbosityDebug, "client")};
};

}
}