Detailed explanation of the implementation principle of go smooth restart library overseer

func (srv *Server) Serve(l ) error {
	if fn := testHookServerServe; fn != nil {
		fn(srv, l) // call hook with unwrapped listener
	}
 
	origListener := l
	l = &onceCloseListener{Listener: l}
	defer ()
 
	if err := srv.setupHTTP2_Serve(); err != nil {
		return err
	}
 
	if !(&l, true) {
		return ErrServerClosed
	}
	defer (&l, false)
 
	baseCtx := ()
	if  != nil {
		baseCtx = (origListener)
		if baseCtx == nil {
			panic("BaseContext returned a nil context")
		}
	}
 
	var tempDelay  // how long to sleep on accept failure
 
	ctx := (baseCtx, ServerContextKey, srv)
	for {
		rw, err := ()
		if err != nil {
			if () {
				return ErrServerClosed
			}
			if ne, ok := err.(); ok && () {
				if tempDelay == 0 {
					tempDelay = 5 * 
				} else {
					tempDelay *= 2
				}
				if max := 1 * ; tempDelay > max {
					tempDelay = max
				}
				("http: Accept error: %v; retrying in %v", err, tempDelay)
				(tempDelay)
				continue
			}
			return err
		}
		connCtx := ctx
		if cc := ; cc != nil {
			connCtx = cc(connCtx, rw)
			if connCtx == nil {
				panic("ConnContext returned nil")
			}
		}
		tempDelay = 0
		c := (rw)
		(, StateNew, runHooks) // before Serve can return
		go (connCtx)
	}
}

func (l *overseerListener) Accept() (, error) {
	conn, err := .(*).AcceptTCP()
	if err != nil {
		return nil, err
	}
	(true)                  // see 
	(3 * ) // see 
	uconn := overseerConn{
		Conn:   conn,
		wg:     &,
		closed: make(chan bool),
	}
	go func() {
		//connection watcher
		select {
		case <-:
			()
		case <-:
			//closed manually
		}
	}()
	(1)
	return uconn, nil
}
 
//non-blocking trigger close
func (l *overseerListener) release(timeout ) {
	//stop accepting connections - release fd
	 = ()
	//start timer, close by force if deadline not met
	waited := make(chan bool)
	go func() {
		()
		waited <- true
	}()
	go func() {
		select {
		case <-(timeout):
			close()
		case <-waited:
			//no need to force close
		}
	}()
}
 
//blocking wait for close
func (l *overseerListener) Close() error {
	()
	return 
}
 
func (o overseerConn) Close() error {
	err := ()
	if err == nil {
		()
		 <- true
	}
	return err
}

func (mp *master) retreiveFileDescriptors() error {
	 = make([]*, len())
	for i, addr := range  {
		a, err := ("tcp", addr)
		if err != nil {
			return ("Invalid address %s (%s)", addr, err)
		}
		l, err := ("tcp", a)
		if err != nil {
			return err
		}
		f, err := ()
		if err != nil {
			return ("Failed to retreive fd for: %s (%s)", addr, err)
		}
		if err := (); err != nil {
			return ("Failed to close listener for: %s (%s)", addr, err)
		}
		[i] = f
	}
	return nil
}

func (mp *master) fork() error {
	("starting %s", )
	cmd := ()
	//mark this new process as the "active" slave process.
	//this process is assumed to be holding the socket files.
	 = cmd
	++
	//provide the slave process with some state
	e := ()
	e = append(e, envBinID+"="+())
	e = append(e, envBinPath+"="+)
	e = append(e, envSlaveID+"="+())
	e = append(e, envIsSlave+"=1")
	e = append(e, envNumFDs+"="+(len()))
	 = e
	//inherit master args/stdfiles
	 = 
	 = 
	 = 
	 = 
	//include socket files
	 = 
	if err := (); err != nil {
		return ("Failed to start slave process: %s", err)
	}
	//was scheduled to restart, notify success
	if  {
		 = ()
		 = false
		 <- true
	}
	//convert wait into channel
	cmdwait := make(chan error)
	go func() {
		cmdwait <- ()
	}()
	//wait....
	select {
	case err := <-cmdwait:
		//program exited before releasing descriptors
		//proxy exit code out to master
		code := 0
		if err != nil {
			code = 1
			if exiterr, ok := err.(*); ok {
				if status, ok := ().(); ok {
					code = ()
				}
			}
		}
		("prog exited with %d", code)
		//if a restarts are disabled or if it was an
		//unexpected crash, proxy this exit straight
		//through to the main process
		if  || ! {
			(code)
		}
	case <-:
		//if descriptors are released, the program
		//has yielded control of its sockets and
		//a parallel instance of the program can be
		//started safely. it should serve 
		//to ensure downtime is kept at <1sec. The previous
		//() will still be consumed though the
		//result will be discarded.
	}
	return nil
}

func (sp *slave) run() error {
	 = (envSlaveID)
	("run")
	 = true
	 = (envBinID)
	 = ()
	 = 
	 = 
	 = make(chan bool, 1)
	 = (envBinPath)
	if err := (); err != nil {
		return err
	}
	if err := (); err != nil {
		return err
	}
	()
	//run program with state
	("start program")
	()
	return nil
}
 
