Einen Prozess starten, in zu Gehen und trennen Sie es

Brauche ich einen neuen Prozess starten im Gehen mit den folgenden Anforderungen:

  • Der Startvorgang soll ausgeführt werden, auch nach dem Go-Prozess beendet
  • Ich muss in der Lage sein, die Unix-Benutzer - /Gruppe ausgeführt wird, die es
  • Ich muss in der Lage sein, um die Umgebungsvariablen vererbt
  • Ich brauche Kontrolle über die std-in/out/err

Hier ist ein Versuch:

var attr = os.ProcAttr {
Dir: "/bin",
Env: os.Environ(),
Files: []*os.File{
    os.Stdin,
    "stdout.log",
    "stderr.log",
  },
}
process, err := os.StartProcess("sleep", []string{"1"}, &attr)

Dies funktioniert gut, hat aber folgende Mängel, die aus den Anforderungen:

  • Keine Möglichkeit, Unix-Benutzer - /Gruppen -
  • Gestarteten Prozess endet, wenn der Go-Prozess (parent) hält

Diese muss auf Linux laufen nur, wenn das vereinfacht die Dinge.

  • Es sieht aus wie, was Sie tun möchten, ist zu Gabel Prozess. Gibt es Einschränkungen dabei in einem Go-Programm Finden Sie in dieser Ausgabe: code.google.com/p/go/issues/detail?id=227
  • Sie können nicht wirklich fork() im Gehen, insbesondere, wenn die runtime läuft. Der Kind-Prozess sollte die Führung der Ablösung von den Eltern, oder verwenden Sie einen wrapper wie start-stop-daemon.
InformationsquelleAutor Khash | 2014-04-12
  1. 11
    1. Sie können Prozess.Release zum trennen der Kind-Prozess von den Eltern ein und machen es zu überleben, nach der Eltern Tod
    2. Blick auf die definition von *os.ProcAttr.Sys.Anmeldeinformationen Attribut : es sieht aus wie mit dem Attribut können Sie festlegen, Prozess user-und group-ID.

    Hier ist eine funktionierende version von deinem Beispiel (ich habe nicht überprüfen, ob die Prozess-ID ist, wo eigentlich der Satz), 

    package main

import "fmt"
import "os"
import "syscall"

const (
    UID = 501
    GUID = 100
    )


func main() {
    //The Credential fields are used to set UID, GID and attitional GIDS of the process
    //You need to run the program as  root to do this
        var cred =  &syscall.Credential{ UID, GUID, []uint32{} }
    //the Noctty flag is used to detach the process from parent tty
    var sysproc = &syscall.SysProcAttr{  Credential:cred, Noctty:true }
    var attr = os.ProcAttr{
        Dir: ".",
        Env: os.Environ(),
        Files: []*os.File{
            os.Stdin,
            nil,
            nil,
        },
            Sys:sysproc,

    }
    process, err := os.StartProcess("/bin/sleep", []string{"/bin/sleep", "100"}, &attr)
    if err == nil {

        //It is not clear from docs, but Realease actually detaches the process
        err = process.Release();
        if err != nil {
            fmt.Println(err.Error())
        }

    } else {
        fmt.Println(err.Error())
    }
}
    InformationsquelleAutor bieffe62
  2. 2

    Was ich gefunden habe, scheint zu funktionieren cross-Plattform ist es, führen Sie das Programm erneut mit einem speziellen flag. In Ihrem main-Programm, überprüfen Sie dieses flag. Wenn auf Start, du bist in der "Gabel". Wenn nicht, wiederholen Sie den Befehl mit der fahne.

    func rerunDetached() error {
    cwd, err := os.Getwd()
    if err != nil {
       return err
    }
    args := append(os.Args, "--detached")
    cmd := exec.Command(args[0], args[1:]...)
    cmd.Dir = cwd
    err = cmd.Start()
    if err != nil {
       return err
    }
    cmd.Process.Release()
    return nil
}

    Dieser wird einfach neu starten Sie Ihren Prozess mit der genauen Parameter und fügen Sie --detached auf die Argumente. Wenn Ihr Programm gestartet wird, überprüfen Sie für die --detached Flagge zu wissen, wenn Sie anrufen müssen rerunDetached oder nicht. Dies ist wie eine Art poor mans fork() die Arbeit wird auf verschiedene OS.

    • Ich denke, das ist falsch. wenn die Eltern-app verschwindet, trennen der app auch beendet,
    InformationsquelleAutor jhaynie
Schreibe einen Kommentar