Codablecashのソースコードで、ノードが「仲間」を見つける仕組みを追う

// src_blockchain/bc_network/NodeIdentifier.h
class NodeIdentifier : public IBlockObject {
public:
	// ・・・・・
	const BigInteger* getPublicKey() const noexcept {
		return this->nodeIdentifier;
	}
	// ・・・・・
private:
	BigInteger* nodeIdentifier; // pubkey
};

// src_blockchain/bc_network/NodeIdentifierSource.h
class NodeIdentifierSource : public IBlockObject {
public:
	// ・・・・・
	static NodeIdentifierSource* create();              // 鍵のペアを新しく作る
	NodeIdentifier toNodeIdentifier() const noexcept;   // 公開鍵から名札を作る
	const BigInteger* getSecretKey() const noexcept;    // 署名に使う秘密鍵
	// ・・・・・
private:
	IKeyPair* pair;   // 秘密鍵と公開鍵のペア
};

// src_blockchain/bc_network_instance/CodablecashNetworkNode.cpp
void CodablecashNetworkNode::startNetwork(INetworkSeeder* seeder, bool pending) {
	// ・・・・・
	// startNetwork
	const UnicodeString* host = this->nwconfig->getHost();
	int port = this->nwconfig->getPort();

	this->inst->startNetwork(host, port);   // 待ち受けを始める

	// start processors
	{
		const NodeIdentifierSource* networkKey = this->nwconfig->getNetworkKey();
		this->inst->startProcessors(networkKey, pending);   // 届いた命令を処理する担当たちを起こす（pendingは7で）
	}

	// init database
	if(seeder != nullptr){
		ArrayList<P2pNodeRecord>* seedList = seeder->getSeedNodes(); __STP(seedList);
		// ・・・・・
		if(seedList != nullptr && !seedList->isEmpty()){
			initDatabase(seedList);    // シーダーの連絡先から電話帳を作る
		}
	}

	// init connections
	maintainNetwork();     // 電話帳から選んで接続する
}

// src_blockchain/bc_network_instance/INetworkSeeder.h
class INetworkSeeder {
public:
	// ・・・・・
	virtual ArrayList<P2pNodeRecord>* getSeedNodes() const noexcept = 0;
	virtual void addRecord(const P2pNodeRecord* record) noexcept = 0;
	// ・・・・・
};

// src_blockchain_p2p/bc_p2p_info/P2pDnsManager.cpp
void P2pDnsManager::importSeeds(int numZone, const P2pNodeRecord *nodeRecord, ISystemLogger *logger) {
	// ・・・・・
	const UnicodeString* host = nodeRecord->getHost();
	int port = nodeRecord->getPort();

	try{
		for(int i = 0; i != numZone; ++i){
			doImportSeeds(i, host, port, logger);     // ゾーンごとに電話帳をもらう
		}

		// add seed
		this->database->importUnconnectedNode(nodeRecord);   // シード自身も電話帳に入れる
	}
	// ・・・・・
}

void P2pDnsManager::doImportSeeds(uint16_t zone, const UnicodeString *host, int port, ISystemLogger *logger) {
	P2pClient client(zone, logger);
	// ・・・・・（接続）

	DownloadDnsInfoCommand command(zone);
	client.sign(&command);
	AbstractCommandResponse* response = client.sendCommnad(&command); __STP(response);

	// client close
	client.close();

	DownloadDnsInfoCommandResponse* dnsInfoResponse = dynamic_cast<DownloadDnsInfoCommandResponse*>(response);
	if(dnsInfoResponse != nullptr){
		const ArrayList<P2pNodeRecord>* list = dnsInfoResponse->getRecords();
		// ・・・・・
		for(int i = 0; i != maxLoop; ++i){
			P2pNodeRecord* rec = list->get(i);
			this->database->importUnconnectedNode(rec);   // もらった連絡先を自分の電話帳へ
		}
	}
}

// src_blockchain_p2p/bc_p2p_cmd_client/DownloadDnsInfoCommand.cpp
DownloadDnsInfoCommand::DownloadDnsInfoCommand(uint16_t zone) : AbstractClientRequestCommand(TYPE_CLIENT_DOWNLOAD_DNS) {
	this->zone = zone;
	this->maxNum = 256;
}

