Warning

This document is for an old release of Galaxy. You can alternatively view this page in the latest release if it exists or view the top of the latest release's documentation.

Source code for galaxy.main

#!/usr/bin/env python
""" Entry point for starting Galaxy without starting as part of a web server.

Example Usage: Start a job/workflow handler without a web server and with
a given name using.

galaxy-main --server-name handler0

Start as a daemon with (requires daemonized - install with 'pip install daemonize'):

galaxy-main -d --daemon-log-file=handler0-daemon.log --pid-file handler0.pid --server-name handler0

In daemon mode logging of Galaxy (as opposed to this script) is configured via
a loggers section in Galaxy's ini file - this can be overridden with sensible
defaults logging to a single file with the following:

galaxy-main -d --server-name handler0 --daemon-log-file=handler0-daemon.log --pid-file handler0.pid --log-file handler0.log

This can also be used to start Galaxy as a uWSGI mule, e.g. for job handling:

uwsgi ... --py-call-osafterfork --mule=lib/galaxy/main.py --mule=lib/galaxy/main.py --farm=job-handlers:1,2

The --py-call-osafterfork allows for proper shutdown on SIGTERM/SIGINT.
"""
import functools
import logging
import os
import signal
import sys
import threading
from argparse import ArgumentParser
from configparser import ConfigParser
from logging.config import fileConfig

try:
    from daemonize import Daemonize
except ImportError:
    Daemonize = None

try:
    import uwsgi
except ImportError:
    uwsgi = None

log = logging.getLogger(__name__)

real_file = os.path.realpath(__file__)
GALAXY_ROOT_DIR_ = os.path.abspath(os.path.join(os.path.dirname(real_file), os.pardir))
if not os.path.exists(os.path.join(GALAXY_ROOT_DIR_, 'run.sh')):
    # Galaxy is installed
    GALAXY_ROOT_DIR = None
else:
    GALAXY_ROOT_DIR = GALAXY_ROOT_DIR_
    GALAXY_LIB_DIR = os.path.join(GALAXY_ROOT_DIR_, "lib")
    try:
        sys.path.insert(1, GALAXY_LIB_DIR)
    except Exception:
        log.exception("Failed to add Galaxy to sys.path")
        raise
from galaxy.util import unicodify
from galaxy.web_stack import get_app_kwds

REQUIRES_DAEMONIZE_MESSAGE = "Attempted to use Galaxy in daemon mode, but daemonize is unavailable."

DEFAULT_INI_APP = "main"
DEFAULT_CONFIG_SECTION = "galaxy"
DEFAULT_INIS = ["config/galaxy.yml", "config/galaxy.ini", "universe_wsgi.ini", "config/galaxy.yml.sample"]

DEFAULT_PID = "galaxy.pid"
DEFAULT_VERBOSE = True
DESCRIPTION = "Daemonized entry point for Galaxy."

SHUTDOWN_MSG = '__SHUTDOWN__'
UWSGI_FARMS_VAR = '_GALAXY_UWSGI_FARM_NAMES'


exit = threading.Event()


