// 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 }