def graceful_shutdown(*_):
""" Stop accepting new requests and exit when all requests are finished
or timeout is exceeded.
"""
signal_time = time.time()
logger.info('Stopping server')
tornado_server.stop()
io_loop = ioloop.IOLoop.current()
def stop_on_signal():
current_requests = service_stats.current_requests
if current_requests and time.time(
) - signal_time < SHUTTING_DOWN_TIMEOUT:
logger.warning(
"Can't stop Taskqueue server now as {reqs} requests are "
"still in progress".format(reqs=current_requests))
else:
if current_requests:
logger.error(
"Shutting down server despite {reqs} requests "
"in progress".format(reqs=current_requests))
# Stop tornado IO loop and zookeeper client
io_loop.stop()
zk_client.stop()
logger.info("IOLoop stopped")
ioloop.PeriodicCallback(stop_on_signal, 200).start()
def main():
""" Main function which initializes and starts the tornado server. """
# Parse command line arguments
parser = argparse.ArgumentParser(description='A taskqueue API server')
parser.add_argument('--port',
'-p',
default='17447',
help='TaskQueue server port')
parser.add_argument('--verbose',
action='store_true',
help='Output debug-level logging')
args = parser.parse_args()
if args.verbose:
logging.getLogger('appscale').setLevel(logging.DEBUG)
# Configure zookeeper and db access
zk_client = KazooClient(hosts=','.join(appscale_info.get_zk_node_ips()),
connection_retry=ZK_PERSISTENT_RECONNECTS)
zk_client.start()
db_access = DatastoreProxy()
# Initialize tornado server
task_queue = distributed_tq.DistributedTaskQueue(db_access, zk_client)
tq_application = prepare_taskqueue_application(task_queue)
# Automatically decompress incoming requests.
server = httpserver.HTTPServer(tq_application, decompress_request=True)
server.listen(args.port)
# Make sure taskqueue shuts down gracefully when signal is received
graceful_shutdown = prepare_graceful_shutdown(zk_client, server)
signal.signal(signal.SIGTERM, graceful_shutdown)
signal.signal(signal.SIGINT, graceful_shutdown)
logger.info('Starting TaskQueue server on port {}'.format(args.port))
ioloop.IOLoop.current().start()
def main():
""" Main function which initializes and starts the tornado server. """
# Parse command line arguments
parser = argparse.ArgumentParser(description='A taskqueue API server')
parser.add_argument('--port', '-p', default='17447',
help='TaskQueue server port')
parser.add_argument('--verbose', action='store_true',
help='Output debug-level logging')
args = parser.parse_args()
if args.verbose:
logger.setLevel(logging.DEBUG)
# Configure zookeeper and db access
zk_client = KazooClient(
hosts=','.join(appscale_info.get_zk_node_ips()),
connection_retry=ZK_PERSISTENT_RECONNECTS)
zk_client.start()
db_access = DatastoreProxy()
# Initialize tornado server
task_queue = distributed_tq.DistributedTaskQueue(db_access, zk_client)
tq_application = prepare_taskqueue_application(task_queue)
# Automatically decompress incoming requests.
server = httpserver.HTTPServer(tq_application, decompress_request=True)
server.listen(args.port)
# Make sure taskqueue shuts down gracefully when signal is received
graceful_shutdown = prepare_graceful_shutdown(zk_client, server)
signal.signal(signal.SIGTERM, graceful_shutdown)
signal.signal(signal.SIGINT, graceful_shutdown)
logger.info('Starting TaskQueue server on port {}'.format(args.port))
ioloop.IOLoop.current().start()
def create_server_node():
""" Creates a server registration entry in ZooKeeper. """
try:
zk_client.retry(zk_client.create, server_node, ephemeral=True)
except NodeExistsError:
# If the server gets restarted, the old node may exist for a short time.
zk_client.retry(zk_client.delete, server_node)
zk_client.retry(zk_client.create, server_node, ephemeral=True)
logger.info('TaskQueue server registered at {}'.format(server_node))
def stop_on_signal():
current_requests = service_stats.current_requests
if current_requests and monotonic.monotonic() < deadline:
logger.warning("Can't stop Taskqueue server now as {reqs} requests are "
"still in progress".format(reqs=current_requests))
else:
if current_requests:
logger.error("Shutting down server despite {reqs} requests "
"in progress".format(reqs=current_requests))
# Stop tornado IO loop and zookeeper client
io_loop.stop()
zk_client.stop()
logger.info("IOLoop stopped")
def stop_on_signal():
current_requests = service_stats.current_requests
if current_requests and time.time() - signal_time < SHUTTING_DOWN_TIMEOUT:
logger.warning("Can't stop Taskqueue server now as {reqs} requests are "
"still in progress".format(reqs=current_requests))
else:
if current_requests:
logger.error("Shutting down server despite {reqs} requests "
"in progress".format(reqs=current_requests))
# Stop tornado IO loop and zookeeper client
io_loop.stop()
zk_client.stop()
logger.info("IOLoop stopped")
def get_connection(self):
""" Provides postgres connection. It can either return existing
working connection or establish new one.
Returns:
An instance of psycopg2 connection.
"""
if not self._connection or self._connection.closed:
logger.info('Establishing new connection to Postgres server')
self._connection = psycopg2.connect(
dsn=self._dsn,
connect_timeout=10,
options='-c statement_timeout=60000',
keepalives_idle=60,
keepalives_interval=15,
keepalives_count=4
)
return self._connection
def graceful_shutdown(*_):
""" Stop accepting new requests and exit when all requests are finished
or timeout is exceeded.
"""
signal_time = time.time()
logger.info('Stopping server')
tornado_server.stop()
io_loop = ioloop.IOLoop.current()
def stop_on_signal():
current_requests = service_stats.current_requests
if current_requests and time.time() - signal_time < SHUTTING_DOWN_TIMEOUT:
logger.warning("Can't stop Taskqueue server now as {reqs} requests are "
"still in progress".format(reqs=current_requests))
else:
if current_requests:
logger.error("Shutting down server despite {reqs} requests "
"in progress".format(reqs=current_requests))
# Stop tornado IO loop and zookeeper client
io_loop.stop()
zk_client.stop()
logger.info("IOLoop stopped")
ioloop.PeriodicCallback(stop_on_signal, 200).start()
def get_connection(self):
if not self._connection or self._connection.closed:
logger.info('Establishing new connection to Postgres server')
self._connection = psycopg2.connect(*self._args, **self._kwargs)
return self._connection
