Vendor dependency cycle-free swarmkit

Moby imports Swarmkit; Swarmkit no longer imports Moby. In order to
accomplish this feat, Swarmkit has introduced a new plugin.Getter
interface so it could stop importing our pkg/plugingetter package. This
new interface is not entirely compatible with our
plugingetter.PluginGetter interface, necessitating a thin adapter.

Swarmkit had to jettison the CNM network allocator to stop having to
import libnetwork as the cnmallocator package is deeply tied to
libnetwork. Move the CNM network allocator into libnetwork, where it
belongs. The package had a short an uninteresting Git history in the
Swarmkit repository so no effort was made to retain history.

Signed-off-by: Cory Snider <csnider@mirantis.com>

vendor/code.cloudfoundry.org/clock/fakeclock/fake_clock.go

@@ -0,0 +1,139 @@
+package fakeclock
+
+import (
+	"errors"
+	"sync"
+	"time"
+
+	"code.cloudfoundry.org/clock"
+)
+
+type timeWatcher interface {
+	timeUpdated(time.Time)
+	shouldFire(time.Time) bool
+	repeatable() bool
+}
+
+type FakeClock struct {
+	now time.Time
+
+	watchers map[timeWatcher]struct{}
+	cond     *sync.Cond
+}
+
+func NewFakeClock(now time.Time) *FakeClock {
+	return &FakeClock{
+		now:      now,
+		watchers: make(map[timeWatcher]struct{}),
+		cond:     &sync.Cond{L: &sync.Mutex{}},
+	}
+}
+
+func (clock *FakeClock) Since(t time.Time) time.Duration {
+	return clock.Now().Sub(t)
+}
+
+func (clock *FakeClock) Now() time.Time {
+	clock.cond.L.Lock()
+	defer clock.cond.L.Unlock()
+
+	return clock.now
+}
+
+func (clock *FakeClock) Increment(duration time.Duration) {
+	clock.increment(duration, false, 0)
+}
+
+func (clock *FakeClock) IncrementBySeconds(seconds uint64) {
+	clock.Increment(time.Duration(seconds) * time.Second)
+}
+
+func (clock *FakeClock) WaitForWatcherAndIncrement(duration time.Duration) {
+	clock.WaitForNWatchersAndIncrement(duration, 1)
+}
+
+func (clock *FakeClock) WaitForNWatchersAndIncrement(duration time.Duration, numWatchers int) {
+	clock.increment(duration, true, numWatchers)
+}
+
+func (clock *FakeClock) NewTimer(d time.Duration) clock.Timer {
+	timer := newFakeTimer(clock, d, false)
+	clock.addTimeWatcher(timer)
+
+	return timer
+}
+
+func (clock *FakeClock) Sleep(d time.Duration) {
+	<-clock.NewTimer(d).C()
+}
+
+func (clock *FakeClock) After(d time.Duration) <-chan time.Time {
+	return clock.NewTimer(d).C()
+}
+
+func (clock *FakeClock) NewTicker(d time.Duration) clock.Ticker {
+	if d <= 0 {
+		panic(errors.New("duration must be greater than zero"))
+	}
+
+	timer := newFakeTimer(clock, d, true)
+	clock.addTimeWatcher(timer)
+
+	return newFakeTicker(timer)
+}
+
+func (clock *FakeClock) WatcherCount() int {
+	clock.cond.L.Lock()
+	defer clock.cond.L.Unlock()
+
+	return len(clock.watchers)
+}
+
+func (clock *FakeClock) increment(duration time.Duration, waitForWatchers bool, numWatchers int) {
+	clock.cond.L.Lock()
+
+	for waitForWatchers && len(clock.watchers) < numWatchers {
+		clock.cond.Wait()
+	}
+
+	now := clock.now.Add(duration)
+	clock.now = now
+
+	watchers := make([]timeWatcher, 0)
+	newWatchers := map[timeWatcher]struct{}{}
+	for w, _ := range clock.watchers {
+		fire := w.shouldFire(now)
+		if fire {
+			watchers = append(watchers, w)
+		}
+
+		if !fire || w.repeatable() {
+			newWatchers[w] = struct{}{}
+		}
+	}
+
+	clock.watchers = newWatchers
+
+	clock.cond.L.Unlock()
+
+	for _, w := range watchers {
+		w.timeUpdated(now)
+	}
+}
+
+func (clock *FakeClock) addTimeWatcher(tw timeWatcher) {
+	clock.cond.L.Lock()
+	clock.watchers[tw] = struct{}{}
+	clock.cond.L.Unlock()
+
+	// force the timer to fire
+	clock.Increment(0)
+
+	clock.cond.Broadcast()
+}
+
+func (clock *FakeClock) removeTimeWatcher(tw timeWatcher) {
+	clock.cond.L.Lock()
+	delete(clock.watchers, tw)
+	clock.cond.L.Unlock()
+}