// src_blockchain_p2p/bc_p2p_cmd_client/DownloadDnsInfoCommand.cpp
AbstractCommandResponse* DownloadDnsInfoCommand::executeAsClient(ClientNodeHandshake *clientHandshake, CodablecashNodeInstance *inst) const {
	P2pDnsManager* p2pManager = inst->getP2pDnsManager();
	DownloadDnsInfoCommandResponse* respose = new DownloadDnsInfoCommandResponse(); __STP(respose);

	ArrayList<P2pNodeRecord>* list = p2pManager->getZoneRecords(this->zone, this->maxNum); __STP(list);
	// ・・・・・
	respose->importRecords(list);

	return __STP_MV(respose);
}

// src_blockchain/bc/CodablecashSystemParam.cpp
CodablecashSystemParam::CodablecashSystemParam() {
	// ・・・・・
	this->numConnectionOwnShard = 8;
	this->numConnectionExtShard = 4;

	this->numInitialSyncNodes = 3;
	// ・・・・・
}

// src_blockchain/bc/CodablecashNodeInstance.cpp
void CodablecashNodeInstance::__maintainNetwork(uint16_t zone) {
	int numNeedConnection = this->param->getNumConnectionExtShard();   // ほかのゾーン: 4
	if(zone == getZoneSelf()){
		numNeedConnection = this->param->getNumConnectionOwnShard();   // 自分のゾーン: 8
	}

	int currentSize = this->p2pManager->getNumNodes(zone);   // 今つながっている数
	int diff = numNeedConnection - currentSize;               // 足りない数

	if(diff > 0){
		ArrayList<P2pNodeRecord>* list = this->p2pDnsManager->getZoneRecords(zone, 1024); __STP(list);
		// ・・・・・
		ConnectNodeSelector selector;
		selector.importCandidates(list);          // 電話帳に載っている連絡先を候補にする

		while(diff > 0 && selector.hasNext()){
			const P2pNodeRecord* rec = selector.fetchNext();   // 1件選ぶ

			if(__connectWithP2pNodeRecord(rec)){  // つながったら
				diff--;                           // 残りを減らす
			}
		}
	}
}

// src_blockchain_p2p/bc_p2p_selector/ConnectNodeSelector.cpp
const P2pNodeRecord* ConnectNodeSelector::fetchNext() const {
	int index = toIndex(this->candidates->size());
	P2pNodeRecord* record = this->candidates->remove(index);   // 取り出した候補は候補から外す
	this->usedCandidates->addElement(record);
	return record;
}

// src_blockchain/bc/CodablecashNodeInstance.cpp
void CodablecashNodeInstance::loginNode(uint16_t zone, P2pHandshake *handshake, const UnicodeString* canonicalName) {
	// login
	NodeIdentifierSource* source = this->p2pRequestProcessor->getNetworkKey();   // 自分の鍵

	uint16_t zoneSelf = this->statusCache->getZoneSelf();
	LoginPubSubCommand cmd(zoneSelf, canonicalName);

	{
		NodeIdentifier nodeId = source->toNodeIdentifier();   // 鍵から名札を作る
		SystemTimestamp tm;

		int protocol = this->p2pManager->getProtocol();
		const UnicodeString* host = this->p2pManager->getHost();
		uint32_t port = this->p2pManager->getPort();

		NodeNetworkInfo info(zoneSelf, &nodeId, &tm, protocol, host, port);   // 名刺を準備
		info.setCanonicalName(this->nodeName);

		cmd.setNodeNetworkInfo(&info); 
	}

	cmd.sign(source);   // 自分の鍵で署名

	AbstractCommandResponse* response = handshake->publishCommand(&cmd); __STP(response); // 「こんにちは、私もノードです（名刺スッ）」
	// ・・・・・
	uint32_t type = response->getType();
	if(type != AbstractCommandResponse::TYPE_RES_OK){
		throw new P2pHandshakeAuthenticationException(L"Already connected.", __FILE__, __LINE__);
	}
}