func (sp *slave) initFileDescriptors() error {
	//inspect file descriptors
	numFDs, err := ((envNumFDs))
	if err != nil {
		return ("invalid %s integer", envNumFDs)
	}
	 = make([]*overseerListener, numFDs)
	 = make([], numFDs)
	for i := 0; i < numFDs; i++ {
		f := (uintptr(3+i), "")
		l, err := (f)
		if err != nil {
			return ("failed to inherit file descriptor: %d", i)
		}
		u := newOverseerListener(l)
		[i] = u
		[i] = u
	}
	if len() > 0 {
		 = [0]
	}
	return nil
}

// convert your 'main()' into a 'prog(state)'
// 'prog()' is run in a child process
func prog(state ) {
	("app#%s (%s) listening...\n", BuildID, )
	("/", (func(w , r *) {
		d, _ := (().Get("d"))
		(d)
		(w, "app#%s (%s) %v says hello\n", BuildID, , )
	}))
	(, nil)
	("app#%s (%s) exiting...\n", BuildID, )
}
 
// then create another 'main' which runs the upgrades
// 'main()' is run in the initial process
func main() {
	({
		Program:          prog,
		Address:          ":5001",
		Fetcher:          &{Path: "my_app_next"},
		Debug:            true, //display log of overseer actions
		TerminateTimeout: 10 * ,
	})
}

// fetchLoop is run in a goroutine
func (mp *master) fetchLoop() {
	min := 
	(min)
	for {
		t0 := ()
		()
		//duration fetch of fetch
		diff := ().Sub(t0)
		if diff < min {
			delay := min - diff
			//ensures at least MinFetchInterval delay.
			//should be throttled by the fetcher!
			(delay)
		}
	}
}

	//tee off to sha1
	hash := ()
	reader = (reader, hash)
	//write to a temp file
	_, err = (tmpBin, reader)
	if err != nil {
		("failed to write temp binary: %s", err)
		return
	}
	//compare hash
	newHash := (nil)
	if (, newHash) {
		("hash match - skip")
		return
	}

	tokenIn := token()
	cmd := (tmpBinPath)
	 = append((), []string{envBinCheck + "=" + tokenIn}...)
	 = 
	returned := false
	go func() {
		(5 * )
		if !returned {
			("sanity check against fetched executable timed-out, check overseer is running")
			if  != nil {
				()
			}
		}
	}()
	tokenOut, err := ()
	returned = true
	if err != nil {
		("failed to run temp binary: %s (%s) output \"%s\"", err, tmpBinPath, tokenOut)
		return
	}
	if tokenIn != string(tokenOut) {
		("sanity check failed")
		return
	}

//sanityCheck returns true if a check was performed
func sanityCheck() bool {
	//sanity check
	if token := (envBinCheck); token != "" {
		(, token)
		return true
	}
	//legacy sanity check using old env var
	if token := (envBinCheckLegacy); token != "" {
		(, token)
		return true
	}
	return false
}

	//overwrite!
	if err := overwrite(, tmpBinPath); err != nil {
		("failed to overwrite binary: %s", err)
		return
	}
	("upgraded binary (%x -> %x)", [:12], newHash[:12])
	 = newHash
	//binary successfully replaced
	if ! {
		()
	}

func (mp *master) triggerRestart() {
	if  {
		("already graceful restarting")
		return //skip
	} else if  == nil ||  {
		("no slave process")
		return //skip
	}
	("graceful restart triggered")
	 = true
	mp.awaitingUSR1 = true
	 = ()
	() //ask nicely to terminate
	select {
	case <-:
		//success
		("restart success")
	case <-():
		//times up mr. process, we did ask nicely!
		("graceful timeout, forcing exit")
		()
	}
}

		if len() > 0 {
			//perform graceful shutdown
			for _, l := range  {
				()
			}
			//signal release of held sockets, allows master to start
			//a new process before this child has actually exited.
			//early restarts not supported with restarts disabled.
			if ! {
				(SIGUSR1)
			}
			//listeners should be waiting on connections to close...
		}

	//**during a restart** a SIGUSR1 signals
	//to the master process that, the file
	//descriptors have been released
	if mp.awaitingUSR1 && s == SIGUSR1 {
		("signaled, sockets ready")
		mp.awaitingUSR1 = false
		 <- true
	} else

func (mp *master) fork() error {
    //... ...
    //... ...
    //... ...
	//convert wait into channel
	cmdwait := make(chan error)
	go func() {
		cmdwait <- ()
	}()
	//wait....
	select {
	case err := <-cmdwait:
		//program exited before releasing descriptors
		//proxy exit code out to master
		code := 0
		if err != nil {
			code = 1
			if exiterr, ok := err.(*); ok {
				if status, ok := ().(); ok {
					code = ()
				}
			}
		}
		("prog exited with %d", code)
		//if a restarts are disabled or if it was an
		//unexpected crash, proxy this exit straight
		//through to the main process
		if  || ! {
			(code)
		}
	case <-:
		//if descriptors are released, the program
		//has yielded control of its sockets and
		//a parallel instance of the program can be
		//started safely. it should serve 
		//to ensure downtime is kept at <1sec. The previous
		//() will still be consumed though the
		//result will be discarded.
	}
	return nil
}