Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/x-mod/routine
go routine control, abstraction of the Main and some useful Executors.如果你不会管理Goroutine的话，用它
https://github.com/x-mod/routine
concurrent crontab goroutine job-scheduler repeat retry
Last synced: 14 days ago
JSON representation
go routine control, abstraction of the Main and some useful Executors.如果你不会管理Goroutine的话，用它
- Host: GitHub
- URL: https://github.com/x-mod/routine
- Owner: x-mod
- License: mit
- Created: 2019-03-04T12:25:23.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-01-11T07:24:07.000Z (10 months ago)
- Last Synced: 2024-07-31T20:51:54.764Z (3 months ago)
- Topics: concurrent, crontab, goroutine, job-scheduler, repeat, retry
- Language: Go
- Homepage:
- Size: 219 KB
- Stars: 61
- Watchers: 3
- Forks: 7
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-go - routine - go routine control with context, support: Main, Go, Pool and some useful Executors. (Goroutines / Search and Analytic Databases)
- awesome-go-extra - routine - 03-04T12:25:23Z|2020-10-08T05:51:14Z| (Goroutines / Advanced Console UIs)
README
routine
===
[](https://godoc.org/github.com/x-mod/routine) [](https://goreportcard.com/report/github.com/x-mod/routine) [](https://travis-ci.org/x-mod/routine) [](https://github.com/x-mod/routine/releases) [](https://coveralls.io/github/x-mod/routine?branch=master)
## Routine Architecture
## Quick Start
````go
package main
import (
"log"
"context"
"github.com/x-mod/routine"
)
func main(){
if err := routine.Main(
context.TODO(),
routine.Command("echo", routine.ARG("hello routine!")),
); err != nil {
log.Fatal(err)
}
}
````
Or you can just clone the repo, then running `go run quickstart/main.go`.
## Main Routine
The most functional feature is providing the `Main` function abstraction, you can use the `routine.Main` to wrap your main function logic very quickly.
````go
package main
import (
"context"
"github.com/x-mod/routine"
)
func MainGo(ctx context.Context) error {
log.Println("this is the Main Go func")
return nil
}
func ChildGo(ctx context.Context) error {
log.Println("this is the Child Go func")
return nil
}
func prepareGo(ctx context.Context) error {
log.Println("this is the prepare Go func")
return nil
}
func cleanupGo(ctx context.Context) error {
log.Println("this is the Clean Go func")
return nil
}
func main(){
log.Println(
routine.Main(
context.TODO(),
//main Go
routine.ExecutorFunc(MainGo),
//prpare Go
routine.Prepare(routine.ExecutorFunc(prepareGo)),
//cleanup Go
routine.Cleanup(routine.ExecutorFunc(cleanupGo)),
routine.Go(routine.ExecutorFunc(ChildGo)),//child Go
routine.Go(routine.ExecutorFunc(ChildGo)),
routine.Go(routine.ExecutorFunc(ChildGo)),
//signals
routine.Signal(syscall.SIGINT, routine.SigHandler(func() {
os.Exit(1)
})),
),
)
}
````
## Routine
create and control your own routine by `routine.New`.
````go
import "github.com/x-mod/routine"
err := routine.New(opts...).Execute(ctx)
````
## Executors
The package provides many useful executor adapters for you:
- guarantee
- timeout & deadline
- retry & repeat
- concurrent
- crontab
- parallel & sequence
- command
- profiling
with these executor adapters, you can building the most complex goroutine logic.
````go
import "github.com/x-mod/routine"
//timeout
timeout := routine.Timeout(time.Minute, exec)
//retry
retry := routine.Retry(3, exec)
//repeat
repeat := routine.Repeat(10, time.Second, exec)
//concurrent
concurrent := routine.Concurrent(4, exec)
//schedule executor
crontab := routine.Crontab("* * * * *", exec)
//command
command := routine.Command("echo", routine.ARG("hello routine!"))
//parallel
parallel := routine.Parallel(exec1, exec2, exec3, ...)
//sequence
sequece := routine.Append(exec1, exec2, exec3, ...)
````
# Enjoy
More details, please check the [example](example/main.go) and trace it.
````bash
$: go run example/main.go
# trace go routine & tasks
$: go tool trace trace.out
````
Then you can check the tasks like this:
