Refactor

peer/peer.go

@@ -6,23 +6,23 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"math"
 	"net"
 	"net/http"
 	"net/netip"
 	"net/url"
-	"sync"
-	"sync/atomic"
+<<<<<<< HEAD
+	"os"
+=======
+>>>>>>> 69f2536 (WIP)
 	"vppn/m"
 )
 
 type peerMain struct {
-	conf       localConfig
-	rt         *atomic.Pointer[routingTable]
-	ifReader   *ifReader
-	connReader *connReader
-	iface      io.Writer
-	hubPoller  *hubPoller
-	super      *supervisor
+	Globals
+	ifReader   *IFReader
+	connReader *ConnReader
+	hubPoller  *HubPoller
 }
 
 type mainArgs struct {
@@ -53,12 +53,31 @@ func newPeerMain(args mainArgs) *peerMain {
 		log.Fatalf("Failed to load network state: %v", err)
 	}
 
-	iface, err := openInterface(config.Network, config.PeerIP, args.NetName)
+<<<<<<< HEAD
+	startupCount, err := loadStartupCount(args.NetName)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			log.Fatalf("Failed to load startup count: %v", err)
+		}
+	}
+
+	if startupCount.Count == math.MaxUint16 {
+		log.Fatalf("Startup counter overflow.")
+	}
+	startupCount.Count += 1
+
+	if err := storeStartupCount(args.NetName, startupCount); err != nil {
+		log.Fatalf("Failed to write startup count: %v", err)
+	}
+
+=======
+>>>>>>> 69f2536 (WIP)
+	iface, err := openInterface(config.Network, config.LocalPeerIP, args.NetName)
 	if err != nil {
 		log.Fatalf("Failed to open interface: %v", err)
 	}
 
-	localPeer := state.Peers[config.PeerIP]
+	localPeer := state.Peers[config.LocalPeerIP]
 
 	myAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", localPeer.Port))
 	if err != nil {
@@ -74,59 +93,47 @@ func newPeerMain(args mainArgs) *peerMain {
 	conn.SetReadBuffer(1024 * 1024 * 8)
 	conn.SetWriteBuffer(1024 * 1024 * 8)
 
-	// Wrap write function - this is necessary to avoid starvation.
-	writeLock := sync.Mutex{}
-	writeToUDPAddrPort := func(b []byte, addr netip.AddrPort) (n int, err error) {
-		writeLock.Lock()
-		n, err = conn.WriteToUDPAddrPort(b, addr)
-		if err != nil {
-			logf("Failed to write packet: %v", err)
-		}
-		writeLock.Unlock()
-		return n, err
-	}
-
 	var localAddr netip.AddrPort
 	ip, localAddrValid := netip.AddrFromSlice(localPeer.PublicIP)
 	if localAddrValid {
 		localAddr = netip.AddrPortFrom(ip, localPeer.Port)
 	}
 
-	rt := newRoutingTable(localPeer.PeerIP, localAddr)
-	rtPtr := &atomic.Pointer[routingTable]{}
-	rtPtr.Store(&rt)
+<<<<<<< HEAD
+	g := NewGlobals(config, startupCount, localAddr, conn, iface)
+=======
+	g := NewGlobals(config, localAddr, conn, iface)
+>>>>>>> 69f2536 (WIP)
 
-	ifReader := newIFReader(iface, writeToUDPAddrPort, rtPtr)
-	super := newSupervisor(writeToUDPAddrPort, rtPtr, config.PrivKey)
-	connReader := newConnReader(conn.ReadFromUDPAddrPort, writeToUDPAddrPort, iface, super.HandleControlMsg, rtPtr)
-	hubPoller, err := newHubPoller(config.PeerIP, args.NetName, args.HubAddress, args.APIKey, super.HandleControlMsg)
+	hubPoller, err := NewHubPoller(g, args.NetName, args.HubAddress, args.APIKey)
 	if err != nil {
 		log.Fatalf("Failed to create hub poller: %v", err)
 	}
 
 	return &peerMain{
-		conf:       config,
-		rt:         rtPtr,
-		iface:      iface,
-		ifReader:   ifReader,
-		connReader: connReader,
+		Globals:    g,
+		ifReader:   NewIFReader(g),
+		connReader: NewConnReader(g, conn),
 		hubPoller:  hubPoller,
-		super:      super,
 	}
 }
 
 func (p *peerMain) Run() {
+	for i := range p.RemotePeers {
+		remote := p.RemotePeers[i].Load()
+		go newRemoteFSM(remote).Run()
+	}
 
 	go p.ifReader.Run()
 	go p.connReader.Run()
-	p.super.Start()
 
-	if !p.rt.Load().LocalAddr.IsValid() {
-		go runMCWriter(p.conf.PeerIP, p.conf.PrivSignKey)
-		go runMCReader(p.rt, p.super.HandleControlMsg)
+	if !p.LocalAddrValid {
+		go RunMCWriter(p.LocalPeerIP, p.PrivSignKey)
+		go RunMCReader(p.Globals)
 	}
 
 	go p.hubPoller.Run()
+
 	select {}
 }
 
@@ -171,8 +178,8 @@ func initPeerWithHub(args mainArgs) {
 		log.Fatalf("Failed to parse configuration: %v\n%s", err, data)
 	}
 
-	config := localConfig{}
-	config.PeerIP = initResp.PeerIP
+	config := LocalConfig{}
+	config.LocalPeerIP = initResp.PeerIP
 	config.Network = initResp.Network
 	config.PubKey = keys.PubKey
 	config.PrivKey = keys.PrivKey