Revert "chore: cover supervisor package with unit tests" (#14)

Revert "chore: cover supervisor package with unit tests (#12)"

This reverts commit a11f921.

Author: ricardomaraschini

pkg/controller/k0scontroller.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/csv"
 	"fmt"
+	"io"
 	"os"
 	"os/user"
 	"path/filepath"
@@ -27,7 +28,8 @@ import (
 type K0sController struct {
 	Options config.K0sControllerOptions
 
-	supervisor *supervisor.Supervisor
+	supervisor supervisor.Supervisor
+	Output     io.Writer
 	uid        int
 	gid        int
 }
@@ -66,9 +68,16 @@ func (k *K0sController) Init(_ context.Context) error {
 	if k.Options.CmdLogLevels != nil {
 		args = append(args, fmt.Sprintf("--logging=%s", createS2SFlag(k.Options.CmdLogLevels)))
 	}
-	k0spath := assets.BinPath("k0s", k.Options.BinDir())
-	if k.supervisor, err = supervisor.New(k0spath, args); err != nil {
-		return fmt.Errorf("failed to create supervisor: %w", err)
+	k.supervisor = supervisor.Supervisor{
+		Name:          "k0s",
+		UID:           k.uid,
+		GID:           k.gid,
+		BinPath:       assets.BinPath("k0s", k.Options.BinDir()),
+		Output:        k.Output,
+		RunDir:        k.Options.RunDir(),
+		DataDir:       k.Options.DataDir,
+		KeepEnvPrefix: true,
+		Args:          args,
 	}
 	return nil
 }

pkg/supervisor/detachattr.go

@@ -0,0 +1,27 @@
+//go:build !windows
+// +build !windows
+
+package supervisor
+
+import (
+	"os"
+	"syscall"
+)
+
+// DetachAttr creates the proper syscall attributes to run the managed processes
+func DetachAttr(uid, gid int) *syscall.SysProcAttr {
+	var creds *syscall.Credential
+
+	if os.Geteuid() == 0 {
+		creds = &syscall.Credential{
+			Uid: uint32(uid),
+			Gid: uint32(gid),
+		}
+	}
+
+	return &syscall.SysProcAttr{
+		Setpgid:    true,
+		Pgid:       0,
+		Credential: creds,
+	}
+}

pkg/supervisor/logwriter.go

@@ -0,0 +1,82 @@
+package supervisor
+
+import (
+	"bytes"
+	"unicode/utf8"
+
+	"github.com/sirupsen/logrus"
+)
+
+// logWriter implements [io.Writer] by forwarding whole lines to log. In case
+// the lines get too long, it logs them in multiple chunks.
+//
+// This is in contrast to logrus's implementation of io.Writer, which simply
+// errors out if the log line gets longer than 64k.
+type logWriter struct {
+	log     logrus.FieldLogger // receives (possibly chunked) log lines
+	buf     []byte             // buffer in which to accumulate chunks; len(buf) determines the chunk length
+	len     int                // current buffer length
+	chunkNo uint               // current chunk number; 0 means "no chunk"
+}
+
+// Write implements [io.Writer].
+func (w *logWriter) Write(in []byte) (int, error) {
+	w.writeBytes(in)
+	return len(in), nil
+}
+
+func (w *logWriter) writeBytes(in []byte) {
+	// Fill and drain buffer with available data until everything has been consumed.
+	for rest := in; len(rest) > 0; {
+
+		n := copy(w.buf[w.len:], rest) // fill buffer with new input data
+		rest = rest[n:]                // strip copied input data
+		w.len += n                     // increase buffer length accordingly
+
+		// Loop over buffer as long as there are newlines in it
+		for off := 0; ; {
+			idx := bytes.IndexRune(w.buf[off:w.len], '\n')
+
+			// Discard already logged chunks and break if no newline left
+			if idx < 0 {
+				if off > 0 {
+					w.len = copy(w.buf, w.buf[off:w.len])
+				}
+				break
+			}
+
+			// Strip trailing carriage returns
+			line := bytes.TrimRight(w.buf[off:off+idx], "\r")
+
+			if w.chunkNo == 0 {
+				w.log.Infof("%s", line)
+			} else {
+				if len(line) > 0 {
+					w.log.WithField("chunk", w.chunkNo+1).Infof("%s", line)
+				}
+				w.chunkNo = 0
+			}
+
+			off += idx + 1 // advance read offset behind the newline
+		}
+
+		// Issue a chunked log entry in case the buffer is full
+		if w.len == len(w.buf) {
+			// Try to chunk at UTF-8 rune boundaries
+			length := w.len
+			for i := 0; i < utf8.MaxRune && i < w.len; i++ {
+				if r, _ := utf8.DecodeLastRune(w.buf[:w.len-i]); r != utf8.RuneError {
+					length = length - i
+					break
+				}
+			}
+
+			// Strip trailing carriage returns
+			line := bytes.TrimRight(w.buf[:length], "\r")
+
+			w.log.WithField("chunk", w.chunkNo+1).Infof("%s", line)
+			w.chunkNo++                         // increase chunk number
+			w.len = copy(w.buf, w.buf[length:]) // discard logged bytes
+		}
+	}
+}