Add WebTorrent module

pkg/core/helpers.go

@@ -1,71 +1,19 @@
 package core
 
 import (
-	"sync"
+	cryptorand "crypto/rand"
 )
 
-// Waiter support:
-// - autotart on first Wait
-// - block new waiters after last Done
-// - safe Done after finish
-type Waiter struct {
-	sync.WaitGroup
-	mu    sync.Mutex
-	state int // state < 0 means finish
-}
+const digits = "0123456789abcdefghijklmnopqrstuvwxyz"
+const maxSize = byte(len(digits))
 
-func (w *Waiter) Add(delta int) {
-	w.mu.Lock()
-	if w.state >= 0 {
-		w.state += delta
-		w.WaitGroup.Add(delta)
+func RandString(size byte) string {
+	b := make([]byte, size)
+	if _, err := cryptorand.Read(b); err != nil {
+		panic(err)
 	}
-	w.mu.Unlock()
-}
-
-func (w *Waiter) Wait() {
-	w.mu.Lock()
-	// first wait auto start waiter
-	if w.state == 0 {
-		w.state++
-		w.WaitGroup.Add(1)
+	for i := byte(0); i < size; i++ {
+		b[i] = digits[b[i]%maxSize]
 	}
-	w.mu.Unlock()
-
-	w.WaitGroup.Wait()
-}
-
-func (w *Waiter) Done() {
-	w.mu.Lock()
-
-	// safe run Done only when have tasks
-	if w.state > 0 {
-		w.state--
-		w.WaitGroup.Done()
-	}
-
-	// block waiter for any operations after last done
-	if w.state == 0 {
-		w.state = -1
-	}
-
-	w.mu.Unlock()
-}
-
-func (w *Waiter) WaitChan() <-chan struct{} {
-	var ch chan struct{}
-
-	w.mu.Lock()
-
-	if w.state >= 0 {
-		ch = make(chan struct{})
-		go func() {
-			w.Wait()
-			ch <- struct{}{}
-		}()
-	}
-
-	w.mu.Unlock()
-
-	return ch
+	return string(b)
 }

pkg/core/waiter.go

@@ -0,0 +1,71 @@
+package core
+
+import (
+	"sync"
+)
+
+// Waiter support:
+// - autotart on first Wait
+// - block new waiters after last Done
+// - safe Done after finish
+type Waiter struct {
+	sync.WaitGroup
+	mu    sync.Mutex
+	state int // state < 0 means finish
+}
+
+func (w *Waiter) Add(delta int) {
+	w.mu.Lock()
+	if w.state >= 0 {
+		w.state += delta
+		w.WaitGroup.Add(delta)
+	}
+	w.mu.Unlock()
+}
+
+func (w *Waiter) Wait() {
+	w.mu.Lock()
+	// first wait auto start waiter
+	if w.state == 0 {
+		w.state++
+		w.WaitGroup.Add(1)
+	}
+	w.mu.Unlock()
+
+	w.WaitGroup.Wait()
+}
+
+func (w *Waiter) Done() {
+	w.mu.Lock()
+
+	// safe run Done only when have tasks
+	if w.state > 0 {
+		w.state--
+		w.WaitGroup.Done()
+	}
+
+	// block waiter for any operations after last done
+	if w.state == 0 {
+		w.state = -1
+	}
+
+	w.mu.Unlock()
+}
+
+func (w *Waiter) WaitChan() <-chan struct{} {
+	var ch chan struct{}
+
+	w.mu.Lock()
+
+	if w.state >= 0 {
+		ch = make(chan struct{})
+		go func() {
+			w.Wait()
+			ch <- struct{}{}
+		}()
+	}
+
+	w.mu.Unlock()
+
+	return ch
+}

pkg/core/worker.go

@@ -0,0 +1,52 @@
+package core
+
+import (
+	"time"
+)
+
+type Worker struct {
+	timer *time.Timer
+	done  chan struct{}
+}
+
+// NewWorker run f after d
+func NewWorker(d time.Duration, f func() time.Duration) *Worker {
+	timer := time.NewTimer(d)
+	done := make(chan struct{})
+
+	go func() {
+		for {
+			select {
+			case <-timer.C:
+				if d = f(); d > 0 {
+					timer.Reset(d)
+					continue
+				}
+			case <-done:
+				timer.Stop()
+			}
+			break
+		}
+	}()
+
+	return &Worker{timer: timer, done: done}
+}
+
+// Do - instant timer run
+func (w *Worker) Do() {
+	if w == nil {
+		return
+	}
+	w.timer.Reset(0)
+}
+
+func (w *Worker) Stop() {
+	if w == nil {
+		return
+	}
+
+	select {
+	case w.done <- struct{}{}:
+	default:
+	}
+}