#!/usr/bin/env python
# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

"""
OpenERP - Server
OpenERP is an ERP+CRM program for small and medium businesses.

The whole source code is distributed under the terms of the
GNU Public Licence.

(c) 2003-TODAY, Fabien Pinckaers - OpenERP SA
"""

import logging
import os
import signal
import sys
import threading
import traceback
import time

import openerp
__author__ = openerp.release.author
__version__ = openerp.release.version

import sys
import imp

def check_root_user():
    """ Exit if the process's user is 'root' (on POSIX system)."""
    if os.name == 'posix':
        import pwd
        if pwd.getpwuid(os.getuid())[0] == 'root' :
            sys.stderr.write("Running as user 'root' is a security risk, aborting.\n")
            sys.exit(1)

def check_postgres_user():
    """ Exit if the configured database user is 'postgres'.

    This function assumes the configuration has been initialized.
    """
    config = openerp.tools.config
    if config['db_user'] == 'postgres':
        sys.stderr.write("Using the database user 'postgres' is a security risk, aborting.")
        sys.exit(1)

def report_configuration():
    """ Log the server version and some configuration values.

    This function assumes the configuration has been initialized.
    """
    config = openerp.tools.config
    logger = logging.getLogger('server')
    logger.info("OpenERP version %s", __version__)
    for name, value in [('addons paths', config['addons_path']),
                        ('database hostname', config['db_host'] or 'localhost'),
                        ('database port', config['db_port'] or '5432'),
                        ('database user', config['db_user'])]:
        logger.info("%s: %s", name, value)

def setup_pid_file():
    """ Create a file with the process id written in it.

    This function assumes the configuration has been initialized.
    """
    config = openerp.tools.config
    if config['pidfile']:
        fd = open(config['pidfile'], 'w')
        pidtext = "%d" % (os.getpid())
        fd.write(pidtext)
        fd.close()

def preload_registry(dbname):
    """ Preload a registry, and start the cron."""
    try:
        db, registry = openerp.pooler.get_db_and_pool(dbname, update_module=config['init'] or config['update'], pooljobs=False)

        # jobs will start to be processed later, when openerp.cron.start_master_thread() is called by openerp.service.start_services()
        registry.schedule_cron_jobs()
    except Exception:
        logging.exception('Failed to initialize database `%s`.', dbname)

def run_test_file(dbname, test_file):
    """ Preload a registry, possibly run a test file, and start the cron."""
    try:
        db, registry = openerp.pooler.get_db_and_pool(dbname, update_module=config['init'] or config['update'], pooljobs=False)
        cr = db.cursor()
        logger = logging.getLogger('server')
        logger.info('loading test file %s', test_file)
        openerp.tools.convert_yaml_import(cr, 'base', file(test_file), {}, 'test', True)
        cr.rollback()
        cr.close()
    except Exception:
        logging.exception('Failed to initialize database `%s` and run test file `%s`.', dbname, test_file)


def export_translation():
    config = openerp.tools.config
    dbname = config['db_name']
    logger = logging.getLogger('server')

    if config["language"]:
        msg = "language %s" % (config["language"],)
    else:
        msg = "new language"
    logger.info('writing translation file for %s to %s', msg,
        config["translate_out"])

    fileformat = os.path.splitext(config["translate_out"])[-1][1:].lower()
    buf = file(config["translate_out"], "w")
    cr = openerp.pooler.get_db(dbname).cursor()
    openerp.tools.trans_export(config["language"],
        config["translate_modules"] or ["all"], buf, fileformat, cr)
    cr.close()
    buf.close()

    logger.info('translation file written successfully')

def import_translation():
    config = openerp.tools.config
    context = {'overwrite': config["overwrite_existing_translations"]}
    dbname = config['db_name']

    cr = openerp.pooler.get_db(dbname).cursor()
    openerp.tools.trans_load( cr, config["translate_in"], config["language"],
        context=context)
    openerp.tools.trans_update_res_ids(cr)
    cr.commit()
    cr.close()

# Variable keeping track of the number of calls to the signal handler defined
# below. This variable is monitored by ``quit_on_signals()``.
quit_signals_received = 0

def signal_handler(sig, frame):
    """ Signal handler: exit ungracefully on the second handled signal.

    :param sig: the signal number
    :param frame: the interrupted stack frame or None
    """
    global quit_signals_received
    quit_signals_received += 1
    if quit_signals_received > 1:
        # logging.shutdown was already called at this point.
        sys.stderr.write("Forced shutdown.\n")
        os._exit(0)

def dumpstacks(sig, frame):
    """ Signal handler: dump a stack trace for each existing thread."""
    # code from http://stackoverflow.com/questions/132058/getting-stack-trace-from-a-running-python-application#answer-2569696
    # modified for python 2.5 compatibility
    thread_map = dict(threading._active, **threading._limbo)
    id2name = dict([(threadId, thread.getName()) for threadId, thread in thread_map.items()])
    code = []
    for threadId, stack in sys._current_frames().items():
        code.append("\n# Thread: %s(%d)" % (id2name[threadId], threadId))
        for filename, lineno, name, line in traceback.extract_stack(stack):
            code.append('File: "%s", line %d, in %s' % (filename, lineno, name))
            if line:
                code.append("  %s" % (line.strip()))
    logging.getLogger('dumpstacks').info("\n".join(code))

