Go-libp2p四 | 穿透NAT

//chat.go
package main

const RelayProtocolRequest = "/relay/relayreq/1.0.0"
const RelayProtocolResponse = "/relay/relayrsp/1.0.0"
const FirstP2PMsg = "/First/P2PMsg/1.0.0"
const P2PMsg = "/Start/P2PMsg/1.0.0"
const RelayMsg = "/relay/relaymsg/1.0.0"


type NodeProtocol struct {
	node *Node
}

func NewNodeProtocol(server *Node)*NodeProtocol {
	protocol := &NodeProtocol{ node: server}
	server.SetStreamHandler(RelayProtocolResponse, protocol.onRsp)
	server.SetStreamHandler(FirstP2PMsg, protocol.onFirstP2PMsg)
	server.SetStreamHandler(P2PMsg, protocol.onP2PMsg)
	return protocol
}

func (p* NodeProtocol) onFirstP2PMsg(s network.Stream)  {
	buf, _ := ioutil.ReadAll(s)
	log.Println("receive onFirstP2PMsg: ", string(buf))
	time.Sleep(5*time.Second)
	p.node.CmdP2P()
}

func (p* NodeProtocol) onP2PMsg(s network.Stream)  {
	rw := bufio.NewReadWriter(bufio.NewReader(s), bufio.NewWriter(s))
	go p.node.writeData(rw)
	go p.node.readData(rw)
}

type Node struct {
	host.Host
	HoleService *holepunch.Service
	*NodeProtocol

	chatP2PAddr *peer.AddrInfo
	Ctx context.Context
	//记录RelayServer
	ServerAddrInfo *peer.AddrInfo
	//记录peers
	Mutex *sync.Mutex
	Peers *list.List
}

func NewNode(host host.Host, hps *holepunch.Service) *Node {
	relayServer := &Node{ Host: host, HoleService: hps, chatP2PAddr: new(peer.AddrInfo), Ctx: context.Background(), Mutex: new(sync.Mutex), Peers: new(list.List)}
	relayServer.NodeProtocol = NewNodeProtocol(relayServer)
	return relayServer
}

func (n* Node)ConnectNode(nodePeerID string, nodeAddr string) {
	log.Println("start ConnectNodeByRelay....", nodePeerID, nodeAddr)
	peerID, err := peer.Decode(nodePeerID)
	if err != nil {
		log.Println(err.Error())
		return
	}
	n.Network().(*swarm.Swarm).Backoff().Clear(peerID)

	var address = nodeAddr +"/p2p/" + n.ServerAddrInfo.ID.Pretty()  + "/p2p-circuit/p2p/" + peerID.Pretty()
	//var address = nodeAddr +"/p2p/" + peerID.Pretty() + "/p2p-circuit"
	//var address = nodeAddr +"/p2p/" + peerID.Pretty()
	//var address = "/p2p/"+ peerID.Pretty()
	chatTargetAddr, err := multiaddr.NewMultiaddr(address)
	if err != nil {
		log.Println("chatTargetAddr is err")
		log.Println(err.Error())
		return
	}

	chatTargetAddrInfo := peer.AddrInfo{
		ID:    peerID,
		Addrs: []multiaddr.Multiaddr{chatTargetAddr},
	}

	if err := n.Connect(n.Ctx, chatTargetAddrInfo); err != nil {
		log.Println("chatTargetAddr connect err")
		log.Println(err.Error())
		return
	}

	n.chatP2PAddr = &chatTargetAddrInfo
	n.sendMessage(chatTargetAddrInfo.ID, FirstP2PMsg, "Hello Im " + chatTargetAddrInfo.ID.Pretty())
	//n.CmdRelay()
}

func (n *Node)CmdP2P()  {
	log.Println("Cmdp2p start ....")
	peerInfo := n.chatP2PAddr

	n.Peerstore().AddAddrs(peerInfo.ID, peerInfo.Addrs, peerstore.ConnectedAddrTTL)
	err := n.HoleService.DirectConnect(peerInfo.ID)
	if err != nil {
		log.Println("DirectConnect error: ")
		log.Println(err.Error())
		return
	}

	s, err := n.NewStream(n.Ctx, peerInfo.ID, P2PMsg)
	if err != nil {
		log.Println("p2p NewStream err")
		log.Println(err)
		return
	}

	rw := bufio.NewReadWriter(bufio.NewReader(s), bufio.NewWriter(s))
	log.Println("opening p2p chat stream")
	log.Println("[INFO] p2p chat connected!")

	rw.WriteString("Hello this is  msg")
	rw.Flush()
	go n.writeData(rw)
	go n.readData(rw)
}

func makeRandomNode(relay string) *Node {
	peerInfo ,err := getPeerInfoByDest(relay)
	if err != nil {
		log.Println(err.Error())
		return nil
	}

	h, err := libp2p.New(
		libp2p.ListenAddrs(multiaddr.StringCast("/ip4/127.0.0.1/tcp/0/")),
		libp2p.EnableRelay(),
		libp2p.EnableAutoRelay(),
		libp2p.ForceReachabilityPrivate(),
		libp2p.StaticRelays([]peer.AddrInfo{*peerInfo}),
		libp2p.EnableHolePunching(),
	)

	if err != nil {
		log.Println(err.Error())
		return nil
	}
	hps := AddHolePunchService(h)
	if hps == nil { return nil}
	return NewNode(h, hps)
}

func main() {
	relay := flag.String("relay", "", "relay addrs")
	flag.Parse()

	if *relay == "" {
		fmt.Println("Please Use -relay ")
		return
	}
	flag.Parse()

	node := makeRandomNode(*relay)
	if err := node.ConnectRelay(*relay); err != nil {
		log.Println(err.Error())
		return
	}
	log.Println("Connect relay success Next Login...")
	node.Login()

	log.Println("Im ", node.ID())
	select {
	case <-node.Ctx.Done():
		log.Println(node.Ctx.Err().Error())
	}
}