vendor/code.cloudfoundry.org/clock/fakeclock/fake_ticker.go

@@ -0,0 +1,25 @@
+package fakeclock
+
+import (
+	"time"
+
+	"code.cloudfoundry.org/clock"
+)
+
+type fakeTicker struct {
+	timer clock.Timer
+}
+
+func newFakeTicker(timer *fakeTimer) *fakeTicker {
+	return &fakeTicker{
+		timer: timer,
+	}
+}
+
+func (ft *fakeTicker) C() <-chan time.Time {
+	return ft.timer.C()
+}
+
+func (ft *fakeTicker) Stop() {
+	ft.timer.Stop()
+}

vendor/code.cloudfoundry.org/clock/fakeclock/fake_timer.go

@@ -0,0 +1,87 @@
+package fakeclock
+
+import (
+	"sync"
+	"time"
+)
+
+type fakeTimer struct {
+	clock *FakeClock
+
+	mutex          sync.Mutex
+	completionTime time.Time
+	channel        chan time.Time
+	duration       time.Duration
+	repeat         bool
+}
+
+func newFakeTimer(clock *FakeClock, d time.Duration, repeat bool) *fakeTimer {
+	return &fakeTimer{
+		clock:          clock,
+		completionTime: clock.Now().Add(d),
+		channel:        make(chan time.Time, 1),
+		duration:       d,
+		repeat:         repeat,
+	}
+}
+
+func (ft *fakeTimer) C() <-chan time.Time {
+	ft.mutex.Lock()
+	defer ft.mutex.Unlock()
+	return ft.channel
+}
+
+func (ft *fakeTimer) reset(d time.Duration) bool {
+	currentTime := ft.clock.Now()
+
+	ft.mutex.Lock()
+	active := !ft.completionTime.IsZero()
+	ft.completionTime = currentTime.Add(d)
+	ft.mutex.Unlock()
+	return active
+}
+
+func (ft *fakeTimer) Reset(d time.Duration) bool {
+	active := ft.reset(d)
+	ft.clock.addTimeWatcher(ft)
+	return active
+}
+
+func (ft *fakeTimer) Stop() bool {
+	ft.mutex.Lock()
+	active := !ft.completionTime.IsZero()
+	ft.mutex.Unlock()
+
+	ft.clock.removeTimeWatcher(ft)
+
+	return active
+}
+
+func (ft *fakeTimer) shouldFire(now time.Time) bool {
+	ft.mutex.Lock()
+	defer ft.mutex.Unlock()
+
+	if ft.completionTime.IsZero() {
+		return false
+	}
+
+	return now.After(ft.completionTime) || now.Equal(ft.completionTime)
+}
+
+func (ft *fakeTimer) repeatable() bool {
+	return ft.repeat
+}
+
+func (ft *fakeTimer) timeUpdated(now time.Time) {
+	select {
+	case ft.channel <- now:
+	default:
+		// drop on the floor. timers have a buffered channel anyway. according to
+		// godoc of the `time' package a ticker can loose ticks in case of a slow
+		// receiver
+	}
+
+	if ft.repeatable() {
+		ft.reset(ft.duration)
+	}
+}

vendor/code.cloudfoundry.org/clock/fakeclock/package.go

@@ -0,0 +1 @@
+package fakeclock // import "code.cloudfoundry.org/clock/fakeclock"