1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
// Copyright (C) MongoDB, Inc. 2014-present.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
package signals
import (
"github.com/mongodb/mongo-tools/common/log"
"github.com/mongodb/mongo-tools/common/util"
"os"
"os/signal"
"syscall"
)
// Handle is like HandleWithInterrupt but it doesn't take a finalizer and will
// exit immediately after the first signal is received.
func Handle() chan struct{} {
return HandleWithInterrupt(nil)
}
// HandleWithInterrupt starts a goroutine which listens for SIGTERM, SIGINT, and
// SIGKILL and explicitly ignores SIGPIPE. It calls the finalizer function when
// the first signal is received and forcibly terminates the program after the
// second. If a nil function is provided, the program will exit after the first
// signal.
func HandleWithInterrupt(finalizer func()) chan struct{} {
finishedChan := make(chan struct{})
go handleSignals(finalizer, finishedChan)
return finishedChan
}
func handleSignals(finalizer func(), finishedChan chan struct{}) {
// explicitly ignore SIGPIPE; the tools should deal with write errors
noopChan := make(chan os.Signal)
signal.Notify(noopChan, syscall.SIGPIPE)
log.Logv(log.DebugLow, "will listen for SIGTERM, SIGINT, and SIGKILL")
sigChan := make(chan os.Signal, 2)
signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT, syscall.SIGKILL)
defer signal.Stop(sigChan)
if finalizer != nil {
select {
case sig := <-sigChan:
// first signal use finalizer to terminate cleanly
log.Logvf(log.Always, "signal '%s' received; attempting to shut down", sig)
finalizer()
case <-finishedChan:
return
}
}
select {
case sig := <-sigChan:
// second signal exits immediately
log.Logvf(log.Always, "signal '%s' received; forcefully terminating", sig)
os.Exit(util.ExitKill)
case <-finishedChan:
return
}
}
|
