333 lines
10 KiB
C++
333 lines
10 KiB
C++
// Copyright (c) 2011-2015 The Cryptonote developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "BaseFunctionalTest.h"
|
|
|
|
#include <vector>
|
|
#include <thread>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <cstdlib>
|
|
|
|
#include <boost/lexical_cast.hpp>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
#include "p2p/NetNodeConfig.h"
|
|
#include "cryptonote_core/CoreConfig.h"
|
|
|
|
#include "RPCTestNode.h"
|
|
#include "wallet/Wallet.h"
|
|
#include "Logger.h"
|
|
|
|
#if defined __linux__
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#endif
|
|
|
|
using namespace Tests::Common;
|
|
|
|
void BaseFunctionalTest::launchTestnet(size_t count, Topology t) {
|
|
if (count < 1) LOG_WARNING("Testnet has no nodes");
|
|
for (uint16_t i = 0; i < count; ++i) {
|
|
std::string dataDirPath = m_dataDir + "/node";
|
|
dataDirPath += boost::lexical_cast<std::string>(i);
|
|
boost::filesystem::create_directory(dataDirPath);
|
|
|
|
std::ofstream config(dataDirPath + "/daemon.conf", std::ios_base::trunc | std::ios_base::out);
|
|
|
|
uint16_t rpcPort = RPC_FIRST_PORT + i;
|
|
uint16_t p2pPort = P2P_FIRST_PORT + i;
|
|
|
|
config
|
|
<< "rpc-bind-port=" << rpcPort << std::endl
|
|
<< "p2p-bind-port=" << p2pPort << std::endl
|
|
<< "log-level=2" << std::endl
|
|
<< "log-file=test_" << CRYPTONOTE_NAME << "d_" << i + 1 << ".log" << std::endl;
|
|
|
|
switch (t) {
|
|
case Line:
|
|
if (i != count - 1) config << "add-exclusive-node=127.0.0.1:" << p2pPort + 1 << std::endl;
|
|
if (i != 0) config << "add-exclusive-node=127.0.0.1:" << p2pPort - 1 << std::endl;
|
|
break;
|
|
case Ring: {
|
|
uint16_t p2pExternalPort = P2P_FIRST_PORT + (i + 1) % count;
|
|
config << "add-exclusive-node=127.0.0.1:" << p2pExternalPort + 1 << std::endl;
|
|
}
|
|
break;
|
|
case Star:
|
|
if (i == 0) {
|
|
for (size_t node = 1; node < count; ++node)
|
|
config << "add-exclusive-node=127.0.0.1:" << P2P_FIRST_PORT + node << std::endl;
|
|
}
|
|
else {
|
|
config << "add-exclusive-node=127.0.0.1:" << P2P_FIRST_PORT << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
config.close();
|
|
#if defined WIN32
|
|
std::string commandLine = "start /MIN \"" + std::string(CRYPTONOTE_NAME) + "d\" \"" + m_daemonDir + "\\" + std::string(CRYPTONOTE_NAME) + "d.exe\" --testnet --data-dir=\"" + dataDirPath + "\" --config-file=daemon.conf";
|
|
LOG_DEBUG(commandLine);
|
|
system(commandLine.c_str());
|
|
#elif defined __linux__
|
|
auto pid = fork();
|
|
if( pid == 0 ) {
|
|
std::string pathToDaemon = "" + m_daemonDir + "/" + std::string(CRYPTONOTE_NAME) + "d";
|
|
close(1);
|
|
close(2);
|
|
std::string dataDir = "--data-dir=" + dataDirPath + "";
|
|
if(execl(pathToDaemon.c_str(), (std::string(CRYPTONOTE_NAME) + "d").c_str(), "--testnet", dataDir.c_str(), "--config-file=daemon.conf", NULL) == -1) {
|
|
LOG_ERROR(TO_STRING(errno));
|
|
}
|
|
throw std::runtime_error("failed to start daemon");
|
|
} else if(pid > 0) {
|
|
pids.push_back(pid);
|
|
}
|
|
#else
|
|
|
|
#endif
|
|
|
|
nodeDaemons.push_back(
|
|
std::unique_ptr<TestNode>(new RPCTestNode(rpcPort, m_dispatcher))
|
|
);
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10000)); //for initial update
|
|
nodeDaemons[0]->makeINode(mainNode);
|
|
makeWallet(workingWallet, mainNode);
|
|
}
|
|
|
|
void BaseFunctionalTest::launchTestnetWithInprocNode(size_t count, Topology t) {
|
|
if (count < 1) LOG_WARNING("Testnet has no nodes");
|
|
for (uint16_t i = 0; i < count-1; ++i) {
|
|
std::string dataDirPath = m_dataDir + "/node";
|
|
dataDirPath += boost::lexical_cast<std::string>(i);
|
|
boost::filesystem::create_directory(dataDirPath);
|
|
|
|
std::ofstream config(dataDirPath + "/daemon.conf", std::ios_base::trunc | std::ios_base::out);
|
|
|
|
uint16_t rpcPort = RPC_FIRST_PORT + i;
|
|
uint16_t p2pPort = P2P_FIRST_PORT + i;
|
|
|
|
config
|
|
<< "rpc-bind-port=" << rpcPort << std::endl
|
|
<< "p2p-bind-port=" << p2pPort << std::endl
|
|
<< "log-level=2" << std::endl
|
|
<< "log-file=test_" << CRYPTONOTE_NAME << "d_" << i + 1 << ".log" << std::endl;
|
|
|
|
switch (t) {
|
|
case Line:
|
|
config << "add-exclusive-node=127.0.0.1:" << p2pPort + 1 << std::endl;
|
|
if (i != 0) config << "add-exclusive-node=127.0.0.1:" << p2pPort - 1 << std::endl;
|
|
break;
|
|
case Ring: {
|
|
uint16_t p2pExternalPort = P2P_FIRST_PORT + (i + 1) % count;
|
|
config << "add-exclusive-node=127.0.0.1:" << p2pExternalPort + 1 << std::endl;
|
|
}
|
|
break;
|
|
case Star:
|
|
if (i == 0) {
|
|
for (size_t node = 1; node < count; ++node)
|
|
config << "add-exclusive-node=127.0.0.1:" << P2P_FIRST_PORT + node << std::endl;
|
|
} else {
|
|
config << "add-exclusive-node=127.0.0.1:" << P2P_FIRST_PORT << std::endl;
|
|
}
|
|
break;
|
|
}
|
|
config.close();
|
|
#if defined WIN32
|
|
std::string commandLine = "start /MIN \"" + std::string(CRYPTONOTE_NAME) + "d\" \"" + m_daemonDir + "\\" + std::string(CRYPTONOTE_NAME) + "d.exe\" --testnet --data-dir=\"" + dataDirPath + "\" --config-file=daemon.conf";
|
|
LOG_DEBUG(commandLine);
|
|
system(commandLine.c_str());
|
|
#elif defined __linux__
|
|
auto pid = fork();
|
|
if (pid == 0) {
|
|
std::string pathToDaemon = "" + m_daemonDir + "/" + std::string(CRYPTONOTE_NAME) + "d";
|
|
close(1);
|
|
close(2);
|
|
std::string dataDir = "--data-dir=" + dataDirPath + "";
|
|
if (execl(pathToDaemon.c_str(), (std::string(CRYPTONOTE_NAME) + "d").c_str(), "--testnet", dataDir.c_str(), "--config-file=daemon.conf", NULL) == -1) {
|
|
LOG_ERROR(TO_STRING(errno));
|
|
}
|
|
throw std::runtime_error("failed to start daemon");
|
|
} else if (pid > 0) {
|
|
pids.push_back(pid);
|
|
}
|
|
#else
|
|
|
|
#endif
|
|
|
|
nodeDaemons.push_back(
|
|
std::unique_ptr<TestNode>(new RPCTestNode(rpcPort, m_dispatcher))
|
|
);
|
|
}
|
|
|
|
this->core.reset(new cryptonote::core(m_currency, NULL));
|
|
this->protocol.reset(new cryptonote::t_cryptonote_protocol_handler<cryptonote::core>(*core, NULL));
|
|
this->p2pNode.reset(new nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core>>(*protocol));
|
|
protocol->set_p2p_endpoint(p2pNode.get());
|
|
core->set_cryptonote_protocol(protocol.get());
|
|
|
|
std::string dataDirPath = m_dataDir + "/node";
|
|
dataDirPath += boost::lexical_cast<std::string>(count - 1);
|
|
boost::filesystem::create_directory(dataDirPath);
|
|
|
|
uint16_t p2pPort = P2P_FIRST_PORT + static_cast<uint16_t>(count) - 1;
|
|
|
|
nodetool::NetNodeConfig p2pConfig;
|
|
p2pConfig.bindIp = "127.0.0.1";
|
|
p2pConfig.bindPort = boost::lexical_cast<std::string>(p2pPort);
|
|
nodetool::net_address addr;
|
|
addr.ip = 0x7f000001;
|
|
|
|
p2pConfig.externalPort = 0;
|
|
p2pConfig.allowLocalIp = false;
|
|
p2pConfig.hideMyPort = false;
|
|
p2pConfig.configFolder = dataDirPath;
|
|
|
|
|
|
switch (t) {
|
|
case Line:
|
|
addr.port = p2pPort - 1;
|
|
p2pConfig.exclusiveNodes.push_back(addr);
|
|
break;
|
|
case Ring:
|
|
addr.port = p2pPort - 1;
|
|
p2pConfig.exclusiveNodes.push_back(addr);
|
|
addr.port = P2P_FIRST_PORT;
|
|
p2pConfig.exclusiveNodes.push_back(addr);
|
|
break;
|
|
case Star:
|
|
addr.port = P2P_FIRST_PORT;
|
|
p2pConfig.exclusiveNodes.push_back(addr);
|
|
break;
|
|
}
|
|
|
|
if (!p2pNode->init(p2pConfig, true)) {
|
|
throw std::runtime_error("Failed to init p2pNode");
|
|
}
|
|
|
|
protocol->init();
|
|
|
|
cryptonote::MinerConfig emptyMiner;
|
|
cryptonote::CoreConfig coreConfig;
|
|
coreConfig.configFolder = dataDirPath;
|
|
core->init(coreConfig, emptyMiner, true);
|
|
|
|
inprocNode.reset(new CryptoNote::InProcessNode(*core, *protocol));
|
|
std::promise<void> p;
|
|
auto future = p.get_future();
|
|
inprocNode->init([&p](std::error_code ec) {
|
|
p.set_value();
|
|
if (ec) {
|
|
std::cout << ec.message() << std::endl;
|
|
}
|
|
});
|
|
|
|
future.get();
|
|
|
|
std::thread serverThread(
|
|
std::bind(
|
|
&nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<cryptonote::core>>::run,
|
|
p2pNode.get()
|
|
)
|
|
);
|
|
serverThread.detach();
|
|
|
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10000)); //for initial update
|
|
nodeDaemons[0]->makeINode(mainNode);
|
|
makeWallet(workingWallet, mainNode);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
BaseFunctionalTest::~BaseFunctionalTest() {
|
|
if (mainNode) {
|
|
mainNode->shutdown();
|
|
}
|
|
|
|
if (inprocNode) {
|
|
inprocNode->shutdown();
|
|
}
|
|
|
|
if (p2pNode) {
|
|
p2pNode->send_stop_signal();
|
|
}
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(2));
|
|
stopTestnet();
|
|
}
|
|
|
|
namespace {
|
|
class WaitForCoinBaseObserver : public CryptoNote::IWalletObserver {
|
|
Semaphore& m_gotReward;
|
|
CryptoNote::IWallet& m_wallet;
|
|
public:
|
|
WaitForCoinBaseObserver(Semaphore& gotReward, CryptoNote::IWallet& wallet) : m_gotReward(gotReward), m_wallet(wallet) { }
|
|
virtual void externalTransactionCreated(CryptoNote::TransactionId transactionId) override {
|
|
CryptoNote::TransactionInfo trInfo;
|
|
m_wallet.getTransaction(transactionId, trInfo);
|
|
if (trInfo.isCoinbase) m_gotReward.notify();
|
|
}
|
|
};
|
|
}
|
|
|
|
bool BaseFunctionalTest::mineBlock(std::unique_ptr<CryptoNote::IWallet>& wallet) {
|
|
if (nodeDaemons.empty() || !wallet) return false;
|
|
if (!nodeDaemons.front()->stopMining()) return false;
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10000));
|
|
Semaphore gotReward;
|
|
WaitForCoinBaseObserver cbo(gotReward, *wallet.get());
|
|
wallet->addObserver(&cbo);
|
|
if(!nodeDaemons.front()->startMining(1, wallet->getAddress())) return false;
|
|
gotReward.wait();
|
|
if (!nodeDaemons.front()->stopMining()) return false;
|
|
wallet->removeObserver(&cbo);
|
|
return true;
|
|
}
|
|
bool BaseFunctionalTest::mineBlock() {
|
|
return mineBlock(workingWallet);
|
|
}
|
|
|
|
bool BaseFunctionalTest::startMining(size_t threads) {
|
|
if (nodeDaemons.empty() || !workingWallet) return false;
|
|
if(!stopMining()) return false;
|
|
return nodeDaemons.front()->startMining(threads, workingWallet->getAddress());
|
|
}
|
|
|
|
bool BaseFunctionalTest::stopMining() {
|
|
if (nodeDaemons.empty()) return false;
|
|
return nodeDaemons.front()->stopMining();
|
|
}
|
|
|
|
bool BaseFunctionalTest::makeWallet(std::unique_ptr<CryptoNote::IWallet> & wallet, std::unique_ptr<CryptoNote::INode>& node, const std::string& password) {
|
|
if (!node) return false;
|
|
wallet = std::unique_ptr<CryptoNote::IWallet>(new CryptoNote::Wallet(m_currency, *node));
|
|
wallet->initAndGenerate(password);
|
|
return true;
|
|
}
|
|
|
|
void BaseFunctionalTest::stopTestnet() {
|
|
for (auto& Daemon : nodeDaemons) {
|
|
Daemon->stopDaemon();
|
|
}
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(5000));
|
|
#ifdef __linux__
|
|
for (auto& pid : pids) {
|
|
int status;
|
|
while (-1 == waitpid(pid, &status, 0));
|
|
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
|
|
std::cerr << "Process " << " (pid " << pid << ") failed" << std::endl;
|
|
exit(1);
|
|
}
|
|
}
|
|
#endif
|
|
}
|