def get_async_run_status(self, async_content):
"""
get the command's status
"""
try:
async_process = linux.Process(async_content.pid)
res = async_process.get_process_status()
except err.NoSuchProcess:
res = "process is destructor"
return res
def test_get_fd():
"""test get fd"""
# get_pid 第一个参数是启动程序的路径, 第二个是匹配参数, 比如mysqld
arrow_pid = oper.get_pid('/home/maguannan/.jumbo/bin/', 'arrow_agent')
print('pid {0}'.format(arrow_pid))
process = linux.Process(arrow_pid)
# 通过 get_open_files 函数获得打开文件数目
print('opened fd {0}'.format(process.get_open_files()))
# linux.Process(pid) 对象可以获取所有该进程的有效信息, 比如open fd, cpu时间
# vi:set tw=0 ts=4 sw=4 nowrap fdm=indent
def _target(argcontent):
argcontent.__subpro = subprocess.Popen(argcontent.cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
preexec_fn=_signal_handle)
from cup.res import linux
parent = linux.Process(argcontent.__subpro.pid)
children = parent.children(True)
ret_dict = []
for process in children:
ret_dict.append(process)
argcontent.child_list = ret_dict
def get_async_run_status(cls, async_content):
"""
get the process status of executing async cmd
:return:
None if the process has finished.
Otherwise, return a object of linux.Process(async_pid)
"""
try:
async_process = linux.Process(async_content.pid)
res = async_process.get_process_status()
except err.NoSuchProcess:
res = None
return res
def _monitor(start_time, argcontent):
while (int(time.mktime(datetime.datetime.now().timetuple())) -
int(start_time) < int(argcontent.timeout)):
time.sleep(1)
if argcontent.subproc.poll() is not None:
self._subpro_data = argcontent.subproc.communicate()
argcontent.ret[
'returncode'] = argcontent.subproc.returncode
argcontent.ret['stdout'] = self._subpro_data[0]
argcontent.ret['stderr'] = self._subpro_data[1]
return
parent = linux.Process(argcontent.subproc.pid)
children = parent.children(True)
ret_dict = []
for process in children:
ret_dict.append(process)
argcontent.child_list = ret_dict
str_warn = ('Shell "{0}"execution timout:{1}. To kill it'.format(
argcontent.cmd, argcontent.timeout))
self.kill_all_process(argcontent)
argcontent.ret['returncode'] = 999
argcontent.ret['stderr'] = str_warn
argcontent.subproc.terminate()
def run(self, cmd, timeout):
"""
refer to the class description
:param timeout:
If the cmd is not returned after [timeout] seconds, the cmd process
will be killed. If timeout is None, will block there until the cmd
execution returns
:return:
{
'stdout' : 'Success',
'stderr' : None,
'returncode' : 0
}
returncode == 0 means success, while 999 means timeout
E.g.
::
import cup
shelltool = cup.shell.ShellExec()
print shelltool.run('/bin/ls', timeout=1)
"""
def _signal_handle():
"""
signal setup
"""
signal.signal(signal.SIGPIPE, signal.SIG_DFL)
def _pipe_asshell(cmd):
"""
run shell with subprocess.Popen
"""
tempscript = tempfile.NamedTemporaryFile(dir=self._tmpdir,
prefix=self._tmpprefix,
delete=True)
with open(tempscript.name, 'w+b') as fhandle:
fhandle.write('cd {0};\n'.format(os.getcwd()))
fhandle.write(cmd)
shexe = self.which('sh')
cmds = [shexe, tempscript.name]
log.info('cup shell execute {0} with script {1}'.format(cmd, cmds))
self._subpro = subprocess.Popen(cmds,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
preexec_fn=_signal_handle)
self._subpro_data = self._subpro.communicate()
ret = {'stdout': None, 'stderr': None, 'returncode': 0}
cmdthd = threading.Thread(target=_pipe_asshell, args=(cmd, ))
cmdthd.start()
cmdthd.join(timeout)
if cmdthd.isAlive():
str_warn = ('Shell "%s"execution timout:%d. Killed it' %
(cmd, timeout))
warnings.warn(str_warn, RuntimeWarning)
parent = linux.Process(self._subpro.pid)
for child in parent.children(True):
os.kill(child, signal.SIGKILL)
ret['returncode'] = 999
ret['stderr'] = str_warn
self._subpro.terminate()
else:
self._subpro.wait()
times = 0
while self._subpro.returncode is None and times < 10:
time.sleep(1)
times += 1
ret['returncode'] = self._subpro.returncode
assert type(self._subpro_data) == tuple, \
'self._subpro_data should be a tuple'
ret['stdout'] = self._subpro_data[0]
ret['stderr'] = self._subpro_data[1]
return ret
