a couple race fixes and use timer.AfterFunc instead of sleeping goroutines or ticker in a few places

src/yggdrasil/api.go

@@ -344,10 +344,8 @@ func (c *Core) GetNodeInfo(key crypto.BoxPubKey, coords []uint64, nocache bool)
 		c.router.nodeinfo.sendNodeInfo(key, wire_coordsUint64stoBytes(coords), false)
 	}
 	c.router.doAdmin(sendNodeInfoRequest)
-	go func() {
-		time.Sleep(6 * time.Second)
-		close(response)
-	}()
+	timer := time.AfterFunc(6*time.Second, func() { close(response) })
+	defer timer.Stop()
 	for res := range response {
 		return *res, nil
 	}

src/yggdrasil/debug.go

@@ -552,7 +552,7 @@ func (c *Core) DEBUG_addAllowedEncryptionPublicKey(boxStr string) {
 ////////////////////////////////////////////////////////////////////////////////
 
 func DEBUG_simLinkPeers(p, q *peer) {
-	// Sets q.out() to point to p and starts p.linkLoop()
+	// Sets q.out() to point to p and starts p.start()
 	goWorkers := func(source, dest *peer) {
 		source.linkOut = make(chan []byte, 1)
 		send := make(chan []byte, 1)
@@ -561,7 +561,7 @@ func DEBUG_simLinkPeers(p, q *peer) {
 				send <- bs
 			}
 		}
-		go source.linkLoop()
+		go source.start()
 		go func() {
 			var packets [][]byte
 			for {

src/yggdrasil/link.go

@@ -216,7 +216,7 @@ func (intf *linkInterface) handler() error {
 	intf.link.core.log.Infof("Connected %s: %s, source %s",
 		strings.ToUpper(intf.info.linkType), themString, intf.info.local)
 	// Start the link loop
-	go intf.peer.linkLoop()
+	go intf.peer.start()
 	// Start the writer
 	signalReady := make(chan struct{}, 1)
 	signalSent := make(chan bool, 1)

src/yggdrasil/nodeinfo.go

@@ -47,25 +47,25 @@ func (m *nodeinfo) init(core *Core) {
 	m.callbacks = make(map[crypto.BoxPubKey]nodeinfoCallback)
 	m.cache = make(map[crypto.BoxPubKey]nodeinfoCached)
 
-	go func() {
-		for {
-			m.callbacksMutex.Lock()
-			for boxPubKey, callback := range m.callbacks {
-				if time.Since(callback.created) > time.Minute {
-					delete(m.callbacks, boxPubKey)
-				}
+	var f func()
+	f = func() {
+		m.callbacksMutex.Lock()
+		for boxPubKey, callback := range m.callbacks {
+			if time.Since(callback.created) > time.Minute {
+				delete(m.callbacks, boxPubKey)
 			}
-			m.callbacksMutex.Unlock()
-			m.cacheMutex.Lock()
-			for boxPubKey, cache := range m.cache {
-				if time.Since(cache.created) > time.Hour {
-					delete(m.cache, boxPubKey)
-				}
-			}
-			m.cacheMutex.Unlock()
-			time.Sleep(time.Second * 30)
 		}
-	}()
+		m.callbacksMutex.Unlock()
+		m.cacheMutex.Lock()
+		for boxPubKey, cache := range m.cache {
+			if time.Since(cache.created) > time.Hour {
+				delete(m.cache, boxPubKey)
+			}
+		}
+		m.cacheMutex.Unlock()
+		time.AfterFunc(time.Second*30, f)
+	}
+	go f()
 }
 
 // Add a callback for a nodeinfo lookup

src/yggdrasil/peer.go

@@ -184,18 +184,21 @@ func (ps *peers) sendSwitchMsgs(from phony.Actor) {
 
 // This must be launched in a separate goroutine by whatever sets up the peer struct.
 // It handles link protocol traffic.
-func (p *peer) linkLoop() {
-	tick := time.NewTicker(time.Second)
-	defer tick.Stop()
-	<-p.SyncExec(p._sendSwitchMsg) // Startup message
-	for {
-		select {
-		case <-p.done:
-			return
-		case _ = <-tick.C:
-			<-p.SyncExec(p._updateDHT)
-		}
+func (p *peer) start() {
+	var updateDHT func()
+	updateDHT = func() {
+		<-p.SyncExec(func() {
+			select {
+			case <-p.done:
+			default:
+				p._updateDHT()
+				time.AfterFunc(time.Second, updateDHT)
+			}
+		})
 	}
+	updateDHT()
+	// Just for good measure, immediately send a switch message to this peer when we start
+	<-p.SyncExec(p._sendSwitchMsg)
 }
 
 func (p *peer) _updateDHT() {

src/yggdrasil/router.go

@@ -92,7 +92,7 @@ func (r *router) reconfigure(e chan error) {
 // Starts the tickerLoop goroutine.
 func (r *router) start() error {
 	r.core.log.Infoln("Starting router")
-	go r.tickerLoop()
+	go r.doMaintenance()
 	return nil
 }
 
@@ -122,18 +122,14 @@ func (r *router) reset(from phony.Actor) {
 
 // TODO remove reconfigure so this is just a ticker loop
 // and then find something better than a ticker loop to schedule things...
-func (r *router) tickerLoop() {
-	ticker := time.NewTicker(time.Second)
-	defer ticker.Stop()
-	for {
-		<-ticker.C
-		<-r.SyncExec(func() {
-			// Any periodic maintenance stuff goes here
-			r.core.switchTable.doMaintenance()
-			r.dht.doMaintenance()
-			r.sessions.cleanup()
-		})
-	}
+func (r *router) doMaintenance() {
+	<-r.SyncExec(func() {
+		// Any periodic maintenance stuff goes here
+		r.core.switchTable.doMaintenance()
+		r.dht.doMaintenance()
+		r.sessions.cleanup()
+	})
+	time.AfterFunc(time.Second, r.doMaintenance)
 }
 
 // Checks incoming traffic type and passes it to the appropriate handler.

src/yggdrasil/search.go

@@ -152,18 +152,16 @@ func (sinfo *searchInfo) continueSearch() {
 	// In case the search dies, try to spawn another thread later
 	// Note that this will spawn multiple parallel searches as time passes
 	// Any that die aren't restarted, but a new one will start later
-	retryLater := func() {
-		// FIXME this keeps the search alive forever if not for the searches map, fix that
-		newSearchInfo := sinfo.searches.searches[sinfo.dest]
-		if newSearchInfo != sinfo {
-			return
-		}
-		sinfo.continueSearch()
-	}
-	go func() {
-		time.Sleep(search_RETRY_TIME)
-		sinfo.searches.router.doAdmin(retryLater)
-	}()
+	time.AfterFunc(search_RETRY_TIME, func() {
+		sinfo.searches.router.RecvFrom(nil, func() {
+			// FIXME this keeps the search alive forever if not for the searches map, fix that
+			newSearchInfo := sinfo.searches.searches[sinfo.dest]
+			if newSearchInfo != sinfo {
+				return
+			}
+			sinfo.continueSearch()
+		})
+	})
 }
 
 // Calls create search, and initializes the iterative search parts of the struct before returning it.

src/yggdrasil/session.go

@@ -262,7 +262,6 @@ func (ss *sessions) createSession(theirPermKey *crypto.BoxPubKey) *sessionInfo {
 			sinfo.sessions.removeSession(&sinfo)
 		})
 	}()
-	//go sinfo.startWorkers()
 	return &sinfo
 }
 

src/yggdrasil/switch.go

@@ -200,10 +200,8 @@ func (t *switchTable) init(core *Core) {
 }
 
 func (t *switchTable) reconfigure(e chan error) {
-	go func() {
-		defer close(e)
-		// This is where reconfiguration would go, if we had anything useful to do.
-	}()
+	defer close(e)
+	// This is where reconfiguration would go, if we had anything useful to do.
 }
 
 // Safely gets a copy of this node's locator.