def run(self):
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
# close inherited father pipes
self.father_pipes[0].close()
self.father_pipes[1].close()
self.socks = Queue.Queue() #线程安全的queue
self.clean_timer = threading.Timer(60, self.clean)
self.clean_timer.start()
self.f_control = ControlFatherProcess(self)
self.f_control.start()
while self.f_control.is_alive() or not self.socks.empty():
try:
sock = self.socks.get(timeout=0.01) #在timeout时间内，假如socks为空，返回Empty Exception
sock.accept()
ProtocolDetectDispatcher(sock, self.f_control)
except (IOError, Queue.Empty):
continue
# reload asyncore if stopped
if self.t_asyncore is None or not self.t_asyncore.is_alive():
# timeout needed for more SSL layer reactivity
self.t_asyncore = threading.Thread(target=lambda:asyncore.loop(timeout=0.01))
self.t_asyncore.start()
if self.t_asyncore is not None and self.t_asyncore.is_alive():
asyncore.close_all()
self.t_asyncore.join()
def run(self):
cfg = self.session.config.sys.smtpd
if cfg.host and cfg.port:
server = SMTPServer(self.session, (cfg.host, cfg.port))
while not self.quitting:
asyncore.poll(timeout=1.0)
asyncore.close_all()
def closeall_check(self, usedefault):
# Check that close_all() closes everything in a given map
l = []
testmap = {}
for i in range(10):
c = dummychannel()
l.append(c)
self.assertEqual(c.socket.closed, False)
testmap[i] = c
if usedefault:
socketmap = asyncore.socket_map
try:
asyncore.socket_map = testmap
asyncore.close_all()
finally:
testmap, asyncore.socket_map = asyncore.socket_map, socketmap
else:
asyncore.close_all(testmap)
self.assertEqual(len(testmap), 0)
for c in l:
self.assertEqual(c.socket.closed, True)
def run(self):
self.active = True
self.__flag.set()
while self.active and asyncore.socket_map:
with self.active_lock:
asyncore.loop(timeout=0.1, count=1)
asyncore.close_all()
def debugging_server(serv, serv_evt, client_evt):
serv_evt.set()
try:
if hasattr(select, 'poll'):
poll_fun = asyncore.poll2
else:
poll_fun = asyncore.poll
n = 1000
while asyncore.socket_map and n > 0:
poll_fun(0.01, asyncore.socket_map)
# when the client conversation is finished, it will
# set client_evt, and it's then ok to kill the server
if client_evt.is_set():
serv.close()
break
n -= 1
except socket.timeout:
pass
finally:
if not client_evt.is_set():
# allow some time for the client to read the result
time.sleep(0.5)
serv.close()
asyncore.close_all()
serv_evt.set()
def stop_server(self):
self._ftp_server.close()
asyncore.close_all()
self._async_thread.join()
if 'threads' in tests.selftest_debug_flags:
sys.stderr.write('Thread joined: %s\n'
% (self._async_thread.ident,))
def _HandleCommand(self, cmdtext):
"""Handle system control commands which arrive via the web
interface.
Parameters: cmdtext (string) = The command JSON string.
"""
# Decode the JSON.
try:
cmd = MonUtils.JSONDecode(cmdtext)
cmdcode = cmd['mblogicsyscmd']
except:
self._SendError(404, MonUtils.JSONEncode({'mblogicsyscmd' : 'error'}))
return
timestamp = time.mktime(time.gmtime())
respjson = MonUtils.JSONEncode({'mblogicsyscmd' : 'ok'})
# Now, see what the command was.
if cmdcode == 'reloadhmiconfig':
print('\nRemote config reload command at %s\n' % time.ctime())
# Send the headers and content.
self._SendOKResponse('application/json', len(respjson), timestamp, respjson)
HMIConf.LoadHMIConfig()
elif cmdcode == 'shutdown':
print('\nRemote shutdown command at %s\n' % time.ctime())
# Send the headers and content.
self._SendOKResponse('application/json', len(respjson), timestamp, respjson)
asyncore.close_all()
# We don't recognise the command.
else:
self._SendError(404, MonUtils.JSONEncode({'mblogicsyscmd' : 'error'}))
def FindFastest(varname, sitelist):
latencies = {}
# Ignore duplicates
sitelist = set(sitelist)
def callback(url, duration):
latencies.setdefault(url, 0)
latencies[url] += duration
for url in sitelist:
AsyncConnect(url, callback)
count = len(sitelist)
# We probaly don't need more than 10 results, so if there are more than 10
# servers, lets only track the first few that return quickly:
if count > 10:
count = 10
asyncore.loop(timeout=1, count=count)
if not latencies:
# No data has come back yet, let's wait
print >>sys.stderr, " => Still waiting on data for %s" % varname
asyncore.loop(timeout=30)
# Close any still-open connections...
asyncore.close_all()
# Return the latency dict sorted by latency as list of (key, value)
latency_list = sorted(latencies.iteritems(), key=lambda (a,b): (b,a))
return latency_list
def run_client(self, command):
time.sleep(1) # TODO need a blocking queue
s = socket.create_connection(('localhost', PORT))
s.send(command)
data = s.recv(1024)
s.close()
asyncore.close_all()
self.assertEquals(data, command)
def run(self):
self.active = True
self.__flag.set()
while self.active and asyncore.socket_map:
self.active_lock.acquire()
asyncore.loop(timeout=0.1, count=1)
self.active_lock.release()
asyncore.close_all()
def drop(self, calling_irc_handler):
# Prevent accidental rogue irc timers?
print("DC message from " + calling_irc_handler.__str__())
if self.irc is calling_irc_handler:
self.socket.close()
asyncore.close_all()
else:
print("Bot is ignoring out of date handler. Masti is bad at threading!")
def start_server(self, port=2199, **kw):
"""Starts an asyncore server reading commands for clients and opening
a new interpreter for each connection."""
_AsynServer(self, _AsynHandler, port) # register the server
try:
asyncore.loop(**kw)
except KeyboardInterrupt:
pass
finally:
asyncore.close_all()
def stop(self, signum=None, frame=None):
if signum is not None:
log(1, "caught %s" % STOP_SIGNALS[signum])
log(1, "shutting down...")
for app in self.config.apps:
if hasattr(app, 'close') and inspect.ismethod(app.close):
app.close()
self.task_dispatcher.shutdown()
asyncore.close_all()
log(1, "httpy stopped")
def found_terminator(self):
data, self.buffer = self.buffer, ''
if not data:
asyncore.close_all()
print("done")
return
n = string.atoi(string.split(data)[0])
tf = trigger_file(self)
self.count = self.count + 1
thread.start_new_thread(thread_function, (tf, self.count, n))
def test(port='8021'):
fs = ftp_server(unix_authorizer(), port=string.atoi(port))
try:
asyncore.loop()
except KeyboardInterrupt:
fs.log_info('FTP server shutting down. (received SIGINT)',
'warning')
# close everything down on SIGINT.
# of course this should be a cleaner shutdown.
asyncore.close_all()
def found_terminator (self):
data, self.buffer = self.buffer, ''
if not data:
asyncore.close_all()
print "done"
return
n = string.atoi (string.split (data)[0])
tf = trigger_file (self)
self.count = self.count + 1
thread.start_new_thread (thread_function, (tf, self.count, n))
def handle_close(self):
"""When closed, this method will be call. clean itself."""
LOGGER.debug("server closed")
self.clear()
data = {}
self.update_notify_state(data, STAGE_SERVER_UNCONNECTED)
self.close()
# close all and restart
asyncore.close_all()
def start_server(self, port=2199, **kw):
"""Starts an asyncore server reading commands for clients and opening
a new interpreter for each connection."""
_AsynServer(self, _AsynHandler, port) # register the server
try:
asyncore.loop(**kw)
except (KeyboardInterrupt, TerminatedProcess):
pass
finally:
asyncore.close_all()
def shutdown():
global SHUTDOWN_PERFORMED
if not SHUTDOWN_PERFORMED:
l.warn('Passing out...')
l.debug("Socket map: %s" % repr(asyncore.socket_map))
l.info("Closing %d socket(s)" % len(asyncore.socket_map))
asyncore.close_all()
l.debug("Socket map: %s" % repr(asyncore.socket_map))
l.warn('Gone')
def stop_and_close(self):
'''To check the correctness of connection closing - we need to close
it before stopping sniffer and analyzing sniffer's output (and throwing
an exception in case of failure); so, we need to close Deproxy client
and server connections in test_* function (not in tearDown).
'''
asyncore.close_all()
self.client.stop()
self.tempesta.stop()
self.tester.stop()
def stop(self):
global IS_FINISH
IS_FINISH = True
self.__task_handler.join()
self.__logger.log("Debug", "Closing all connections...")
asyncore.close_all()
self.__logger.log("Debug", "Waiting for service"
" dispatcher to close...")
self.__service.close()
self.__logger.log("Debug", "Service dispatcher closed...")
self.join()
def stop(self):
if self.running:
self.running = False
self.commitTimer.cancel()
for service in self.services:
try:
service.stop()
except Exception as e:
self.handler.stop_error(service, e)
pass
asyncore.close_all()
self.asyncLoop.join()
def shutdown(self, arg1=None, arg2=None):
print('Initiating shutdown...')
runtime.logger.info('Initiating shutdown...')
self.running = False
# stop services
runtime.logger.info('Stopping services...')
services.stop()
# join asyn thread
asyncore.close_all()
self._asyn_thread.join()
def test (port='8021'):
fs = ftp_server (
unix_authorizer(),
port=string.atoi (port)
)
try:
asyncore.loop()
except KeyboardInterrupt:
fs.log_info('FTP server shutting down. (received SIGINT)', 'warning')
# close everything down on SIGINT.
# of course this should be a cleaner shutdown.
asyncore.close_all()
def shutdown(self, arg1=None, arg2=None):
print('Initiating shutdown...')
runtime.logger.info('Initiating shutdown...')
self.running = False
# stop services
runtime.logger.info('Stopping services...')
services.stop()
# join asyn thread
asyncore.close_all()
self._asyn_thread.join()
def run_server(self, password="", port=DEFAULT_PORT):
self.password = password
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.bind(("", port))
self.listen(1)
try:
asyncore.loop(map=self.socket_map)
except:
asyncore.close_all()
raise
return self.taskmanager.results
def run_server(self, password="", port=DEFAULT_PORT):
self.password = password
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.bind(("", port))
self.listen(1)
try:
asyncore.loop(map=self.socket_map)
except:
asyncore.close_all()
raise
return self.taskmanager.results
def close(self, cancel_async_services = False):
if cancel_async_services:
logger.info('Cancelling all running asynchronous requests...')
ResponseCallback.cancel_all()
self.executor.cancel_all()
else:
logger.info('Waiting for all asynchronous requests to complete...')
self.executor.shutdown(wait = True)
self.simulator_service.close()
# Close all other asyncore sockets (StreanJSON)
asyncore.close_all()
Morse._asyncore_thread.join(TIMEOUT)
Morse._asyncore_thread = None # in case we want to re-create
logger.info('Done. Bye bye!')
def close(self, cancel_async_services = False):
if cancel_async_services:
logger.info('Cancelling all running asynchronous requests...')
ResponseCallback.cancel_all()
self.executor.cancel_all()
else:
logger.info('Waiting for all asynchronous requests to complete...')
self.executor.shutdown(wait = True)
self.simulator_service.close()
# Close all other asyncore sockets (StreanJSON)
asyncore.close_all()
Morse._asyncore_thread.join(TIMEOUT)
Morse._asyncore_thread = None # in case we want to re-create
logger.info('Done. Bye bye!')
def run(self):
self.active = True
self.__flag.set()
try:
while self.active and asyncore.socket_map:
self.active_lock.acquire()
try:
asyncore.loop(timeout=0.1, count=1)
except:
self.active_lock.release()
raise
self.active_lock.release()
finally:
asyncore.close_all(ignore_all=True)
def exit_parent(self, sig, frame):
self.zk.stop()
self.close()
asyncore.close_all()
pids = []
for pid in self.child_pids:
print 'before kill'
try:
os.kill(pid, signal.SIGINT)
pids.append(pid)
except OSError, ex:
if ex.args[0] == errno.ECHILD:
continue
raise ex
print 'after kill', pid
def _wait_data(self, clients, queue):
result_data = [None] * self.num_workers
ready_flags = [False] * self.num_workers
all_ready_flags = [True] * self.num_workers
while True:
time.sleep(0.2)
for index in range(self.num_workers):
if clients[index].ready() and clients[index] is not None:
result_data[index] = clients[index].get()
ready_flags[index] = True
if ready_flags == all_ready_flags:
raveled_data = ravel_array(result_data)
queue.put(raveled_data)
break
asyncore.close_all()
def exit_parent(self, sig, frame):
self.zk.stop() # 关闭 zk 客户端
self.close() # 关闭 serversocket
asyncore.close_all() # 关闭所有 clientsocket
pids = []
for pid in self.child_pids:
print 'before kill'
try:
os.kill(pid, signal.SIGINT) # 关闭子进程
pids.append(pid)
except OSError, ex:
if ex.args[0] == errno.ECHILD: # 目标子进程已经提前挂了
continue
raise ex
print 'after kill', pid
def exit_parent(self, sig, frame):
self.zk.stop() # 关闭zk客户端
self.close() # 关闭serversocket
asyncore.close_all() # 关闭所有clientsocket
pids = []
for pid in self.child_pids:
print 'before kill'
try:
os.kill(pid, signal.SIGINT) # 关闭子进程
pids.append(pid)
except OSError, ex:
if ex.args[0] == errno.ECHILD: # 目标子进程已经提前挂了
continue
raise ex
print 'after kill', pid
def close(self):
DebugLogger.log('A', id(self._request),
'%s %s' % (self._request.reply_code, self._bytes))
if not self._channel.closed:
self._channel.push(LoggingProducer(self._request, self._bytes), 0)
self._channel.push(CallbackProducer(self._channel.done), 0)
self._channel.push(CallbackProducer(
lambda t=('E', id(self._request)): apply(DebugLogger.log, t)), 0)
if self._shutdown:
self._channel.push(ShutdownProducer(), 0)
Wakeup()
else:
if self._close: self._channel.push(None, 0)
Wakeup()
else:
# channel closed too soon
self._request.log(self._bytes)
DebugLogger.log('E', id(self._request))
if self._shutdown:
Wakeup(lambda: asyncore.close_all())
else:
Wakeup()
self._channel=None #need to break cycles?
self._request=None
def run_server(self):
logging.info("Starting server.")
self.datasource = mapreducer.READER(FLAGS.reader)().read(FLAGS.input)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
logging.info("Number of input key value pairs: %d " % \
(len(self.datasource.keys())))
self.bind(("", FLAGS.port))
self.listen(1)
logging.info("Starting listening on %d" % (FLAGS.port))
try:
asyncore.loop()
except:
asyncore.close_all()
raise
logging.info("Mapreduce done.")
mapreducer.WRITER(FLAGS.writer)().write(self.taskmanager.results)
def _finish(self):
self.channel.reply_code=self.status
DebugLogger.log('A', id(self.channel), '%d %d' % (
self.status, self.stdout.length))
t=self._tempfile
if t is not None:
self.stdout.write((file_close_producer(t), 0))
self._tempfile=None
self.channel.sendStreamTerminator(FCGI_STDOUT)
self.channel.sendEndRecord()
self.stdout.close()
self.stderr.close()
if not self.channel.closed:
self.channel.push_with_producer(LoggingProducer(self.channel,
self.stdout.length,
'log_request'), 0)
if self._shutdownRequested():
self.channel.push(ShutdownProducer(), 0)
Wakeup(lambda: asyncore.close_all())
else:
self.channel.push(None,0)
Wakeup()
self.channel=None
def startSocketServer_clearAll(closeAllSockets=True, stopAllPolling=True):
"""
use this to stop all prior started servers
"""
if closeAllSockets:
asyncore.close_all()
if stopAllPolling:
global _pollers
for p in _pollers:
try:
p.Stop
except:
import traceback
traceback.print_exc()
_pollers = []
def socketServer_clearAll(closeAllSockets=True, stopAllPolling=True):
"""
use this to stop all prior started servers
"""
if closeAllSockets:
asyncore.close_all()
if stopAllPolling:
global _pollers
for p in _pollers:
try:
p.Stop
except:
import traceback
traceback.print_exc()
_pollers = []
def close(self):
if not self._channel.closed:
data = self._data.getvalue()
l = len(data)
DebugLogger.log('A', id(self._channel),
'%s %s' % (self._channel.reply_code, l))
self._channel.push('%010d%s%010d' % (l, data, 0), 0)
self._channel.push(
LoggingProducer(self._channel, l, 'log_request'), 0)
self._channel.push(
CallbackProducer(lambda t=('E', id(self._channel)): apply(
DebugLogger.log, t)), 0)
if self._shutdown:
try:
r = self._shutdown[0]
except:
r = 0
config.ZSERVER_EXIT_CODE = r
self._channel.push(ShutdownProducer(), 0)
Wakeup(lambda: asyncore.close_all())
else:
self._channel.push(None, 0)
Wakeup()
self._data = None
self._channel = None
def run_server(self):
logging.info("Starting server.")
self.datasource = mapreducer.READER(FLAGS.reader)().read(FLAGS.input)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
logging.info("Number of input key value pairs: %d " % \
(len(self.datasource.keys())))
self.bind(("", FLAGS.port))
self.listen(1)
logging.info("Starting listening on %d" % (FLAGS.port))
try:
asyncore.loop()
except:
asyncore.close_all()
raise
logging.info("Mapreduce done.")
mapreducer.WRITER(FLAGS.writer)().write(self.taskmanager.results)
def close(self):
log('A', id(self._request),
'%s %s' % (self._request.reply_code, self._bytes))
if not self._channel.closed:
self._channel.push(LoggingProducer(self._request, self._bytes), 0)
self._channel.push(CallbackProducer(self._channel.done), 0)
self._channel.push(
CallbackProducer(lambda t=
('E', id(self._request)): apply(log, t)), 0)
if self._shutdown:
self._channel.push(ShutdownProducer(), 0)
Wakeup()
else:
if self._close: self._channel.push(None, 0)
Wakeup()
else:
# channel closed too soon
self._request.log(self._bytes)
log('E', id(self._request))
if self._shutdown:
Wakeup(lambda: asyncore.close_all())
else:
Wakeup()
self._channel = None #need to break cycles?
self._request = None
def _finish(self):
self.channel.reply_code=self.status
DebugLogger.log('A', id(self.channel), '%d %d' % (
self.status, self.stdout.length))
t=self._tempfile
if t is not None:
self.stdout.write((file_close_producer(t), 0))
self._tempfile=None
self.channel.sendStreamTerminator(FCGI_STDOUT)
self.channel.sendEndRecord()
self.stdout.close()
self.stderr.close()
if not self.channel.closed:
self.channel.push_with_producer(LoggingProducer(self.channel,
self.stdout.length,
'log_request'), 0)
if self._shutdownRequested():
self.channel.push(ShutdownProducer(), 0)
Wakeup(lambda: asyncore.close_all())
else:
self.channel.push(None,0)
Wakeup()
self.channel=None
def proxy_loop(self):
"""Handle main loop and reconnection."""
self.molo_client.sock_connect()
while not self.is_exited:
try:
asyncore.loop()
except asyncore.ExitNow as exc:
logging.exception(exc)
LOGGER.error("asyncore.loop exception")
if not self.is_exited:
asyncore.close_all()
self.molo_client.sock_connect()
time.sleep(RECONNECT_INTERVAL)
LOGGER.info("moloserver reconnecting...")
asyncore.close_all()
LOGGER.debug("proxy exited")
def onShuttingDown(self):
if self.isRunning:
self.logger.info('Shutting down bot')
if self.cmdHandler.monitor_thread:
self.cmdHandler.monitor_thread.cancel()
for user in self.users.values():
if user.dccSocket:
user.dccSocket.handle_close()
self.isRunning = False
self.isReady = False
self.isIdentified = False
self.dccSocket.handle_close()
self.socket.handle_close()
# Just in case we missed any somehow
asyncore.close_all()
def mockup_smtp_server(bind=('localhost', 0)):
SMTP_SERVER_LOCK = threading.Event()
class MockupSMTPServer(smtpd.SMTPServer):
def __init__(self, bind):
super().__init__(bind, None, decode_data=False)
self.server_address = self.socket.getsockname()[:2]
SMTP_SERVER_LOCK.set()
def process_message(*args, **kwargs):
pass
server = MockupSMTPServer(bind)
thread = threading.Thread(target=asyncore.loop, daemon=True)
thread.start()
SMTP_SERVER_LOCK.wait()
yield server, server.server_address
asyncore.close_all()
def close(self, cancel_async_services = False, wait_publishers = True):
if wait_publishers:
import time
for stream in self.get_publisher_streams():
while len(stream.producer_fifo) > 0:
time.sleep(0.001)
if cancel_async_services:
logger.info('Cancelling all running asynchronous requests...')
ResponseCallback.cancel_all()
self.executor.cancel_all()
else:
logger.info('Waiting for all asynchronous requests to complete...')
self.executor.shutdown(wait = True)
# Close all other asyncore sockets (StreanJSON)
if Morse.poll_thread:
Morse.poll_thread.syncstop(TIMEOUT)
asyncore.close_all()
Morse.poll_thread = None # in case we want to re-create
logger.info('Done. Bye bye!')
def main(argv):
if '-d' in argv[1:]:
logger.setLevel(logging.DEBUG)
logger.debug("Hybrid node started...")
hn = HybridNode()
try:
while 1:
hn.synchronize()
except KeyboardInterrupt:
logger.info("Quit (Ctrl+C)")
finally:
del hn
logger.info("Closing all connections")
asyncore.close_all()
logger.info("Bye!")
return 0
def main(argv):
if '-d' in argv[1:]:
logger.setLevel(logging.DEBUG)
logger.debug("Hybrid node started...")
hn = HybridNode()
try:
while 1:
hn.synchronize()
except KeyboardInterrupt:
logger.info("Quit (Ctrl+C)")
finally:
del hn
logger.info("Closing all connections")
asyncore.close_all()
logger.info("Bye!")
return 0
def close(self, cancel_async_services=False, wait_publishers=True):
if wait_publishers:
import time
for stream in self.get_publisher_streams():
while len(stream.producer_fifo) > 0:
time.sleep(0.001)
if cancel_async_services:
logger.info('Cancelling all running asynchronous requests...')
ResponseCallback.cancel_all()
self.executor.cancel_all()
else:
logger.info('Waiting for all asynchronous requests to complete...')
self.executor.shutdown(wait=True)
# Close all other asyncore sockets (StreanJSON)
if Morse.poll_thread:
Morse.poll_thread.syncstop(TIMEOUT)
asyncore.close_all()
Morse.poll_thread = None # in case we want to re-create
logger.info('Done. Bye bye!')
def run(self):
Logger.info("[WebApps] new process started")
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
# close inherited father pipes
self.father_pipes[0].close()
self.father_pipes[1].close()
self.socks = Queue.Queue()
self.clean_timer = threading.Timer(Config.process_timeout, self.clean)
self.clean_timer.start()
self.f_control = ControlFatherProcess(self)
self.f_control.start()
while self.f_control.is_alive() or not self.socks.empty():
try:
sock = self.socks.get(timeout=0.01)
if Config.connection_secure:
ssl_conn = SSL.Connection(self.ssl_ctx, sock)
Logger.debug("[WebApps] new connection => %s" % str(ssl_conn.getpeername()))
ssl_conn.set_accept_state()
ProtocolDetectDispatcher(ssl_conn, self.f_control, self.ssl_ctx)
else:
HttpProtocolDetectDispatcher(sock, self.f_control)
except (IOError, Queue.Empty):
continue
# reload asyncore if stopped
if self.is_sleeping():
# timeout needed for more SSL layer reactivity
self.t_asyncore = threading.Thread(target=lambda:asyncore.loop(timeout=0.01))
self.t_asyncore.start()
if not self.is_sleeping():
asyncore.close_all()
self.t_asyncore.join()
Logger.info("[WebApps] child process stopped")
def run(self):
Logger.info("[WebApps] new process started")
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal.SIG_IGN)
# close inherited father pipes
self.father_pipes[0].close()
self.father_pipes[1].close()
self.socks = Queue.Queue()
self.clean_timer = threading.Timer(Config.process_timeout, self.clean)
self.clean_timer.start()
self.f_control = ControlFatherProcess(self)
self.f_control.start()
while self.f_control.is_alive() or not self.socks.empty():
try:
sock = self.socks.get(timeout=0.01)
if Config.connection_secure:
ssl_conn = SSL.Connection(self.ssl_ctx, sock)
Logger.debug("[WebApps] new connection => %s" % str(ssl_conn.getpeername()))
ssl_conn.set_accept_state()
ProtocolDetectDispatcher(ssl_conn, self.f_control, self.ssl_ctx)
else:
HttpProtocolDetectDispatcher(sock, self.f_control)
except (IOError, Queue.Empty):
continue
# reload asyncore if stopped
if self.is_sleeping():
# timeout needed for more SSL layer reactivity
self.t_asyncore = threading.Thread(target=lambda: asyncore.loop(timeout=0.01))
self.t_asyncore.start()
if not self.is_sleeping():
asyncore.close_all()
self.t_asyncore.join()
Logger.info("[WebApps] child process stopped")
def stop(self, signum=None, frame=None):
"""Stop the server.
"""
if signum is not None:
msg = "caught %s, shutting down..." % STOP_SIGNALS[signum]
sys.stderr.write(msg)
sys.stderr.flush()
if hasattr(self.responder, 'stop'):
if inspect.ismethod(self.responder.stop):
self.responder.stop()
self.task_dispatcher.shutdown()
asyncore.close_all()
if (not WINDOWS) and (self.sockfam == socket.AF_UNIX):
if os.path.exists(self.address):
os.unlink(self.address)
sys.stderr.write("done\n")
sys.stderr.flush()
def closeall_check(self, usedefault):
l = []
testmap = {}
for i in range(10):
c = dummychannel()
l.append(c)
self.assertEqual(c.socket.closed, False)
testmap[i] = c
if usedefault:
socketmap = asyncore.socket_map
try:
asyncore.socket_map = testmap
asyncore.close_all()
finally:
testmap, asyncore.socket_map = asyncore.socket_map, socketmap
else:
asyncore.close_all(testmap)
self.assertEqual(len(testmap), 0)
for c in l:
self.assertEqual(c.socket.closed, True)
def HandleExit(soft=False):
global client, thread, keepal, renderer, eventh, exit, promptWait, console
try: client.send("DROP")
except: pass
if soft:
try: console.visible = False
except: pass
exit = True
return
try: server.server.stop()
except: pass
client.close()
asyncore.close_all()
exit = True
kill = True
pscreen.UnloadScreen()
pygame.quit()
promptWait = False
print "EXITING"
os._exit(1)
def stop(self, signum=None, frame=None):
"""Stop the server.
"""
if signum is not None:
logger.debug("caught %s" % STOP_SIGNALS[signum])
logger.info("shutting down...")
if hasattr(self.responder, 'stop'):
if inspect.ismethod(self.responder.stop):
self.responder.stop()
self.task_dispatcher.shutdown()
asyncore.close_all()
if (not WINDOWS) and (self.config.sockfam == socket.AF_UNIX):
if not os.path.exists(self.config.address):
logger.debug("what happened to our socket?")
os.unlink(self.config.address)
logger.info("httpy stopped")
def ping_server(self):
"""Send ping to server every ping_interval."""
while not self.is_exited:
try:
if self.molo_client:
self.set_ping_buffer(self.molo_client.ping_server_buffer())
time.sleep(self.ping_interval)
time_interval = time.time() - self.last_activate_time
LOGGER.debug("data interval: %f", time_interval)
if time_interval > PROXY_TCP_CONNECTION_ACTIVATE_TIME:
LOGGER.info("connection timeout, reconnecting server")
self.molo_client.handle_close()
self.reset_activate_time()
except Exception as exc:
print("ping_server(): " + str(exc))
asyncore.close_all()
self.molo_client.sock_connect()
time.sleep(RECONNECT_INTERVAL)
LOGGER.info("moloserver reconnecting...")
def main_loop(self):
"""Handle main loop and reconnection."""
self.molo_client.sock_connect()
while not self.is_exited:
try:
asyncore.loop(map=self.async_map)
except asyncore.ExitNow as exc:
logging.exception(exc)
LOGGER.error("asyncore.loop exception")
if not self.is_exited:
try:
asyncore.close_all()
self.molo_client.sock_connect()
time.sleep(RECONNECT_INTERVAL)
LOGGER.info("moloserver reconnecting...")
except Exception as exc:
print("main_loop(): " + str(exc))
LOGGER.info("reconnect failed, retry...")
time.sleep(RECONNECT_INTERVAL)
asyncore.close_all()
LOGGER.debug("main loop exited")
def debugging_server(serv, serv_evt, client_evt):
serv_evt.set()
try:
if hasattr(select, 'poll'):
poll_fun = asyncore.poll2
else:
poll_fun = asyncore.poll
n = 1000
while asyncore.socket_map and n > 0:
poll_fun(0.01, asyncore.socket_map)
if client_evt.is_set():
serv.close()
break
n -= 1
except socket.timeout:
pass
finally:
if not client_evt.is_set():
time.sleep(0.5)
serv.close()
asyncore.close_all()
serv_evt.set()
def stop(self, signum=None, frame=None):
self.alive = False
logger.info("Number of Threads: {0}".format(threading.activeCount()))
try:
asyncore.close_all(self.socket_map)
except:
pass
try:
self.scheduler.stop()
except:
pass
try:
self._plugins.stop()
except:
pass
time.sleep(0.5)
if threading.active_count() > 1:
for thread in threading.enumerate():
logger.info("Thread: %s, still alive" % thread.name)
try:
os.remove(PID_FILE)
except OSError, e:
logger.critical("Could not remove pid file: {0} - {1}".format(PID_FILE, e))
