def runforever(self):
events.notify(events.SupervisorRunningEvent())
timeout = 1 # this cannot be fewer than the smallest TickEvent (5)
socket_map = self.options.get_socket_map()
while 1:
combined_map = {}
combined_map.update(socket_map)
combined_map.update(self.get_process_map())
pgroups = self.process_groups.values()
pgroups.sort()
if self.options.mood < SupervisorStates.RUNNING:
if not self.stopping:
# first time, set the stopping flag, do a
# notification and set stop_groups
self.stopping = True
self.stop_groups = pgroups[:]
events.notify(events.SupervisorStoppingEvent())
self.ordered_stop_groups_phase_1()
if not self.shutdown_report():
# if there are no unstopped processes (we're done
# killing everything), it's OK to swtop or reload
raise asyncore.ExitNow
r, w, x = [], [], []
for fd, dispatcher in combined_map.items():
if dispatcher.readable():
r.append(fd)
if dispatcher.writable():
w.append(fd)
try:
r, w, x = self.options.select(r, w, x, timeout)
except select.error, err:
r = w = x = []
if err.args[0] == errno.EINTR:
self.options.logger.blather('EINTR encountered in select')
else:
raise
for fd in r:
if combined_map.has_key(fd):
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'read event caused by %(dispatcher)s',
dispatcher=dispatcher)
dispatcher.handle_read_event()
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for fd in w:
if combined_map.has_key(fd):
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'write event caused by %(dispatcher)s',
dispatcher=dispatcher)
dispatcher.handle_write_event()
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
[group.transition() for group in pgroups]
self.reap()
self.handle_signal()
self.tick()
if self.options.mood < SupervisorStates.RUNNING:
self.ordered_stop_groups_phase_2()
if self.options.test:
break
def runforever(self):
events.notify(events.SupervisorRunningEvent())
timeout = 1 # this cannot be fewer than the smallest TickEvent (5)
socket_map = self.options.get_socket_map()
while 1:
combined_map = {}
combined_map.update(socket_map)
combined_map.update(self.get_process_map())
pgroups = list(self.process_groups.values())
pgroups.sort()
if self.options.mood < SupervisorStates.RUNNING:
if not self.stopping:
# first time, set the stopping flag, do a
# notification and set stop_groups
self.stopping = True
self.stop_groups = pgroups[:]
events.notify(events.SupervisorStoppingEvent())
self.ordered_stop_groups_phase_1()
if not self.shutdown_report():
# if there are no unstopped processes (we're done
# killing everything), it's OK to shutdown or reload
raise asyncore.ExitNow
for fd, dispatcher in combined_map.items():
if dispatcher.readable():
self.options.poller.register_readable(fd)
if dispatcher.writable():
self.options.poller.register_writable(fd)
r, w = self.options.poller.poll(timeout)
for fd in r:
if fd in combined_map:
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'read event caused by %(dispatcher)r',
dispatcher=dispatcher)
dispatcher.handle_read_event()
if not dispatcher.readable():
self.options.poller.unregister_readable(fd)
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for fd in w:
if fd in combined_map:
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'write event caused by %(dispatcher)r',
dispatcher=dispatcher)
dispatcher.handle_write_event()
if not dispatcher.writable():
self.options.poller.unregister_writable(fd)
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for group in pgroups:
group.transition()
self.reap()
self.handle_signal()
self.tick()
if self.options.mood < SupervisorStates.RUNNING:
self.ordered_stop_groups_phase_2()
if self.options.test:
break
def test_supervisor_sc_event(self):
from supervisor import events
event = events.SupervisorRunningEvent()
headers, payload = self._deserialize(str(event))
self.assertEqual(headers, {})
self.assertEqual(payload, '')
def runforever(self):
events.notify(events.SupervisorRunningEvent())
timeout = 1 # this cannot be fewer than the smallest TickEvent (5)
# 网络 socket io
socket_map = self.options.get_socket_map()
while 1:
combined_map = {} # 合并句柄
combined_map.update(socket_map) # socket io
combined_map.update(self.get_process_map()) # process 管道
# 管道比较特殊，只能单向传输，要读就必须关闭写操作，要写就必须关闭读操作
# 子进程
pgroups = list(self.process_groups.values())
pgroups.sort()
if self.options.mood < SupervisorStates.RUNNING:
if not self.stopping:
# first time, set the stopping flag, do a
# notification and set stop_groups
self.stopping = True
self.stop_groups = pgroups[:]
events.notify(events.SupervisorStoppingEvent())
self.ordered_stop_groups_phase_1()
if not self.shutdown_report():
# if there are no unstopped processes (we're done
# killing everything), it's OK to shutdown or reload
raise asyncore.ExitNow
# 注册事件监听
for fd, dispatcher in combined_map.items():
if dispatcher.readable():
self.options.poller.register_readable(fd)
if dispatcher.writable():
self.options.poller.register_writable(fd)
# 获取事件监听结果集 并 处理监听事件
r, w = self.options.poller.poll(timeout)
for fd in r:
if fd in combined_map:
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'read event caused by %(dispatcher)r',
dispatcher=dispatcher)
dispatcher.handle_read_event()
if not dispatcher.readable(): # 管道特殊处理
self.options.poller.unregister_readable(fd)
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for fd in w:
if fd in combined_map:
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'write event caused by %(dispatcher)r',
dispatcher=dispatcher)
dispatcher.handle_write_event()
if not dispatcher.writable(): # 管道特殊处理
self.options.poller.unregister_writable(fd)
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
# 子进程状态检测（本身进程的当前状态和目标状态的匹配，状态转换）
for group in pgroups:
# 判断配置子进程的状态，来决定该子进程是否运行(这其中是由于有些进程可以配置延迟执行)
# 通过调用子进程实例的spwn()方法来运行子进程
group.transition()
# 清理死进程以及相关维护信息
self.reap()
# 信号处理
self.handle_signal()
# 发送标记信号
self.tick()
if self.options.mood < SupervisorStates.RUNNING:
self.ordered_stop_groups_phase_2()
if self.options.test:
break
def runforever(self):
events.notify(events.SupervisorRunningEvent())
socket_map = self.options.get_socket_map()
# this cannot be fewer than the smallest TickEvent (5)
poller_timeout = 1.0
while True:
combined_map = {}
combined_map.update(socket_map)
combined_map.update(self.get_process_map())
pgroups = list(self.process_groups.values())
pgroups.sort()
if self.options.mood < SupervisorStates.RUNNING:
if not self.stopping:
# first time, set the stopping flag, do a
# notification and set stop_groups
self.stopping = True
self.stop_groups = pgroups[:]
events.notify(events.SupervisorStoppingEvent())
self.ordered_stop_groups_phase_1()
if not self.shutdown_report():
# if there are no unstopped processes (we're done
# killing everything), it's OK to swtop or reload
raise asyncore.ExitNow
for fd, dispatcher in combined_map.items():
if dispatcher.readable():
if hasattr(dispatcher, "socket"):
self.options.poller.register_readable(
dispatcher.socket)
else:
self.dispatcher_handle_event(dispatcher,
"handle_read_event")
if dispatcher.writable():
if hasattr(dispatcher, "socket"):
self.options.poller.register_writable(
dispatcher.socket)
else:
self.dispatcher_handle_event(dispatcher,
"handle_write_event")
readables, writables = self.options.poller.poll(poller_timeout)
for fd in readables:
if fd in combined_map:
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'read event caused by %(dispatcher)s',
dispatcher=dispatcher)
dispatcher.handle_read_event()
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for fd in writables:
if fd in combined_map:
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'write event caused by %(dispatcher)s',
dispatcher=dispatcher)
dispatcher.handle_write_event()
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for group in pgroups:
group.transition()
self.reap()
self.handle_signal()
self.tick()
if self.options.mood < SupervisorStates.RUNNING:
self.ordered_stop_groups_phase_2()
if self.options.test:
break
try:
# Avoid overloading the processor
time.sleep(self.options.delay_secs)
except IOError:
continue
def runforever(self):
# 事件通知机制，使用callbacks中的方法对event实例进行操作
# callbacks一直是空的，现在还不知道怎么添加方法到其中
events.notify(events.SupervisorRunningEvent())
timeout = 1 # this cannot be fewer than the smallest TickEvent (5)
# 获得一件注册的句柄 {4: <supervisor.http.supervisor_af_unix_http_server at 0x7f8b5fcb0488>} 不知道在哪里设置的
# supervisor_af_unix_http_server对象
socket_map = self.options.get_socket_map()
# print('socket_map:',socket_map)
while 1:
# 保存运行的信息
combined_map = {}
combined_map.update(socket_map)
combined_map.update(self.get_process_map())
# 进程信息 socket_map我追溯了很长时间，类之间关联太复杂了，放弃治疗
# 更新，窝没有放弃治疗，我找到了
# self.get_process_map()为空
pgroups = list(self.process_groups.values())
# 这个排序是按照内存地址进行的吗
# 这个排序是processgroup中定义的，按照配置中的优先级进行排序
# def __lt__(self, other):
# return self.config.priority < other.config.priority
pgroups.sort()
# 根据进程的配置开启或者关闭进程
# self.options.mood 在信号中变化， RESTARTING = 0 SHUTDOWN = -1 这两个是小于
if self.options.mood < SupervisorStates.RUNNING:
if not self.stopping:
# first time, set the stopping flag, do a
# notification and set stop_groups
self.stopping = True
self.stop_groups = pgroups[:]
events.notify(events.SupervisorStoppingEvent())
self.ordered_stop_groups_phase_1()
if not self.shutdown_report():
# if there are no unstopped processes (we're done
# killing everything), it's OK to shutdown or reload
raise asyncore.ExitNow
# 这个和我们用redis差不多来着
for fd, dispatcher in combined_map.items():
# class http_server (asyncore.dispatcher): 在右键第四个
if dispatcher.readable():
#可读，注册到select,证明这个句柄是好的
self.options.poller.register_readable(fd)
if dispatcher.writable():
# 初始时候不可写，注册到select
self.options.poller.register_writable(fd)
# poll操作,返回可读可写的文件描述符,到这一步完全没有问题
r, w = self.options.poller.poll(timeout)
# print(combined_map)
# for i,key in combined_map.items():
# print(key)
for fd in r:
if fd in combined_map:
# print('r start running',fd)
try:
dispatcher = combined_map[fd]
# print(dispatcher)
self.options.logger.blather(
'read event caused by %(dispatcher)r',
dispatcher=dispatcher)
# print('ttttt')
# print(dispatcher)
# <socket._socketobject object at 0x7fdfa69b96e0>
# print(dispatcher.__class__.__name__)
# dispatcher.test_handler()
dispatcher.handle_read_event()
if not dispatcher.readable():
self.options.poller.unregister_readable(fd)
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
# 依次遍历注册的文件句柄
for fd in w:
if fd in combined_map:
# print('w start running', fd)
try:
dispatcher = combined_map[fd]
self.options.logger.blather(
'write event caused by %(dispatcher)r',
dispatcher=dispatcher)
dispatcher.handle_write_event()
if not dispatcher.writable():
self.options.poller.unregister_writable(fd)
except asyncore.ExitNow:
raise
except:
combined_map[fd].handle_error()
for group in pgroups:
group.transition()
# 获取已经死亡的子进程信息
self.reap()
# 处理信号
self.handle_signal()
# tick时钟
self.tick()
if self.options.mood < SupervisorStates.RUNNING:
self.ordered_stop_groups_phase_2()
if self.options.test:
break
# 新加，测试用
# break
'''
