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 --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 --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/ --mule=lib/galaxy/ --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 logging.config import fileConfig

from six.moves.configparser import ConfigParser

    from daemonize import Daemonize
except ImportError:
    Daemonize = None

    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, '')):
    # Galaxy is installed
    GALAXY_LIB_DIR = os.path.join(GALAXY_ROOT_DIR, "lib")
        sys.path.insert(1, GALAXY_LIB_DIR)
    except Exception:
        log.exception("Failed to add Galaxy to sys.path")
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_INIS = ["config/galaxy.yml", "config/galaxy.ini", "universe_wsgi.ini", "config/galaxy.yml.sample"]

DESCRIPTION = "Daemonized entry point for Galaxy."


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 import load_app_properties kwds = config_builder.app_kwds() kwds = load_app_properties(**kwds) from 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):'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(object): """ 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 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 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()[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(): 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( else: fh = logging.StreamHandler(sys.stderr) fh.setLevel(logging.DEBUG) log.addHandler(fh) daemon = Daemonize( app="galaxy", pid=pid_file, action=functools.partial(app_loop, args, log), verbose=DEFAULT_VERBOSE, logger=log, keep_fds=keep_fds, ) daemon.start() else: app_loop(args, log)
if __name__ == "__main__": main()