// src_blockchain_p2p/bc_p2p_cmd/LoginPubSubCommand.cpp
AbstractCommandResponse* LoginPubSubCommand::execute(const PubSubId* pubsubId, IPubsubCommandListner *listner) const {
	try{
		checkSignature();  // 1. 署名が名札（公開鍵）と合うか
	}
	catch(Exception* e){
		delete e;
		return new SignatureErrorResponse();
	}

	{
		// ・・・・・
		BlockchainNodeHandshake* node = p2pMgr->getNodeHandshakeByNodeId(this->nodeId);
		StackHandshakeReleaser __releaser(node);
		if(node != nullptr){    // 2. 同じ名札がもうつながっていたら断る
			ErrorPubsubResponse* res = new ErrorPubsubResponse();
			return res;
		}
	}

	listner->fireExecuteCommand(pubsubId, this);   // 3. 接続として登録

	// check & register dns
	if(this->nodeNetInfo){    // 4. 名刺を担当に回す
		// ・・・・・
		netDnsProcessor->requestDnsCheck(this->nodeNetInfo);
	}

	OkPubsubResponse* res = new OkPubsubResponse();
	return res;
}

// src_blockchain_p2p/bc_p2p_processor/DnsCheckCommandMessage.cpp
void DnsCheckCommandMessage::checkAndRegister(P2pRequestProcessor* processor, ISystemLogger* logger) {
	{
		IClientSocket* con = this->nodeNetInfo->getConnection(); __STP(con);   // もらった名刺の連絡先に自分から接続してみる
		StackConnectionCloser _st_closer(con);

		ExceptionThrower<PubsubNetworkException>::throwExceptionIfCondition(!con->isConnected(), L"Connection does not reach.", __FILE__, __LINE__);
	}

	// dns check
	P2pDnsManager* dnsManager = processor->getP2pDnsManager();
	dnsManager->updateOrAddRecord(this->nodeNetInfo, logger);   // 届いたときだけ電話帳に登録
}

// src_blockchain/bc_network_instance/CodablecashNetworkNode.cpp
void CodablecashNetworkNode::syncNetwork() {
	NetworkNodeSync sync(this);
	sync.sync();                                 // 仲間に追いつく

	this->inst->resumeRequestProcessor();        // 保留箱を片付けて、保留モードを解除する
}

// src_blockchain/bc_network_instance_sync/AbstractZoneSync.cpp
ArrayList<NodeIdentifier>* nodelist = p2pManager->getNodeIds(this->zone); __STP(nodelist);
// ・・・・・
int num = param->getNumInitialSyncNodes();     // 3
RamdomNodesSelector sel(nodelist, num);          // つながっている中から3台

while(sel.hasNext()){
	const NodeIdentifier* nodeId = sel.next();
	// ・・・・・
	HeaderSyncWorker* worker = new HeaderSyncWorker(this->zone, nodeId, this, this->logger, &str);
	this->workers->addElement(worker);
	worker->start();
}

// src_blockchain/bc/CodablecashNodeInstance.cpp
void CodablecashNodeInstance::broadCastShutdownCommand(const NodeIdentifierSource *source) {
	NodeShutdownCommand command;

	NodeIdentifier nodeId = source->toNodeIdentifier();

	command.signTimestamp(source);   // 時刻に署名
	command.sign(source);            // 本体に署名

	this->p2pManager->broadCastAllZones(nullptr, &command, this->p2pRequestProcessor);   // 全ゾーンへ
}

// src_blockchain_p2p/bc_p2p_cmd_network/NodeShutdownCommand.cpp
AbstractCommandResponse* NodeShutdownCommand::executeAsNode(BlockchainNodeHandshake *nodeHandShake, CodablecashNodeInstance *inst, bool suspend) const {
	{
		bool vl = verifyTimestamp();   // 本人の署名か
		// ・・・・・
	}

	bool updated = updateShutdownNode(inst);   // 電話帳から消して、接続を切る

	if(!suspend && updated && this->hops < 5){   // まだ5回転送されていなければ
		// ・・・・・
		command.incHpos();
		command.sign(source);
		// ・・・・・
		p2pManager->broadCastAllZones(this->nodeId, &command, processor);   // 自分の仲間にも転送
	}

	return new OkPubsubResponse();
}