如何确保脚本仅在subprocess.Popen完成执行之后才执行后续方法

Question

I'm running into some problems here trying to use subprocess.Popen. I cannot use subprocess.Call for the script I'm writing because I'd like to be able to specify the environment for my execution, something which I can only do so in Popen through an argument to the method. I've noticed that subprocess.Popen takes longer to complete that subprocess.Call, and this creates problems downstream in my script because the rest of my script relies on the exit code (return code) from the spawned process to decide (through a set of conditional If statements) on a suitable action.

The method that involves using Subprocess is:

def execute_local(self):
'''
Spawns a test execution process locally and directs the standard output and 
error streams from the process to the appropriate log files.  
'''
self.return_code = subprocess.Popen(args = self.cmd_string, 
                                   stdout = open(self.out_log_filepath, 'w'),
                                   stderr = open(self.err_log_filepath, 'w'), 
                                   shell = True)

I have not yet specified the env arguments yet because I need to make sure this works before I can move on.

And the subsequent method that contains the conditionals is:

def get_status(self):
'''
Returns a string named either passed or failed back to itself, depending on 
exit status of the process that was spawned in the execute_local method.

This is important for main.py to be able to examine the status of the test 
processes and take appropriate administrative actions to either continue to 
a new test step or retry a give test.
'''
print self.return_code
if self.return_code == 0:
  return 'passed'
else:
  return 'failed'

In a higher level module, the methods would be called in the following order: execute_local ---followed by ----> get_status.

Previously when I did this with call, the execution went smoothly through to the conditionals, but now with Popen, it doesn't. When I tried debugging with a print statement to print out the return code of the process spawned by subprocess (I added a print self.return_code statement at the get_status method as you can see below), I've observed that with call, I actual get to see the return code, but with Popen, all I get is the object itself and its memory address.

I would greatly appreciate any help on this, and also if someone could explain to me why Popen takes so much longer to run compared to call.

Thank you very much!

Answer 1

subprocess.call is just a wrapper around Popen that waits for the called process to exit. It takes the same arguments as Popen and could could just replace the (incorrectly implemented) Popen and replace it with call to get what you want.

self.return_code = subprocess.call(args = self.cmd_string, 
                                   stdout = open(self.out_log_filepath, 'w'),
                                   stderr = open(self.err_log_filepath, 'w'), 
                                   shell = True,
                                   env=my_env)

In your current implementation, you are returning the Popen object, not the return code.