func (s *Session) Interrupt() *Session {
	return s.Signal(syscall.SIGINT)
}
/*
Interrupt sends the running command a SIGINT signal.  It does not wait for the process to exit.

If the command has already exited, Interrupt returns silently.

The session is returned to enable chaining.
package gexec
import (
	"io"
	"os"
	"os/exec"
	"reflect"
	"sync"
	"syscall"
	. "github.com/cloudcredo/cloudrocker/Godeps/_workspace/src/github.com/onsi/gomega"
	"github.com/cloudcredo/cloudrocker/Godeps/_workspace/src/github.com/onsi/gomega/gbytes"
)
const INVALID_EXIT_CODE = 254
type Session struct {
	Command *exec.Cmd
	Out *gbytes.Buffer
	Err *gbytes.Buffer
	Exited <-chan struct{}
	lock     *sync.Mutex
	exitCode int
}
func Start(command *exec.Cmd, outWriter io.Writer, errWriter io.Writer) (*Session, error) {
	exited := make(chan struct{})
	session := &Session{
		Command:  command,
		Out:      gbytes.NewBuffer(),
		Err:      gbytes.NewBuffer(),
		Exited:   exited,
		lock:     &sync.Mutex{},
		exitCode: -1,
	}
	var commandOut, commandErr io.Writer
	commandOut, commandErr = session.Out, session.Err
	if outWriter != nil && !reflect.ValueOf(outWriter).IsNil() {
		commandOut = io.MultiWriter(commandOut, outWriter)
	}
	if errWriter != nil && !reflect.ValueOf(errWriter).IsNil() {
		commandErr = io.MultiWriter(commandErr, errWriter)
	}
	command.Stdout = commandOut
	command.Stderr = commandErr
	err := command.Start()
	if err == nil {
		go session.monitorForExit(exited)
	}
	return session, err
}
func (s *Session) Buffer() *gbytes.Buffer {
	return s.Out
}
func (s *Session) ExitCode() int {
	s.lock.Lock()
	defer s.lock.Unlock()
	return s.exitCode
}
func (s *Session) Wait(timeout ...interface{}) *Session {
	Eventually(s, timeout...).Should(Exit())
	return s
}
func (s *Session) Kill() *Session {
	if s.ExitCode() != -1 {
		return s
	}
	s.Command.Process.Kill()
	return s
}