added preload transfer rate

pkg/fs/preload.go

@@ -4,7 +4,10 @@ package fs
 
 import (
 	"context"
+	"io"
+	"strconv"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/go-logr/logr"
@@ -54,14 +57,89 @@ func (q *queue) GetPreload(name string) *Preload {
 	return nil
 }
 
+type Rate struct {
+	r        io.Reader
+	done     chan struct{}
+	rate     atomic.Pointer[string]
+	num      int64
+	last     int64
+	interval int
+}
+
+var zeroRate = fmtRate(0)
+
+func newRate() *Rate {
+	r := &Rate{
+		done:     make(chan struct{}),
+		interval: 10,
+	}
+	r.rate.Store(&zeroRate)
+	return r
+}
+
+func (r *Rate) SetReader(reader io.Reader) {
+	r.r = reader
+	go r.sampler()
+}
+
+func (r *Rate) Read(b []byte) (n int, err error) {
+	n, err = r.r.Read(b)
+	atomic.AddInt64(&r.num, int64(n))
+	return
+}
+
+func fmtRate(r int) string {
+	switch {
+	case r >= GiB:
+		return strconv.FormatFloat(float64(r)/GiB, 'f', 2, 64) + " GiB/s"
+	case r >= MiB:
+		return strconv.FormatFloat(float64(r)/MiB, 'f', 2, 64) + " MiB/s"
+	case r >= KiB:
+		return strconv.FormatFloat(float64(r)/KiB, 'f', 2, 64) + " KiB/s"
+	}
+	return strconv.Itoa(r) + " B/s"
+}
+
+func (r *Rate) sampler() {
+	t := time.NewTicker(time.Duration(r.interval) * time.Second)
+	for {
+		select {
+		case <-r.done:
+			t.Stop()
+			return
+		case <-t.C:
+			num := atomic.LoadInt64(&r.num)
+			rate := int(num-r.last) / r.interval
+			r.last = num
+			s := fmtRate(rate)
+			r.rate.Store(&s)
+		}
+	}
+}
+
+func (r *Rate) String() string {
+	s := r.rate.Load()
+	if s == nil {
+		return ""
+	}
+	return *s
+}
+
+func (r *Rate) Stop() {
+	close(r.done)
+	r.rate.Store(&zeroRate)
+}
+
 type Preload struct {
 	ph      *PreloadHandler
+	rate    *Rate
 	delay   time.Duration
 	Name    string
 	cancel  func()
 	Prio    int
 	Status  int
 	Errc    int
+	Size    int64
 	Running bool
 }
 
@@ -132,6 +210,13 @@ func (ph *PreloadHandler) schedule() {
 	}
 }
 
+func (p *Preload) Rate() string {
+	if p.rate != nil {
+		return p.rate.String()
+	}
+	return ""
+}
+
 func (p *Preload) start() {
 	if p.Running {
 		return
@@ -153,7 +238,10 @@ func (p *Preload) start() {
 	ctx, cancel := context.WithCancel(context.Background())
 	p.Running = true
 	p.cancel = cancel
+	p.rate = newRate()
+	p.Size = f.size()
 	go f.Preload(ctx,
+		p.rate,
 		func() {
 			p.ph.fin <- name
 		},