skovtunenko / graterm Goto Github PK

It doesn't make sense to concurrently stop (HTTP) Server simultaneously when regular registered components are stopped.
The server shall be the first component to stop in a sequence of terminations.

To log it something like:

"registered hook for component: %q (priority: %d) finished termination in %v out of %v"

• Add more documentation for WithName()method . It is now not clear when to use this method
• And Hook type a detailed description
• Document, what will happen if the passed root context (to the Terminator constructor) will be canceled.
• Document that ctx that will be passed into actual termination hook is used only for cancellation signaling

To better reflect the purpose of the library, the core type Stopper shall be renamed to Terminator.

Update Readme.md with description and examples

• Update README.md to add more details regarding hooks with the same Order -- what would be the effect?
• Reformat code snippets in README.md to be vertical-oriented instead of horizontal-oriented.
• In README.md, choose fewer indentation spaces.
• Fix code indentation in this line: // ..........
• Try to refactor this function into smaller ones:

  graterm/terminator.go

  Lines 118 to 176 in 9ba2fb9

  	func (t *Terminator) waitShutdown(appCtx context.Context) {
  	defer t.wg.Done()
  	<-appCtx.Done() // Block until application context is done (most likely, when the registered os.Signal will be received)
  	t.hooksMx.Lock()
  	defer t.hooksMx.Unlock()
  	order := make([]int, 0, len(t.hooks))
  	for k := range t.hooks {
  	order = append(order, int(k))
  	}
  	sort.Ints(order)
  	for _, o := range order {
  	o := o
  	runWg := sync.WaitGroup{}
  	for _, c := range t.hooks[Order(o)] {
  	runWg.Add(1)
  	go func(f Hook) {
  	defer runWg.Done()
  	ctx, cancel := context.WithTimeout(context.Background(), f.timeout)
  	defer cancel()
  	var execDuration time.Duration
  	go func() {
  	currentTime := time.Now()
  	defer func() {
  	defer cancel()
  	execDuration = time.Since(currentTime)
  	if err := recover(); err != nil {
  	t.log.Printf("registered hook panicked after %v for %v, recovered: %+v", execDuration, &f, err)
  	}
  	}()
  	f.hookFunc(ctx)
  	}()
  	<-ctx.Done() // block until the hookFunc is over OR timeout has been expired
  	switch err := ctx.Err(); {
  	case errors.Is(err, context.DeadlineExceeded):
  	t.log.Printf("registered hook timed out after %v for %v", f.timeout, &f)
  	case errors.Is(err, context.Canceled):
  	t.log.Printf("registered hook finished termination in %v (out of maximum %v) for %v", execDuration, f.timeout, &f)
  	}
  	}(c)
  	}
  	runWg.Wait()
  	}
  	}

• In "Integration with HTTP server" doc section, fix indentation for ReadHeaderTimeout
• Remove HTTP server config to address Slowris attack (it is unnecessary details)
• Add "AwesomeGo" label to the repo.

Remove extra constructor to register default Signals.
Let this to be up to the API consumer.

Update the linter to the current v1.50.1 version:

https://github.com/golangci/golangci-lint/releases/tag/v1.50.1

Add goroutines leak test

• Update the go version in the testing matrix to test on the latest (officially supported by Google) Go versions: 1.18 and 1.19.
• Revisit annotations: https://github.com/skovtunenko/graterm/actions/runs/2781832066

• Move the Features section in README.md to be more visible
• Fix the description in * dependency only on a standard Go library

Update Readme.md with code quality metrics

Properly handle possible panics inside user-defined Hooks