// ValidateMain is called by the generated validate command.
// ke: {"func": {"notest": true}}
func ValidateMain(path string) {
// Using process.Flags as the options means that the non-specified options are read from the
// command flags.
update := false
options := &process.Flags{
Update: &update,
Path: &path,
}
ctx, cancel, err := process.Initialise(context.Background(), options)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
// The log function outputs errors and messages to the console. We pass it in to permit testing.
log := func(message string) {
fmt.Println(message)
}
// The interrupt chanel signals that Ctrl+C or other OS interrupts have happened.
interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, os.Interrupt)
signal.Notify(interrupt, syscall.SIGTERM)
exitStatus := validateMain(ctx, cancel, log, interrupt)
wgctx.WaitAndExit(ctx, exitStatus)
}
func main() {
flag.Parse()
if *host == "" || *topic == "" {
fmt.Printf("pararm error,host=%s,topic=%s\n", *host, *topic)
os.Exit(0)
}
hosts := strings.Split(*host, ",")
//kafka
kafkaClient := NewKafkaClient()
err := kafkaClient.NewConsumer(hosts)
if err != nil {
os.Exit(-2)
}
defer kafkaClient.Close()
kafkaClient.GetTopicMsg(*topic)
// Trap SIGINT to trigger a shutdown.
signals := make(chan os.Signal, 2)
signal.Notify(signals, os.Interrupt)
signal.Notify(signals, os.Kill)
ConsumerLoop:
for {
select {
case msg := <-kafkaClient.Topicmap[*topic].Msgs:
log.Println("get msg ", string(msg.Value))
case <-signals:
break ConsumerLoop
}
}
}
func main() {
sigchan := make(chan os.Signal, 1)
signal.Notify(sigchan, os.Interrupt)
signal.Notify(sigchan, syscall.SIGTERM)
go func() {
<-sigchan
shutdownFlag = true
}()
rides = map[int64]*Ride{}
rideUpdates = make(chan *Ride, 0)
http.Handle("/live", websocket.Handler(livemap))
http.HandleFunc("/location", locationHandler)
// run main application in goroutine
go http.ListenAndServe(":8080", nil)
go updateClients()
go rideCleanup()
for !shutdownFlag {
time.Sleep(1 * time.Second)
}
shutdown()
os.Exit(1)
}
//Called by main
//If main dies, we get missed signals -> kill the parent and return
func backup() {
missed_signal := 0
sigint := make(chan os.Signal, 1)
sigquit := make(chan os.Signal, 1)
sigusr := make(chan os.Signal, 1)
signal.Notify(sigint, syscall.SIGINT)
signal.Notify(sigquit, syscall.SIGQUIT)
signal.Notify(sigusr, syscall.SIGUSR1)
ppid := os.Getppid()
log.Println("Backup started by pid: ", ppid)
for {
select {
case <-sigusr:
missed_signal = 0
time.Sleep(200 * time.Millisecond)
case <-sigint:
log.Println("Backup caught SIGINT, ignore")
case <-sigquit:
log.Println("Received SIGQUIT. Shutting down backup")
os.Exit(0)
default:
if missed_signal == 3 {
killParent(ppid)
return
}
missed_signal += 1
time.Sleep(200 * time.Millisecond)
}
}
}
func main() {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
cleanup()
os.Exit(1)
}()
name := flag.String("name", "default", "vm name")
flag.Parse()
if *name == "" {
os.Exit(10)
}
for {
fp, err := os.OpenFile("/tmp/"+*name, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
if err != nil {
panic(err)
}
fmt.Fprintf(fp, "%s:%d alive\n", *name, os.Getpid())
fp.Close()
time.Sleep(5 * time.Second)
}
}
// Start - Will loop throught each of servers and attempt to start them up.
// In case that channel receives single error it will kill function otherwise, will listen
// forever
func (m *Manager) Start() error {
m.Info("Starting service management...")
errors := make(chan error)
signal.Notify(m.GetInterruptChan(), os.Interrupt)
signal.Notify(m.GetInterruptChan(), syscall.SIGTERM)
go m.HandleInterrupt()
for _, serv := range m.Servers {
go func(serv servers.Serverer) {
if err := serv.Start(); err != nil {
errors <- err
}
}(serv)
}
select {
case err := <-errors:
return err
case <-m.GetInterruptChan():
m.Warn("Service management interrupt signal caught. Giving it few seconds before we shut down permanently...")
close(m.GetInterruptChan())
time.Sleep(m.InterruptWaitTimeout)
m.Info("All done :( We go underground now for good...")
return nil
}
}
func main() {
flag.Parse()
if helpFlag {
flag.Usage()
os.Exit(0)
}
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGTERM)
signal.Notify(c, os.Interrupt)
s := daemon.NewServer()
go func() {
<-c
if s != nil {
s.Close()
}
os.Exit(1)
}()
if s == nil {
util.Warn.Println("Failed to start Hover Server")
os.Exit(1)
}
util.Info.Printf("Hover Server listening on %s\n", listenSocket)
http.ListenAndServe(listenSocket, s.Handler())
}
func signalHandle() {
c := make(chan os.Signal)
signal.Notify(c)
signal.Notify(c, syscall.SIGHUP)
s := <-c
fmt.Println("get signal:", s)
}
func (lc *LogCourier) registerSignals() {
// *nix systems support SIGTERM so handle shutdown on that too
signal.Notify(lc.shutdown_chan, os.Interrupt, syscall.SIGTERM)
// *nix has SIGHUP for reload
signal.Notify(lc.reload_chan, syscall.SIGHUP)
}
func Launch(option *options.SysOption) {
signalChannel := make(chan os.Signal, 1)
signal.Notify(signalChannel, os.Interrupt)
signal.Notify(signalChannel, syscall.SIGTERM)
coremethods.Setup()
mustExit := false
stat := statistic.NewStatistic(*option)
manager := coresupport.NewCoreWorkerManager(*option, stat)
server := connectionserver.NewServer(*option, stat)
server.Start(manager)
manager.Start(server)
// wait
for !mustExit {
select {
case newSig := <-signalChannel:
{
if newSig != nil {
rllogger.Output(rllogger.LogInfo, "Stoping service, now wait..")
server.Stop()
manager.Stop()
}
}
case <-manager.OutSignalChannel:
{
rllogger.Output(rllogger.LogInfo, "Close manager.")
mustExit = true
}
}
}
manager.Close()
stat.Close()
close(signalChannel)
}
func watchSignals(ex chan struct{}, t chan Trigger) {
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, os.Interrupt)
signal.Notify(sigCh, syscall.SIGTERM)
signal.Notify(sigCh, syscall.SIGHUP)
// main control flow
for {
select {
// when exit chan closes, return
case <-ex:
return
// If a signal is caught, either shutdown or reload gracefully
case sig := <-sigCh:
switch sig {
case os.Interrupt:
fallthrough
case syscall.SIGTERM:
t <- TriggerStop
case syscall.SIGHUP:
t <- TriggerReload
}
}
}
}
func main() {
flag.Parse()
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Printf("Could not open profile file: %s", err)
} else {
log.Printf("Logging CPU profile to %s", *cpuprofile)
pprof.StartCPUProfile(f)
}
}
database := ridc.CreateDatabase()
go ridc.StartWebInterface(database)
go ridc.StartSocketInterface(database, "3001")
cleanup := func() {
pprof.StopCPUProfile()
}
signalHandler := make(chan os.Signal, 1)
signal.Notify(signalHandler, os.Interrupt)
signal.Notify(signalHandler, syscall.SIGTERM)
go func() {
<-signalHandler
log.Printf("Shutting down...")
cleanup()
os.Exit(1)
}()
select {}
}
func sigHandleDemo() {
sigRecv1 := make(chan os.Signal, 1)
sigs1 := []os.Signal{syscall.SIGINT, syscall.SIGQUIT}
fmt.Printf("Set notification for %s... [sigRecv1]\n", sigs1)
signal.Notify(sigRecv1, sigs1...)
sigRecv2 := make(chan os.Signal, 1)
sigs2 := []os.Signal{syscall.SIGQUIT}
fmt.Printf("Set notification for %s... [sigRecv2]\n", sigs2)
signal.Notify(sigRecv2, sigs2...)
var wg sync.WaitGroup
wg.Add(2)
go func() {
for sig := range sigRecv1 {
fmt.Printf("Received a signal from sigRecv1: %s\n", sig)
}
fmt.Printf("End. [sigRecv1]\n")
wg.Done()
}()
go func() {
for sig := range sigRecv2 {
fmt.Printf("Received a signal from sigRecv2: %s\n", sig)
}
fmt.Printf("End. [sigRecv2]\n")
wg.Done()
}()
fmt.Println("Wait for 2 seconds... ")
time.Sleep(2 * time.Second)
fmt.Printf("Stop notification...")
signal.Stop(sigRecv1)
close(sigRecv1)
fmt.Printf("done. [sigRecv1]\n")
wg.Wait()
}
func run(context *cli.Context) {
etcdURI, serverKey, uri := getOpts(context)
control := make(chan bool)
go loop(etcdURI, serverKey, uri, control)
go iterate(control)
sigTerm := make(chan os.Signal)
signal.Notify(sigTerm, syscall.SIGTERM)
sigHup := make(chan os.Signal)
signal.Notify(sigHup, syscall.SIGHUP)
go func() {
for {
<-sigHup
fmt.Println("SIGHUP received, deregistering")
control <- false
onNotHealthy(etcdURI, serverKey)
fmt.Println("deregistered, paused for 5 seconds")
time.Sleep(5 * time.Second)
go loop(etcdURI, serverKey, uri, control)
}
}()
<-sigTerm
fmt.Println("SIGTERM received, cleaning up")
control <- false
onNotHealthy(etcdURI, serverKey)
os.Exit(0)
}
// Run starts an elector loop.
func (e *Elector) Run() error {
log.Println("Starting elector.")
if e.updates != nil {
return fmt.Errorf("Elector has already been initialized. Electors can be started once.")
}
// 0 so blocks on updates while error handler is executing
e.updates = make(chan State)
go e.reconcileStateLoop()
go e.ElectionBackend.ElectionLoop(e.updates)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
e.updates <- StateNotLeader
log.Println("Allowing 10s for StateNotLeader to process.")
time.Sleep(10 * time.Second)
}()
group := sync.WaitGroup{}
group.Add(2)
defer group.Done()
group.Wait()
return nil
}
// We need to be able to intercept execution so we can inject signal handling in
// a "child." To do this we ensure that we can fork/exec the built test
// executable and have it do the childs work for us.
func init() {
if len(os.Args) != 2 {
return
} else if os.Args[1] != EXECUTION_TOKEN {
return
}
usr1 := make(chan os.Signal, 100)
usr2 := make(chan os.Signal, 100)
signal.Notify(usr1, syscall.SIGUSR1)
signal.Notify(usr2, syscall.SIGUSR2)
// Send a ready message to the user.
fmt.Fprintf(os.Stderr, "READY\n")
os.Stderr.Close()
for {
select {
case <-time.NewTimer(time.Second * 3).C:
fmt.Println("TIMEOUT")
os.Exit(1)
case <-usr1:
fmt.Println("SIGUSR1")
os.Exit(0)
case <-usr2:
fmt.Println("SIGUSR2")
os.Exit(0)
}
}
}
func main() {
path := flag.String("config", "/etc/pt-client.conf", "path to configuration file")
debug := flag.Bool("v", false, "debug mode")
flag.Parse()
parsed := LoadConfig(path)
if *debug {
SetLogLevel(LOG_LEVEL_DEBUG)
}
if !parsed {
os.Exit(1)
}
sig := make(chan os.Signal)
signal.Notify(sig, syscall.SIGHUP)
signal.Notify(sig, syscall.SIGINT)
signal.Notify(sig, syscall.SIGTERM)
ctrl := newController()
ctrl.RunLoop()
for {
s := <-sig
LogInfo("Got a signal: %d", s)
if s != nil {
if s == syscall.SIGHUP { // HUP
LogLotate()
} else {
LogInfo("Finalizing controls...")
ctrl.Stop()
LogInfo("Bye.")
break
}
}
}
}
// Golog function which starts local loggers
func Golog(windowLogGranularity int, keyLogGranularity int, standalone bool, serverAddr string) {
// Setup our receiver
receiver := &Receiver{
ServerAddress: serverAddr,
}
// Setup our loggers
l := &lgr{
Receiver: receiver,
}
l.setupLoggers()
// Trigger our updater in the background
l.Updater(windowLogGranularity, keyLogGranularity)
// Trap the exit signal
exitChan := make(chan os.Signal, 1)
signal.Notify(exitChan, os.Interrupt)
signal.Notify(exitChan, syscall.SIGTERM)
// And push remaining entries to the server
go func() {
// In cleanup, we need to
<-exitChan
l.SendLogs()
os.Exit(0)
}()
// Every 10 seconds, send logs
c := time.Tick(10 * time.Second)
for _ = range c {
l.SendLogs()
}
}
func HandleSignals(shutdownc <-chan io.Closer) {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGHUP)
signal.Notify(c, syscall.SIGINT)
for {
sig := <-c
sysSig, ok := sig.(syscall.Signal)
if !ok {
glog.Fatal("Not a unix signal")
}
switch sysSig {
case syscall.SIGHUP:
case syscall.SIGINT:
glog.Warningln("Got SIGTERM: shutting down")
donec := make(chan bool)
go func() {
cl := <-shutdownc
if err := cl.Close(); err != nil {
exitf("Error shutting down: %v", err)
}
donec <- true
}()
select {
case <-donec:
glog.Infoln("Shut down completed.")
os.Exit(0)
case <-time.After(5 * time.Second):
exitf("Timeout shutting down. Exiting uncleanly.")
}
default:
glog.Fatal("Received another signal, should not happen.")
}
}
}
func trapSignal() chan os.Signal {
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
return c
}
func main() {
watchDir, targetDir := "tmp/source", "tmp/target"
godotenv.Load(".env")
fm, err := fm.NewFM("mms_prod")
if err != nil {
panic(err)
}
defer fm.Destroy()
fm.Watch(watchDir, targetDir)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
fmt.Println("Bye Bye")
fm.Destroy()
os.Exit(0)
}()
quit := make(chan bool, 1)
/*
for {
fmt.Println("sleeping...")
time.Sleep(10 * time.Second) // or runtime.Gosched() or similar per @misterbee
}
*/
<-quit
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
log.Println("Initializing Imagemagick")
imagick.Initialize()
http.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
log.Println("Hit the /test route")
imagick.Terminate()
})
sigint := make(chan os.Signal, 1)
signal.Notify(sigint, syscall.SIGINT)
signal.Notify(sigint, syscall.SIGTERM)
go func() {
for {
<-sigint
log.Println("Caught SIGINT, shutting down imagick environment")
imagick.Terminate()
os.Exit(0)
}
}()
http.ListenAndServe(":4000", nil)
}
func main() {
g.LoadConfig()
g.InitialConn()
g.InitTransfers()
defer g.CloseConn()
lenz.InitLenz()
status.InitStatus()
network.InitVlan()
utils.WritePid(g.Config.PidFile)
defer os.Remove(g.Config.PidFile)
api.Serve()
status.Load()
status.StartMonitor()
health.Check()
app.Limit()
var c = make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
signal.Notify(c, syscall.SIGHUP)
signal.Notify(c, syscall.SIGKILL)
signal.Notify(c, syscall.SIGQUIT)
logs.Info("Eru Agent Catch", <-c)
}
func HandleSignals() {
sigs := make(chan os.Signal, 1)
infosigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
signal.Notify(infosigs, syscall.SIGTSTP)
go func() {
quitInProgress := false
for {
<-sigs
if quitInProgress == true {
os.Exit(1)
}
go GracefullQuit()
quitInProgress = true
}
}()
go func() {
for {
<-infosigs
DisplayInfo()
}
}()
}
func main() {
runtime, err := loadRuntime()
if err != nil {
panic(err)
}
if err := runtime.Cache.Load("cache.save"); err != nil {
fmt.Println("failed to restore cache", err)
}
go garnish.Start(runtime)
go func() {
sigusr2 := make(chan os.Signal, 1)
signal.Notify(sigusr2, syscall.SIGUSR2)
for {
<-sigusr2
runtime, err := loadRuntime()
if err != nil {
fmt.Println("invalid configuration, did not reload.", err)
} else {
garnish.Reload(runtime)
fmt.Println("reloaded")
}
}
}()
sigquit := make(chan os.Signal, 1)
signal.Notify(sigquit, syscall.SIGQUIT)
<-sigquit
if err := runtime.Cache.Save("cache.save", 5000, time.Second*10); err != nil {
fmt.Println("failed to save cache", err)
}
}
// setupStopSignals sets up UNIX-specific signals for terminating
// the program
func setupStopSignals(signalChannel chan os.Signal) {
// TODO: not sure whether SIGHUP should be used here, only if not in
// daemon mode
signal.Notify(signalChannel, syscall.SIGHUP)
signal.Notify(signalChannel, syscall.SIGTERM)
}
// runStart starts the cockroach node using --stores as the list of
// storage devices ("stores") on this machine and --gossip as the list
// of "well-known" hosts used to join this node to the cockroach
// cluster via the gossip network.
func runStart(cmd *cobra.Command, args []string) {
info := util.GetBuildInfo()
log.Infof("build Vers: %s", info.Vers)
log.Infof("build Tag: %s", info.Tag)
log.Infof("build Time: %s", info.Time)
log.Infof("build Deps: %s", info.Deps)
// Default user for servers.
Context.User = security.NodeUser
// First initialize the Context as it is used in other places.
err := Context.Init("start")
if err != nil {
log.Errorf("failed to initialize context: %s", err)
return
}
log.Info("starting cockroach cluster")
stopper := util.NewStopper()
stopper.AddWorker()
s, err := server.NewServer(Context, stopper)
if err != nil {
log.Errorf("failed to start Cockroach server: %s", err)
return
}
err = s.Start(false)
if err != nil {
log.Errorf("cockroach server exited with error: %s", err)
return
}
signalCh := make(chan os.Signal, 1)
signal.Notify(signalCh, os.Interrupt, os.Kill)
// TODO(spencer): move this behind a build tag.
signal.Notify(signalCh, syscall.SIGTERM)
// Block until one of the signals above is received or the stopper
// is stopped externally (for example, via the quit endpoint).
select {
case <-stopper.ShouldStop():
stopper.SetStopped()
case <-signalCh:
log.Infof("initiating graceful shutdown of server")
stopper.SetStopped()
go func() {
s.Stop()
}()
}
select {
case <-signalCh:
log.Warningf("second signal received, initiating hard shutdown")
case <-time.After(time.Minute):
log.Warningf("time limit reached, initiating hard shutdown")
return
case <-stopper.IsStopped():
log.Infof("server drained and shutdown completed")
}
log.Flush()
}
// Prepares the signal handlers so that we handle interrupts properly.
// The signal handler exists in a goroutine.
func setupSignalHandlers() {
ch := make(chan os.Signal, 1)
signal.Notify(ch, os.Interrupt)
signal.Notify(ch, syscall.SIGTERM)
go func() {
// First interrupt. We mostly ignore this because it allows the
// plugins time to cleanup.
<-ch
log.Println("First interrupt. Ignoring to allow plugins to clean up.")
//ui.Error("Interrupt signal received. Cleaning up...")
// Second interrupt. Go down hard.
<-ch
log.Println("Second interrupt. Exiting now.")
//ui.Error("Interrupt signal received twice. Forcefully exiting now.")
// Force kill all the plugins, but mark that we're killing them
// first so that we don't get panics everywhere.
//plugin.CleanupClients()
os.Exit(1)
}()
}
// Set up signal handlers. Go sends signal notifications to a "signal
// channel".
func setupSignals(cmd *exec.Cmd) chan os.Signal {
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGTERM)
signal.Notify(sigChan, syscall.SIGINT)
signal.Notify(sigChan, syscall.SIGQUIT)
return sigChan
}
func Init(service_interface IServiceInterface, port string) bool {
sigs := make(chan os.Signal)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGABRT, syscall.SIGTERM)
sigs_hub := make(chan os.Signal)
signal.Notify(sigs_hub, syscall.SIGHUP)
go func() {
for {
select {
case <-sigs:
{
fmt.Println("Terminate")
service_interface.Terminate()
break
}
case <-sigs_hub:
{
fmt.Println("reloadConfig")
service_interface.ReloadConfig()
}
}
}
}()
rand.New(rand.NewSource(time.Now().Unix()))
return service_interface.Init(port)
}