示例#1
0
 def __call_async__(self, commander):
     (self.pid, self.r_pipe, self.w_pipe, self.stdin_pipe, self.stdout_pipe,
      self.stderr_pipe) = create_process_cmd()
     if self.pid == 0:  # Child process make commands
         commander._close_cmds_stdios(self)
         self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
                                 ms.StdIOWrapperOut(self.w_pipe))
         try:
             self.basecmd.results = self.obj(*self.basecmd.args,
                                             **self.basecmd.kargs)
         except Exception:
             err_msg = traceback.format_exc()
             self.msg.write_msg(remote_interface.CmdTraceBack(err_msg))
             sys.exit(-1)
         finally:
             self.msg.write_msg(self.basecmd.results)
             self.msg.write_msg(CmdFinish())
         sys.exit(0)
     else:  # Parent process create communication interface to child process
         self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
                                 ms.StdIOWrapperOut(self.w_pipe))
示例#2
0
 def recover_fds(self):
     """
     Helper function for reconnect to daemon/nohup process.
     """
     if self.r_pipe is None:
         self.recover_paths()
         self.w_pipe = os.open(self.w_path, os.O_WRONLY)
         self.r_pipe = os.open(self.r_path, os.O_RDONLY)
         self.stdin_pipe = os.open(self.stdin_path, os.O_WRONLY)
         self.stdout_pipe = os.open(self.stdout_path, os.O_RDONLY)
         self.stderr_pipe = os.open(self.stderr_path, os.O_RDONLY)
         self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
                                 ms.StdIOWrapperOut(self.w_pipe))
示例#3
0
    def __call_nohup__(self, commander):
        (pid, self.r_path, self.w_path, self.stdin_path, self.stdout_path,
         self.stderr_path) = daemonize(self.basecmd.cmd_hash)
        if pid == 1:  # Child process make commands
            commander._close_cmds_stdios(self)
            (self.pid, r_pipe, w_pipe, stdin_pipe, stdout_pipe,
             stderr_pipe) = create_process_cmd()
            if self.pid == 0:  # Child process make commands
                self.msg = ms.Messenger(ms.StdIOWrapperIn(r_pipe),
                                        ms.StdIOWrapperOut(w_pipe))
                try:
                    self.basecmd.results = self.obj(*self.basecmd.args,
                                                    **self.basecmd.kargs)
                except Exception:
                    err_msg = traceback.format_exc()
                    self.msg.write_msg(remote_interface.CmdTraceBack(err_msg))
                    sys.exit(-1)
                finally:
                    self.msg.write_msg(self.basecmd.results)
                sys.exit(0)
            else:
                # helper child process open communication pipes.
                # This process is able to manage problem with connection width
                # main parent process. It allows start unchanged child process.
                self.r_pipe = os.open(self.r_path, os.O_RDONLY)
                self.w_pipe = os.open(self.w_path, os.O_WRONLY)
                sys.stdout = os.fdopen(os.open(self.stdout_path, os.O_WRONLY),
                                       "w", 0)
                sys.stderr = os.fdopen(os.open(self.stderr_path, os.O_WRONLY),
                                       "w", 0)
                sys.stdin = os.fdopen(os.open(self.stdin_path, os.O_RDONLY),
                                      "r", 0)

                w_fds = [r_pipe, w_pipe, stdin_pipe, stdout_pipe, stderr_pipe]
                m_fds = [
                    self.r_pipe, self.w_pipe,
                    sys.stdin.fileno(),
                    sys.stdout.fileno(),
                    sys.stderr.fileno()
                ]
                p = select.poll()
                p.register(r_pipe)
                p.register(w_pipe)
                # p.register(stdin_pipe)
                p.register(stdout_pipe)
                p.register(stderr_pipe)
                p.register(self.r_pipe)
                # p.register(self.w_pipe)
                p.register(sys.stdin.fileno())
                # p.register(sys.stdout.fileno())
                # p.register(sys.stderr.fileno())
                io_map = {
                    r_pipe: self.w_pipe,
                    self.r_pipe: w_pipe,
                    sys.stdin.fileno(): stdin_pipe,
                    stdout_pipe: sys.stdout.fileno(),
                    stderr_pipe: sys.stderr.fileno()
                }
                while 1:
                    d = p.poll()
                    w_ev = [x for x in d if x[0] in w_fds]
                    m_ev = [x for x in d if x[0] in m_fds]
                    w_hup, w_read, _ = sort_fds_event(w_ev)
                    m_hup, m_read, _ = sort_fds_event(m_ev)
                    if m_hup:
                        time.sleep(0.1)
                    if w_hup:  # child process finished
                        for r in w_read:
                            data = os.read(r, 16384)
                            os.write(io_map[r], data)
                        break
                    for r in w_read:
                        data = os.read(r, 16384)
                        os.write(io_map[r], data)
                    for r in m_read:
                        data = os.read(r, 16384)
                        os.write(io_map[r], data)
                self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
                                        ms.StdIOWrapperOut(self.w_pipe))
                self.msg.write_msg(CmdFinish())
                exit(0)
        else:  # main process open communication named pipes.
            self.w_pipe = os.open(self.w_path, os.O_WRONLY)
            self.r_pipe = os.open(self.r_path, os.O_RDONLY)
            self.stdout_pipe = os.open(self.stdout_path, os.O_RDONLY)
            self.stderr_pipe = os.open(self.stderr_path, os.O_RDONLY)
            self.stdin_pipe = os.open(self.stdin_path, os.O_WRONLY)
            self.msg = ms.Messenger(ms.StdIOWrapperIn(self.r_pipe),
                                    ms.StdIOWrapperOut(self.w_pipe))