Selective export (#770)

vendor/github.com/modern-go/concurrent/.gitignore

@@ -0,0 +1 @@
+/coverage.txt

vendor/github.com/modern-go/concurrent/.travis.yml

@@ -0,0 +1,14 @@
+language: go
+
+go:
+  - 1.8.x
+  - 1.x
+
+before_install:
+  - go get -t -v ./...
+
+script:
+  - ./test.sh
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

vendor/github.com/modern-go/concurrent/README.md

@@ -1,2 +1,49 @@
 # concurrent
-concurrency utilities
+
+[![Sourcegraph](https://sourcegraph.com/github.com/modern-go/concurrent/-/badge.svg)](https://sourcegraph.com/github.com/modern-go/concurrent?badge)
+[![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/modern-go/concurrent)
+[![Build Status](https://travis-ci.org/modern-go/concurrent.svg?branch=master)](https://travis-ci.org/modern-go/concurrent)
+[![codecov](https://codecov.io/gh/modern-go/concurrent/branch/master/graph/badge.svg)](https://codecov.io/gh/modern-go/concurrent)
+[![rcard](https://goreportcard.com/badge/github.com/modern-go/concurrent)](https://goreportcard.com/report/github.com/modern-go/concurrent)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://raw.githubusercontent.com/modern-go/concurrent/master/LICENSE)
+
+* concurrent.Map: backport sync.Map for go below 1.9
+* concurrent.Executor: goroutine with explicit ownership and cancellable
+
+# concurrent.Map
+
+because sync.Map is only available in go 1.9, we can use concurrent.Map to make code portable
+
+```go
+m := concurrent.NewMap()
+m.Store("hello", "world")
+elem, found := m.Load("hello")
+// elem will be "world"
+// found will be true
+```
+
+# concurrent.Executor
+
+```go
+executor := concurrent.NewUnboundedExecutor()
+executor.Go(func(ctx context.Context) {
+    everyMillisecond := time.NewTicker(time.Millisecond)
+    for {
+        select {
+        case <-ctx.Done():
+            fmt.Println("goroutine exited")
+            return
+        case <-everyMillisecond.C:
+            // do something
+        }
+    }
+})
+time.Sleep(time.Second)
+executor.StopAndWaitForever()
+fmt.Println("executor stopped")
+```
+
+attach goroutine to executor instance, so that we can
+
+* cancel it by stop the executor with Stop/StopAndWait/StopAndWaitForever
+* handle panic by callback: the default behavior will no longer crash your application

vendor/github.com/modern-go/concurrent/executor.go

@@ -2,6 +2,13 @@ package concurrent
 
 import "context"
 
+// Executor replace go keyword to start a new goroutine
+// the goroutine should cancel itself if the context passed in has been cancelled
+// the goroutine started by the executor, is owned by the executor
+// we can cancel all executors owned by the executor just by stop the executor itself
+// however Executor interface does not Stop method, the one starting and owning executor
+// should use the concrete type of executor, instead of this interface.
 type Executor interface {
+	// Go starts a new goroutine controlled by the context
 	Go(handler func(ctx context.Context))
-}
+}

vendor/github.com/modern-go/concurrent/go_above_19.go

@@ -4,10 +4,12 @@ package concurrent
 
 import "sync"
 
+// Map is a wrapper for sync.Map introduced in go1.9
 type Map struct {
 	sync.Map
 }
 
+// NewMap creates a thread safe Map
 func NewMap() *Map {
 	return &Map{}
-}
+}

vendor/github.com/modern-go/concurrent/go_below_19.go

@@ -4,17 +4,20 @@ package concurrent
 
 import "sync"
 
+// Map implements a thread safe map for go version below 1.9 using mutex
 type Map struct {
 	lock sync.RWMutex
 	data map[interface{}]interface{}
 }
 
+// NewMap creates a thread safe map
 func NewMap() *Map {
 	return &Map{
 		data: make(map[interface{}]interface{}, 32),
 	}
 }
 
+// Load is same as sync.Map Load
 func (m *Map) Load(key interface{}) (elem interface{}, found bool) {
 	m.lock.RLock()
 	elem, found = m.data[key]
@@ -22,9 +25,9 @@ func (m *Map) Load(key interface{}) (elem interface{}, found bool) {
 	return
 }
 
+// Load is same as sync.Map Store
 func (m *Map) Store(key interface{}, elem interface{}) {
 	m.lock.Lock()
 	m.data[key] = elem
 	m.lock.Unlock()
 }
-

vendor/github.com/modern-go/concurrent/log.go

@@ -0,0 +1,13 @@
+package concurrent
+
+import (
+	"os"
+	"log"
+	"io/ioutil"
+)
+
+// ErrorLogger is used to print out error, can be set to writer other than stderr
+var ErrorLogger = log.New(os.Stderr, "", 0)
+
+// InfoLogger is used to print informational message, default to off
+var InfoLogger = log.New(ioutil.Discard, "", 0)

vendor/github.com/modern-go/concurrent/test.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+echo "" > coverage.txt
+
+for d in $(go list ./... | grep -v vendor); do
+    go test -coverprofile=profile.out -coverpkg=github.com/modern-go/concurrent $d
+    if [ -f profile.out ]; then
+        cat profile.out >> coverage.txt
+        rm profile.out
+    fi
+done

vendor/github.com/modern-go/concurrent/unbounded_executor.go

@@ -4,33 +4,37 @@ import (
 	"context"
 	"fmt"
 	"runtime"
+	"runtime/debug"
 	"sync"
 	"time"
-	"runtime/debug"
+	"reflect"
 )
 
-var LogInfo = func(event string, properties ...interface{}) {
+// HandlePanic logs goroutine panic by default
+var HandlePanic = func(recovered interface{}, funcName string) {
+	ErrorLogger.Println(fmt.Sprintf("%s panic: %v", funcName, recovered))
+	ErrorLogger.Println(string(debug.Stack()))
 }
 
-var LogPanic = func(recovered interface{}, properties ...interface{}) interface{} {
-	fmt.Println(fmt.Sprintf("paniced: %v", recovered))
-	debug.PrintStack()
-	return recovered
-}
-
-const StopSignal = "STOP!"
-
+// UnboundedExecutor is a executor without limits on counts of alive goroutines
+// it tracks the goroutine started by it, and can cancel them when shutdown
 type UnboundedExecutor struct {
 	ctx                   context.Context
 	cancel                context.CancelFunc
 	activeGoroutinesMutex *sync.Mutex
 	activeGoroutines      map[string]int
+	HandlePanic           func(recovered interface{}, funcName string)
 }
 
 // GlobalUnboundedExecutor has the life cycle of the program itself
 // any goroutine want to be shutdown before main exit can be started from this executor
+// GlobalUnboundedExecutor expects the main function to call stop
+// it does not magically knows the main function exits
 var GlobalUnboundedExecutor = NewUnboundedExecutor()
 
+// NewUnboundedExecutor creates a new UnboundedExecutor,
+// UnboundedExecutor can not be created by &UnboundedExecutor{}
+// HandlePanic can be set with a callback to override global HandlePanic
 func NewUnboundedExecutor() *UnboundedExecutor {
 	ctx, cancel := context.WithCancel(context.TODO())
 	return &UnboundedExecutor{
@@ -41,8 +45,13 @@ func NewUnboundedExecutor() *UnboundedExecutor {
 	}
 }
 
+// Go starts a new goroutine and tracks its lifecycle.
+// Panic will be recovered and logged automatically, except for StopSignal
 func (executor *UnboundedExecutor) Go(handler func(ctx context.Context)) {
-	_, file, line, _ := runtime.Caller(1)
+	pc := reflect.ValueOf(handler).Pointer()
+	f := runtime.FuncForPC(pc)
+	funcName := f.Name()
+	file, line := f.FileLine(pc)
 	executor.activeGoroutinesMutex.Lock()
 	defer executor.activeGoroutinesMutex.Unlock()
 	startFrom := fmt.Sprintf("%s:%d", file, line)
@@ -50,46 +59,57 @@ func (executor *UnboundedExecutor) Go(handler func(ctx context.Context)) {
 	go func() {
 		defer func() {
 			recovered := recover()
-			if recovered != nil && recovered != StopSignal {
-				LogPanic(recovered)
+			// if you want to quit a goroutine without trigger HandlePanic
+			// use runtime.Goexit() to quit
+			if recovered != nil {
+				if executor.HandlePanic == nil {
+					HandlePanic(recovered, funcName)
+				} else {
+					executor.HandlePanic(recovered, funcName)
+				}
 			}
 			executor.activeGoroutinesMutex.Lock()
-			defer executor.activeGoroutinesMutex.Unlock()
 			executor.activeGoroutines[startFrom] -= 1
+			executor.activeGoroutinesMutex.Unlock()
 		}()
 		handler(executor.ctx)
 	}()
 }
 
+// Stop cancel all goroutines started by this executor without wait
 func (executor *UnboundedExecutor) Stop() {
 	executor.cancel()
 }
 
+// StopAndWaitForever cancel all goroutines started by this executor and
+// wait until all goroutines exited
 func (executor *UnboundedExecutor) StopAndWaitForever() {
 	executor.StopAndWait(context.Background())
 }
 
+// StopAndWait cancel all goroutines started by this executor and wait.
+// Wait can be cancelled by the context passed in.
 func (executor *UnboundedExecutor) StopAndWait(ctx context.Context) {
 	executor.cancel()
 	for {
-		fiveSeconds := time.NewTimer(time.Millisecond * 100)
+		oneHundredMilliseconds := time.NewTimer(time.Millisecond * 100)
 		select {
-		case <-fiveSeconds.C:
+		case <-oneHundredMilliseconds.C:
+			if executor.checkNoActiveGoroutines() {
+				return
+			}
 		case <-ctx.Done():
 			return
 		}
-		if executor.checkGoroutines() {
-			return
-		}
 	}
 }
 
-func (executor *UnboundedExecutor) checkGoroutines() bool {
+func (executor *UnboundedExecutor) checkNoActiveGoroutines() bool {
 	executor.activeGoroutinesMutex.Lock()
 	defer executor.activeGoroutinesMutex.Unlock()
 	for startFrom, count := range executor.activeGoroutines {
 		if count > 0 {
-			LogInfo("event!unbounded_executor.still waiting goroutines to quit",
+			InfoLogger.Println("UnboundedExecutor is still waiting goroutines to quit",
 				"startFrom", startFrom,
 				"count", count)
 			return false