Make docker use the signal pkg with strings

Docker-DCO-1.1-Signed-off-by: Guillaume J. Charmes <guillaume@charmes.net> (github: creack)

api/client.go

@@ -540,7 +540,17 @@ func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {
 			if s == syscall.SIGCHLD {
 				continue
 			}
-			if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%d", cid, s), nil, false)); err != nil {
+			var sig string
+			for sigStr, sigN := range signal.SignalMap {
+				if sigN == s {
+					sig = sigStr
+					break
+				}
+			}
+			if sig == "" {
+				utils.Errorf("Unsupported signal: %d. Discarding.", s)
+			}
+			if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", cid, sig), nil, false)); err != nil {
 				utils.Debugf("Error sending signal: %s", err)
 			}
 		}

pkg/signal/signal.go

@@ -7,7 +7,7 @@ import (
 
 func CatchAll(sigc chan os.Signal) {
 	handledSigs := []os.Signal{}
-	for _, s := range signalMap {
+	for _, s := range SignalMap {
 		handledSigs = append(handledSigs, s)
 	}
 	signal.Notify(sigc, handledSigs...)

pkg/signal/signal_darwin.go

@@ -4,37 +4,37 @@ import (
 	"syscall"
 )
 
-var signalMap = map[string]syscall.Signal{
+var SignalMap = map[string]syscall.Signal{
-	"ABRT": syscall.SIGABRT,
+	"ABRT":   syscall.SIGABRT,
-	"ALRM": syscall.SIGALRM,
+	"ALRM":   syscall.SIGALRM,
-	"BUG": syscall.SIGBUS,
+	"BUG":    syscall.SIGBUS,
-	"CHLD": syscall.SIGCHLD,
+	"CHLD":   syscall.SIGCHLD,
-	"CONT": syscall.SIGCONT,
+	"CONT":   syscall.SIGCONT,
-	"EMT": syscall.SIGEMT,
+	"EMT":    syscall.SIGEMT,
-	"FPE": syscall.SIGFPE,
+	"FPE":    syscall.SIGFPE,
-	"HUP": syscall.SIGHUP,
+	"HUP":    syscall.SIGHUP,
-	"ILL": syscall.SIGILL,
+	"ILL":    syscall.SIGILL,
-	"INFO": syscall.SIGINFO,
+	"INFO":   syscall.SIGINFO,
-	"INT": syscall.SIGINT,
+	"INT":    syscall.SIGINT,
-	"IO": syscall.SIGIO,
+	"IO":     syscall.SIGIO,
-	"IOT": syscall.SIGIOT,
+	"IOT":    syscall.SIGIOT,
-	"KILL": syscall.SIGKILL,
+	"KILL":   syscall.SIGKILL,
-	"PIPE": syscall.SIGPIPE,
+	"PIPE":   syscall.SIGPIPE,
-	"PROF": syscall.SIGPROF,
+	"PROF":   syscall.SIGPROF,
-	"QUIT": syscall.SIGQUIT,
+	"QUIT":   syscall.SIGQUIT,
-	"SEGV": syscall.SIGSEGV,
+	"SEGV":   syscall.SIGSEGV,
-	"STOP": syscall.SIGSTOP,
+	"STOP":   syscall.SIGSTOP,
-	"SYS": syscall.SIGSYS,
+	"SYS":    syscall.SIGSYS,
-	"TERM": syscall.SIGTERM,
+	"TERM":   syscall.SIGTERM,
-	"TRAP": syscall.SIGTRAP,
+	"TRAP":   syscall.SIGTRAP,
-	"TSTP": syscall.SIGTSTP,
+	"TSTP":   syscall.SIGTSTP,
-	"TTIN": syscall.SIGTTIN,
+	"TTIN":   syscall.SIGTTIN,
-	"TTOU": syscall.SIGTTOU,
+	"TTOU":   syscall.SIGTTOU,
-	"URG": syscall.SIGURG,
+	"URG":    syscall.SIGURG,
-	"USR1": syscall.SIGUSR1,
+	"USR1":   syscall.SIGUSR1,
-	"USR2": syscall.SIGUSR2,
+	"USR2":   syscall.SIGUSR2,
 	"VTALRM": syscall.SIGVTALRM,
-	"WINCH": syscall.SIGWINCH,
+	"WINCH":  syscall.SIGWINCH,
-	"XCPU": syscall.SIGXCPU,
+	"XCPU":   syscall.SIGXCPU,
-	"XFSZ": syscall.SIGXFSZ,
+	"XFSZ":   syscall.SIGXFSZ,
 }

pkg/signal/signal_freebsd.go

@@ -6,7 +6,7 @@ import (
 	"syscall"
 )
 
-var signalMap = map[string]syscall.Signal{
+var SignalMap = map[string]syscall.Signal{
 	"ABRT":   syscall.SIGABRT,
 	"ALRM":   syscall.SIGALRM,
 	"BUF":    syscall.SIGBUS,

pkg/signal/signal_linux.go

@@ -4,7 +4,7 @@ import (
 	"syscall"
 )
 
-var signalMap = map[string]syscall.Signal{
+var SignalMap = map[string]syscall.Signal{
 	"ABRT":   syscall.SIGABRT,
 	"ALRM":   syscall.SIGALRM,
 	"BUS":    syscall.SIGBUS,

pkg/signal/signal_unsupported.go

@@ -6,4 +6,4 @@ import (
 	"syscall"
 )
 
-var signalMap = map[string]syscall.Signal{}
+var SignalMap = map[string]syscall.Signal{}

server.go

@@ -8,6 +8,7 @@ import (
 	"github.com/dotcloud/docker/dockerversion"
 	"github.com/dotcloud/docker/engine"
 	"github.com/dotcloud/docker/pkg/graphdb"
+	"github.com/dotcloud/docker/pkg/signal"
 	"github.com/dotcloud/docker/registry"
 	"github.com/dotcloud/docker/runconfig"
 	"github.com/dotcloud/docker/utils"
@@ -18,7 +19,7 @@ import (
 	"net/url"
 	"os"
 	"os/exec"
-	"os/signal"
+	gosignal "os/signal"
 	"path"
 	"path/filepath"
 	"runtime"
@@ -47,7 +48,7 @@ func InitServer(job *engine.Job) engine.Status {
 	}
 	job.Logf("Setting up signal traps")
 	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)
+	gosignal.Notify(c, os.Interrupt, syscall.SIGTERM, syscall.SIGQUIT)
 	go func() {
 		sig := <-c
 		log.Printf("Received signal '%v', exiting\n", sig)
@@ -122,56 +123,30 @@ func (v *simpleVersionInfo) Version() string {
 // for the container to exit.
 // If a signal is given, then just send it to the container and return.
 func (srv *Server) ContainerKill(job *engine.Job) engine.Status {
-	signalMap := map[string]syscall.Signal{
-		"HUP":  syscall.SIGHUP,
-		"INT":  syscall.SIGINT,
-		"QUIT": syscall.SIGQUIT,
-		"ILL":  syscall.SIGILL,
-		"TRAP": syscall.SIGTRAP,
-		"ABRT": syscall.SIGABRT,
-		"BUS":  syscall.SIGBUS,
-		"FPE":  syscall.SIGFPE,
-		"KILL": syscall.SIGKILL,
-		"USR1": syscall.SIGUSR1,
-		"SEGV": syscall.SIGSEGV,
-		"USR2": syscall.SIGUSR2,
-		"PIPE": syscall.SIGPIPE,
-		"ALRM": syscall.SIGALRM,
-		"TERM": syscall.SIGTERM,
-		//"STKFLT": syscall.SIGSTKFLT,
-		"CHLD":   syscall.SIGCHLD,
-		"CONT":   syscall.SIGCONT,
-		"STOP":   syscall.SIGSTOP,
-		"TSTP":   syscall.SIGTSTP,
-		"TTIN":   syscall.SIGTTIN,
-		"TTOU":   syscall.SIGTTOU,
-		"URG":    syscall.SIGURG,
-		"XCPU":   syscall.SIGXCPU,
-		"XFSZ":   syscall.SIGXFSZ,
-		"VTALRM": syscall.SIGVTALRM,
-		"PROF":   syscall.SIGPROF,
-		"WINCH":  syscall.SIGWINCH,
-		"IO":     syscall.SIGIO,
-		//"PWR":    syscall.SIGPWR,
-		"SYS": syscall.SIGSYS,
-	}
-
 	if n := len(job.Args); n < 1 || n > 2 {
 		return job.Errorf("Usage: %s CONTAINER [SIGNAL]", job.Name)
 	}
-	name := job.Args[0]
+	var (
-	var sig uint64
+		name = job.Args[0]
+		sig  uint64
+		err  error
+	)
+
+	// If we have a signal, look at it. Otherwise, do nothing
 	if len(job.Args) == 2 && job.Args[1] != "" {
-		sig = uint64(signalMap[job.Args[1]])
+		// Check if we passed the singal as a number:
-		if sig == 0 {
+		// The largest legal signal is 31, so let's parse on 5 bits
-			var err error
+		sig, err = strconv.ParseUint(job.Args[1], 10, 5)
-			// The largest legal signal is 31, so let's parse on 5 bits
+		if err != nil {
-			sig, err = strconv.ParseUint(job.Args[1], 10, 5)
+			// The signal is not a number, treat it as a string
-			if err != nil {
+			sig = uint64(signal.SignalMap[job.Args[1]])
+			if sig == 0 {
 				return job.Errorf("Invalid signal: %s", job.Args[1])
 			}
+
 		}
 	}
+
 	if container := srv.runtime.Get(name); container != nil {
 		// If no signal is passed, or SIGKILL, perform regular Kill (SIGKILL + wait())
 		if sig == 0 || syscall.Signal(sig) == syscall.SIGKILL {