2025-09-09 15:40:44

Author: mohanson

daze.go

@@ -1209,7 +1209,7 @@ func LoadApnic() map[string][]*net.IPNet {
 	log.Println("main: load apnic data from", url)
 	rep := doa.Try(http.Get(url))
 	defer rep.Body.Close()
-	f := io.TeeReader(rep.Body, pretty.NewProgressWriter(rep.ContentLength))
+	f := io.TeeReader(rep.Body, pretty.NewProgressWriter(uint64(rep.ContentLength)))
 	r := map[string][]*net.IPNet{}
 	s := bufio.NewScanner(f)
 	for s.Scan() {

lib/pretty/pretty.go

@@ -69,14 +69,14 @@ func NewProgress() *Progress {
 // ProgressWriter is an io.Writer that updates a progress bar as data is written.
 type ProgressWriter struct {
 	p *Progress
-	m int64
-	n int64
+	m uint64
+	n uint64
 }
 
 // Write writes data to the ProgressWriter and updates the progress bar.
 func (p *ProgressWriter) Write(b []byte) (int, error) {
 	l := len(b)
-	p.m += int64(l)
+	p.m += uint64(l)
 	p.p.Print(float64(p.m) / float64(p.n))
 	return l, nil
 }
@@ -90,7 +90,7 @@ func (p *ProgressWriter) Write(b []byte) (int, error) {
 // Or to display progress while writing to a writer:
 //
 //	writer := io.MultiWriter(os.Stdout, NewProgressWriter(1024))
-func NewProgressWriter(n int64) *ProgressWriter {
+func NewProgressWriter(n uint64) *ProgressWriter {
 	p := NewProgress()
 	p.Print(0)
 	return &ProgressWriter{

lib/rate/rate.go

@@ -89,3 +89,27 @@ func NewLimits(r uint64, p time.Duration) *Limits {
 		step:     p / time.Duration(gcd),
 	}
 }
+
+// LimitsWriter is an io.Writer that applies rate limiting to write operations.
+//
+// For example, to limit a reader's read speed to 1MB/s:
+//
+//	reader := io.TeeReader(os.Stdin, NewLimitsWriter(1024*1024, time.Second))
+//
+// Or, to limit a writer's write speed to 1MB/s:
+//
+//	writer := io.MultiWriter(os.Stdout, NewLimitsWriter(1024*1024, time.Second))
+type LimitsWriter struct {
+	li *Limits
+}
+
+// Write writes data to the underlying writer, applying rate limiting based on the configured limits.
+func (l *LimitsWriter) Write(p []byte) (int, error) {
+	l.li.Wait(uint64(len(p)))
+	return len(p), nil
+}
+
+// NewLimitsWriter creates a new LimitsWriter that limits write operations to r bytes per period p.
+func NewLimitsWriter(limits *Limits) *LimitsWriter {
+	return &LimitsWriter{li: limits}
+}