// In "SBooting", we have a pid and socket to the process we will use,
// but it has not yet finished initializing (generally, running the code
// specific to this slave. When we receive a message about the success or
// failure of this operation, we transition to either crashed or ready.
func (s *SlaveNode) doBootingState() string { // -> {SCrashed, SReady}
// The slave will execute its action and respond with a status...
// Note we don't hold the mutex while waiting for the action to execute.
msg, err := s.socket.ReadMessage()
if err != nil {
slog.Error(err)
}
s.L.Lock()
defer s.L.Unlock()
msg, err = messages.ParseActionResponseMessage(msg)
if err != nil {
slog.ErrorString("[" + s.Name + "] " + err.Error())
}
if msg == "OK" {
return SReady
}
if s.Pid > 0 {
syscall.Kill(s.Pid, syscall.SIGKILL)
}
s.wipe()
s.Error = msg
return SCrashed
}
func (s *SlaveNode) SlaveWasInitialized(pid int, usock *unixsocket.Usock, featurePipeFd int) {
file := os.NewFile(uintptr(featurePipeFd), "featurepipe")
s.L.Lock()
s.wipe()
s.featurePipe = file
s.Pid = pid
s.socket = usock
if s.State == SUnbooted {
s.event <- true
} else {
if pid > 0 {
syscall.Kill(pid, syscall.SIGKILL)
}
slog.ErrorString("Unexpected process for slave `" + s.Name + "` was killed")
}
s.L.Unlock()
}
func doRun() int {
if os.Getenv("RAILS_ENV") != "" {
println("Warning: Specifying a Rails environment via RAILS_ENV has no effect for commands run with zooms.")
}
isTerminal := ttyutils.IsTerminal(os.Stdout.Fd())
var master, slave *os.File
var err error
if isTerminal {
master, slave, err = pty.Open()
} else {
master, slave, err = unixsocket.Socketpair(syscall.SOCK_STREAM)
}
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
defer master.Close()
var oldState *ttyutils.Termios
if isTerminal {
oldState, err = ttyutils.MakeTerminalRaw(os.Stdout.Fd())
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
defer ttyutils.RestoreTerminalState(os.Stdout.Fd(), oldState)
}
// should this happen if we're running over a pipe? I think maybe not?
ttyutils.MirrorWinsize(os.Stdout, master)
addr, err := net.ResolveUnixAddr("unixgram", zoomsSockName)
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
conn, err := net.DialUnix("unix", nil, addr)
if err != nil {
zerror.ErrorCantConnectToMaster()
return 1
}
usock := unixsocket.NewUsock(conn)
msg := messages.CreateCommandAndArgumentsMessage(os.Args[1], os.Getpid(), os.Args[2:])
usock.WriteMessage(msg)
usock.WriteFD(int(slave.Fd()))
slave.Close()
msg, err = usock.ReadMessage()
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
parts := strings.Split(msg, "\000")
commandPid, err := strconv.Atoi(parts[0])
defer func() {
if commandPid > 0 {
// Just in case.
syscall.Kill(commandPid, 9)
}
}()
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
if isTerminal {
c := make(chan os.Signal, 1)
handledSignals := append(append(terminatingSignals, syscall.SIGWINCH), syscall.SIGCONT)
signal.Notify(c, handledSignals...)
go func() {
for sig := range c {
if sig == syscall.SIGCONT {
syscall.Kill(commandPid, syscall.SIGCONT)
} else if sig == syscall.SIGWINCH {
ttyutils.MirrorWinsize(os.Stdout, master)
syscall.Kill(commandPid, syscall.SIGWINCH)
} else { // member of terminatingSignals
ttyutils.RestoreTerminalState(os.Stdout.Fd(), oldState)
print("\r")
syscall.Kill(commandPid, sig.(syscall.Signal))
os.Exit(1)
}
}
}()
}
var exitStatus int = -1
if len(parts) > 2 {
exitStatus, err = strconv.Atoi(parts[0])
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
}
eof := make(chan bool)
go func() {
for {
buf := make([]byte, 1024)
n, err := master.Read(buf)
if err != nil {
eof <- true
break
}
os.Stdout.Write(buf[:n])
}
}()
go func() {
buf := make([]byte, 8192)
for {
n, err := os.Stdin.Read(buf)
if err != nil {
eof <- true
break
}
if isTerminal {
for i := 0; i < n; i++ {
switch buf[i] {
case sigInt:
syscall.Kill(commandPid, syscall.SIGINT)
case sigQuit:
syscall.Kill(commandPid, syscall.SIGQUIT)
case sigTstp:
syscall.Kill(commandPid, syscall.SIGTSTP)
syscall.Kill(os.Getpid(), syscall.SIGTSTP)
}
}
}
master.Write(buf[:n])
}
}()
<-eof
if exitStatus == -1 {
msg, err = usock.ReadMessage()
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
parts := strings.Split(msg, "\000")
exitStatus, err = strconv.Atoi(parts[0])
if err != nil {
slog.ErrorString(err.Error() + "\r")
return 1
}
}
return exitStatus
}
