WebThree.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 <thread>
#include <mutex>
#include <list>
#include <atomic>
#include <boost/asio.hpp> // Make sure boost/asio.hpp is included before windows.h.
#include <boost/utility.hpp>
#include <libdevcore/Common.h>
#include <libdevcore/CommonIO.h>
#include <libdevcore/Guards.h>
#include <libdevcore/Exceptions.h>
#include <libp2p/Host.h>
#include <libethereum/Client.h>
#include <libethereum/ChainParams.h>
 
namespace dev
{
 
enum WorkState
{
    Active = 0,
    Deleting,
    Deleted
};
 
namespace eth { class Interface; }
namespace shh { class Interface; }
namespace bzz { class Interface; class Client; }
 
class NetworkFace
{
public:
    virtual ~NetworkFace() = default;
 
    virtual p2p::NodeInfo nodeInfo() const = 0;
 
    virtual std::vector<p2p::PeerSessionInfo> peers() = 0;
 
    virtual size_t peerCount() const = 0;
 
    virtual void addPeer(p2p::NodeSpec const& _node, p2p::PeerType _t) = 0;
 
    virtual void addNode(p2p::NodeID const& _node, bi::tcp::endpoint const& _hostEndpoint) = 0;
    
    virtual void requirePeer(p2p::NodeID const& _node, bi::tcp::endpoint const& _endpoint) = 0;
    
    virtual dev::bytes saveNetwork() = 0;
 
    virtual void setIdealPeerCount(size_t _n) = 0;
 
    virtual u256 networkId() const = 0;
 
    virtual void startNetwork() = 0;
 
    virtual void stopNetwork() = 0;
 
    virtual bool isNetworkStarted() const = 0;
 
    virtual std::string enode() const = 0;
};
 
 
class WebThreeDirect: public NetworkFace
{
public:
    WebThreeDirect(std::string const& _clientVersion, boost::filesystem::path const& _dbPath,
        boost::filesystem::path const& _snapshotPath, eth::ChainParams const& _params,
        WithExisting _we = WithExisting::Trust, p2p::NetworkConfig const& _n = p2p::NetworkConfig{},
        bytesConstRef _network = bytesConstRef(), bool _testing = false);
 
    ~WebThreeDirect() override;
 
    // The mainline interfaces:
 
    eth::Client* ethereum() const
    {
        if (!m_ethereum)
            BOOST_THROW_EXCEPTION(InterfaceNotSupported() << errinfo_interface("eth"));
        return m_ethereum.get();
    }
 
    // Misc stuff:
 
    static std::string composeClientVersion(std::string const& _client);
    std::string const& clientVersion() const { return m_clientVersion; }
 
    // Network stuff:
 
    std::vector<p2p::PeerSessionInfo> peers() override;
 
    size_t peerCount() const override;
    
    virtual void addPeer(p2p::NodeSpec const& _node, p2p::PeerType _t) override;
 
    virtual void addNode(p2p::NodeID const& _node, bi::tcp::endpoint const& _hostEndpoint) override;
 
    void addNode(p2p::NodeID const& _node, std::string const& _hostString) { addNode(_node, p2p::Network::resolveHost(_hostString)); }
    
    void addNode(bi::tcp::endpoint const& _endpoint) { addNode(p2p::NodeID(), _endpoint); }
 
    void addNode(std::string const& _hostString) { addNode(p2p::NodeID(), _hostString); }
    
    void requirePeer(p2p::NodeID const& _node, bi::tcp::endpoint const& _endpoint) override;
 
    void requirePeer(p2p::NodeID const& _node, std::string const& _hostString) { requirePeer(_node, p2p::Network::resolveHost(_hostString)); }
 
    dev::bytes saveNetwork() override;
 
    void setIdealPeerCount(size_t _n) override;
 
    void setPeerStretch(size_t _n);
    
    p2p::NodeInfo nodeInfo() const override { return m_net.nodeInfo(); }
 
    u256 networkId() const override { return m_ethereum.get()->networkId(); }
 
    std::string enode() const override { return m_net.enode(); }
 
    void startNetwork() override { m_net.start(); }
 
    void stopNetwork() override { m_net.stop(); }
 
    bool isNetworkStarted() const override { return m_net.isStarted(); }
 
private:
    std::string m_clientVersion;                    
 
    std::unique_ptr<eth::Client> m_ethereum;        
 
    p2p::Host m_net;                                
};
 
 
}