modified: a_test.go

	modified:   daemon.go
	modified:   signals.go
	modified:   signals_test.go

a_test.go

@@ -1,7 +1,6 @@
 package immortal
 
 import (
-	//	"fmt"
 	"os"
 	"reflect"
 	"runtime"
@@ -43,20 +42,15 @@ func (self *catchSignals) SetProcess(p *os.Process) {
 }
 
 func (self *catchSignals) Kill() (err error) {
-	println("<--------", self.Process.Pid)
-	err = self.Process.Kill()
-	if err != nil {
-		return
-	}
-	return
+	return self.Process.Kill()
 }
 
-func (self *catchSignals) Signal(sig os.Signal) error {
+func (self *catchSignals) Signal(sig os.Signal) (err error) {
 	process, _ := os.FindProcess(self.Pid)
-	if err := process.Signal(syscall.Signal(0)); err != nil {
+	if err = process.Signal(syscall.Signal(0)); err != nil {
 		self.signal <- syscall.SIGILL
-		return err
+		return
 	}
 	self.signal <- sig
-	return nil
+	return
 }

daemon.go

@@ -138,16 +138,7 @@ func (self *Daemon) Run() {
 			}
 		}
 
-		// handle zombies
-		err := cmd.Wait()
-		if err != nil {
-			if exitError, ok := err.(*exec.ExitError); ok {
-				ws := exitError.Sys().(syscall.WaitStatus)
-				wpid, err := syscall.Wait4(-1, &ws, syscall.WNOHANG, &syscall.Rusage{})
-				println(wpid, err.Error())
-			}
-		}
-		//	self.Control.state <- err
+		self.Control.state <- cmd.Wait()
 	}()
 }
 

signals.go

@@ -24,6 +24,12 @@ func (self *Sup) HandleSignals(signal string, d *Daemon) {
 			log.Print(err)
 		}
 
+	// t: Terminate. Send the service a TERM signal.
+	case "t", "term":
+		if err := d.process.Signal(syscall.SIGTERM); err != nil {
+			log.Print(err)
+		}
+
 	// o: Once. If the service is not running, start it. Do not restart it if it stops.
 	case "o", "once":
 		d.count_defer = 1
@@ -76,17 +82,19 @@ func (self *Sup) HandleSignals(signal string, d *Daemon) {
 			log.Print(err)
 		}
 
-	// t: Terminate. Send the service a TERM signal.
-	case "t", "term":
-		if err := d.process.Signal(syscall.SIGTERM); err != nil {
-			log.Print(err)
-		}
-
 	// k: Kill. Send the service a KILL signal.
 	case "k", "kill":
 		if err := d.process.Kill(); err != nil {
 			log.Print(err)
 		}
+		// to handle zombies
+		var w syscall.WaitStatus
+		pid, err := syscall.Wait4(-1, &w, 0, nil)
+		if err != nil {
+			log.Println(err)
+		} else {
+			log.Println("pid", pid, "exited", w.Exited(), "exit status", w.ExitStatus())
+		}
 
 	// in: TTIN. Send the service a TTIN signal.
 	case "in", "TTIN":
@@ -115,5 +123,6 @@ func (self *Sup) HandleSignals(signal string, d *Daemon) {
 
 	default:
 		log.Printf("unknown signal: %s", signal)
+		println("UNKNOW")
 	}
 }

signals_test.go

@@ -111,29 +111,17 @@ func TestSignals(t *testing.T) {
 
 	// test kill process will restart and get new pid
 	old_pid := d.process.GetPid()
-	println(old_pid, "first kill")
-	time.Sleep(10 * time.Second)
 	d.Control.fifo <- Return{err: nil, msg: "k"}
 	expect(t, d.count, uint32(1))
 	expect(t, d.count_defer, uint32(0))
-	println("killing pid ", d.process.GetPid())
 	for old_pid == d.process.GetPid() {
-		// wait for new pid
+		// wait for process to end
 	}
-	println("new pid: ", d.process.GetPid())
 
-	for {
-	}
 	// send signal "once"
 	d.Control.fifo <- Return{err: nil, msg: "o"}
-	expect(t, d.count, uint32(1))
-
-	// kill for test once (should re-sestart)
 	d.Control.fifo <- Return{err: nil, msg: "k"}
 	// process shuld not start and pids remains the same
-	expect(t, d.count, uint32(1))
-	expect(t, d.count_defer, uint32(1))
-
 	for sup.IsRunning(d.process.GetPid()) {
 		// wait for process to die
 	}
@@ -187,9 +175,6 @@ func TestSignals(t *testing.T) {
 	for old_pid == d.process.GetPid() {
 		// wait for new pid
 	}
-	println(d.process.GetPid())
-	for {
-	}
 
 	// test down
 	d.Control.fifo <- Return{err: nil, msg: "down"}
@@ -200,27 +185,24 @@ func TestSignals(t *testing.T) {
 	// test up
 	// bring up the service (new pid expected)
 	d.Control.fifo <- Return{err: nil, msg: "up"}
-	for !sup.IsRunning(d.process.GetPid()) {
+	for sup.IsRunning(d.process.GetPid()) {
+		// want it up
 	}
 	d.Control.fifo <- Return{err: nil, msg: "once"}
 	for d.count_defer != 1 {
 	}
 	expect(t, d.count, uint32(1))
 	expect(t, d.count_defer, uint32(1))
 
-	// save old pid
-	old_pid = d.process.GetPid()
-
 	// send kill (should not start)
 	d.Control.fifo <- Return{err: nil, msg: "k"}
 	for sup.IsRunning(d.process.GetPid()) {
 	}
-	expect(t, old_pid, d.process.GetPid())
 	expect(t, false, sup.IsRunning(d.process.GetPid()))
 
 	// test up
 	// bring up the service (new pid expected)
-	d.Control.fifo <- Return{err: nil, msg: "up"}
+	d.Control.fifo <- Return{err: nil, msg: "u"}
 	for !sup.IsRunning(d.process.GetPid()) {
 	}
 	old_pid = d.process.GetPid()
@@ -229,6 +211,7 @@ func TestSignals(t *testing.T) {
 	d.Control.fifo <- Return{err: nil, msg: "k"}
 	for sup.IsRunning(d.process.GetPid()) {
 	}
+
 	select {
 	case <-wait:
 	case <-time.After(2 * time.Second):