Streaming File Copy with Progress and SHA-256 Verification

package main

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
	"log"
	"os"
	"time"
)

func copyWithProgress(ctx context.Context, srcPath, dstPath string) (int64, string, error) {
	src, err := os.Open(srcPath)
	if err != nil {
		return 0, "", fmt.Errorf("open src: %w", err)
	}
	defer src.Close()

	dst, err := os.Create(dstPath)
	if err != nil {
		return 0, "", fmt.Errorf("create dst: %w", err)
	}
	defer func() {
		dst.Sync()
		dst.Close()
	}()

	hasher := sha256.New()
	buf := make([]byte, 256*1024)

	var total int64
	ticker := time.NewTicker(500 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			return total, "", ctx.Err()
		case <-ticker.C:
			log.Printf("copied %d bytes", total)
		default:
		}

		n, rerr := src.Read(buf)
		if n > 0 {
			chunk := buf[:n]
			hasher.Write(chunk)
			if _, werr := dst.Write(chunk); werr != nil {
				return total, "", fmt.Errorf("write dst: %w", werr)
			}
			total += int64(n)
		}
		if rerr != nil {
			if rerr == io.EOF {
				break
			}
			return total, "", fmt.Errorf("read src: %w", rerr)
		}
	}

	if err := dst.Sync(); err != nil {
		return total, "", fmt.Errorf("sync dst: %w", err)
	}

	sum := hex.EncodeToString(hasher.Sum(nil))
	return total, sum, nil
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	bytes, sha, err := copyWithProgress(ctx, "input.bin", "output.bin")
	if err != nil {
		log.Fatalf("copy failed: %v", err)
	}
	log.Printf("done bytes=%d sha256=%s", bytes, sha)
}