func (mon *SlaveMonitor) slaveDidBeginRegistration(fd int) {
// Having just started the process, we expect an IO, which we convert to a UNIX domain socket
fileName := strconv.Itoa(rand.Int())
slaveFile := unixsocket.FdToFile(fd, fileName)
slaveUsock, err := unixsocket.NewUsockFromFile(slaveFile)
if err != nil {
fmt.Println(err)
}
if err = slaveUsock.Conn.SetReadBuffer(1024); err != nil {
fmt.Println(err)
}
if err = slaveUsock.Conn.SetWriteBuffer(1024); err != nil {
fmt.Println(err)
}
// We now expect the slave to use this fd they send us to send a Pid&Identifier Message
msg, err := slaveUsock.ReadMessage()
if err != nil {
fmt.Println(err)
}
pid, identifier, err := ParsePidMessage(msg)
slaveNode := mon.tree.FindSlaveByName(identifier)
if slaveNode == nil {
panic("slavemonitor.go:slaveDidBeginRegistration:Unknown identifier:" + identifier)
}
go slaveNode.Run(identifier, pid, slaveUsock)
}
func receiveTTY(usock *unixsocket.Usock, err error) (*os.File, error) {
if err != nil {
return nil, err
}
clientFd, err := usock.ReadFD()
if err != nil {
return nil, errors.New("Expected FD, none received!")
}
fileName := strconv.Itoa(rand.Int())
clientFile := unixsocket.FdToFile(clientFd, fileName)
return clientFile, nil
}
// This should only be called while holding a lock on s.L.
// This unfortunately holds the mutex for a little while, and if the
// command dies super early, the entire slave pretty well deadlocks.
// TODO: review this.
func (s *SlaveNode) bootCommand(request *CommandRequest) {
identifier := request.Name
// TODO: If crashed, do something different...
msg := messages.CreateSpawnCommandMessage(identifier)
_, err := s.socket.WriteMessage(msg)
if err != nil {
slog.Error(err)
return
}
commandFD, err := s.socket.ReadFD()
if err != nil {
fmt.Println(s.socket)
slog.Error(err)
return
}
fileName := strconv.Itoa(rand.Int())
commandFile := unixsocket.FdToFile(commandFD, fileName)
request.Retchan <- commandFile
}
// This should only be called while holding a lock on s.L.
// This unfortunately holds the mutex for a little while, and if the
// command dies super early, the entire slave pretty well deadlocks.
// TODO: review this.
func (s *SlaveNode) bootCommand(request *CommandRequest) {
if s.State == SCrashed {
request.Retchan <- &CommandReply{SCrashed, nil}
return
}
identifier := request.Name
msg := messages.CreateSpawnCommandMessage(identifier)
_, err := s.socket.WriteMessage(msg)
if err != nil {
slog.Error(err)
return
}
commandFD, err := s.socket.ReadFD()
if err != nil {
fmt.Println(s.socket)
slog.Error(err)
return
}
fileName := strconv.Itoa(rand.Int())
commandFile := unixsocket.FdToFile(commandFD, fileName)
request.Retchan <- &CommandReply{s.State, commandFile}
}
func (mon *SlaveMonitor) slaveDidBeginRegistration(fd int) {
// Having just started the process, we expect an IO, which we convert to a UNIX domain socket
fileName := strconv.Itoa(rand.Int())
slaveFile := unixsocket.FdToFile(fd, fileName)
slaveUsock, err := unixsocket.NewUsockFromFile(slaveFile)
if err != nil {
slog.Error(err)
}
if err = slaveUsock.Conn.SetReadBuffer(1024); err != nil {
slog.Error(err)
}
if err = slaveUsock.Conn.SetWriteBuffer(1024); err != nil {
slog.Error(err)
}
// We now expect the slave to use this fd they send us to send a Pid&Identifier Message
msg, err := slaveUsock.ReadMessage()
if err != nil {
slog.Error(err)
}
pid, identifier, err := messages.ParsePidMessage(msg)
// And the last step before executing its action, the slave sends us a pipe it will later use to
// send us all the features it's loaded.
featurePipeFd, err := slaveUsock.ReadFD()
if err != nil {
slog.Error(err)
}
slaveNode := mon.tree.FindSlaveByName(identifier)
if slaveNode == nil {
Error("slavemonitor.go:slaveDidBeginRegistration:Unknown identifier:" + identifier)
}
slaveNode.SlaveWasInitialized(pid, slaveUsock, featurePipeFd)
}
// see docs/client_master_handshake.md
func handleClientConnection(tree *ProcessTree, usock *unixsocket.Usock) {
defer usock.Close()
// we have established first contact to the client.
// we first read the command and arguments specified from the connection. (step 1)
msg, err := usock.ReadMessage()
if err != nil {
fmt.Println(err)
return
}
command, arguments, err := ParseClientCommandRequestMessage(msg)
if err != nil {
fmt.Println(err)
return
}
commandNode := tree.FindCommand(command)
if commandNode == nil {
fmt.Println("ERROR: Node not found!: ", command)
return
}
command = commandNode.Name // resolve aliases
slaveNode := commandNode.Parent
// Now we read the terminal IO socket to use for raw IO (step 2)
clientFd, err := usock.ReadFD()
if err != nil {
fmt.Println("Expected FD, none received!")
return
}
fileName := strconv.Itoa(rand.Int())
clientFile := unixsocket.FdToFile(clientFd, fileName)
defer clientFile.Close()
// We now need to fork a new command process.
// For now, we naively assume it's running...
if slaveNode.Error != "" {
// we can skip steps 3-5 as they deal with the command process we're not spawning.
// Write a fake pid (step 6)
usock.WriteMessage("0")
// Write the error message to the terminal
clientFile.Write([]byte(slaveNode.Error))
// Skip step 7, and write an exit code to the client (step 8)
usock.WriteMessage("1")
return
}
// boot a command process and establish a socket connection to it.
slaveNode.WaitUntilBooted()
msg = CreateSpawnCommandMessage(command)
slaveNode.mu.Lock()
slaveNode.Socket.Write([]byte(msg))
slaveNode.mu.Unlock()
// TODO: deadline? how to respond if this is never sent?
commandFd := <-slaveNode.ClientCommandPTYFileDescriptor
if err != nil {
fmt.Println("Couldn't start command process!", err)
}
fileName = strconv.Itoa(rand.Int())
commandFile := unixsocket.FdToFile(commandFd, fileName)
defer commandFile.Close()
// Send the arguments to the command process (step 3)
commandFile.Write([]byte(arguments)) // TODO: What if they're too long?
commandSocket, err := unixsocket.MakeUnixSocket(commandFile)
if err != nil {
fmt.Println("MakeUnixSocket", err)
}
defer commandSocket.Close()
// Send the client terminal connection to the command process (step 4)
commandUsock := unixsocket.NewUsock(commandSocket)
commandUsock.WriteFD(clientFd)
// Receive the pid from the command process (step 5)
msg, err = commandUsock.ReadMessage()
if err != nil {
println(err)
}
intPid, _, _ := ParsePidMessage(msg)
// Send the pid to the client process (step 6)
strPid := strconv.Itoa(intPid)
usock.WriteMessage(strPid)
// Receive the exit status from the command (step 7)
msg, err = commandUsock.ReadMessage()
if err != nil {
println(err)
}
// Forward the exit status to the Client (step 8)
usock.WriteMessage(msg)
// Done! Hooray!
}
