move notifySocket out of signalHandler

In fact, notifySocket has no relationship to signalHandler, we
can move it out of signalHandler to make the code more clear.

Signed-off-by: lifubang <[email protected]>

Author: lifubang

notify_socket.go

@@ -150,6 +150,22 @@ func (n *notifySocket) run(pid1 int) error {
 	}
 }
 
+// forward reads systemd notifications from the container and forwards them
+// to notifySocketHost.
+func (s *notifySocket) forward(process *libcontainer.Process, detach bool) error {
+	if detach {
+		pid, err := process.Pid()
+		if err != nil {
+			return err
+		}
+		_ = s.run(pid)
+	} else {
+		_ = s.run(os.Getpid())
+		go func() { _ = s.run(0) }()
+	}
+	return nil
+}
+
 // notifyHost tells the host (usually systemd) that the container reported READY.
 // Also sends MAINPID and BARRIER.
 func notifyHost(client *net.UnixConn, ready []byte, pid1 int) error {

signals.go

@@ -16,9 +16,7 @@ const signalBufferSize = 2048
 
 // newSignalHandler returns a signal handler for processing SIGCHLD and SIGWINCH signals
 // while still forwarding all other signals to the process.
-// If notifySocket is present, use it to read systemd notifications from the container and
-// forward them to notifySocketHost.
-func newSignalHandler(enableSubreaper bool, notifySocket *notifySocket) chan *signalHandler {
+func newSignalHandler(enableSubreaper bool) chan *signalHandler {
 	if enableSubreaper {
 		// set us as the subreaper before registering the signal handler for the container
 		if err := system.SetSubreaper(1); err != nil {
@@ -37,8 +35,7 @@ func newSignalHandler(enableSubreaper bool, notifySocket *notifySocket) chan *si
 		// handle all signals for the process.
 		signal.Notify(s)
 		handler <- &signalHandler{
-			signals:      s,
-			notifySocket: notifySocket,
+			signals: s,
 		}
 	}()
 	return handler
@@ -52,16 +49,15 @@ type exit struct {
 }
 
 type signalHandler struct {
-	signals      chan os.Signal
-	notifySocket *notifySocket
+	signals chan os.Signal
 }
 
 // forward handles the main signal event loop forwarding, resizing, or reaping depending
 // on the signal received.
 func (h *signalHandler) forward(process *libcontainer.Process, tty *tty, detach bool) (int, error) {
 	// make sure we know the pid of our main process so that we can return
 	// after it dies.
-	if detach && h.notifySocket == nil {
+	if detach {
 		return 0, nil
 	}
 
@@ -70,15 +66,6 @@ func (h *signalHandler) forward(process *libcontainer.Process, tty *tty, detach
 		return -1, err
 	}
 
-	if h.notifySocket != nil {
-		if detach {
-			_ = h.notifySocket.run(pid1)
-			return 0, nil
-		}
-		_ = h.notifySocket.run(os.Getpid())
-		go func() { _ = h.notifySocket.run(0) }()
-	}
-
 	// Perform the initial tty resize. Always ignore errors resizing because
 	// stdout might have disappeared (due to races with when SIGHUP is sent).
 	_ = tty.resize()

utils_linux.go

@@ -251,7 +251,7 @@ func (r *runner) run(config *specs.Process) (_ int, retErr error) {
 	// Setting up IO is a two stage process. We need to modify process to deal
 	// with detaching containers, and then we get a tty after the container has
 	// started.
-	handlerCh := newSignalHandler(r.enableSubreaper, r.notifySocket)
+	handlerCh := newSignalHandler(r.enableSubreaper)
 	tty, err := setupIO(process, r.container, config.Terminal, detach, r.consoleSocket)
 	if err != nil {
 		return -1, err
@@ -290,6 +290,12 @@ func (r *runner) run(config *specs.Process) (_ int, retErr error) {
 			return -1, err
 		}
 	}
+	if r.notifySocket != nil {
+		if err = r.notifySocket.forward(process, detach); err != nil {
+			r.terminate(process)
+			return -1, err
+		}
+	}
 	handler := <-handlerCh
 	status, err := handler.forward(process, tty, detach)
 	if err != nil {