PeerSearcher.go

package service

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"time"

	"saseul/config"
	"saseul/data/chain"
	"saseul/data/env"
	"saseul/data/resourcechain"
	"saseul/data/tracker"
	"saseul/datasource/poolclient"
	"saseul/staff/processmanager"
	"saseul/util/clock"
	"saseul/util/filter"
	"saseul/util/hasher"
	"saseul/util/parser"
	"saseul/util/restcall"
	"saseul/util/signer"
)

// PeerSearcher 구조체는 피어 탐색 서비스를 정의합니다.
type PeerSearcher struct {
	Description string
	Iterate     int
	CheckCount  int
}

// NewPeerSearcher 함수는 PeerSearcher 인스턴스를 생성하고 초기화합니다.
func NewPeerSearcher() *PeerSearcher {
	return &PeerSearcher{
		Description: "Peer searcher service",
		Iterate:     1000000,
		CheckCount:  32,
	}
}

// Main 함수는 PeerSearcher의 메인 작업을 수행합니다.
func (ps *PeerSearcher) Main() {
	if config.Environment == "process" {
		if processmanager.IsRunning(processmanager.PEER_SEARCHER) {
			log.Println("Peer searcher process is already running.")
			os.Exit(1)
		}
		processmanager.Save(processmanager.PEER_SEARCHER)
	}

	poolclient.Instance().SetMode("rewind")
	restcall.Instance().SetTimeout(config.ROUND_TIMEOUT)

	defer func() {
		if processmanager.PID(processmanager.PEER_SEARCHER) == os.Getpid() {
			log.Println("Peer searcher process has been successfully removed.")
			processmanager.Delete(processmanager.PEER_SEARCHER)
		}
	}()

	ps.Init()
	for i := 0; i < ps.Iterate; i++ {
		time.Sleep(1 * time.Second) // 필요한 경우 조정
	}
}

// Init 함수는 PeerSearcher를 초기화합니다.
func (ps *PeerSearcher) Init() {
	ps.addRoutine(ps.checkRequestedPeers, 5*time.Second)
	ps.addRoutine(ps.checkPeers, 120*time.Second)
	ps.addRoutine(ps.checkKnownHosts, 60*time.Second)
	ps.addRoutine(ps.makeStatusBundle, 60*time.Second)

	ps.checkRequestedPeers()
	ps.checkPeers()
	ps.checkKnownHosts()
	ps.makeStatusBundle()

	log.Println("Peer searcher process has started.")
}

// addRoutine 함수는 주기적인 작업을 수행하는 고루틴을 생성합니다.
func (ps *PeerSearcher) addRoutine(fn func(), interval time.Duration) {
	go func() {
		for range time.Tick(interval) {
			fn()
		}
	}()
}

// checkRequestedPeers 함수는 요청된 피어를 확인합니다.
func (ps *PeerSearcher) checkRequestedPeers() {
	requests := poolclient.Instance().DrainPeerRequests()
	peerHosts := tracker.GetPeerHosts()
	knownHosts := tracker.GetKnownHosts()

	bucket := []string{}

	for _, item := range requests {
		if !contains(peerHosts, item) && filter.IsPublicHost(item) {
			bucket = append(bucket, parser.Endpoint(item))
		}
	}

	knownHosts = uniqueStrings(append(knownHosts, bucket...))
	tracker.SetKnownHosts(knownHosts)
}

// checkPeers 함수는 피어를 확인합니다.
func (ps *PeerSearcher) checkPeers() {
	log.Println("Check peers...")

	hosts := tracker.GetPeerHosts()
	peers := []map[string]interface{}{}
	knownHosts := []string{}

	for len(hosts) > 0 {
		part := take(&hosts, ps.CheckCount)
		trackers := ps.seeTrackers(part, true)
		peers = append(peers, trackers["peers"].([]map[string]interface{})...)
		knownHosts = uniqueStrings(append(knownHosts, trackers["known_hosts"].([]string)...))
	}

	peerHosts := getHosts(peers)
	bucket := []string{}

	for _, knownHost := range knownHosts {
		if !contains(peerHosts, knownHost) && filter.IsPublicHost(knownHost) {
			bucket = append(bucket, parser.Endpoint(knownHost))
		}
	}

	knownHosts = uniqueStrings(append(bucket, tracker.GetKnownHosts()...))
	tracker.SetPeers(peers)
	tracker.SetKnownHosts(knownHosts)
}

