Add a ProcessManager interface for managing processes by pid file

This commit does the following:
- Adds ProcessManager interface and Process struct
- Read and write to a pidFile specified by the user
- Adds tests for process lifecycle with a dummy process

Author: vyasgun

pkg/process/process.go

@@ -0,0 +1,90 @@
+package process
+
+import (
+	"os"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/pkg/errors"
+)
+
+type Manager interface {
+	Pid() (int, error)
+	Name() string
+	PidFilePath() string
+	Exists() bool
+	Kill() error
+	FindProcess() (*os.Process, error)
+	WritePidFile(pid int) error
+}
+
+type Process struct {
+	name        string
+	pidFilePath string
+}
+
+func New(name, pidFilePath string) (*Process, error) {
+	return &Process{name: name, pidFilePath: pidFilePath}, nil
+}
+
+func (p *Process) Name() string {
+	return p.name
+}
+
+func (p *Process) PidFilePath() string {
+	return p.pidFilePath
+}
+
+func (p *Process) Pid() (int, error) {
+	data, err := os.ReadFile(p.PidFilePath())
+	if err != nil {
+		return -1, err
+	}
+	pidStr := strings.TrimSpace(string(data))
+	pid, err := strconv.Atoi(pidStr)
+	return pid, errors.Wrap(err, "invalid pid file")
+}
+
+func (p *Process) FindProcess() (*os.Process, error) {
+	pid, err := p.Pid()
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot find process")
+	}
+
+	proc, err := os.FindProcess(pid)
+	if err != nil {
+		return nil, errors.Wrap(err, "cannot find process")
+	}
+	return proc, nil
+}
+
+func (p *Process) Exists() bool {
+	proc, err := p.FindProcess()
+	if err != nil {
+		return false
+	}
+	if err := proc.Signal(syscall.Signal(0)); err != nil {
+		return false
+	}
+	return true
+}
+
+func (p *Process) Kill() error {
+	proc, err := p.FindProcess()
+	if err != nil {
+		return errors.Wrap(err, "cannot find process")
+	}
+	if err := proc.Signal(syscall.SIGKILL); err != nil {
+		return errors.Wrap(err, "cannot kill process")
+	}
+	_, err = proc.Wait()
+	if err != nil {
+		return errors.Wrap(err, "failed to wait for process termination")
+	}
+	return nil
+}
+
+func (p *Process) WritePidFile(pid int) error {
+	return os.WriteFile(p.pidFilePath, []byte(strconv.Itoa(pid)), 0600)
+}

pkg/process/process_test.go

@@ -0,0 +1,99 @@
+package process
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	dummyProcessName = "sleep"
+	dummyProcessArgs = "60"
+)
+
+var (
+	dummyProcess   *exec.Cmd
+	managedProcess *Process
+	pidFilePath    = filepath.Join(os.TempDir(), "pid")
+)
+
+func startDummyProcess() error {
+	dummyProcess = exec.Command(dummyProcessName, dummyProcessArgs)
+	err := dummyProcess.Start()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func TestMain(m *testing.M) {
+	err := startDummyProcess()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to start process:", err)
+		os.Exit(1)
+	}
+
+	managedProcess, err = New(dummyProcessName, pidFilePath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "Failed to create process:", err)
+		os.Exit(1)
+	}
+	err = managedProcess.WritePidFile(dummyProcess.Process.Pid)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	exitCode := m.Run()
+	if dummyProcess.Process != nil {
+		_ = dummyProcess.Process.Kill()
+	}
+
+	os.Exit(exitCode)
+}
+
+func TestProcess_Name(t *testing.T) {
+	assert.Equal(t, dummyProcessName, managedProcess.Name())
+}
+
+func TestProcess_FindProcess(t *testing.T) {
+	foundProcess, err := managedProcess.FindProcess()
+	assert.NoError(t, err)
+	assert.NotNil(t, foundProcess)
+	assert.Equal(t, dummyProcess.Process.Pid, foundProcess.Pid)
+
+	assert.True(t, managedProcess.Exists())
+}
+
+func TestProcess_KillProcess(t *testing.T) {
+	err := managedProcess.Kill()
+	assert.NoError(t, err)
+	assert.False(t, managedProcess.Exists())
+
+	// Try to kill the non-existent process
+	// This should result in an error
+	err = managedProcess.Kill()
+	assert.Error(t, err)
+}
+
+func TestProcess_FindProcess_InvalidPidFile(t *testing.T) {
+	tmpfile, err := os.CreateTemp("", "invalid_pid")
+	require.NoError(t, err)
+	defer os.Remove(tmpfile.Name())
+
+	// Write non-numeric content into the file to mimic an invalid pid
+	_, err = tmpfile.WriteString("non-numeric")
+	require.NoError(t, err)
+	tmpfile.Close()
+
+	invalidProcess, err := New("invalid-process", tmpfile.Name())
+	assert.NoError(t, err)
+
+	foundProcess, err := invalidProcess.FindProcess()
+	assert.Error(t, err)
+	assert.Nil(t, foundProcess)
+}