Using Go lang with Linux (ubuntu).

A service (running as deamon, can be found with systemctl but not ps for example) runs a command (see code) that runs an executable (not sure if worth mentioning but – they are actually the same executable in sense of code).

The services are managed with the github.com/kardianos/service package.

As part of the code that the child service runs – i need to stop the parent service (service.control("stop")). At this oment the child process fails as well, instead of proceeding with the rest of the flow.

I tried:

1. set session id (Setsid=true)

2. set group id (Setpgid-true)

3. call Release() on the underlying process after calling Start()

4. combinations of the above (as suggested here https://groups.google.com/g/golang-nuts/c/Jx-ZsdQIMJA)

Not sure what other options i have and would love your advice.

code of the function that inits the process (note: this is a mixture of what i tried. i also tried them separately etc):

func ExecuteCommandAsync(command, args string, detach bool) error {
    logger.Notify("Running cli command:", command, args)

    cmd := exec.Command(command, args)
    if detach {
        logger.Notify("Detaching from parent process")
        cmd.SysProcAttr = &syscall.SysProcAttr{
            Setsid: true, // new session id prevents sigkill to parent kill the child
            //Setpgid: true, // new group id prevents sigkill to parent kill the child
        }
    }

    err := cmd.Start()
    if err != nil {
        logger.Error("Failed running cli command:", command, err)
        return err
    }

    if detach {
        logger.Notify("Detached from parent process - releasing child process")
        err = cmd.Process.Release()
        if err != nil {
            return err
        }
    } else {
        go func() {
            logger.Notify("Waiting for cli command to finish")
            waitErr := cmd.Wait()
            if waitErr != nil {
                logger.Error("Error waiting for cli command to finish:", waitErr)
            } else {
                logger.Notify("Command finished successfully")
            }
        }()
    }

    return nil
}

code of the function that stops the service:

func systemStopService(s service.Service) error {
    if s == nil {
        return errors.New("stopService - service is nil")
    }

    logger.Notify(s.String() + " Stopping service")
    err := service.Control(s, "stop")
    if err == nil {
        logger.Notify(s.String() + " Service stopped")
    } else if strings.Contains(err.Error(), "service does not exist") ||
        strings.Contains(err.Error(), "service has not been started") {
        logger.Notify(s.String() + err.Error())
        err = nil // not an error
    } else {
        logger.Error(s.String()+" Failed to stop service", err)
    }
    return err
}