Add catchup indicator

Author: galt-tr

services/asset/httpimpl/GetCatchupStatus.go

@@ -0,0 +1,83 @@
+package httpimpl
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"github.com/bsv-blockchain/teranode/services/blockvalidation/blockvalidation_api"
+	"github.com/labstack/echo/v4"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+)
+
+// GetCatchupStatus returns the current catchup status from the BlockValidation service
+func (h *HTTP) GetCatchupStatus(c echo.Context) error {
+	ctx, cancel := context.WithTimeout(c.Request().Context(), 5*time.Second)
+	defer cancel()
+
+	// Connect to BlockValidation gRPC service
+	blockvalidationAddr := h.settings.BlockValidation.GRPCListenAddress
+	if blockvalidationAddr == "" {
+		blockvalidationAddr = "localhost:8082" // default
+	}
+
+	conn, err := grpc.DialContext(ctx, blockvalidationAddr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
+	if err != nil {
+		h.logger.Errorf("[GetCatchupStatus] Failed to connect to BlockValidation service: %v", err)
+		return c.JSON(http.StatusServiceUnavailable, map[string]interface{}{
+			"error": "Failed to connect to BlockValidation service",
+			"is_catching_up": false,
+		})
+	}
+	defer conn.Close()
+
+	// Call the GetCatchupStatus gRPC method
+	client := blockvalidation_api.NewBlockValidationAPIClient(conn)
+	resp, err := client.GetCatchupStatus(ctx, &blockvalidation_api.EmptyMessage{})
+	if err != nil {
+		h.logger.Errorf("[GetCatchupStatus] Failed to get catchup status: %v", err)
+		return c.JSON(http.StatusInternalServerError, map[string]interface{}{
+			"error": "Failed to get catchup status",
+			"is_catching_up": false,
+		})
+	}
+
+	// Convert gRPC response to JSON
+	jsonResp := map[string]interface{}{
+		"is_catching_up":         resp.IsCatchingUp,
+		"peer_id":                resp.PeerId,
+		"peer_url":               resp.PeerUrl,
+		"target_block_hash":      resp.TargetBlockHash,
+		"target_block_height":    resp.TargetBlockHeight,
+		"current_height":         resp.CurrentHeight,
+		"total_blocks":           resp.TotalBlocks,
+		"blocks_fetched":         resp.BlocksFetched,
+		"blocks_validated":       resp.BlocksValidated,
+		"start_time":             resp.StartTime,
+		"duration_ms":            resp.DurationMs,
+		"fork_depth":             resp.ForkDepth,
+		"common_ancestor_hash":   resp.CommonAncestorHash,
+		"common_ancestor_height": resp.CommonAncestorHeight,
+	}
+
+	// Add previous attempt if available
+	if resp.PreviousAttempt != nil {
+		jsonResp["previous_attempt"] = map[string]interface{}{
+			"peer_id":             resp.PreviousAttempt.PeerId,
+			"peer_url":            resp.PreviousAttempt.PeerUrl,
+			"target_block_hash":   resp.PreviousAttempt.TargetBlockHash,
+			"target_block_height": resp.PreviousAttempt.TargetBlockHeight,
+			"error_message":       resp.PreviousAttempt.ErrorMessage,
+			"error_type":          resp.PreviousAttempt.ErrorType,
+			"attempt_time":        resp.PreviousAttempt.AttemptTime,
+			"duration_ms":         resp.PreviousAttempt.DurationMs,
+			"blocks_validated":    resp.PreviousAttempt.BlocksValidated,
+		}
+	}
+
+	return c.JSON(http.StatusOK, jsonResp)
+}

services/asset/httpimpl/http.go

@@ -327,6 +327,9 @@ func New(logger ulogger.Logger, tSettings *settings.Settings, repo *repository.R
 	apiGroup.POST("/block/revalidate", blockHandler.RevalidateBlock)
 	apiGroup.GET("/blocks/invalid", blockHandler.GetLastNInvalidBlocks)
 
+	// Register catchup status endpoint
+	apiGroup.GET("/catchup/status", h.GetCatchupStatus)
+
 	// Add OPTIONS handlers for block operations
 	apiGroup.OPTIONS("/block/invalidate", func(c echo.Context) error {
 		return c.NoContent(http.StatusOK)

services/blockvalidation/Server.go

@@ -213,6 +213,24 @@ type Server struct {
 	// The success rate can be calculated as: catchupSuccesses / catchupAttempts.
 	// The value persists for the lifetime of the server and is never reset.
 	catchupSuccesses atomic.Int64
+
+	// activeCatchupCtx stores the current catchup context for status reporting to the dashboard.
+	// This is updated when a catchup operation starts and cleared when it completes.
+	// Protected by activeCatchupCtxMu for thread-safe access.
+	activeCatchupCtx   *CatchupContext
+	activeCatchupCtxMu sync.RWMutex
+
+	// catchupProgress tracks the current progress through block headers during catchup.
+	// blocksFetched and blocksValidated are updated as blocks are processed.
+	// These counters are reset at the start of each catchup operation.
+	// Protected by activeCatchupCtxMu for thread-safe access.
+	blocksFetched   atomic.Int64
+	blocksValidated atomic.Int64
+
+	// previousCatchupAttempt stores details about the last failed catchup attempt.
+	// This is used to display in the dashboard why we switched from one peer to another.
+	// Protected by activeCatchupCtxMu for thread-safe access.
+	previousCatchupAttempt *PreviousAttempt
 }
 
 // New creates a new block validation server with the provided dependencies.
@@ -427,6 +445,61 @@ func (u *Server) HealthGRPC(ctx context.Context, _ *blockvalidation_api.EmptyMes
 	}, errors.WrapGRPC(err)
 }
 
+// GetCatchupStatus returns the current catchup status via gRPC.
+// This method provides real-time information about ongoing catchup operations
+// for monitoring and dashboard display purposes.
+//
+// The response includes details about the peer being synced from, progress metrics,
+// and timing information. If no catchup is active, the response will indicate
+// IsCatchingUp=false and other fields will be empty/zero.
+//
+// This method is thread-safe and can be called concurrently with catchup operations.
+//
+// Parameters:
+//   - ctx: Context for the gRPC request
+//   - _: Empty request message (unused but required by gRPC interface)
+//
+// Returns:
+//   - *blockvalidation_api.CatchupStatusResponse: Current catchup status
+//   - error: Any error encountered (always nil for this method)
+func (u *Server) GetCatchupStatus(ctx context.Context, _ *blockvalidation_api.EmptyMessage) (*blockvalidation_api.CatchupStatusResponse, error) {
+	status := u.getCatchupStatusInternal()
+
+	resp := &blockvalidation_api.CatchupStatusResponse{
+		IsCatchingUp:         status.IsCatchingUp,
+		PeerId:               status.PeerID,
+		PeerUrl:              status.PeerURL,
+		TargetBlockHash:      status.TargetBlockHash,
+		TargetBlockHeight:    status.TargetBlockHeight,
+		CurrentHeight:        status.CurrentHeight,
+		TotalBlocks:          int32(status.TotalBlocks),
+		BlocksFetched:        status.BlocksFetched,
+		BlocksValidated:      status.BlocksValidated,
+		StartTime:            status.StartTime,
+		DurationMs:           status.DurationMs,
+		ForkDepth:            status.ForkDepth,
+		CommonAncestorHash:   status.CommonAncestorHash,
+		CommonAncestorHeight: status.CommonAncestorHeight,
+	}
+
+	// Add previous attempt if available
+	if status.PreviousAttempt != nil {
+		resp.PreviousAttempt = &blockvalidation_api.PreviousCatchupAttempt{
+			PeerId:            status.PreviousAttempt.PeerID,
+			PeerUrl:           status.PreviousAttempt.PeerURL,
+			TargetBlockHash:   status.PreviousAttempt.TargetBlockHash,
+			TargetBlockHeight: status.PreviousAttempt.TargetBlockHeight,
+			ErrorMessage:      status.PreviousAttempt.ErrorMessage,
+			ErrorType:         status.PreviousAttempt.ErrorType,
+			AttemptTime:       status.PreviousAttempt.AttemptTime,
+			DurationMs:        status.PreviousAttempt.DurationMs,
+			BlocksValidated:   status.PreviousAttempt.BlocksValidated,
+		}
+	}
+
+	return resp, nil
+}
+
 // Init initializes the block validation server with required dependencies and services.
 // It establishes connections to subtree validation services, configures UTXO store access,
 // and starts background processing components. This method must be called before Start().