def destroy(self):
"""
For spring python. Just call stop_server().
"""
logger.info("destroy : Entering, calling self.stop_server(), %s",
SolBase.get_current_pid_as_string())
self.stop_server()
def stop_server(self):
"""
Stop server
"""
with self.__stop_start_lock:
logger.info("stop_server : stopping, %s",
SolBase.get_current_pid_as_string())
try:
# No more running
self._is_running = False
# Check
if self._is_started is False:
logger.info(
"stop_server : already stopped, doing nothing, %s",
SolBase.get_current_pid_as_string())
return
# Low level stop
try:
gevent.with_timeout(
self._tcp_server_config.stop_server_timeout_ms,
self._stop_server)
except Timeout:
logger.warning(
"Timeout while calling low level _stop_server, some socket may be stucked"
)
# Stop
self._is_started = False
# Done
logger.info("stop_server : stopped, %s",
SolBase.get_current_pid_as_string())
except Exception as e:
logger.error("stop_server : exception, ex=%s, %s",
SolBase.extostr(e),
SolBase.get_current_pid_as_string())
raise
def _on_connection(self, socket, address):
"""
Callback called upon client connection.
:param socket: The client socket.
:type socket: socket.socket
:param address: The client remote address:
:type address: str
"""
logger.debug("_on_connection : address=%s %s", address,
SolBase.get_current_pid_as_string())
# Register a new session
# This will start the read/write loop on client.
local_client = self._register_client(socket, address)
# Check
if local_client is None:
logger.error("_on_connection : _register_client returned none")
def setUp(self):
"""
Setup
"""
logger.info("*** SETUP in")
SolBase.voodoo_init()
self.run_idx = 0
self.current_dir = dirname(
abspath(__file__)) + SolBase.get_pathseparator()
# Reset (teamcity broke the whole stuff)
self.tc_stdin = sys.stdin
self.tc_stdout = sys.stdout
self.tc_stderr = sys.stderr
sys.stdin = real_stdin
sys.stdout = real_stdout
sys.stderr = real_stderr
# Log
logger.info("Entering, %s", SolBase.get_current_pid_as_string())
# Config
self.test_timeout_ms = 30000
self.stdout_timeout_ms = 5000
self.std_err_timeout_ms = 500
self.daemon_pid_file = "/tmp/Daemon.pid"
self.daemon_std_out = "/tmp/Daemon.out.txt"
self.daemon_std_err = "/tmp/Daemon.err.txt"
# Clean
self._clean_files()
logger.info("*** SETUP out")
def start_server(self):
"""
Start
"""
with self.__stop_start_lock:
logger.info("start_server : starting")
try:
if self._is_started is True:
logger.warning(
"start_server : already started, doing nothing")
return False
# Running
self._is_running = True
# Low level start
self._start_server()
# Start
self._is_started = True
# Done
logger.info("start_server : started, %s",
SolBase.get_current_pid_as_string())
# Exit
return True
except Exception as e:
logger.error("start_server : exception, ex=%s",
SolBase.extostr(e))
# Failed, not more running
self._is_running = False
# Raise
raise
def _godaemon(self):
"""
daemonize us
"""
logger.debug("Entering, pid=%s", os.getpid())
# Limit
self._set_limits()
# Fork1
logger.debug("fork1, %s", SolBase.get_current_pid_as_string())
try:
pid = gevent.fork()
if pid > 0:
# Exit first parent
logger.debug("exit(0) first parent")
sys.exit(0)
except OSError as ex:
logger.error("fork1 failed, exit(1) now : errno=%s, err=%s, ex=%s",
ex.errno, ex.strerror, SolBase.extostr(ex))
sys.exit(1)
logger.debug("fork1 done, %s", SolBase.get_current_pid_as_string())
# Diverge from parent
if self._changeDir:
logger.debug("chdir now")
os.chdir("/")
# Set stuff
logger.debug("setsid and umask")
# noinspection PyArgumentList
os.setsid()
os.umask(0)
# Fork2
logger.debug("fork2, %s", SolBase.get_current_pid_as_string())
try:
pid = gevent.fork()
if pid > 0:
# exit from second parent
logger.debug("exit(0) second parent")
sys.exit(0)
except OSError as ex:
logger.error("fork2 failed, exit(2) now : errno=%s, err=%s, ex=%s",
ex.errno, ex.strerror, SolBase.extostr(ex))
sys.exit(2)
logger.debug("fork2 done, %s", SolBase.get_current_pid_as_string())
# Redirect std
self._redirect_all_std()
# Go
logger.debug("initializing _pidfile=%s", self._pidfile)
# Register the method called at exit
atexit.register(self._remove_pid_file)
# Write pidfile
pid = str(os.getpid())
try:
f = open(self._pidfile, "w")
f.write("%s" % pid)
f.close()
except IOError as ex:
logger.error(
"pid file initialization failed, going exit(3), ex=%s",
SolBase.extostr(ex))
sys.exit(3)
# Ok
logger.debug("pid file set")
# Finish
logger.debug("registering gevent signal handler : SIGUSR1")
signal(SIGUSR1, self._on_reload)
logger.debug("registering gevent signal handler : SIGUSR2")
signal(SIGUSR2, self._on_status)
logger.debug("registering gevent signal handler : SIGTERM")
signal(SIGTERM, self._exit_handler)
logger.debug("registering gevent signal handler : done")
# Fatality
SolBase.voodoo_init()
logger.debug("process started, pid=%s, pidfile=%s", os.getpid(),
self._pidfile)
def _start_server(self):
"""
Low level start
"""
# Allocate a server, and provide a connection callback
logger.info("listen_addr=%s", self._tcp_server_config.listen_addr)
logger.info("listen_port=%s", self._tcp_server_config.listen_port)
logger.info("ssl_enable=%s", self._tcp_server_config.ssl_enable)
logger.info("ssl_key_file=%s", self._tcp_server_config.ssl_key_file)
logger.info("ssl_certificate_file=%s",
self._tcp_server_config.ssl_certificate_file)
logger.info("child_process_count=%s",
self._tcp_server_config.child_process_count)
logger.info("ssl_handshake_timeout_ms=%s",
self._tcp_server_config.ssl_handshake_timeout_ms)
logger.info("onstop_call_client_stopsynch=%s",
self._tcp_server_config.onstop_call_client_stopsynch)
logger.info("socket_absolute_timeout_ms=%s",
self._tcp_server_config.socket_absolute_timeout_ms)
logger.info("socket_relative_timeout_ms=%s",
self._tcp_server_config.socket_relative_timeout_ms)
logger.info("socket_min_checkinterval_ms=%s",
self._tcp_server_config.socket_min_checkinterval_ms)
logger.info("_effective_control_interval_ms=%s",
self._effective_control_interval_ms)
logger.info("stop_client_timeout_ms=%s",
self._tcp_server_config.stop_client_timeout_ms)
logger.info("stop_server_timeout_ms=%s",
self._tcp_server_config.stop_server_timeout_ms)
logger.info("client_factory=%s",
self._tcp_server_config.client_factory)
if self._tcp_server_config.ssl_enable is False:
# No SSL
logger.info("Starting in TCP/CLEAR mode")
self._server = StreamServerNoClose(
(self._tcp_server_config.listen_addr,
self._tcp_server_config.listen_port), self._on_connection)
else:
# SSL ON
logger.info("Starting in TCP/SSL mode")
self._server = StreamServerNoClose(
(self._tcp_server_config.listen_addr,
self._tcp_server_config.listen_port),
self._on_connection,
# SSL enabling
keyfile=self._tcp_server_config.ssl_key_file,
certfile=self._tcp_server_config.ssl_certificate_file,
# SSL handshake after accept
do_handshake_on_connect=True,
# TLS
ssl_version=PROTOCOL_TLSv1,
# Cipher
# ciphers="RC4-MD5",
# Args
)
self._server.min_delay = 0.0
self._server.max_delay = 0.0
# Startup
if self._tcp_server_config.child_process_count <= 0:
# Normal start-up
logger.info("Starting in NON-FORKED mode")
self._server.start()
else:
# Child process startup : prestart
logger.info("Pre-starting in FORKED mode, subprocess=%s",
self._tcp_server_config.child_process_count)
# GEVENT_RC1 fix : pre_start => init_socket
self._server.init_socket()
# Let's rock
logger.info("Forking gevent")
for idx in range(self._tcp_server_config.child_process_count):
# Fork gevent hub
# GEVENT_RC1 fix : hub.fork => os.fork
_fork_pid = gevent.fork()
logger.info("Forking gevent hub done, idx=%s, forkPid=%s, %s",
idx, _fork_pid,
SolBase.get_current_pid_as_string())
# Check it
if _fork_pid == 0:
# We are in a child => exit this loop
SolBase.set_master_process(False)
break
else:
# Master on
SolBase.set_master_process(True)
# Store child pid
logger.info("Storing child _fork_pid=%s", _fork_pid)
self._fork_pid_list.append(int(_fork_pid))
# Start accepting now (parent and all sub-processes)
logger.info("Accepting now, %s",
SolBase.get_current_pid_as_string())
self._server.start_accepting()