// checkKnownHosts 함수는 알려진 호스트를 확인합니다.
func (ps *PeerSearcher) checkKnownHosts() {
	log.Println("Check requested hosts...")

	hosts := tracker.GetKnownHosts()
	peers := []map[string]interface{}{}
	knownHosts := []string{}

	for len(hosts) > 0 {
		part := take(&hosts, ps.CheckCount)
		trackers := ps.seeTrackers(part, false)
		peers = append(peers, trackers["peers"].([]map[string]interface{})...)
		knownHosts = uniqueStrings(append(knownHosts, trackers["known_hosts"].([]string)...))
	}

	newPeers := tracker.GetPeers()
	peerHosts := getHosts(newPeers)

	for _, peer := range peers {
		host := peer["host"].(string)
		address := peer["address"].(string)
		execTime := peer["exec_time"].(int)

		if !contains(peerHosts, host) && filter.IsPublicHost(host) {
			newPeers = append(newPeers, map[string]interface{}{
				"host":      parser.Endpoint(host),
				"address":   address,
				"exec_time": execTime,
			})
		}
	}

	tracker.SetPeers(newPeers)

	peerHosts = tracker.GetPeerHosts()
	bucket := []string{}

	for _, knownHost := range knownHosts {
		if !contains(peerHosts, knownHost) && filter.IsPublicHost(knownHost) {
			bucket = append(bucket, parser.Endpoint(knownHost))
		}
	}

	tracker.SetKnownHosts(bucket)
}

// makeStatusBundle 함수는 상태 번들을 생성합니다.
func (ps *PeerSearcher) makeStatusBundle() {
	log.Println("Bundling...")
	chain.Bundling()
}

// seeTrackers 함수는 트래커를 확인하고 피어 및 알려진 호스트 정보를 반환합니다.
func (ps *PeerSearcher) seeTrackers(hosts []string, register bool) map[string]interface{} {
	if len(hosts) == 0 {
		return nil
	}

	endpoint := env.Endpoint()
	now := clock.UTime()
	height := max(chain.FixedHeight()-config.RESOURCE_CONFIRM_COUNT, 0)
	items := ps.searchRequestItems(hosts, endpoint, register, height, now)
	items2 := ps.searchVersionItems(hosts, endpoint)

	var phrase string
	if height > 0 {
		phrase = resourcechain.Instance().Block(height).Blockhash
	} else {
		phrase = config.NetworkKey()
	}

	rs := restcall.Instance().MultiPOST(items)
	rs2 := restcall.Instance().MultiPOST(items2)

	peers := []map[string]interface{}{}
	knownHosts := []string{}
	latests := []string{}

	for _, item := range rs2 {
		host := item["host"].(string)
		result := parseJSON(item["result"].(string))
		data := result["data"].(map[string]interface{})
		version := data["version"].(string)

		if version >= "2.1.9.0" {
			latests = append(latests, host)
		}
	}

	for _, item := range rs {
		host := item["host"].(string)
		execTime := item["exec_time"].(int)
		result := parseJSON(item["result"].(string))

		if result == nil {
			continue
		}

		data := result["data"].(map[string]interface{})
		nodeData := data["node"].(map[string]interface{})
		peerAddress := ps.peerAddress(nodeData, phrase, now)

		if peerAddress == "" || !contains(latests, host) {
			continue
		}

		peerData := data["peers"].([]map[string]interface{})
		peerHosts := getHosts(peerData)

		peers = append(peers, map[string]interface{}{
			"host":      host,
			"address":   peerAddress,
			"exec_time": execTime,
		})
		knownHosts = uniqueStrings(append(knownHosts, peerHosts...))
	}

	return map[string]interface{}{
		"peers":       peers,
		"known_hosts": knownHosts,
	}
}

// searchRequestItems 함수는 요청 아이템을 생성합니다.
func (ps *PeerSearcher) searchRequestItems(hosts []string, endpoint string, register bool, height int, utime int) []map[string]interface{} {
	items := []map[string]interface{}{}
	for _, host := range hosts {
		item := map[string]interface{}{
			"url": fmt.Sprintf("%s/peer", host),
			"data": map[string]interface{}{
				"register":       register,
				"authentication": true,
				"height":         height,
				"t":              utime,
			},
		}
		if endpoint != "" {
			item["data"].(map[string]interface{})["host"] = endpoint
		}
		items = append(items, item)
	}
	return items
}

// searchVersionItems 함수는 버전 아이템을 생성합니다.
func (ps *PeerSearcher) searchVersionItems(hosts []string, endpoint string) []map[string]interface{} {
	items := []map[string]interface{}{}
	for _, host := range hosts {
		item := map[string]interface{}{
			"url":  fmt.Sprintf("%s/info", host),
				"data": map[string]interface{}{},
			}
		if endpoint != "" {
			item["data"].(map[string]interface{})["host"] = endpoint
		}
		items = append(items, item)
	}
	return items
}

