Release v0.1.0

vendor/github.com/lightningnetwork/lnd/ticker/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2015-2018 Lightning Labs and The Lightning Network Developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/lightningnetwork/lnd/ticker/force.go

@@ -0,0 +1,105 @@
+package ticker
+
+import (
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Force implements the Ticker interface, and provides a method of force-feeding
+// ticks, even while paused.
+type Force struct {
+	isActive uint32 // used atomically
+
+	// Force is used to force-feed a ticks into the ticker. Useful for
+	// debugging when trying to wake an event.
+	Force chan time.Time
+
+	ticker <-chan time.Time
+	skip   chan struct{}
+
+	wg   sync.WaitGroup
+	quit chan struct{}
+}
+
+// A compile-time constraint to ensure Force satisfies the Ticker interface.
+var _ Ticker = (*Force)(nil)
+
+// NewForce returns a Force ticker, used for testing and debugging. It supports
+// the ability to force-feed events that get output by the
+func NewForce(interval time.Duration) *Force {
+	m := &Force{
+		ticker: time.NewTicker(interval).C,
+		Force:  make(chan time.Time),
+		skip:   make(chan struct{}),
+		quit:   make(chan struct{}),
+	}
+
+	// Proxy the real ticks to our Force channel if we are active.
+	m.wg.Add(1)
+	go func() {
+		defer m.wg.Done()
+		for {
+			select {
+			case t := <-m.ticker:
+				if atomic.LoadUint32(&m.isActive) == 0 {
+					continue
+				}
+
+				select {
+				case m.Force <- t:
+				case <-m.skip:
+				case <-m.quit:
+					return
+				}
+
+			case <-m.quit:
+				return
+			}
+		}
+	}()
+
+	return m
+}
+
+// Ticks returns a receive-only channel that delivers times at the ticker's
+// prescribed interval when active. Force-fed ticks can be delivered at any
+// time.
+//
+// NOTE: Part of the Ticker interface.
+func (m *Force) Ticks() <-chan time.Time {
+	return m.Force
+}
+
+// Resume starts underlying time.Ticker and causes the ticker to begin
+// delivering scheduled events.
+//
+// NOTE: Part of the Ticker interface.
+func (m *Force) Resume() {
+	atomic.StoreUint32(&m.isActive, 1)
+}
+
+// Pause suspends the underlying ticker, such that Ticks() stops signaling at
+// regular intervals.
+//
+// NOTE: Part of the Ticker interface.
+func (m *Force) Pause() {
+	atomic.StoreUint32(&m.isActive, 0)
+
+	// If the ticker fired and read isActive as true, it may still send the
+	// tick. We'll try to send on the skip channel to drop it.
+	select {
+	case m.skip <- struct{}{}:
+	default:
+	}
+}
+
+// Stop suspends the underlying ticker, such that Ticks() stops signaling at
+// regular intervals, and permanently frees up any resources.
+//
+// NOTE: Part of the Ticker interface.
+func (m *Force) Stop() {
+	m.Pause()
+	close(m.quit)
+	m.wg.Wait()
+}

vendor/github.com/lightningnetwork/lnd/ticker/go.mod

@@ -0,0 +1 @@
+module github.com/lightningnetwork/lnd/ticker

vendor/github.com/lightningnetwork/lnd/ticker/ticker.go

@@ -0,0 +1,126 @@
+package ticker
+
+import "time"
+
+// Ticker defines a resumable ticker interface, whose activity can be toggled to
+// free up resources during periods of inactivity.
+//
+// Example of resuming ticker:
+//
+//   ticker.Resume() // can remove to keep inactive at first
+//   defer ticker.Stop()
+//   for {
+//     select {
+//       case <-ticker.Tick():
+//         if shouldGoInactive {
+//           ticker.Pause()
+//           continue
+//         }
+//         ...
+//
+//       case <-otherEvent:
+//         ...
+//         if shouldGoActive {
+//           ticker.Resume()
+//         }
+//     }
+//
+// NOTE: ONE DOES NOT SIMPLY assume that Tickers are safe for concurrent access.
+type Ticker interface {
+	// Ticks returns a read-only channel delivering ticks according to a
+	// prescribed interval. The value returned does not need to be the same
+	// channel, and may be nil.
+	//
+	// NOTE: Callers should assume that reads from Ticks() are stale after
+	// any invocations of Resume, Pause, or Stop.
+	Ticks() <-chan time.Time
+
+	// Resume starts or resumes the underlying ticker, such that Ticks()
+	// will fire at regular intervals. After calling Resume, Ticks() should
+	// minimally send ticks at the prescribed interval.
+	//
+	// NOTE: It MUST be safe to call Resume at any time, and more than once
+	// successively.
+	Resume()
+
+	// Pause suspends the underlying ticker, such that Ticks() stops
+	// signaling at regular intervals. After calling Pause, the ticker
+	// should not send any ticks scheduled with the chosen interval. Forced
+	// ticks are still permissible, as in the case of the Force Ticker.
+	//
+	// NOTE: It MUST be safe to call Pause at any time, and more than once
+	// successively.
+	Pause()
+
+	// Stop suspends the underlying ticker, such that Ticks() stops
+	// signaling at regular intervals, and permanently frees up any
+	// remaining resources.
+	//
+	// NOTE: The behavior of a Ticker is undefined after calling Stop.
+	Stop()
+}
+
+// T is the production implementation of the resumable Ticker interface. This
+// allows various components to toggle their need for tick events, which may
+// vary depending on system load.
+type T struct {
+	// interval is the desired duration between ticks when active.
+	interval time.Duration
+
+	// ticker is the ephemeral, underlying time.Ticker. We keep a reference
+	// to this ticker so that it can be stopped and cleaned up on Pause or
+	// Stop.
+	ticker *time.Ticker
+}
+
+// A compile-time constraint to ensure T satisfies the Ticker interface.
+var _ Ticker = (*T)(nil)
+
+// New returns a new ticker that signals with the given interval when not
+// paused. The ticker starts off inactive.
+func New(interval time.Duration) *T {
+	return &T{
+		interval: interval,
+	}
+}
+
+// Ticks returns a receive-only channel that delivers times at the ticker's
+// prescribed interval. This method returns nil when the ticker is paused.
+//
+// NOTE: Part of the Ticker interface.
+func (t *T) Ticks() <-chan time.Time {
+	if t.ticker == nil {
+		return nil
+	}
+	return t.ticker.C
+}
+
+// Resume starts underlying time.Ticker and causes the ticker to begin
+// delivering scheduled events.
+//
+// NOTE: Part of the Ticker interface.
+func (t *T) Resume() {
+	if t.ticker == nil {
+		t.ticker = time.NewTicker(t.interval)
+	}
+}
+
+// Pause suspends the underlying ticker, such that Ticks() stops signaling at
+// regular intervals.
+//
+// NOTE: Part of the Ticker interface.
+func (t *T) Pause() {
+	if t.ticker != nil {
+		t.ticker.Stop()
+		t.ticker = nil
+	}
+}
+
+// Stop suspends the underlying ticker, such that Ticks() stops signaling at
+// regular intervals, and permanently frees up any resources. For this
+// implementation, this is equivalent to Pause.
+//
+// NOTE: Part of the Ticker interface.
+func (t *T) Stop() {
+	t.Pause()
+}