[docs]def load_galaxy_app( config_builder, config_env=False, log=None, attach_to_pools=None, **kwds ): # Allow specification of log so daemon can reuse properly configured one. if log is None: log = logging.getLogger(__name__) # If called in daemon mode, set the ROOT directory and ensure Galaxy is on # sys.path. if config_env: try: os.chdir(GALAXY_ROOT_DIR) except Exception: log.exception("Failed to chdir") raise config_builder.setup_logging() from galaxy.util.properties import load_app_properties kwds = config_builder.app_kwds() kwds = load_app_properties(**kwds) from galaxy.app import UniverseApplication app = UniverseApplication( global_conf=config_builder.global_conf(), attach_to_pools=attach_to_pools, **kwds ) app.database_heartbeat.start() app.application_stack.log_startup() return app
[docs]def handle_signal(signum, frame): log.info('Received signal %d, exiting', signum) if uwsgi and 'mule_id' in dir(uwsgi) and uwsgi.mule_id() > 0: farms = os.environ.get(UWSGI_FARMS_VAR, None) if farms: for farm in farms.split(','): uwsgi.farm_msg(farm, SHUTDOWN_MSG) else: uwsgi.mule_msg(SHUTDOWN_MSG, uwsgi.mule_id()) exit.set()
[docs]def register_signals(): for name in ('TERM', 'INT', 'HUP'): sig = getattr(signal, 'SIG%s' % name) signal.signal(sig, handle_signal)
[docs]def app_loop(args, log): try: config_builder = GalaxyConfigBuilder(args) config_env = GALAXY_ROOT_DIR is not None galaxy_app = load_galaxy_app( config_builder, config_env=config_env, log=log, attach_to_pools=args.attach_to_pool, ) except BaseException: log.exception("Failed to initialize Galaxy application") raise try: # A timeout is required or the signals won't be handled while not exit.wait(20): pass except (KeyboardInterrupt, SystemExit): pass try: galaxy_app.shutdown() except Exception: log.exception("Failed to shutdown Galaxy application") raise
[docs]def absolute_config_path(path, galaxy_root): if path and not os.path.isabs(path): path = os.path.join(galaxy_root, path) return path
[docs]def find_config(supplied_config, galaxy_root): if supplied_config: return supplied_config if galaxy_root is None: return os.path.abspath('galaxy.yml') # If not explicitly supplied an config, check galaxy.ini and then # just resort to sample if that has not been configured. for guess in DEFAULT_INIS: config_path = os.path.join(galaxy_root, guess) if os.path.exists(config_path): return config_path return guess
[docs]class GalaxyConfigBuilder: """ Generate paste-like configuration from supplied command-line arguments. """
[docs] def __init__(self, args=None, **kwds): self.config_file = None self.config_section = None self.app_name = kwds.get("app") or (args and args.app) or DEFAULT_CONFIG_SECTION config_file = kwds.get("config_file", None) or (args and args.config_file) # If given app_conf_path - use that - else we need to ensure we have a # config file path. if not config_file and 'config_file' in self.app_kwds(): config_file = self.app_kwds()['config_file'] if not config_file: galaxy_root = kwds.get("galaxy_root", GALAXY_ROOT_DIR) config_file = find_config(config_file, galaxy_root) config_file = absolute_config_path(config_file, galaxy_root=galaxy_root) self.config_file = unicodify(config_file) # FIXME: this won't work for non-Paste ini configs if self.config_is_ini: self.config_section = "app:%s" % unicodify(kwds.get("app") or (args and args.app) or DEFAULT_INI_APP) else: self.config_section = self.app_name self.log_file = (args and args.log_file)
[docs] @classmethod def populate_options(cls, arg_parser): arg_parser.add_argument("-c", "--config-file", default=None, help="Galaxy config file (defaults to config/galaxy.ini)") arg_parser.add_argument("--ini-path", default=None, help="DEPRECATED: use -c/--config-file") arg_parser.add_argument("--app", default=None, help="app section in config file (defaults to 'galaxy' for YAML/JSON, 'main' (w/ 'app:' prepended) for INI") arg_parser.add_argument("-d", "--daemonize", default=False, help="Daemonize process", action="store_true") arg_parser.add_argument("--daemon-log-file", default=None, help="log file for daemon script ") arg_parser.add_argument("--log-file", default=None, help="Galaxy log file (overrides log configuration in config_file if set)") arg_parser.add_argument("--pid-file", default=DEFAULT_PID, help="pid file (default is %s)" % DEFAULT_PID) arg_parser.add_argument("--server-name", default=None, help="set a galaxy server name") arg_parser.add_argument("--attach-to-pool", action="append", default=None, help="attach to asynchronous worker pool (specify multiple times for multiple pools)")
@property def config_is_ini(self): return self.config_file.endswith('.ini') or self.config_file.endswith('.ini.sample')
[docs] def app_kwds(self): kwds = get_app_kwds(self.app_name, app_name=self.app_name) if 'config_file' not in kwds: kwds['config_file'] = self.config_file if 'config_section' not in kwds: kwds['config_section'] = self.config_section return kwds
[docs] def global_conf(self): conf = {} if self.config_is_ini: conf["__file__"] = self.config_file return conf
[docs] def setup_logging(self): # Galaxy will attempt to setup logging if loggers is not present in # ini config file - this handles that loggers block however if present # (the way paste normally would) if not self.config_file: return if self.config_is_ini: raw_config = ConfigParser() raw_config.read([self.config_file]) if raw_config.has_section('loggers'): config_file = os.path.abspath(self.config_file) fileConfig( config_file, dict(__file__=config_file, here=os.path.dirname(config_file)) )
[docs]def main(func=app_loop): arg_parser = ArgumentParser(description=DESCRIPTION) GalaxyConfigBuilder.populate_options(arg_parser) args = arg_parser.parse_args() if args.ini_path and not args.config_file: args.config_file = args.ini_path if args.log_file: os.environ["GALAXY_CONFIG_LOG_DESTINATION"] = os.path.abspath(args.log_file) if args.server_name: os.environ["GALAXY_CONFIG_SERVER_NAME"] = args.server_name pid_file = args.pid_file log.setLevel(logging.DEBUG) log.propagate = False register_signals() if args.daemonize: if Daemonize is None: raise ImportError(REQUIRES_DAEMONIZE_MESSAGE) keep_fds = [] if args.daemon_log_file: fh = logging.FileHandler(args.daemon_log_file, "w") fh.setLevel(logging.DEBUG) log.addHandler(fh) keep_fds.append(fh.stream.fileno()) else: fh = logging.StreamHandler(sys.stderr) fh.setLevel(logging.DEBUG) log.addHandler(fh) daemon = Daemonize( app="galaxy", pid=pid_file, action=functools.partial(func, args, log), verbose=DEFAULT_VERBOSE, logger=log, keep_fds=keep_fds, ) daemon.start() else: func(args, log)
if __name__ == "__main__": main()