misc: fix lint

Author: djkazic

channeldb/graph.go

@@ -248,51 +248,51 @@ func (c *ChannelGraph) startWorker() {
 }
 
 func (c *ChannelGraph) enqueueWriteOperation(op func() error) {
-	// Send the operation to the channel; non-blocking if the buffer isn't full
+	// Send the operation to the channel.
+	// This is non-blocking as long as the buffer isn't full.
 	select {
 	case c.writeOps <- op:
 		// Operation enqueued successfully
 	default:
-		// Handle the case where the channel is full
-		// Could log an error, block until space is available, or drop the operation
-		// For example, to block until space is available, remove the select and default case
 		log.Warn("writeOps queue is full, operation not enqueued")
 	}
 }
 
-func (g *ChannelGraph) populateGraphCache() {
+func (c *ChannelGraph) populateGraphCache() {
 	startTime := time.Now()
 	log.Debugf("Populating in-memory channel graph, this might " +
 		"take a while...")
 
-	err := g.ForEachNodeCacheable(
+	err := c.ForEachNodeCacheable(
 		func(tx kvdb.RTx, node GraphCacheNode) error {
-			g.graphCache.AddNodeFeatures(node)
+			c.graphCache.AddNodeFeatures(node)
 
 			return nil
 		},
 	)
 	if err != nil {
-		g.graphCacheErr = err
+		c.graphCacheErr = err
 		return
 	}
 
-	err = g.ForEachChannel(func(info *models.ChannelEdgeInfo,
+	err = c.ForEachChannel(func(info *models.ChannelEdgeInfo,
 		policy1, policy2 *models.ChannelEdgePolicy) error {
 
-		g.graphCache.AddChannel(info, policy1, policy2)
+		c.graphCache.AddChannel(info, policy1, policy2)
 
 		return nil
 	})
 	if err != nil {
-		g.graphCacheErr = err
+		c.graphCacheErr = err
 		return
 	}
 
-	log.Debugf("Finished populating in-memory channel graph (took "+
-		"%v, %s)", time.Since(startTime), g.graphCache.Stats())
+	if c.graphCache != nil {
+		log.Debugf("Finished populating in-memory channel graph (took "+
+			"%v, %s)", time.Since(startTime), c.graphCache.Stats())
+	}
 
-	g.graphCacheReady.Store(true)
+	c.graphCacheReady.Store(true)
 }
 
 func (c *ChannelGraph) getGraphCache() (*GraphCache, error) {
@@ -302,8 +302,7 @@ func (c *ChannelGraph) getGraphCache() (*GraphCache, error) {
 
 	// Check if graph cache is ready without waiting
 	if !c.graphCacheReady.Load() {
-		// Return an error or a special indicator that cache is not ready
-		// Caller should handle this case appropriately, maybe by queuing write operations
+		// Return an error to show that cache is not ready.
 		return nil, ErrGraphCacheNotReady
 	}
 
@@ -898,16 +897,18 @@ func (c *ChannelGraph) AddLightningNode(node *LightningNode,
 		Update: func(tx kvdb.RwTx) error {
 			graphCache, err := c.getGraphCache()
 			if err != nil {
-				if err == ErrGraphCacheNotReady {
+				if errors.Is(err, ErrGraphCacheNotReady) {
 					// Queue this update function
 					c.enqueueWriteOperation(func() error {
 						return c.AddLightningNode(
 							node,
 							op...,
 						)
 					})
+
 					return nil
 				}
+
 				return err
 			}
 
@@ -917,6 +918,7 @@ func (c *ChannelGraph) AddLightningNode(node *LightningNode,
 				)
 				err := graphCache.AddNode(tx, cNode)
 				if err != nil {
+
 					return err
 				}
 			}
@@ -1001,13 +1003,15 @@ func (c *ChannelGraph) DeleteLightningNode(nodePub route.Vertex) error {
 
 		graphCache, err := c.getGraphCache()
 		if err != nil {
-			if err == ErrGraphCacheNotReady {
+			if errors.Is(err, ErrGraphCacheNotReady) {
 				// Queue this delete function
 				c.enqueueWriteOperation(func() error {
 					return c.DeleteLightningNode(nodePub)
 				})
+
 				return nil
 			}
+
 			return err
 		}
 
@@ -1144,13 +1148,15 @@ func (c *ChannelGraph) addChannelEdge(tx kvdb.RwTx,
 
 	graphCache, err := c.getGraphCache()
 	if err != nil {
-		if err == ErrGraphCacheNotReady {
+		if errors.Is(err, ErrGraphCacheNotReady) {
 			// Queue this function
 			c.enqueueWriteOperation(func() error {
 				return c.addChannelEdge(tx, edge)
 			})
+
 			return nil
 		}
+
 		return err
 	}
 
@@ -1359,13 +1365,15 @@ func (c *ChannelGraph) UpdateChannelEdge(edge *models.ChannelEdgeInfo) error {
 
 		graphCache, err := c.getGraphCache()
 		if err != nil {
-			if err == ErrGraphCacheNotReady {
+			if errors.Is(err, ErrGraphCacheNotReady) {
 				// Queue this update function
 				c.enqueueWriteOperation(func() error {
 					return c.UpdateChannelEdge(edge)
 				})
+
 				return nil
 			}
+
 			return err
 		}
 
@@ -1606,13 +1614,15 @@ func (c *ChannelGraph) pruneGraphNodes(nodes kvdb.RwBucket,
 
 	graphCache, err := c.getGraphCache()
 	if err != nil {
-		if err == ErrGraphCacheNotReady {
+		if errors.Is(err, ErrGraphCacheNotReady) {
 			// Queue this prune operation
 			c.enqueueWriteOperation(func() error {
 				return c.pruneGraphNodes(nodes, edgeIndex)
 			})
+
 			return nil
 		}
+
 		return err
 	}
 
@@ -2660,10 +2670,18 @@ func (c *ChannelGraph) delChannelEdgeUnsafe(edges, edgeIndex, chanIndex,
 
 	graphCache, err := c.getGraphCache()
 	if err != nil {
-		if err == ErrGraphCacheNotReady {
+		if errors.Is(err, ErrGraphCacheNotReady) {
 			// Queue this delete function
 			c.enqueueWriteOperation(func() error {
-				return c.delChannelEdgeUnsafe(edges, edgeIndex, chanIndex, zombieIndex, chanID, isZombie, strictZombie)
+				return c.delChannelEdgeUnsafe(
+					edges,
+					edgeIndex,
+					chanIndex,
+					zombieIndex,
+					chanID,
+					isZombie,
+					strictZombie,
+				)
 			})
 			return nil
 		}
@@ -2929,7 +2947,7 @@ func updateEdgePolicy(tx kvdb.RwTx, edge *models.ChannelEdgePolicy,
 
 	graphCache, err := c.getGraphCache()
 	if err != nil {
-		if err == ErrGraphCacheNotReady {
+		if errors.Is(err, ErrGraphCacheNotReady) {
 			// Queue this update function
 			c.enqueueWriteOperation(func() error {
 				_, err := updateEdgePolicy(tx, edge, c)
@@ -3822,10 +3840,14 @@ func (c *ChannelGraph) MarkEdgeZombie(chanID uint64,
 
 		graphCache, err := c.getGraphCache()
 		if err != nil {
-			if err == ErrGraphCacheNotReady {
+			if errors.Is(err, ErrGraphCacheNotReady) {
 				// Queue this function
 				c.enqueueWriteOperation(func() error {
-					return c.MarkEdgeZombie(chanID, pubKey1, pubKey2)
+					return c.MarkEdgeZombie(
+						chanID,
+						pubKey1,
+						pubKey2,
+					)
 				})
 				return nil
 			}
@@ -3918,7 +3940,7 @@ func (c *ChannelGraph) markEdgeLiveUnsafe(tx kvdb.RwTx, chanID uint64) error {
 	// won't use it for path finding.
 	graphCache, err := c.getGraphCache()
 	if err != nil {
-		if err == ErrGraphCacheNotReady {
+		if errors.Is(err, ErrGraphCacheNotReady) {
 			// Queue the operation to add the channel back.
 			c.enqueueWriteOperation(func() error {
 				return c.markEdgeLiveUnsafe(tx, chanID)

channeldb/graph_test.go

@@ -3986,6 +3986,26 @@ func TestGraphCacheForEachNodeChannel(t *testing.T) {
 	require.Nil(t, getSingleChannel())
 }
 
+func waitForGraphCache(graph *ChannelGraph, timeout time.Duration) error {
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	timeoutChan := time.After(timeout)
+	for {
+		select {
+		case <-timeoutChan:
+			return fmt.Errorf("timed out waiting for graphCache " +
+				"to be ready")
+		case <-ticker.C:
+			if graphCache, err := graph.getGraphCache(); err != nil {
+				return fmt.Errorf("error getting graphCache: %v", err)
+			} else if graphCache != nil {
+				return nil
+			}
+		}
+	}
+}
+
 // TestGraphLoading asserts that the cache is properly reconstructed after a
 // restart.
 func TestGraphLoading(t *testing.T) {
@@ -4007,6 +4027,7 @@ func TestGraphLoading(t *testing.T) {
 	)
 	require.NoError(t, err)
 
+	waitForGraphCache(graph, 5*time.Second)
 	_, err = graph.getGraphCache()
 	require.NoError(t, err)
 
@@ -4024,6 +4045,7 @@ func TestGraphLoading(t *testing.T) {
 	)
 	require.NoError(t, err)
 
+	waitForGraphCache(graphReloaded, 5*time.Second)
 	_, err = graphReloaded.getGraphCache()
 	require.NoError(t, err)