// peerAddress 함수는 피어 주소를 반환합니다.
func (ps *PeerSearcher) peerAddress(nodeData map[string]interface{}, phrase string, now int) string {
	timestamp := int(nodeData["timestamp"].(float64))
	genesisAddress := nodeData["genesis_address"].(string)
	publicKey := nodeData["public_key"].(string)
	signature := nodeData["signature"].(string)
	stringToHash := hasher.Hash(hasher.HexTime(timestamp) + phrase)

	timeValidity := abs(now-timestamp) < config.TIMESTAMP_ERROR_LIMIT
	signatureValidity := signer.SignatureValidity(stringToHash, publicKey, signature)
	genesisValidity := genesisAddress == config.GenesisAddress

	if timeValidity && signatureValidity && genesisValidity {
		return signer.Address(publicKey)
	}

	return ""
}

// take 함수는 슬라이스에서 지정된 수의 요소를 가져옵니다.
func take(hosts *[]string, count int) []string {
	n := min(count, len(*hosts))
	part := (*hosts)[:n]
	*hosts = (*hosts)[n:]
	return part
}

// contains 함수는 슬라이스에 지정된 항목이 포함되어 있는지 확인합니다.
func contains(slice []string, item string) bool {
	for _, s := range slice {
		if s == item {
			return true
		}
	}
	return false
}

// uniqueStrings 함수는 슬라이스의 고유 문자열을 반환합니다.
func uniqueStrings(input []string) []string {
	unique := make(map[string]struct{}, len(input))
	for _, str := range input {
		unique[str] = struct{}{}
	}

	output := make([]string, 0, len(unique))
	for str := range unique {
		output = append(output, str)
	}

	return output
}

// parseJSON 함수는 JSON 문자열을 파싱합니다.
func parseJSON(jsonStr string) map[string]interface{} {
	var result map[string]interface{}
	if err := json.Unmarshal([]byte(jsonStr), &result); err != nil {
		return nil
	}
	return result
}

// getHosts 함수는 피어 목록에서 호스트를 추출합니다.
func getHosts(peers []map[string]interface{}) []string {
	hosts := []string{}
	for _, peer := range peers {
		hosts = append(hosts, peer["host"].(string))
	}
	return hosts
}

// abs 함수는 절대값을 반환합니다.
func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

// max 함수는 두 값 중 더 큰 값을 반환합니다.
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// min 함수는 두 값 중 더 작은 값을 반환합니다.
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// main 함수는 PeerSearcher 인스턴스를 생성하고 메인 작업을 수행합니다.
func main() {
	ps := NewPeerSearcher()
	ps.Main()
}

코드 설명:

이 코드는 피어 검색 서비스(PeerSearcher)를 구현합니다. 이 서비스는 네트워크에서 피어를 찾고, 알려진 호스트 정보를 유지 관리하며, 상태 번들을 생성하는 작업을 수행합니다.

주요 함수:

NewPeerSearcher: PeerSearcher 구조체의 인스턴스를 생성하고 초기화합니다.
Main: PeerSearcher의 메인 작업을 수행합니다. 서비스가 이미 실행 중인지 확인하고 초기화합니다.
Init: PeerSearcher를 초기화합니다. 주기적인 작업을 설정하고 초기 상태를 확인합니다.
addRoutine: 주기적인 작업을 수행하는 고루틴을 생성합니다.
checkRequestedPeers: 요청된 피어를 확인하고, 알려진 호스트 목록을 업데이트합니다.
checkPeers: 피어를 확인하고, 피어 및 알려진 호스트 목록을 업데이트합니다.
checkKnownHosts: 알려진 호스트를 확인하고, 피어 및 알려진 호스트 목록을 업데이트합니다.
makeStatusBundle: 상태 번들을 생성합니다.
seeTrackers: 트래커를 확인하고 피어 및 알려진 호스트 정보를 반환합니다.
searchRequestItems: 요청 아이템을 생성합니다.
searchVersionItems: 버전 아이템을 생성합니다.
peerAddress: 피어 주소를 반환합니다.
take: 슬라이스에서 지정된 수의 요소를 가져옵니다.
contains: 슬라이스에 지정된 항목이 포함되어 있는지 확인합니다.
uniqueStrings: 슬라이스의 고유 문자열을 반환합니다.
parseJSON: JSON 문자열을 파싱합니다.
getHosts: 피어 목록에서 호스트를 추출합니다.
abs: 절대값을 반환합니다.
max: 두 값 중 더 큰 값을 반환합니다.
min: 두 값 중 더 작은 값을 반환합니다.
main: PeerSearcher 인스턴스를 생성하고 메인 작업을 수행합니다.

PreviousMaster.go NextResourceMiner.go

Last updated 1 year ago

hashtag코드 설명:

hashtag주요 함수:

코드 설명:

주요 함수: