mirror of
https://github.com/opencloud-eu/opencloud.git
synced 2026-01-05 03:40:01 -06:00
ab321b744c
Bumps [github.com/oklog/run](https://github.com/oklog/run) from 1.1.0 to 1.2.0. - [Release notes](https://github.com/oklog/run/releases) - [Commits](https://github.com/oklog/run/compare/v1.1.0...v1.2.0) --- updated-dependencies: - dependency-name: github.com/oklog/run dependency-version: 1.2.0 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com>
92 lines
2.7 KiB
Markdown
92 lines
2.7 KiB
Markdown
# run
|
|
|
|
[](https://godoc.org/github.com/oklog/run)
|
|
[](https://github.com/oklog/run/actions/workflows/test.yaml)
|
|
[](https://goreportcard.com/report/github.com/oklog/run)
|
|
[](https://raw.githubusercontent.com/oklog/run/master/LICENSE)
|
|
|
|
run.Group is a universal mechanism to manage goroutine lifecycles.
|
|
|
|
Create a zero-value run.Group, and then add actors to it. Actors are defined as
|
|
a pair of functions: an **execute** function, which should run synchronously;
|
|
and an **interrupt** function, which, when invoked, should cause the execute
|
|
function to return. Finally, invoke Run, which concurrently runs all of the
|
|
actors, waits until the first actor exits, invokes the interrupt functions, and
|
|
finally returns control to the caller only once all actors have returned. This
|
|
general-purpose API allows callers to model pretty much any runnable task, and
|
|
achieve well-defined lifecycle semantics for the group.
|
|
|
|
run.Group was written to manage component lifecycles in func main for
|
|
[OK Log](https://github.com/oklog/oklog).
|
|
But it's useful in any circumstance where you need to orchestrate multiple
|
|
goroutines as a unit whole.
|
|
[Click here](https://www.youtube.com/watch?v=LHe1Cb_Ud_M&t=15m45s) to see a
|
|
video of a talk where run.Group is described.
|
|
|
|
## Examples
|
|
|
|
### context.Context
|
|
|
|
```go
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
g.Add(func() error {
|
|
return myProcess(ctx, ...)
|
|
}, func(error) {
|
|
cancel()
|
|
})
|
|
```
|
|
|
|
### net.Listener
|
|
|
|
```go
|
|
ln, _ := net.Listen("tcp", ":8080")
|
|
g.Add(func() error {
|
|
return http.Serve(ln, nil)
|
|
}, func(error) {
|
|
ln.Close()
|
|
})
|
|
```
|
|
|
|
### io.ReadCloser
|
|
|
|
```go
|
|
var conn io.ReadCloser = ...
|
|
g.Add(func() error {
|
|
s := bufio.NewScanner(conn)
|
|
for s.Scan() {
|
|
println(s.Text())
|
|
}
|
|
return s.Err()
|
|
}, func(error) {
|
|
conn.Close()
|
|
})
|
|
```
|
|
|
|
### http.Server graceful Shutdown
|
|
|
|
```go
|
|
httpServer := &http.Server{
|
|
Addr: "localhost:8080",
|
|
Handler: ...,
|
|
}
|
|
g.Add(func() error {
|
|
return httpServer.ListenAndServe()
|
|
}, func(error) {
|
|
ctx, cancel := context.WithTimeout(context.TODO(), 3*time.Second)
|
|
defer cancel()
|
|
httpServer.Shutdown(ctx)
|
|
})
|
|
```
|
|
|
|
## Comparisons
|
|
|
|
Package run is somewhat similar to package
|
|
[errgroup](https://godoc.org/golang.org/x/sync/errgroup),
|
|
except it doesn't require actor goroutines to understand context semantics.
|
|
|
|
It's somewhat similar to package
|
|
[tomb.v1](https://godoc.org/gopkg.in/tomb.v1) or
|
|
[tomb.v2](https://godoc.org/gopkg.in/tomb.v2),
|
|
except it has a much smaller API surface, delegating e.g. staged shutdown of
|
|
goroutines to the caller.
|