def closed(self):
global old
log.msg('closed %s' % self)
log.msg(repr(self.conn.channels))
if not options['nocache']: # fork into the background
if os.fork():
if old:
fd = sys.stdin.fileno()
tty.tcsetattr(fd, tty.TCSANOW, old)
if (options['command'] and options['tty']) or \
not options['notty']:
signal.signal(signal.SIGWINCH, signal.SIG_DFL)
os._exit(0)
os.setsid()
for i in range(3):
try:
os.close(i)
except OSError, e:
import errno
if e.errno != errno.EBADF:
raise
python类setsid()的实例源码
def play(self):
if self._process is None:
if self.station:
fifo_path = self._create_fifo()
if fifo_path:
self._process = subprocess.Popen(self._cmd.format(fifo=fifo_path, url=self.station),
stdin=subprocess.PIPE,
stdout=open('/dev/null', 'w'),
stderr=open('/dev/null', 'w'),
shell=True, preexec_fn=os.setsid)
if self._is_running():
self._volume = 100
else:
print "Error: no station selected"
else:
print "Error: Already playing"
def execute(cmd, stderr_to_stdout=False, stdin=None):
"""Execute a command in the shell and return a tuple (rc, stdout, stderr)"""
if stderr_to_stdout:
stderr = STDOUT
else:
stderr = PIPE
if stdin is None:
_stdin = None
else:
_stdin = PIPE
p = Popen(cmd, close_fds=True, stdin=_stdin, stdout=PIPE, stderr=stderr, preexec_fn=os.setsid)
stdout, stderr = p.communicate(input=stdin)
return p.returncode, stdout, stderr
def daemonize(self):
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError, e:
sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
os.chdir("/")
os.setsid()
os.umask(0)
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError, e:
sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
sys.stdout.flush()
sys.stderr.flush()
si = file(self.stdin, 'r')
so = file(self.stdout, 'a+')
se = file(self.stderr, 'a+', 0)
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
atexit.register(self.delpid)
pid = str(os.getpid())
file(self.pidfile,'w+').write("%s\n" % pid)
def daemonize(double_fork=True):
'''Puts process in the background using usual UNIX best practices.'''
try:
os.umask(0o22)
except Exception as e:
raise Exception("Unable to change file creation mask: %s" % e)
os.chdir('/')
# First fork
if double_fork:
try:
pid = os.fork()
if pid > 0:
os._exit(0)
except OSError as e:
raise Exception("Error on first fork: [%d] %s" % (e.errno, e.strerr,))
os.setsid()
# Second fork
try:
pid = os.fork()
if pid > 0:
os._exit(0)
except OSError as e:
raise Exception("Error on second fork: [%d] %s" % (e.errno, e.strerr,))
close_open_files()
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stdin.fileno())
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stdout.fileno())
os.dup2(os.open(os.devnull, os.O_RDWR), sys.stderr.fileno())
def open_maybe_gzip(filename, mode='r'):
if filename.endswith(cr_constants.GZIP_SUFFIX):
gunzip = subprocess.Popen(['gunzip', '-c', filename],
stdout=subprocess.PIPE,
preexec_fn=os.setsid)
return gunzip.stdout
else:
return open(filename, mode)
def daemonize(stdin="/dev/null", stdout="/dev/null", stderr="/dev/null"):
'''
Daemonize current script
'''
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError, e:
sys.stderr.write ("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror) )
sys.exit(1)
os.chdir("/")
os.umask(0)
os.setsid()
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError, e:
sys.stderr.write ("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror) )
sys.exit(1)
stdin_par = os.path.dirname(stdin)
stdout_par = os.path.dirname(stdout)
stderr_par = os.path.dirname(stderr)
if not stdin_par:
os.path.makedirs(stdin_par)
if not stdout_par:
os.path.makedirs(stdout_par)
if not stderr_par:
os.path.makedirs(stderr_par)
si = open(stdin, 'r')
so = open(stdout, 'a+')
se = open(stderr, 'a+', 0)
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
def _preexec_val(self):
return os.setsid if sublime.platform() != "windows" else None
def _daemonize(self):
# double-fork. refer to "Advanced Programming in the UNIX Environment"
try: # first fork
pid = os.fork()
if pid > 0: # first parent
os.waitpid(pid, 0) # wait for second child to start
return False # return to caller of daemonize()
except OSError, e:
self.log('fork #1 failed: %s' % e)
return # return caller of daemonize()
# decouple first parent
os.setsid()
os.chdir("/")
os.umask(0)
ppid = os.getpid() # yes, getpid(). it will be the child's ppid
try: # second fork
self._pid = os.fork()
if self._pid > 0: # second parent. just exit
os._exit(0) # this is the wait() above
except OSError, e:
self.log('fork #2 failed: %s' % e)
os._exit(1)
# wait until ppid changes
while os.getppid() == ppid:
time.sleep(0.1)
return True
def _daemonize(self):
# double-fork. refer to "Advanced Programming in the UNIX Environment"
try: # first fork
pid = os.fork()
if pid > 0: # first parent
os.waitpid(pid, 0) # wait for second child to start
return False # return to caller of daemonize()
except OSError, e:
self.log('fork #1 failed: %s' % e)
return # return caller of daemonize()
# decouple first parent
os.setsid()
os.chdir("/")
os.umask(0)
ppid = os.getpid() # yes, getpid(). it will be the child's ppid
try: # second fork
self._pid = os.fork()
if self._pid > 0: # second parent. just exit
os._exit(0) # this is the wait() above
except OSError, e:
self.log('fork #2 failed: %s' % e)
os._exit(1)
# wait until ppid changes
while os.getppid() == ppid:
time.sleep(0.1)
return True
def takePicture(self, lat, longit, altitude):
self.proc2 = subprocess.Popen("omxplayer" + " -o hdmi videos/pictureTaken4.mp4", stdout=subprocess.PIPE, shell=True, preexec_fn=os.setsid)
try :
pictureTaken=self.api.actTakePicture()
#retrieve name of the picture taken
#actTakePicture return a json Array of array and the name of the picture is given under 'result' field
picturefilestring = pictureTaken['result'][0][0]
#removing the backslashes
picturefilestring = picturefilestring.replace('\\',"")
#get the picture name
picturename = re.search('DSC.*\.JPG', picturefilestring).group(0)
self.picturefilestringList.append(picturefilestring)
self.picturenameList.append(picturename)
self.latList.append(lat)
self.longList.append(longit)
self.altitudeList.append(altitude)
except Exception:
proc5 = subprocess.Popen("omxplayer" + " -o hdmi /mnt/Usb-Solo-Mapper/videos/errorTakingPicture.mp4", stdout=subprocess.PIPE, shell=True, preexec_fn=os.setsid)
proc5.wait()
self.logger.debug('errorTakingPicture!')
#
# Telecharge les photos prises pendant le vol, et ecrit dans les .exif les donnees GPS sauvegardees
#
def run(self):
#Every 10s, we check prospective USB-disconnect messages in kern.log
while self.goOn:
with verrou:
try:
checkProcess = subprocess.Popen("sudo tail -n 5 /var/log/kern.log | grep disconnect >> /mnt/Usb-Solo-Mapper/Logs/usbCheck.log", stdout=subprocess.PIPE, shell=True, preexec_fn=os.setsid)
checkProcess.wait()
usb_file = open("/mnt/Usb-Solo-Mapper/Logs/usbCheck.log", "a")
usb_file.close()
except Exception as e:
self.logger.error('USB check process failed : %s',e)
finally:
time.sleep(10)
def run_checker(self, name, test, out):
cmd = './'+name+' '+test.inp.path+' '+test.out.path+' '+out
r = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE,
cwd=MEDIA_ROOT, preexec_fn=os.setsid)
stdout, stderr = r.communicate()
return str(stdout, "utf-8")
def run(self, inp=None):
name = self.get_obj_file_name()
sandbox = Sandbox()
cmd = self.get_run_command(name, sandbox)
start = timer()
stdout = b''
stderr = b''
env = os.environ.copy()
r = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
stdout=subprocess.PIPE, bufsize=4*1024,
cwd=MEDIA_ROOT, preexec_fn=os.setsid,env=env)
try:
if inp is not None:
stdout, stderr = r.communicate(timeout=timeout, input=inp.encode())
else:
stdout, stderr = r.communicate(timeout=timeout)
print('STDOUT : ' + str(stdout, "utf-8"))
print('STDERR : ' + str(stderr, "utf-8"))
except subprocess.TimeoutExpired as e:
print("Timeout expired")
os.killpg(r.pid, signal.SIGINT)
r.returncode = 124
print('Return Code : ' + str(r.returncode))
if self.lang != 'python':
os.remove(MEDIA_ROOT+'/'+name)
print('Elapsed seconds: {:.2f}'.format(timer() - start))
sandbox.delete_sandbox()
return Result(timer() - start, r.returncode, stdout)
def onConnect():
# if keyAgent and options['agent']:
# cc = protocol.ClientCreator(reactor, SSHAgentForwardingLocal, conn)
# cc.connectUNIX(os.environ['SSH_AUTH_SOCK'])
if hasattr(conn.transport, 'sendIgnore'):
_KeepAlive(conn)
if options.localForwards:
for localPort, hostport in options.localForwards:
s = reactor.listenTCP(localPort,
forwarding.SSHListenForwardingFactory(conn,
hostport,
SSHListenClientForwardingChannel))
conn.localForwards.append(s)
if options.remoteForwards:
for remotePort, hostport in options.remoteForwards:
log.msg('asking for remote forwarding for %s:%s' %
(remotePort, hostport))
conn.requestRemoteForwarding(remotePort, hostport)
reactor.addSystemEventTrigger('before', 'shutdown', beforeShutdown)
if not options['noshell'] or options['agent']:
conn.openChannel(SSHSession())
if options['fork']:
if os.fork():
os._exit(0)
os.setsid()
for i in range(3):
try:
os.close(i)
except OSError, e:
import errno
if e.errno != errno.EBADF:
raise
def fork():
"""fork() -> (pid, master_fd)
Fork and make the child a session leader with a controlling terminal."""
try:
pid, fd = os.forkpty()
except (AttributeError, OSError):
pass
else:
if pid == CHILD:
try:
os.setsid()
except OSError:
# os.forkpty() already set us session leader
pass
return pid, fd
master_fd, slave_fd = openpty()
pid = os.fork()
if pid == CHILD:
# Establish a new session.
os.setsid()
os.close(master_fd)
# Slave becomes stdin/stdout/stderr of child.
os.dup2(slave_fd, STDIN_FILENO)
os.dup2(slave_fd, STDOUT_FILENO)
os.dup2(slave_fd, STDERR_FILENO)
if (slave_fd > STDERR_FILENO):
os.close (slave_fd)
# Explicitly open the tty to make it become a controlling tty.
tmp_fd = os.open(os.ttyname(STDOUT_FILENO), os.O_RDWR)
os.close(tmp_fd)
else:
os.close(slave_fd)
# Parent and child process.
return pid, master_fd
def setUp(self):
super(Base, self).setUp()
examplepy = os.path.join(os.path.dirname(__file__),
"examples.py")
self.subp = subprocess.Popen(['python', examplepy, self.name],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
close_fds=True,
preexec_fn=os.setsid)
def __init__(self, wait_interval=0.01):
"""Creates the ServiceManager object
:param wait_interval: time between each new process spawn
:type wait_interval: float
"""
if self._process_runner_already_created:
raise RuntimeError("Only one instance of ProcessRunner per "
"application is allowed")
ServiceManager._process_runner_already_created = True
self._wait_interval = wait_interval
self._shutdown = threading.Event()
self._running_services = collections.defaultdict(dict)
self._services = []
self._forktimes = []
self._current_process = None
# Try to create a session id if possible
try:
os.setsid()
except OSError:
pass
self.readpipe, self.writepipe = os.pipe()
signal.signal(signal.SIGTERM, self._clean_exit)
signal.signal(signal.SIGINT, self._fast_exit)
signal.signal(signal.SIGALRM, self._alarm_exit)
signal.signal(signal.SIGHUP, self._reload_services)
def daemonize(self):
"""Deamonize class. UNIX double fork mechanism."""
try:
pid = os.fork()
if pid > 0:
# exit first parent
sys.exit(0)
except OSError as err:
sys.stderr.write('fork #1 failed: {0}\n'.format(err))
sys.exit(1)
# decouple from parent environment
os.chdir('/')
os.setsid()
os.umask(0)
# do second fork
try:
pid = os.fork()
if pid > 0:
# exit from second parent
sys.exit(0)
except OSError as err:
sys.stderr.write('fork #2 failed: {0}\n'.format(err))
sys.exit(1)
# redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()
stdi = open(os.devnull, 'r')
stdo = open(os.devnull, 'a+')
stde = open(os.devnull, 'a+')
os.dup2(stdi.fileno(), sys.stdin.fileno())
os.dup2(stdo.fileno(), sys.stdout.fileno())
os.dup2(stde.fileno(), sys.stderr.fileno())
# write pidfile
self.write_pid()
def launch_udocker_container(event, context, command):
lambda_output = "/tmp/%s/lambda-stdout.txt" % request_id
remaining_seconds = get_invocation_remaining_seconds(context)
logger.info("Executing udocker container. Timeout set to %s seconds" % str(remaining_seconds))
with subprocess.Popen(command, stderr=subprocess.STDOUT, stdout=open(lambda_output, "w"), preexec_fn=os.setsid) as process:
try:
process.wait(timeout=remaining_seconds)
except subprocess.TimeoutExpired:
kill_udocker_process(process)
# Processing recursive function
if (is_recursive()):
launch_recursive_lambda(event, context.function_name)
else:
logger.warning("Container timeout")
return lambda_output
