Initial commit

vendor/github.com/ivpusic/grpool/BUILD.bazel

@@ -0,0 +1,23 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["grpool.go"],
+    importmap = "go-common/vendor/github.com/ivpusic/grpool",
+    importpath = "github.com/ivpusic/grpool",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/ivpusic/grpool/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Ivan Pusic
+
+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/ivpusic/grpool/README.md

@@ -0,0 +1,89 @@
+# grpool
+[![Build Status](https://travis-ci.org/ivpusic/grpool.svg?branch=master)](https://travis-ci.org/ivpusic/grpool)
+
+Lightweight Goroutine pool
+
+Clients can submit jobs. Dispatcher takes job, and sends it to first available worker.
+When worker is done with processing job, will be returned back to worker pool.
+
+Number of workers and Job queue size is configurable.
+
+## Docs
+https://godoc.org/github.com/ivpusic/grpool
+
+## Installation
+```
+go get github.com/ivpusic/grpool
+```
+
+## Simple example
+```Go
+package main
+
+import (
+  "fmt"
+  "runtime"
+  "time"
+
+  "github.com/ivpusic/grpool"
+)
+
+func main() {
+  // number of workers, and size of job queue
+  pool := grpool.NewPool(100, 50)
+
+  // release resources used by pool
+  defer pool.Release()
+
+  // submit one or more jobs to pool
+  for i := 0; i < 10; i++ {
+    count := i
+
+    pool.JobQueue <- func() {
+      fmt.Printf("I am worker! Number %d\n", count)
+    }
+  }
+
+  // dummy wait until jobs are finished
+  time.Sleep(1 * time.Second)
+}
+```
+
+## Example with waiting jobs to finish
+```Go
+package main
+
+import (
+  "fmt"
+  "runtime"
+
+  "github.com/ivpusic/grpool"
+)
+
+func main() {
+  // number of workers, and size of job queue
+  pool := grpool.NewPool(100, 50)
+  defer pool.Release()
+
+  // how many jobs we should wait
+  pool.WaitCount(10)
+
+  // submit one or more jobs to pool
+  for i := 0; i < 10; i++ {
+    count := i
+
+    pool.JobQueue <- func() {
+      // say that job is done, so we can know how many jobs are finished
+      defer pool.JobDone()
+
+      fmt.Printf("hello %d\n", count)
+    }
+  }
+
+  // wait until we call JobDone for all jobs
+  pool.WaitAll()
+}
+```
+
+## License
+*MIT*

vendor/github.com/ivpusic/grpool/grpool.go

@@ -0,0 +1,130 @@
+package grpool
+
+import "sync"
+
+// Gorouting instance which can accept client jobs
+type worker struct {
+	workerPool chan *worker
+	jobChannel chan Job
+	stop       chan struct{}
+}
+
+func (w *worker) start() {
+	go func() {
+		var job Job
+		for {
+			// worker free, add it to pool
+			w.workerPool <- w
+
+			select {
+			case job = <-w.jobChannel:
+				job()
+			case <-w.stop:
+				w.stop <- struct{}{}
+				return
+			}
+		}
+	}()
+}
+
+func newWorker(pool chan *worker) *worker {
+	return &worker{
+		workerPool: pool,
+		jobChannel: make(chan Job),
+		stop:       make(chan struct{}),
+	}
+}
+
+// Accepts jobs from clients, and waits for first free worker to deliver job
+type dispatcher struct {
+	workerPool chan *worker
+	jobQueue   chan Job
+	stop       chan struct{}
+}
+
+func (d *dispatcher) dispatch() {
+	for {
+		select {
+		case job := <-d.jobQueue:
+			worker := <-d.workerPool
+			worker.jobChannel <- job
+		case <-d.stop:
+			for i := 0; i < cap(d.workerPool); i++ {
+				worker := <-d.workerPool
+
+				worker.stop <- struct{}{}
+				<-worker.stop
+			}
+
+			d.stop <- struct{}{}
+			return
+		}
+	}
+}
+
+func newDispatcher(workerPool chan *worker, jobQueue chan Job) *dispatcher {
+	d := &dispatcher{
+		workerPool: workerPool,
+		jobQueue:   jobQueue,
+		stop:       make(chan struct{}),
+	}
+
+	for i := 0; i < cap(d.workerPool); i++ {
+		worker := newWorker(d.workerPool)
+		worker.start()
+	}
+
+	go d.dispatch()
+	return d
+}
+
+// Represents user request, function which should be executed in some worker.
+type Job func()
+
+type Pool struct {
+	JobQueue   chan Job
+	dispatcher *dispatcher
+	wg         sync.WaitGroup
+}
+
+// Will make pool of gorouting workers.
+// numWorkers - how many workers will be created for this pool
+// queueLen - how many jobs can we accept until we block
+//
+// Returned object contains JobQueue reference, which you can use to send job to pool.
+func NewPool(numWorkers int, jobQueueLen int) *Pool {
+	jobQueue := make(chan Job, jobQueueLen)
+	workerPool := make(chan *worker, numWorkers)
+
+	pool := &Pool{
+		JobQueue:   jobQueue,
+		dispatcher: newDispatcher(workerPool, jobQueue),
+	}
+
+	return pool
+}
+
+// In case you are using WaitAll fn, you should call this method
+// every time your job is done.
+//
+// If you are not using WaitAll then we assume you have your own way of synchronizing.
+func (p *Pool) JobDone() {
+	p.wg.Done()
+}
+
+// How many jobs we should wait when calling WaitAll.
+// It is using WaitGroup Add/Done/Wait
+func (p *Pool) WaitCount(count int) {
+	p.wg.Add(count)
+}
+
+// Will wait for all jobs to finish.
+func (p *Pool) WaitAll() {
+	p.wg.Wait()
+}
+
+// Will release resources used by pool
+func (p *Pool) Release() {
+	p.dispatcher.stop <- struct{}{}
+	<-p.dispatcher.stop
+}