def _collect_status_data(self):
try:
now = datetime.datetime.now()
children = self.controller.children.values()
status_data = {
'active_children_count':len([c
for c in children
if c.active]),
'killed_children_count':len([c
for c in children
if not c.active]),
'configured_children_count':self.controller.num_processes,
'now':now.ctime(),
'pid':os.getpid(),
'uptime':format_timedelta(now - self.controller.started_at),
'started_at':self.controller.started_at.ctime(),
'config':self.controller.config}
# fire up a few greenthreads to wait on children's responses
p = eventlet.GreenPile()
for child in self.controller.children.values():
p.spawn(self.collect_child_status, child)
status_data['children'] = dict([pid_cd for pid_cd in p])
# total concurrent connections
status_data['concurrent_requests'] = sum([
child.get('concurrent_requests', 0)
for child in status_data['children'].values()])
finally:
# wipe out the waiter so that subsequent requests create new ones
self.status_waiter = None
return status_data
def spawn_children(self, number=1):
parent_pid = os.getpid()
self.log.debug('Controller.spawn_children(number=%d)' % number)
for i in range(number):
child_side, parent_side = os.pipe()
try:
child_pid = os.fork()
except:
print_exc('Could not fork child! Panic!')
### TODO: restart
if not child_pid: # child process
os.close(parent_side)
command = [
sys.executable, '-c',
'import sys; from spawning import spawning_child; spawning_child.main()',
str(parent_pid),
str(self.sock.fileno()),
str(child_side), self.factory,
json.dumps(self.args)
]
if self.args['reload'] == 'dev':
command.append('--reload')
env = environ()
tpool_size = int(self.config.get('threadpool_workers', 0))
assert tpool_size >= 0, (
tpool_size, 'Cannot have a negative --threads argument')
if not tpool_size in (0, 1):
env['EVENTLET_THREADPOOL_SIZE'] = str(tpool_size)
os.execve(sys.executable, command, env)
# controller process
os.close(child_side)
self.children[child_pid] = Child(child_pid, parent_side)
def _collect_status_data(self):
try:
now = datetime.datetime.now()
children = self.controller.children.values()
status_data = {
'active_children_count':
len([c for c in children if c.active]),
'killed_children_count':
len([c for c in children if not c.active]),
'configured_children_count': self.controller.num_processes,
'now': now.ctime(),
'pid': os.getpid(),
'uptime': format_timedelta(now - self.controller.started_at),
'started_at': self.controller.started_at.ctime(),
'config': self.controller.config
}
# fire up a few greenthreads to wait on children's responses
p = eventlet.GreenPile()
for child in self.controller.children.values():
p.spawn(self.collect_child_status, child)
status_data['children'] = dict([pid_cd for pid_cd in p])
# total concurrent connections
status_data['concurrent_requests'] = sum([
child.get('concurrent_requests', 0)
for child in status_data['children'].values()
])
finally:
# wipe out the waiter so that subsequent requests create new ones
self.status_waiter = None
return status_data
def spawn_children(self, number=1):
parent_pid = os.getpid()
for i in range(number):
child_side, parent_side = os.pipe()
try:
child_pid = os.fork()
except:
print_exc('Could not fork child! Panic!')
### TODO: restart
if not child_pid: # child process
os.close(parent_side)
command = [sys.executable, '-c',
'import sys; from spawning import spawning_child; spawning_child.main()',
str(parent_pid),
str(self.sock.fileno()),
str(child_side),
self.factory,
json.dumps(self.args)]
if self.args['reload'] == 'dev':
command.append('--reload')
env = environ()
tpool_size = int(self.config.get('threadpool_workers', 0))
assert tpool_size >= 0, (tpool_size, 'Cannot have a negative --threads argument')
if not tpool_size in (0, 1):
env['EVENTLET_THREADPOOL_SIZE'] = str(tpool_size)
os.execve(sys.executable, command, env)
# controller process
os.close(child_side)
self.children[child_pid] = Child(child_pid, parent_side)
def __init__(self, sock, factory, args, **kwargs):
self.sock = sock
self.factory = factory
self.config = spawning.util.named(factory)(args)
self.args = args
self.children = {}
self.log = logging.getLogger('Spawning')
if not kwargs.get('log_handler'):
self.log.addHandler(logging.StreamHandler())
self.log.setLevel(logging.DEBUG)
self.controller_pid = os.getpid()
self.num_processes = int(self.config.get('num_processes', 0))
self.started_at = datetime.datetime.now()
def __init__(self, sock, factory, args, **kwargs):
self.sock = sock
self.factory = factory
self.config = spawning.util.named(factory)(args)
self.args = args
self.children = {}
self.log = logging.getLogger('Spawning')
if not kwargs.get('log_handler'):
self.log.addHandler(logging.StreamHandler())
self.log.setLevel(logging.DEBUG)
self.controller_pid = os.getpid()
self.num_processes = int(self.config.get('num_processes', 0))
self.started_at = datetime.datetime.now()
def bind_socket(config):
sleeptime = 0.5
host = config.get('host', '')
port = config.get('port', 8080)
for x in range(8):
try:
sock = eventlet.listen((host, port))
break
except socket.error, e:
if e[0] != errno.EADDRINUSE:
raise
print "(%s) socket %s:%s already in use, retrying after %s seconds..." % (
os.getpid(), host, port, sleeptime)
eventlet.sleep(sleeptime)
sleeptime *= 2
def bind_socket(config):
sleeptime = 0.5
host = config.get('host', '')
port = config.get('port', 8080)
for x in range(8):
try:
sock = eventlet.listen((host, port))
break
except socket.error, e:
if e[0] != errno.EADDRINUSE:
raise
print "(%s) socket %s:%s already in use, retrying after %s seconds..." % (
os.getpid(), host, port, sleeptime)
eventlet.sleep(sleeptime)
sleeptime *= 2
def spawn_children(self, number=1):
parent_pid = os.getpid()
for i in range(number):
self.log.debug('createing child %d', i)
to_child_r, to_child_w = os.pipe()
from_child_r, from_child_w = os.pipe()
self.log.debug('pipes create')
to_child_r = copy_fd(to_child_r)
from_child_w = copy_fd(from_child_w)
self.log.debug('pipes copied')
handle = copy_socket(self.sock.fileno())
self.log.debug('socket copied')
command = [_python_exe, '-c',
'import sys; from spawning import spawning_child; spawning_child.main()',
str(parent_pid),
str(handle),
str(to_child_r),
str(from_child_w),
self.factory,
json.dumps(self.args)]
if self.args['reload'] == 'dev':
command.append('--reload')
env = environ()
tpool_size = int(self.config.get('threadpool_workers', 0))
assert tpool_size >= 0, (tpool_size, 'Cannot have a negative --threads argument')
if not tpool_size in (0, 1):
env['EVENTLET_THREADPOOL_SIZE'] = str(tpool_size)
self.log.debug('cmd %s', command)
proc = subprocess.Popen(command, env=env)
# controller process
close(to_child_r)
close(from_child_w)
# XXX create eventlet to listen to from_child_r ?
child = self.children[proc.pid] = Child(proc, to_child_w, from_child_r)
eventlet.spawn(self.read_child_pipe, from_child_r, child)
self.log.debug('create child: %d', proc.pid)
def print_exc(msg="Exception occured!"):
print >> sys.stderr, "(%d) %s" % (os.getpid(), msg)
traceback.print_exc()
sleeptime = 0.5
host = config.get('host', '')
port = config.get('port', 8080)
for x in range(8):
try:
sock = eventlet.listen((host, port))
break
except socket.error, e:
if e[0] != errno.EADDRINUSE:
raise
print "(%s) socket %s:%s already in use, retrying after %s seconds..." % (
os.getpid(), host, port, sleeptime)
eventlet.sleep(sleeptime)
sleeptime *= 2
else:
print "(%s) could not bind socket %s:%s, dying." % (os.getpid(), host,
port)
sys.exit(1)
return sock
def set_process_owner(spec):
import pwd, grp
if ":" in spec:
user, group = spec.split(":", 1)
else:
user, group = spec, None
if group:
os.setgid(grp.getgrnam(group).gr_gid)
if user:
os.setuid(pwd.getpwnam(user).pw_uid)
def install_reload_handler(controller):
from eventlet.green.threading import Thread
import win32event
controller.log.debug('install reload handler')
event = win32event.CreateEvent(None, False, False, 'Spawning Controller HUP %d ' % os.getpid())
def wait_hup():
controller.log.debug('in wait signal thread')
while True:
win32event.WaitForSingleObject(event, win32event.INFINITE)
if not controller.keep_going:
break
controller.handle_sighup()
controller.log.debug('start wait signal thread')
thread = Thread(target=wait_hup)
thread.daemon = True
#thread.start()
controller.log.debug('after thread start')
def print_exc(msg="Exception occured!"):
print >>sys.stderr, "(%d) %s" % (os.getpid(), msg)
traceback.print_exc()
host = config.get('host', '')
port = config.get('port', 8080)
for x in range(8):
try:
sock = eventlet.listen((host, port))
break
except socket.error, e:
if e[0] != errno.EADDRINUSE:
raise
print "(%s) socket %s:%s already in use, retrying after %s seconds..." % (
os.getpid(), host, port, sleeptime)
eventlet.sleep(sleeptime)
sleeptime *= 2
else:
print "(%s) could not bind socket %s:%s, dying." % (
os.getpid(), host, port)
sys.exit(1)
return sock
def set_process_owner(spec):
import pwd, grp
if ":" in spec:
user, group = spec.split(":", 1)
else:
user, group = spec, None
if group:
os.setgid(grp.getgrnam(group).gr_gid)
if user:
os.setuid(pwd.getpwnam(user).pw_uid)
return user, group
host = config.get('host', '')
port = config.get('port', 8080)
for x in range(8):
try:
sock = eventlet.listen((host, port))
break
except socket.error, e:
if e[0] != errno.EADDRINUSE:
raise
print "(%s) socket %s:%s already in use, retrying after %s seconds..." % (
os.getpid(), host, port, sleeptime)
eventlet.sleep(sleeptime)
sleeptime *= 2
else:
print "(%s) could not bind socket %s:%s, dying." % (
os.getpid(), host, port)
sys.exit(1)
return sock
def set_process_owner(spec):
import pwd, grp
if ":" in spec:
user, group = spec.split(":", 1)
else:
user, group = spec, None
if group:
os.setgid(grp.getgrnam(group).gr_gid)
if user:
os.setuid(pwd.getpwnam(user).pw_uid)
return user, group