def setup_signal_handlers():
    """ Register the signal handler defined above. """
    SIGNALS = map(lambda x: getattr(signal, "SIG%s" % x), "INT TERM".split())
    if os.name == 'posix':
        map(lambda sig: signal.signal(sig, signal_handler), SIGNALS)
        signal.signal(signal.SIGQUIT, dumpstacks)
    elif os.name == 'nt':
        import win32api
        win32api.SetConsoleCtrlHandler(lambda sig: signal_handler(sig, None), 1)

def quit_on_signals():
    """ Wait for one or two signals then shutdown the server.

    The first SIGINT or SIGTERM signal will initiate a graceful shutdown while
    a second one if any will force an immediate exit.

    """
    # Wait for a first signal to be handled. (time.sleep will be interrupted
    # by the signal handler.) The try/except is for the win32 case.
    try:
        while quit_signals_received == 0:
            time.sleep(60)
    except KeyboardInterrupt, e:
        pass

    if config['pidfile']:
        os.unlink(config['pidfile'])

    openerp.service.stop_services()
    sys.exit(0)

if __name__ == "__main__":

    os.environ["TZ"] = "UTC"

    check_root_user()
    openerp.tools.config.parse_config(sys.argv[1:])


    class ImportHook(object):
        """
        Import hook to load OpenERP addons from multiple paths.

        OpenERP implements its own import-hook to load its addons. OpenERP
        addons are Python modules. Originally, they were each living in their
        own top-level namespace, e.g. the sale module, or the hr module. For
        backward compatibility, `import <module>` is still supported. Now they
        are living in `openerp.addons`. The good way to import such modules is
        thus `import openerp.addons.module`.

        For backward compatibility, loading an addons puts it in `sys.modules`
        under both the legacy (short) name, and the new (longer) name. This
        ensures that
            import hr
            import openerp.addons.hr
        loads the hr addons only once.

        When an OpenERP addons name clashes with some other installed Python
        module (for instance this is the case of the `resource` addons),
        obtaining the OpenERP addons is only possible with the long name. The
        short name will give the expected Python module.
        """

        def find_module(self, module_name, package_path):
            module_parts = module_name.split('.')
            if len(module_parts) == 3 and module_name.startswith('openerp.addons.'):
                return self # We act as a loader too.

            # TODO list of loadable modules can be cached instead of always
            # calling get_module_path().
            if len(module_parts) == 1 and \
                openerp.modules.module.get_module_path(module_parts[0],
                    display_warning=False):
                try:
                    # Check if the bare module name clashes with another module.
                    f, path, descr = imp.find_module(module_parts[0])
                    logger = logging.getLogger('init')
                    logger.warning("""
    Ambiguous import: the OpenERP module `%s` is shadowed by another
    module (available at %s).
    To import it, use `import openerp.addons.<module>.`.""" % (module_name, path))
                    return
                except ImportError, e:
                    # Using `import <module_name>` instead of
                    # `import openerp.addons.<module_name>` is ugly but not harmful
                    # and kept for backward compatibility.
                    return self # We act as a loader too.

        def load_module(self, module_name):

            module_parts = module_name.split('.')
            if len(module_parts) == 3 and module_name.startswith('openerp.addons.'):
                module_part = module_parts[2]
                if module_name in sys.modules:
                    return sys.modules[module_name]

            if len(module_parts) == 1:
                module_part = module_parts[0]
                if module_part in sys.modules:
                    return sys.modules[module_part]

            try:
                # Check if the bare module name shadows another module.
                f, path, descr = imp.find_module(module_part)
                is_shadowing = True
            except ImportError, e:
                # Using `import <module_name>` instead of
                # `import openerp.addons.<module_name>` is ugly but not harmful
                # and kept for backward compatibility.
                is_shadowing = False

            # Note: we don't support circular import.
            f, path, descr = imp.find_module(module_part, openerp.modules.module.ad_paths)
            mod = imp.load_module(module_name, f, path, descr)
            if not is_shadowing:
                sys.modules[module_part] = mod
            sys.modules['openerp.addons.' + module_part] = mod
            return mod

    openerp.modules.module.initialize_sys_path()
    sys.meta_path.append(ImportHook())

    check_postgres_user()
    openerp.netsvc.init_logger()
    report_configuration()

    config = openerp.tools.config

    setup_signal_handlers()

    if config["test_file"]:
        run_test_file(config['db_name'], config['test_file'])
        sys.exit(0)

    if config["translate_out"]:
        export_translation()
        sys.exit(0)

    if config["translate_in"]:
        import_translation()
        sys.exit(0)

    if not config["stop_after_init"]:
        # Some module register themselves when they are loaded so we need the
        # services to be running before loading any registry.
        openerp.service.start_services()

    for m in openerp.conf.server_wide_modules:
        try:
            __import__(m)
            # Call any post_load hook.
            info = openerp.modules.module.load_information_from_description_file(m)
            if info['post_load']:
                getattr(sys.modules[m], info['post_load'])()
        except Exception:
            msg = ''
            if m == 'web':
                msg = """
The `web` module is provided by the addons found in the `openerp-web` project.
Maybe you forgot to add those addons in your addons_path configuration."""
            logging.exception('Failed to load server-wide module `%s`.%s', m, msg)

    if config['db_name']:
        for dbname in config['db_name'].split(','):
            preload_registry(dbname)

    if config["stop_after_init"]:
        sys.exit(0)

    setup_pid_file()
    logger = logging.getLogger('server')
    logger.info('OpenERP server is running, waiting for connections...')
    quit_on_signals()

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: