def start(daemonize=False, log_level=logging.INFO, **kwargs):
"""
A wrapper for :func:`run` that optionally runs it in a forked daemon process.
:param kwargs: rest of arguments is forwarded to :func:`run`
"""
if daemonize:
aj.log.init_log_directory()
logfile = open(aj.log.LOG_FILE, 'w+')
context = daemon.DaemonContext(
pidfile=PidFile('/var/run/ajenti.pid'),
stdout=logfile,
stderr=logfile,
detach_process=True,
files_preserve=range(1024), # force-closing files breaks gevent badly
)
with context:
gevent.reinit()
aj.log.init_log_rotation()
try:
run(**kwargs)
# pylint: disable=W0703
except Exception as e:
handle_crash(e)
else:
try:
run(**kwargs)
except KeyboardInterrupt:
pass
# pylint: disable=W0703
except Exception as e:
handle_crash(e)
def pywsgi_server_factory(global_conf, host, port):
port = int(port)
reinit()
def serve(app):
WSGIServer((host, port), app).serve_forever()
return serve
def start(daemonize=False, log_level=logging.INFO, **kwargs):
"""
A wrapper for :func:`run` that optionally runs it in a forked daemon process.
:param kwargs: rest of arguments is forwarded to :func:`run`
"""
if daemonize:
aj.log.init_log_directory()
logfile = open(aj.log.LOG_FILE, 'w+')
context = daemon.DaemonContext(
pidfile=PidFile('/var/run/ajenti.pid'),
stdout=logfile,
stderr=logfile,
detach_process=True,
files_preserve=range(1024), # force-closing files breaks gevent badly
)
with context:
gevent.reinit()
aj.log.init_log_rotation()
try:
run(**kwargs)
# pylint: disable=W0703
except Exception as e:
handle_crash(e)
else:
try:
run(**kwargs)
except KeyboardInterrupt:
pass
# pylint: disable=W0703
except Exception as e:
handle_crash(e)
def do_start(self):
if self.daemon:
ginkgo.util.prevent_core_dump()
ginkgo.util.daemonize(
preserve_fds=self.logger.file_descriptors)
self.pid = os.getpid()
self.pidfile.create(self.pid)
self.logger.capture_stdio()
if self.umask is not None:
os.umask(self.umask)
if self.rundir is not None:
os.chdir(self.rundir)
self.app = self.app_factory()
self.add_service(self.app)
# TODO: move this to async manager?
import gevent
gevent.reinit()
# TODO: upgrade to gevent 1.0 and use standard signal
gevent.signal(RELOAD_SIGNAL, self.reload)
gevent.signal(STOP_SIGNAL, self.stop)
def pywsgi_server_factory_patched(global_conf, host, port):
port = int(port)
reinit()
patch_all(dns=False)
def serve(app):
WSGIServer((host, port), app).serve_forever()
return serve
def serve(app):
listener = (host, port)
# listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# listener.bind((host, port))
# listener.listen(port)
reinit()
WSGIServer(listener, app, handler_class=WebSocketWSGIHandler).serve_forever()
def pywsgi_server_factory(global_conf, host, port):
port = int(port)
reinit()
def serve(app):
WSGIServer((host, port), app).serve_forever()
return serve
def run(inflight, urls, ttl):
if ttl > 0:
signal.alarm(ttl)
gevent.reinit()
p = pool.Pool(inflight)
while True:
p.map(get_url, urls)
p.join()
def pywsgi_server_factory_patched(global_conf, host, port):
port = int(port)
reinit()
patch_all(dns=False)
def serve(app):
WSGIServer((host, port), app).serve_forever()
return serve
def gevent_reset(cls):
"""
Reinit
:return: Nothing
"""
logger.info("gevent_reset : reinit now")
# GEVENT_RC1 fix : shutdown : no more
# gevent.shutdown()
gevent.reinit()
def daemonize(self):
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError as e:
sys.stderr.write("fork #1 failed: %d (%s)\n" %
(e.errno, e.strerror))
sys.exit(1)
os.chdir(self.home_dir)
os.setsid()
os.umask(self.umask)
try:
pid = os.fork()
if pid > 0:
sys.exit(0)
except OSError as e:
sys.stderr.write("fork #2 failed: %d (%s)\n" %
(e.errno, e.strerror))
sys.exit(1)
if sys.platform != 'darwin': # This block breaks on OS X
sys.stdout.flush()
sys.stderr.flush()
si = file(self.stdin, 'r')
so = file(self.stdout, 'a+')
if self.stderr:
se = file(self.stderr, 'a+', 0)
else:
se = so
os.dup2(si.fileno(), sys.stdin.fileno())
# os.dup2(so.fileno(), sys.stdout.fileno())
# os.dup2(se.fileno(), sys.stderr.fileno())
sys.stdout = StampedOut(so)
sys.stderr = StampedOut(se)
def sigtermhandler(signum, frame):
self.daemon_alive = False
sys.exit()
if self.use_gevent:
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
if self.verbose >= 1:
print "Started"
atexit.register(
self.delpid) # Make sure pid file is removed if we quit
pid = str(os.getpid())
file(self.pidfile, 'w+').write("%s\n" % pid)
def open(self):
super(GeventDaemonContext, self).open()
# always reinit even when not forked when registering signals
self._apply_monkey_patch()
import gevent
if self.gevent_hub is not None:
# gevent 1.0 only
gevent.get_hub(self.gevent_hub)
gevent.reinit()
self._setup_gevent_signals()
def open(self):
super(GeventDaemonContext, self).open()
# always reinit even when not forked when registering signals
self._apply_monkey_patch()
import gevent
if self.gevent_hub is not None:
# gevent 1.0 only
gevent.get_hub(self.gevent_hub)
gevent.reinit()
self._setup_gevent_signals()
def main():
try:
from gevent import reinit
reinit()
except ImportError:
pass
try:
rescan_scsi_hosts()
return 0
except Exception as err:
logger.exception("{} Unhandled exception in rescan_scsi_bus: {}".format(getpid(), err))
return 1
def open( self ):
self.files_preserve =\
list( tuple(self.files_preserve) + tuple( logger.handler.stream for logger in self.loggers ) )
_DaemonContext.open( self )
gevent.reinit()
## not reliable w/ gevent, unfortunateley .. use stderr redirect instead
#log = logging.getLogger('UNHANDLED')
#sys.excepthook = lambda tp, value, tb:\
# log.error( ''.join( traceback.format_exception( tp, value, tb ) ) )
gevent.signal(signal.SIGTERM, self.run_exit_hooks, signal.SIGTERM, None )
def spawn(self, locust_classes, options, parent):
parent.server.close()
parent.client.close()
try:
parent.greenlet.kill(block=True)
except GreenletExit:
pass
gevent.reinit()
events.clear_events_handlers()
stats.subscribe_stats()
runner = WorkerLocustRunner(locust_classes, options)
runner.greenlet.join()
sys.exit(0)
def make_wsgi_app(global_config, **settings):
""" This function returns a Pyramid WSGI application.
"""
#reinit the gevent lib at first
reinit()
# from storlever.lib.lock import set_lock_factory_from_name
# from storlever.lib.security import AclRootFactory
from ..utils import CustomJSONEncoder
from pyramid.config import Configurator
from pyramid.renderers import JSON
from pyramid.session import UnencryptedCookieSessionFactoryConfig
# from pyramid.authentication import SessionAuthenticationPolicy
# from pyramid.authorization import ACLAuthorizationPolicy
streamswitch_session_factory = UnencryptedCookieSessionFactoryConfig(
'streamswitch201509')
# storlever_authn_policy = SessionAuthenticationPolicy()
# storlever_authz_policy = ACLAuthorizationPolicy()
config = Configurator(
session_factory=streamswitch_session_factory,
# root_factory=AclRootFactory,
# authentication_policy=storlever_authn_policy,
# authorization_policy=storlever_authz_policy,
settings=settings)
config.add_static_view('static', 'static', cache_max_age=3600)
# get user-specific config from setting
json_indent = settings.get("json.indent")
if json_indent is not None:
json_indent = int(json_indent)
# make JSON as the default renderer
config.add_renderer(
None,
JSON(indent=json_indent, check_circular=True, cls=CustomJSONEncoder))
# route and view configuration of REST API version 1 can be found in module storlever.rest
# check storlever.rest.__init__.py for more detail
config.include('streamswitch.wsgiapp.views', route_prefix='stsw/api/v1')
# configure the services into deploy setting
set_services(config)
# loads all the extensions with entry point group "streamswitch.wsgiapp.extensions"
launch_extensions(config)
return config.make_wsgi_app()
def open(self):
self.files_preserve = \
list(tuple(self.files_preserve) + tuple(logger.handler.stream for logger in self.loggers))
_DaemonContext.open(self)
gevent.reinit()
## not reliable w/ gevent, unfortunateley .. use stderr redirect instead
# log = logging.getLogger('UNHANDLED')
# sys.excepthook = lambda tp, value, tb:\
# log.error( ''.join( traceback.format_exception( tp, value, tb ) ) )
gevent.signal(signal.SIGTERM, self.run_exit_hooks, signal.SIGTERM,
None)
def _child(target, args, kwargs): """Wrapper function that runs in child process. Resets gevent/libev state and executes user-given function. """ _tryGevent() _reset_signal_handlers() gevent.reinit() hub = gevent.get_hub() del hub.threadpool hub._threadpool = None hub.destroy(destroy_loop=True) h = gevent.get_hub(default=True) assert h.loop.default, 'Could not create libev default event loop.' target(*args, **kwargs)
def gevent_server_factory(global_config, **kw):
from gevent import reinit
from gevent.wsgi import WSGIServer
from gevent.monkey import patch_all
reinit()
patch_all(dns=False)
host = kw.get('host', '0.0.0.0')
port = int(kw.get('port', 8080))
def _gevent_serve(wsgi_app):
print('Starting Gevent HTTP server on http://%s:%s' % (host, port))
WSGIServer((host, port), wsgi_app).serve_forever()
return _gevent_serve
def gevent_server_factory(global_config, **kw):
from gevent import reinit
from gevent.wsgi import WSGIServer
from gevent.monkey import patch_all
reinit()
patch_all(dns=False)
host = kw.get('host', '0.0.0.0')
port = int(kw.get('port', 8080))
def _gevent_serve(wsgi_app):
print('Starting Gevent HTTP server on http://%s:%s' % (host, port))
WSGIServer((host, port), wsgi_app).serve_forever()
return _gevent_serve
def do_start(self):
if self.umask is not None:
os.umask(self.umask)
if self.rundir is not None:
os.chdir(self.rundir)
self.app = self.app_factory()
self.add_service(self.app)
# TODO: move this to async manager?
import gevent
gevent.reinit()
# TODO: upgrade to gevent 1.0 and use standard signal
gevent.signal(RELOAD_SIGNAL, self.reload)
gevent.signal(STOP_SIGNAL, self.stop)
def do_start(self):
if self.umask is not None:
os.umask(self.umask)
if self.rundir is not None:
os.chdir(self.rundir)
self.app = self.app_factory()
self.add_service(self.app)
# TODO: move this to async manager?
import gevent
gevent.reinit()
# TODO: upgrade to gevent 1.0 and use standard signal
gevent.signal(RELOAD_SIGNAL, self.reload)
gevent.signal(STOP_SIGNAL, self.stop)
def _start_slave(self):
"""
Starts a new slave worker process.
"""
pid = os.fork()
if pid == 0:
# Set up the command line and logger id
set_cmdline('vsmtpd: worker')
log.connection_id = 'worker'
# Call event_reinit()
gevent.reinit()
# Start vsmtpd
self._start(self.sock)
else:
log.info('Worker spawned PID %d', pid)
self.workers.append(pid)
def daemonize(umask=0027):
if gevent.fork():
os._exit(0)
os.setsid()
if gevent.fork():
os._exit(0)
os.umask(umask)
fd_limit = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
if fd_limit == resource.RLIM_INFINITY:
fd_limit = 1024
for fd in xrange(0, fd_limit):
try:
os.close(fd)
except:
pass
os.open(os.devnull, os.O_RDWR)
os.dup2(0, 1)
os.dup2(0, 2)
gevent.reinit()
def daemon(user, group, path='/', pidfile='/tmp/%s.pid' % __default_servicename__, other_groups=()):
'''
Daemonizes current application.
'''
# Get uid and gid from user and group names
uid = int(pwd.getpwnam(user)[2])
gid = int(grp.getgrnam(group)[2])
# Get ID of other groups
other_groups_id = []
for name in other_groups:
try:
other_groups_id.append(int(grp.getgrnam(name)[2]) )
except:
pass
# First fork
pid = gevent.fork()
if not pid == 0:
os._exit(0)
# Creates a session and sets the process group ID
os.setsid()
# Second fork
pid = gevent.fork()
if not pid == 0:
os._exit(0)
# Change directoty
os.chdir(path)
# Set umask
os.umask(0)
# Write pidfile
open(pidfile, 'w').write(str(os.getpid()))
# Set group and groups
os.setgid(gid)
if other_groups_id:
os.setgroups(other_groups_id)
# Set user
os.setuid(uid)
# Redirect stdout/stderr to /dev/null
sys.stdout = sys.stderr = open(os.devnull, 'a+')
gevent.reinit()
def serve(sock, target):
gevent.reinit()
StreamServer(sock, target).serve_forever()
def serve(app):
reinit()
patch_all(dns=False)
WSGIServer((host, port), app).serve_forever()
def serve(app):
reinit()
patch_all(dns=False)
print "Serving on %s:%d (http://127.0.0.1:%d) ..." % (host, port, port)
SocketIOServer((host, port), app,
resource=resource).serve_forever()
def main():
"""Run the daemon from the command line."""
(opts, args) = parse_arguments(sys.argv[1:])
# Create pidfile
pidf = daemon.pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)
# Initialize logger
lvl = logging.DEBUG if opts.debug else logging.INFO
global logger
logger = logging.getLogger("vncauthproxy")
logger.setLevel(lvl)
formatter = logging.Formatter(
"%(asctime)s %(module)s[%(process)d] %(levelname)s: %(message)s",
"%Y-%m-%d %H:%M:%S")
handler = logging.FileHandler(opts.log_file)
handler.setFormatter(formatter)
logger.addHandler(handler)
# Become a daemon:
# Redirect stdout and stderr to handler.stream to catch
# early errors in the daemonization process [e.g., pidfile creation]
# which will otherwise go to /dev/null.
daemon_context = AllFilesDaemonContext(pidfile=pidf,
umask=0022,
stdout=handler.stream,
stderr=handler.stream,
files_preserve=[handler.stream])
daemon_context.open()
logger.info("Became a daemon")
# A fork() has occured while daemonizing,
# we *must* reinit gevent
gevent.reinit()
if os.path.exists(opts.ctrl_socket):
logger.critical("Socket '%s' already exists" % opts.ctrl_socket)
sys.exit(1)
# TODO: make this tunable? chgrp as well?
old_umask = os.umask(0007)
ctrl = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
ctrl.bind(opts.ctrl_socket)
os.umask(old_umask)
ctrl.listen(1)
logger.info("Initialized, waiting for control connections at %s" %
opts.ctrl_socket)
# Catch signals to ensure graceful shutdown,
# e.g., to make sure the control socket gets unlink()ed.
#
# Uses gevent.signal so the handler fires even during
# gevent.socket.accept()
gevent.signal(SIGINT, fatal_signal_handler, "SIGINT")
gevent.signal(SIGTERM, fatal_signal_handler, "SIGTERM")
# Init ephemeral port pool
ports = range(opts.min_port, opts.max_port + 1)
while True:
try:
client, addr = ctrl.accept()
logger.info("New control connection")
# Receive and parse a client request.
response = {"source_port": 0, "status": "FAILED"}
try:
# TODO: support multiple forwardings in the same message?
#
# Control request, in JSON:
#
# {
# "source_port": <source port or 0 for automatic allocation>,
# "destination_address": <destination address of backend server>,
# "destination_port": <destination port>
# "password": <the password to use for MITM authentication of clients>
# }
#
# The <password> is used for MITM authentication of clients
# connecting to <source_port>, who will subsequently be forwarded
# to a VNC server at <destination_address>:<destination_port>
#
# Control reply, in JSON:
# {
# "source_port": <the allocated source port>
# "status": <one of "OK" or "FAILED">
# }
buf = client.recv(1024)
req = json.loads(buf)
sport_orig = int(req['source_port'])
daddr = req['destination_address']
dport = int(req['destination_port'])
password = req['password']
except Exception, e:
logger.warn("Malformed request: %s" % buf)
client.send(json.dumps(response))
client.close()
continue
# Spawn a new Greenlet to service the request.
try:
# If the client has so indicated, pick an ephemeral source port
# randomly, and remove it from the port pool.
if sport_orig == 0:
sport = random.choice(ports)
ports.remove(sport)
logger.debug(
"Got port %d from port pool, contains %d ports", sport,
len(ports))
pool = ports
else:
sport = sport_orig
pool = None
listeners = get_listening_sockets(sport)
VncAuthProxy.spawn(logger, listeners, pool, daddr, dport,
password, opts.connect_timeout)
logger.info(
"New forwarding [%d (req'd by client: %d) -> %s:%d]" %
(sport, sport_orig, daddr, dport))
response = {"source_port": sport, "status": "OK"}
except IndexError:
logger.error("FAILED forwarding, out of ports for [req'd by "
"client: %d -> %s:%d]" %
(sport_orig, daddr, dport))
except socket.error, msg:
logger.error(
"FAILED forwarding [%d (req'd by client: %d) -> %s:%d]" %
(sport, sport_orig, daddr, dport))
if not pool is None:
pool.append(sport)
logger.debug(
"Returned port %d to port pool, contains %d ports",
sport, len(pool))
finally:
def main():
(opts, args) = parse_arguments(sys.argv[1:])
# Rename this process so 'ps' output looks like this is a native
# executable. Can not seperate command-line arguments from actual name of
# the executable by NUL bytes, so only show the name of the executable
# instead. setproctitle.setproctitle("\x00".join(sys.argv))
setproctitle.setproctitle(sys.argv[0])
setup_logging(opts)
# Special case for the clean up queues action
if opts.purge_queues:
purge_queues()
return
# Special case for the clean up exch action
if opts.purge_exchanges:
purge_exchanges()
return
if opts.drain_queue:
drain_queue(opts.drain_queue)
return
# Debug mode, process messages without daemonizing
if opts.debug:
debug_mode()
return
# Create pidfile,
pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)
if daemon.runner.is_pidfile_stale(pidf):
log.warning("Removing stale PID lock file %s", pidf.path)
pidf.break_lock()
files_preserve = []
for handler in log.handlers:
stream = getattr(handler, 'stream')
if stream and hasattr(stream, 'fileno'):
files_preserve.append(handler.stream)
stderr_stream = None
for handler in log.handlers:
stream = getattr(handler, 'stream')
if stream and hasattr(handler, 'baseFilename'):
stderr_stream = stream
break
daemon_context = daemon.DaemonContext(pidfile=pidf,
umask=0022,
stdout=stderr_stream,
stderr=stderr_stream,
files_preserve=files_preserve)
try:
daemon_context.open()
except (pidlockfile.AlreadyLocked, LockTimeout):
log.critical("Failed to lock pidfile %s, another instance running?",
pidf.path)
sys.exit(1)
log.info("Became a daemon")
if 'gevent' in sys.modules:
# A fork() has occured while daemonizing. If running in
# gevent context we *must* reinit gevent
log.debug("gevent imported. Reinitializing gevent")
import gevent
gevent.reinit()
# Catch every exception, make sure it gets logged properly
try:
daemon_mode(opts)
except Exception:
log.exception("Unknown error")
raise
def main():
"""Run the daemon from the command line."""
(opts, args) = parse_arguments(sys.argv[1:])
# Create pidfile
pidf = daemon.pidlockfile.TimeoutPIDLockFile(
opts.pid_file, 10)
# Initialize logger
lvl = logging.DEBUG if opts.debug else logging.INFO
global logger
logger = logging.getLogger("vncauthproxy")
logger.setLevel(lvl)
formatter = logging.Formatter("%(asctime)s %(module)s[%(process)d] %(levelname)s: %(message)s",
"%Y-%m-%d %H:%M:%S")
handler = logging.FileHandler(opts.log_file)
handler.setFormatter(formatter)
logger.addHandler(handler)
# Become a daemon:
# Redirect stdout and stderr to handler.stream to catch
# early errors in the daemonization process [e.g., pidfile creation]
# which will otherwise go to /dev/null.
daemon_context = AllFilesDaemonContext(
pidfile=pidf,
umask=0022,
stdout=handler.stream,
stderr=handler.stream,
files_preserve=[handler.stream])
daemon_context.open()
logger.info("Became a daemon")
# A fork() has occured while daemonizing,
# we *must* reinit gevent
gevent.reinit()
if os.path.exists(opts.ctrl_socket):
logger.critical("Socket '%s' already exists" % opts.ctrl_socket)
sys.exit(1)
# TODO: make this tunable? chgrp as well?
old_umask = os.umask(0007)
ctrl = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
ctrl.bind(opts.ctrl_socket)
os.umask(old_umask)
ctrl.listen(1)
logger.info("Initialized, waiting for control connections at %s" %
opts.ctrl_socket)
# Catch signals to ensure graceful shutdown,
# e.g., to make sure the control socket gets unlink()ed.
#
# Uses gevent.signal so the handler fires even during
# gevent.socket.accept()
gevent.signal(SIGINT, fatal_signal_handler, "SIGINT")
gevent.signal(SIGTERM, fatal_signal_handler, "SIGTERM")
# Init ephemeral port pool
ports = range(opts.min_port, opts.max_port + 1)
while True:
try:
client, addr = ctrl.accept()
logger.info("New control connection")
# Receive and parse a client request.
response = {
"source_port": 0,
"status": "FAILED"
}
try:
# TODO: support multiple forwardings in the same message?
#
# Control request, in JSON:
#
# {
# "source_port": <source port or 0 for automatic allocation>,
# "destination_address": <destination address of backend server>,
# "destination_port": <destination port>
# "password": <the password to use for MITM authentication of clients>
# }
#
# The <password> is used for MITM authentication of clients
# connecting to <source_port>, who will subsequently be forwarded
# to a VNC server at <destination_address>:<destination_port>
#
# Control reply, in JSON:
# {
# "source_port": <the allocated source port>
# "status": <one of "OK" or "FAILED">
# }
buf = client.recv(1024)
req = json.loads(buf)
sport_orig = int(req['source_port'])
daddr = req['destination_address']
dport = int(req['destination_port'])
password = req['password']
except Exception, e:
logger.warn("Malformed request: %s" % buf)
client.send(json.dumps(response))
client.close()
continue
# Spawn a new Greenlet to service the request.
try:
# If the client has so indicated, pick an ephemeral source port
# randomly, and remove it from the port pool.
if sport_orig == 0:
sport = random.choice(ports)
ports.remove(sport)
logger.debug("Got port %d from port pool, contains %d ports",
sport, len(ports))
pool = ports
else:
sport = sport_orig
pool = None
listeners = get_listening_sockets(sport)
VncAuthProxy.spawn(logger, listeners, pool, daddr, dport,
password, opts.connect_timeout)
logger.info("New forwarding [%d (req'd by client: %d) -> %s:%d]" %
(sport, sport_orig, daddr, dport))
response = {
"source_port": sport,
"status": "OK"
}
except IndexError:
logger.error("FAILED forwarding, out of ports for [req'd by "
"client: %d -> %s:%d]" % (sport_orig, daddr, dport))
except socket.error, msg:
logger.error("FAILED forwarding [%d (req'd by client: %d) -> %s:%d]" %
(sport, sport_orig, daddr, dport))
if not pool is None:
pool.append(sport)
logger.debug("Returned port %d to port pool, contains %d ports",
sport, len(pool))
finally:
def daemonize(self) :
try :
pid = os.fork()
if pid > 0 :
sys.exit(0)
except OSError as e:
sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
# Decouple from parent environment
os.chdir(self.homeDir)
os.setsid()
os.umask(self.umask)
try :
pid = os.fork()
if pid > 0 :
sys.exit(0)
except OSError as e :
sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
if sys.platform != 'darwin' :
# Redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()
stdInput = open(self.stdin, 'r')
stdOutput = open(self.stdout, 'a+')
if self.stderr :
stdError = open(self.stderr, 'a+')
else:
stdError = stdOutput
os.dup2(stdInput.fileno(), sys.stdin.fileno())
os.dup2(stdOutput.fileno(), sys.stdout.fileno())
os.dup2(stdError.fileno(), sys.stderr.fileno())
def sigtermhandler(signum, frame) :
self.daemon_alive = False
sys.exit()
if self.useGevent :
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
if self.verbose >= 1 :
print("Started")
# Make sure pid file is removed if we quit
atexit.register(self._delPid)
pid = str(os.getpid())
with open(self.pidFile,'w+') as pidFile :
pidFile.write(pid + '\n')
def try_to_recycle_the_event_hub():
gevent.reinit()
def run(self):
if os.path.isfile(self.args.pidfile):
self.log.error("%s found: is the server already running?" % self.args.pidfile)
return 1
stores = dict()
for container, values in self.conf.iteritems():
cli = client.Connection(
values['authurl'], values['username'], values['password'],
auth_version=values['auth_version'],
tenant_name=values['tenant_name'])
try:
headers, _ = cli.get_container(container)
except (socket.error, client.ClientException) as ex:
if getattr(ex, 'http_status', None) == 404:
self.log.warning("%s doesn't exist, skipping" % container)
continue
else:
self.log.error(ex)
return 1
self.log.debug(headers)
meta = getMeta(headers)
if not meta:
self.log.warning("%s doesn't appear to be setup, skipping" % container)
continue
self.log.debug("Meta: %s" % meta)
try:
object_size = int(meta['object-size'])
objects = int(meta['objects'])
except ValueError as ex:
self.log.error("%s doesn't appear to be correct: %s" % (container, ex))
return 1
if meta['version'] != disk_version:
self.log.warning("Version mismatch %s != %s in %s" % (meta['version'], disk_version, container))
stores[container] = SwiftStorage(values['authurl'],
values['username'],
values['password'],
container,
object_size,
objects,
Cache(int(self.args.cache_limit*1024**2 / object_size)),
values['read-only'].lower() in ('1', 'yes', 'true', 'on'),
auth_version=values['auth_version'],
tenant_name=values['tenant_name']
)
addr = (self.args.bind_address, self.args.bind_port)
server = Server(addr, stores)
gevent.signal(signal.SIGTERM, server.stop)
gevent.signal(signal.SIGINT, server.stop)
if not self.args.foreground:
try:
if gevent.fork() != 0:
os._exit(0)
except OSError as ex:
self.log.error("Failed to daemonize: %s" % ex)
return 1
os.setsid()
fd = os.open(os.devnull, os.O_RDWR)
os.dup2(fd, sys.stdin.fileno())
os.dup2(fd, sys.stdout.fileno())
os.dup2(fd, sys.stderr.fileno())
gevent.reinit()
self.log.info("Starting to serve on %s:%s" % (addr[0], addr[1]))
try:
fd = os.open(self.args.pidfile, (os.O_CREAT|os.O_EXCL|os.O_WRONLY), 0644)
except OSError as ex:
self.log.error("Failed to create the pidfile: %s" % ex)
return 1
with os.fdopen(fd, "w") as pidfile_handle:
pidfile_handle.write("%s\n" % os.getpid())
pidfile_handle.flush()
server.serve_forever()
os.remove(self.args.pidfile)
# unlock the storages before exit
server.unlock_all()
self.log.info("Exiting...")
return 0
def daemonize(self) :
try :
pid = os.fork()
if pid > 0 :
sys.exit(0)
except OSError as e:
sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
# Decouple from parent environment
os.chdir(self.homeDir)
os.setsid()
os.umask(self.umask)
try :
pid = os.fork()
if pid > 0 :
sys.exit(0)
except OSError as e :
sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
if sys.platform != 'darwin' :
# Redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()
stdInput = open(self.stdin, 'r')
stdOutput = open(self.stdout, 'a+')
if self.stderr :
stdError = open(self.stderr, 'a+')
else:
stdError = stdOutput
os.dup2(stdInput.fileno(), sys.stdin.fileno())
os.dup2(stdOutput.fileno(), sys.stdout.fileno())
os.dup2(stdError.fileno(), sys.stderr.fileno())
def sigtermhandler(signum, frame) :
self.daemon_alive = False
sys.exit()
if self.useGevent :
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
if self.verbose >= 1 :
print("Started")
# Make sure pid file is removed if we quit
atexit.register(self._delPid)
pid = str(os.getpid())
with open(self.pidFile,'w+') as pidFile :
pidFile.write(pid + '\n')
from gevent import reinit
from gevent.pywsgi import WSGIServer
from gevent.monkey import patch_all
from flask_caching import Cache
os.environ[
"PATH"] += ':/opt/samba4/bin:/opt/samba4/sbin:/usr/local/samba/bin:/usr/local/samba/sbin'
from app import app
app.template_folder = os.getcwd() + '/templates'
app.static_folder = os.getcwd() + '/static'
app.config['CACHE_TYPE'] = 'simple'
app.cache = Cache(app)
app.secret_key = os.urandom(12)
reinit()
patch_all(dns=False)
def server_prod(host="0.0.0.0", port=8088, ssl=True, debug=True):
if sys.argv[0].split(".")[-1] != 'py':
debug = False
app.debug = debug
try:
if ssl:
print('Starting Gevent HTTP server on https://%s:%s' %
(host, port))
server = WSGIServer((host, port),
app,
keyfile='ssl/server.key',
certfile='ssl/server.crt')
def main():
"""Run the daemon from the command line"""
opts = parse_arguments(sys.argv[1:])
# Create pidfile
pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)
# Initialize logger
lvl = logging.DEBUG if opts.debug else logging.INFO
global logger
logger = logging.getLogger("vncauthproxy")
logger.setLevel(lvl)
formatter = logging.Formatter(("%(asctime)s %(module)s[%(process)d] "
" %(levelname)s: %(message)s"),
"%Y-%m-%d %H:%M:%S")
handler = logging.FileHandler(opts.log_file)
handler.setFormatter(formatter)
logger.addHandler(handler)
# Become a daemon:
# Redirect stdout and stderr to handler.stream to catch
# early errors in the daemonization process [e.g., pidfile creation]
# which will otherwise go to /dev/null.
daemon_context = AllFilesDaemonContext(
pidfile=pidf,
umask=0022,
stdout=handler.stream,
stderr=handler.stream,
files_preserve=[handler.stream])
# Remove any stale PID files, left behind by previous invocations
if daemon.runner.is_pidfile_stale(pidf):
logger.warning("Removing stale PID lock file %s", pidf.path)
pidf.break_lock()
try:
daemon_context.open()
except (AlreadyLocked, LockTimeout):
logger.critical(("Failed to lock PID file %s, another instance "
"running?"), pidf.path)
sys.exit(1)
logger.info("Became a daemon!")
# A fork() has occured while daemonizing,
# we *must* reinit gevent
gevent.reinit()
# Catch signals to ensure graceful shutdown,
#
# Uses gevent.signal so the handler fires even during
# gevent.socket.accept()
gevent.signal(SIGINT, fatal_signal_handler, "SIGINT")
gevent.signal(SIGTERM, fatal_signal_handler, "SIGTERM")
# Init ephemeral port pool
ports = range(opts.min_port, opts.max_port + 1)
# Init VncAuthProxy class attributes
VncAuthProxy.server_timeout = opts.server_timeout
VncAuthProxy.connect_retries = opts.connect_retries
VncAuthProxy.retry_wait = opts.retry_wait
VncAuthProxy.connect_timeout = opts.connect_timeout
VncAuthProxy.ports = ports
try:
VncAuthProxy.authdb = parse_auth_file(opts.auth_file)
except InternalError as err:
logger.critical(err)
sys.exit(1)
except Exception as err:
logger.exception(err)
logger.error("Unexpected error")
sys.exit(1)
try:
sockets = get_listening_sockets(opts.listen_port, opts.listen_address,
reuse_addr=True)
except InternalError as err:
logger.critical("Error binding control socket")
sys.exit(1)
except Exception as err:
logger.exception(err)
logger.error("Unexpected error")
sys.exit(1)
while True:
try:
client = None
rlist, _, _ = select(sockets, [], [])
for ctrl in rlist:
client, _ = ctrl.accept()
logger.info("no ssl option is %s"% opts.no_ssl)
if not opts.no_ssl:
client = ssl.wrap_socket(client,
server_side=True,
keyfile=opts.key_file,
certfile=opts.cert_file,
ssl_version=ssl.PROTOCOL_TLSv1)
logger.info("New control connection")
VncAuthProxy.spawn(logger, client)
continue
except Exception, e:
logger.exception(e)
logger.error("Unexpected error")
if client:
client.close()
continue
except SystemExit:
break
def serve(app):
reinit()
WSGIServer((host, port), app).serve_forever()
def main():
"""Run the daemon from the command line"""
opts = parse_arguments(sys.argv[1:])
# Initialize logger
lvl = logging.DEBUG if opts.debug else logging.INFO
global logger
logger = logging.getLogger("vncauthproxy")
logger.setLevel(lvl)
formatter = logging.Formatter(("%(asctime)s %(module)s[%(process)d] "
" %(levelname)s: %(message)s"),
"%Y-%m-%d %H:%M:%S")
handler = logging.FileHandler(opts.log_file)
handler.setFormatter(formatter)
logger.addHandler(handler)
try:
# Create pidfile
pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)
# Init ephemeral port pool
ports = range(opts.min_port, opts.max_port + 1)
# Init VncAuthProxy class attributes
VncAuthProxy.server_timeout = opts.server_timeout
VncAuthProxy.connect_retries = opts.connect_retries
VncAuthProxy.retry_wait = opts.retry_wait
VncAuthProxy.connect_timeout = opts.connect_timeout
VncAuthProxy.ports = ports
VncAuthProxy.authdb = parse_auth_file(opts.auth_file)
VncAuthProxy.keyfile = opts.key_file
VncAuthProxy.certfile = opts.cert_file
VncAuthProxy.proxy_address = opts.proxy_listen_address
VncAuthProxy.fqdn = socket.getfqdn()
sockets = get_listening_sockets(opts.listen_port,
opts.listen_address,
reuse_addr=True)
wrap_ssl = lambda sock: sock
if opts.enable_ssl:
ssl_prot = ssl.PROTOCOL_TLSv1
wrap_ssl = lambda sock: ssl.wrap_socket(sock,
server_side=True,
keyfile=opts.key_file,
certfile=opts.cert_file,
ssl_version=ssl_prot)
# Become a daemon:
# Redirect stdout and stderr to handler.stream to catch
# early errors in the daemonization process [e.g., pidfile creation]
# which will otherwise go to /dev/null.
daemon_context = AllFilesDaemonContext(pidfile=pidf,
umask=0022,
stdout=handler.stream,
stderr=handler.stream,
files_preserve=[handler.stream])
# Remove any stale PID files, left behind by previous invocations
if daemon.runner.is_pidfile_stale(pidf):
logger.warning("Removing stale PID lock file %s", pidf.path)
pidf.break_lock()
try:
daemon_context.open()
except (AlreadyLocked, LockTimeout):
raise InternalError(("Failed to lock PID file %s, another "
"instance running?"), pidf.path)
logger.info("Became a daemon")
# A fork() has occured while daemonizing,
# we *must* reinit gevent
gevent.reinit()
# Catch signals to ensure graceful shutdown,
#
# Uses gevent.signal so the handler fires even during
# gevent.socket.accept()
gevent.signal(SIGINT, fatal_signal_handler, "SIGINT")
gevent.signal(SIGTERM, fatal_signal_handler, "SIGTERM")
except InternalError as err:
logger.critical(err)
sys.exit(1)
except Exception as err:
logger.critical("Unexpected error:")
logger.exception(err)
sys.exit(1)
while True:
try:
client = None
rlist, _, _ = select(sockets, [], [])
for ctrl in rlist:
client, _ = ctrl.accept()
client = wrap_ssl(client)
logger.info("New control connection")
VncAuthProxy.spawn(logger, client)
continue
except Exception as err:
logger.error("Unexpected error:")
logger.exception(err)
if client:
client.close()
continue
except SystemExit:
break
try:
logger.info("Closing control sockets")
while sockets:
sock = sockets.pop()
sock.close()
daemon_context.close()
sys.exit(0)
except Exception as err:
logger.critical("Unexpected error:")
logger.exception(err)
sys.exit(1)
def cli(ctx, consumer: str, foreground: bool, debug: bool,
pidfile: Optional[str], stop: bool):
if stop:
if not pidfile or not os.path.exists(pidfile):
click.echo('PID file not specified or not found', color=ctx.color)
ctx.exit(1)
try:
pid = read_pidfile(pidfile)
except ValueError as e:
click.echo('Could not read PID file: {0}'.format(e),
color=ctx.color)
ctx.exit(1)
try:
os.kill(pid, signal.SIGTERM)
except OSError as e:
click.echo('Could not send SIGTERM: {0}'.format(e),
color=ctx.color)
ctx.exit(1)
ctx.exit(0)
if not pidfile and not foreground:
click.echo('No PID file specified; running in foreground')
foreground = True
daemon_kwargs = {}
if foreground:
daemon_kwargs.update({
'detach_process': False,
'stdin': sys.stdin,
'stdout': sys.stdout,
'stderr': sys.stderr
})
if pidfile:
pidfile = os.path.abspath(pidfile) \
if not os.path.isabs(pidfile) else pidfile
if os.path.exists(pidfile):
pid = read_pidfile(pidfile)
if not os.path.exists(os.path.join('/proc', str(pid))):
click.echo("""\
Deleting obsolete PID file (process {0} does not exist)
""".format(pid))
os.unlink(pidfile)
daemon_kwargs['pidfile'] = TimeoutPIDLockFile(pidfile, 5)
context = DaemonContext(**daemon_kwargs)
try:
context.open()
except lockfile.LockTimeout:
click.echo("""\
Could not acquire lock on pid file {0}\
Check if the daemon is already running.\
""".format(pidfile))
ctx.exit(1)
except KeyboardInterrupt:
click.echo()
ctx.exit(1)
with context:
import gevent
from gevent import monkey
monkey.patch_all()
gevent.reinit()
gevent.wait(timeout=1)
import_name = prepare_import(consumer)
consumer = locate_consumer(import_name)
consumer.process(debug=debug)
def init(self):
gevent.reinit()
so = file(self.stdout, 'a+')
if self.stderr:
se = file(self.stderr, 'a+', 0)
else:
se = so
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
def sigtermhandler(signum, frame):
self.daemon_alive = False
sys.exit()
if self.use_gevent:
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
if self.verbose >= 1:
print "Started"
# Write pidfile
atexit.register(
self.delpid) # Make sure pid file is removed if we quit
pid = str(os.getpid())
file(self.pidfile, 'w+').write("%s\n" % pid)
def _child(target, args, kwargs):
"""Wrapper function that runs in child process. Resets gevent/libev state
and executes user-given function.
After fork on POSIX-compliant systems, gevent's state is inherited by the
child which may lead to undesired behavior, such as greenlets running in
both, the parent and the child. Therefore, if not on Windows, gevent's and
libev's state is reset before running the user-given function.
"""
log.debug("_child start. target: `%s`", target)
childhandles = list(_filter_handles(chain(args, kwargs.values())))
if not WINDOWS:
# Restore default signal handlers (SIG_DFL). Orphaned libev signal
# watchers may not become properly deactivated otherwise. Note: here, we
# could even reset sigprocmask (Python 2.x does not have API for it, but
# it could be done via ctypes).
_reset_signal_handlers()
# `gevent.reinit` calls `libev.ev_loop_fork()`, which reinitialises
# the kernel state for backends that have one. Must be called in the
# child before using further libev API.
gevent.reinit()
log.debug("Delete current hub's threadpool.")
hub = gevent.get_hub()
# Delete threadpool before hub destruction, otherwise `hub.destroy()`
# might block forever upon `ThreadPool.kill()` as of gevent 1.0rc2.
del hub.threadpool
hub._threadpool = None
# Destroy default event loop via `libev.ev_loop_destroy()` and delete
# hub. This orphans all registered events and greenlets that have been
# duplicated from the parent via fork().
log.debug("Destroy hub and default loop.")
hub.destroy(destroy_loop=True)
# Create a new hub and a new default event loop via
# `libev.gevent_ev_default_loop`.
h = gevent.get_hub(default=True)
log.debug("Created new hub and default event loop.")
assert h.loop.default, 'Could not create libev default event loop.'
# On Unix, file descriptors are inherited by default. Also, the global
# `_all_handles` is inherited from the parent. Close dispensable gipc-
# related file descriptors in child.
for h in _all_handles[:]:
if h not in childhandles:
log.debug("Invalidate %s in child.", h)
h._set_legit_process()
# At duplication time the handle might have been locked. Unlock.
h._lock.counter = 1
h.close()
else:
# On Windows, the state of module globals is not transferred to
# children. Set `_all_handles`.
_set_all_handles(childhandles)
# `_all_handles` now must contain only those handles that have been
# transferred to the child on purpose.
for h in _all_handles:
assert h in childhandles
# Register transferred handles for current process.
for h in childhandles:
h._set_legit_process()
if WINDOWS:
h._winapi_childhandle_after_createprocess_child()
log.debug("Handle `%s` is now valid in child.", h)
# Invoke user-given function.
target(*args, **kwargs)
# Close file descriptors before exiting process. Usually needless (OS
# should take care of this), but being expressive about this is clean.
for h in childhandles:
try:
# The user might already have closed it.
h.close()
except GIPCClosed:
pass
def main():
(opts, args) = parse_arguments(sys.argv[1:])
# Rename this process so 'ps' output looks like this is a native
# executable. Can not seperate command-line arguments from actual name of
# the executable by NUL bytes, so only show the name of the executable
# instead. setproctitle.setproctitle("\x00".join(sys.argv))
setproctitle.setproctitle(sys.argv[0])
setup_logging(opts)
# Special case for the clean up queues action
if opts.purge_queues:
purge_queues()
return
# Special case for the clean up exch action
if opts.purge_exchanges:
purge_exchanges()
return
if opts.drain_queue:
drain_queue(opts.drain_queue)
return
# Debug mode, process messages without daemonizing
if opts.debug:
debug_mode()
return
# Create pidfile,
pidf = pidlockfile.TimeoutPIDLockFile(opts.pid_file, 10)
if daemon.runner.is_pidfile_stale(pidf):
log.warning("Removing stale PID lock file %s", pidf.path)
pidf.break_lock()
files_preserve = []
for handler in log.handlers:
stream = getattr(handler, "stream")
if stream and hasattr(stream, "fileno"):
files_preserve.append(handler.stream)
stderr_stream = None
for handler in log.handlers:
stream = getattr(handler, "stream")
if stream and hasattr(handler, "baseFilename"):
stderr_stream = stream
break
daemon_context = daemon.DaemonContext(
pidfile=pidf, umask=0022, stdout=stderr_stream, stderr=stderr_stream, files_preserve=files_preserve
)
try:
daemon_context.open()
except (pidlockfile.AlreadyLocked, LockTimeout):
log.critical("Failed to lock pidfile %s, another instance running?", pidf.path)
sys.exit(1)
log.info("Became a daemon")
if "gevent" in sys.modules:
# A fork() has occured while daemonizing. If running in
# gevent context we *must* reinit gevent
log.debug("gevent imported. Reinitializing gevent")
import gevent
gevent.reinit()
# Catch every exception, make sure it gets logged properly
try:
daemon_mode(opts)
except Exception:
log.exception("Unknown error")
raise
def daemonize(self):
"""
Do the UNIX double-fork magic, see Stevens' "Advanced
Programming in the UNIX Environment" for details (ISBN 0201563177)
http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
"""
try:
pid = os.fork()
if pid > 0:
# Exit first parent
sys.exit(0)
except OSError as e:
sys.stderr.write(
"fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
# Decouple from parent environment
os.chdir(self.home_dir)
os.setsid()
os.umask(self.umask)
# Do second fork
try:
pid = os.fork()
if pid > 0:
# Exit from second parent
sys.exit(0)
except OSError as e:
sys.stderr.write(
"fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
sys.exit(1)
# if sys.platform != 'darwin': # This block breaks on OS X
# # Redirect standard file descriptors
# sys.stdout.flush()
# sys.stderr.flush()
# si = open(self.stdin, 'r')
# so = open(self.stdout, 'a+')
# if self.stderr:
# se = open(self.stderr, 'a+', 0)
# else:
# se = so
# os.dup2(si.fileno(), sys.stdin.fileno())
# os.dup2(so.fileno(), sys.stdout.fileno())
# os.dup2(se.fileno(), sys.stderr.fileno())
def sigtermhandler(signum, frame):
self.daemon_alive = False
sys.exit()
if self.use_gevent:
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
if self.verbose >= 1:
print("Started")
# Write pidfile
atexit.register(
self.delpid) # Make sure pid file is removed if we quit
pid = str(os.getpid())
open(self.pidfile, 'w+').write("%s\n" % pid)
def daemonize(self):
"""
Do the UNIX double-fork magic, see Stevens' "Advanced
Programming in the UNIX Environment" for details (ISBN 0201563177)
http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
"""
if self.use_eventlet:
import eventlet.tpool
eventlet.tpool.killall()
try:
pid = os.fork()
if pid > 0:
# Exit first parent
sys.exit(0)
except OSError as e:
sys.stderr.write("fork #1 failed: %d (%s)\n" %
(e.errno, e.strerror))
sys.exit(1)
# Decouple from parent environment
os.chdir(self.home_dir)
os.setsid()
os.umask(self.umask)
# Do second fork
try:
pid = os.fork()
if pid > 0:
# Exit from second parent
sys.exit(0)
except OSError as e:
sys.stderr.write("fork #2 failed: %d (%s)\n" %
(e.errno, e.strerror))
sys.exit(1)
if sys.platform != 'darwin': # This block breaks on OS X
# Redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()
si = open(self.stdin, 'r')
so = open(self.stdout, 'a+')
if self.stderr:
try:
se = open(self.stderr, 'a+', 0)
except ValueError:
# Python 3 can't have unbuffered text I/O
se = open(self.stderr, 'a+', 1)
else:
se = so
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
def sigtermhandler(signum, frame):
self.daemon_alive = False
sys.exit()
if self.use_gevent:
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
self.log("Started")
# Write pidfile
atexit.register(
self.delpid) # Make sure pid file is removed if we quit
pid = str(os.getpid())
open(self.pidfile, 'w+').write("%s\n" % pid)
from gevent import reinit
from gevent.monkey import patch_all
reinit()
patch_all(dns=False)
# WebSocket acceleration
import wsaccel
wsaccel.patch_ws4py()
from ws4py.server.geventserver import WSGIServer
from ws4py.server.wsgiutils import WebSocketWSGIApplication
from ws4py import configure_logger
configure_logger()
# For paste.deploy server_runner instantiation (egg:astportal2#ws4py)
def serve(wsgi_app, global_config, **kw):
ws_handler = kw.get('websocket_resource')
host = kw.get('host', '0.0.0.0')
port = int(kw.get('port', 8080))
print('Starting WebSocket (ws4py) enabled Gevent HTTP server on http://%s:%s' % (
host, port))
s = WSGIServer((host, port), WrapWebSocket(host, port, wsgi_app, ws_handler))
s.serve_forever()
def get_class( kls ):
parts = kls.split('.')
module = ".".join(parts[:-1])
m = __import__( module ) # May fail if not found!
so = file(self.stdout, 'a+')
if self.stderr:
se = file(self.stderr, 'a+', 0)
else:
se = so
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
def sigtermhandler(signum, frame):
self.daemon_alive = False
sys.exit()
if self.use_gevent:
import gevent
gevent.reinit()
gevent.signal(signal.SIGTERM, sigtermhandler, signal.SIGTERM, None)
gevent.signal(signal.SIGINT, sigtermhandler, signal.SIGINT, None)
else:
signal.signal(signal.SIGTERM, sigtermhandler)
signal.signal(signal.SIGINT, sigtermhandler)
if self.verbose >= 1:
print "Started"
# Write pidfile
atexit.register(
self.delpid) # Make sure pid file is removed if we quit
pid = str(os.getpid())
file(self.pidfile, 'w+').write("%s\n" % pid)
def reset_gevent():
gevent.reinit()
gevent.get_hub().destroy(destroy_loop=True) # Forget previous callbacks.
gevent.get_hub(default=True) # Here is necessary.
