odoo(OpenERP)模块动态加载原理及启动代码分析

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

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

def login(db, login, password):    pool = pooler.get_pool(db)    user_obj = pool.get('res.users')    return user_obj.login(db, login, password)

def get_db(db_name):    """Return a database connection. The corresponding registry is initialized."""    return get_db_and_pool(db_name)[0]def get_db_and_pool(db_name, force_demo=False, status=None, update_module=False):    """Create and return a database connection and a newly initialized registry."""    registry = RegistryManager.get(db_name, force_demo, status, update_module)    return registry.db, registry

            try:                # This should be a method on Registry                openerp.modules.load_modules(registry.db, force_demo, status, update_module)            except Exception:                del cls.registries[db_name]                raise

        # STEP 1: LOAD BASE (must be done before module dependencies can be computed for later steps)         graph = openerp.modules.graph.Graph()        graph.add_module(cr, 'base', force)        if not graph:            _logger.critical('module base cannot be loaded! (hint: verify addons-path)')            raise osv.osv.except_osv(_('Could not load base module'), _('module base cannot be loaded! (hint: verify addons-path)'))        # processed_modules: for cleanup step after install        # loaded_modules: to avoid double loading        report = pool._assertion_report        loaded_modules, processed_modules = load_module_graph(cr, graph, status, perform_checks=update_module, report=report)        if tools.config['load_language']:            for lang in tools.config['load_language'].split(','):                tools.load_language(cr, lang)        # STEP 2: Mark other modules to be loaded/updated        if update_module:            modobj = pool.get('ir.module.module')            if ('base' in tools.config['init']) or ('base' in tools.config['update']):                _logger.info('updating modules list')                modobj.update_list(cr, SUPERUSER_ID)            _check_module_names(cr, itertools.chain(tools.config['init'].keys(), tools.config['update'].keys()))            mods = [k for k in tools.config['init'] if tools.config['init'][k]]            if mods:                ids = modobj.search(cr, SUPERUSER_ID, ['&', ('state', '=', 'uninstalled'), ('name', 'in', mods)])                if ids:                    modobj.button_install(cr, SUPERUSER_ID, ids)            mods = [k for k in tools.config['update'] if tools.config['update'][k]]            if mods:                ids = modobj.search(cr, SUPERUSER_ID, ['&', ('state', '=', 'installed'), ('name', 'in', mods)])                if ids:                    modobj.button_upgrade(cr, SUPERUSER_ID, ids)            cr.execute("update ir_module_module set state=%s where name=%s", ('installed', 'base'))        # STEP 3: Load marked modules (skipping base which was done in STEP 1)        # IMPORTANT: this is done in two parts, first loading all installed or        #            partially installed modules (i.e. installed/to upgrade), to        #            offer a consistent system to the second part: installing        #            newly selected modules.        #            We include the modules 'to remove' in the first step, because        #            they are part of the "currently installed" modules. They will        #            be dropped in STEP 6 later, before restarting the loading        #            process.        states_to_load = ['installed', 'to upgrade', 'to remove']        processed = load_marked_modules(cr, graph, states_to_load, force, status, report, loaded_modules, update_module)        processed_modules.extend(processed)        if update_module:            states_to_load = ['to install']            processed = load_marked_modules(cr, graph, states_to_load, force, status, report, loaded_modules, update_module)            processed_modules.extend(processed)

        processed = load_marked_modules(cr, graph, states_to_load, force, status, report, loaded_modules, update_module)

def load_marked_modules(cr, graph, states, force, progressdict, report, loaded_modules, perform_checks):    """Loads modules marked with ``states``, adding them to ``graph`` and       ``loaded_modules`` and returns a list of installed/upgraded modules."""    processed_modules = []    while True:        cr.execute("SELECT name from ir_module_module WHERE state IN %s" ,(tuple(states),))        module_list = [name for (name,) in cr.fetchall() if name not in graph]        graph.add_modules(cr, module_list, force)        _logger.debug('Updating graph with %d more modules', len(module_list))        loaded, processed = load_module_graph(cr, graph, progressdict, report=report, skip_modules=loaded_modules, perform_checks=perform_checks)        processed_modules.extend(processed)        loaded_modules.extend(loaded)        if not processed: break    return processed_modules

    # register, instantiate and initialize models for each modules    for index, package in enumerate(graph):        module_name = package.name        module_id = package.id        if skip_modules and module_name in skip_modules:            continue        _logger.debug('module %s: loading objects', package.name)        migrations.migrate_module(package, 'pre')        load_openerp_module(package.name)        models = pool.load(cr, package)        loaded_modules.append(package.name)        if hasattr(package, 'init') or hasattr(package, 'update') or package.state in ('to install', 'to upgrade'):            init_module_models(cr, package.name, models)        pool._init_modules.add(package.name)        status['progress'] = float(index) / len(graph)

        load_openerp_module(package.name)        models = pool.load(cr, package)

    initialize_sys_path()    try:        mod_path = get_module_path(module_name)        zip_mod_path = '' if not mod_path else mod_path + '.zip'        if not os.path.isfile(zip_mod_path):            __import__('openerp.addons.' + module_name)        else:            zimp = zipimport.zipimporter(zip_mod_path)            zimp.load_module(module_name)

    def __init__(self, name, bases, attrs):        if not self._register:            self._register = True            super(MetaModel, self).__init__(name, bases, attrs)            return        # The (OpenERP) module name can be in the `openerp.addons` namespace        # or not. For instance module `sale` can be imported as        # `openerp.addons.sale` (the good way) or `sale` (for backward        # compatibility).        module_parts = self.__module__.split('.')        if len(module_parts) > 2 and module_parts[0] == 'openerp' and \            module_parts[1] == 'addons':            module_name = self.__module__.split('.')[2]        else:            module_name = self.__module__.split('.')[0]        if not hasattr(self, '_module'):            self._module = module_name        # Remember which models to instanciate for this module.        if not self._custom:            self.module_to_models.setdefault(self._module, []).append(self)

    def load(self, cr, module):        """ Load a given module in the registry.        At the Python level, the modules are already loaded, but not yet on a        per-registry level. This method populates a registry with the given        modules, i.e. it instanciates all the classes of a the given module        and registers them in the registry.        """        models_to_load = [] # need to preserve loading order        # Instantiate registered classes (via the MetaModel automatic discovery        # or via explicit constructor call), and add them to the pool.        for cls in openerp.osv.orm.MetaModel.module_to_models.get(module.name, []):            # models register themselves in self.models            model = cls.create_instance(self, cr)            if model._name not in models_to_load:                # avoid double-loading models whose declaration is split                models_to_load.append(model._name)        return [self.models[m] for m in models_to_load]

        parent_names = getattr(cls, '_inherit', None)        # 判断是否有继承父类         if parent_names:            if isinstance(parent_names, (str, unicode)):                name = cls._name or parent_names                parent_names = [parent_names]            else:                name = cls._name            if not name:                raise TypeError('_name is mandatory in case of multiple inheritance')            for parent_name in ((type(parent_names)==list) and parent_names or [parent_names]):                # 读取父类                parent_model = pool.get(parent_name)                if not parent_model:                    raise TypeError('The model "%s" specifies an unexisting parent class "%s"\n'                        'You may need to add a dependency on the parent class\' module.' % (name, parent_name))                if not getattr(cls, '_original_module', None) and name == parent_model._name:                    cls._original_module = parent_model._original_module                parent_class = parent_model.__class__                nattr = {}                # 复制父类属性                for s in attributes:                    new = copy.copy(getattr(parent_model, s, {}))                    if s == '_columns':                        # Don't _inherit custom fields.                        for c in new.keys():                            if new[c].manual:                                del new[c]                        # Duplicate float fields because they have a .digits                        # cache (which must be per-registry, not server-wide).                        for c in new.keys():                            if new[c]._type == 'float':                                new[c] = copy.copy(new[c])                    if hasattr(new, 'update'):                        new.update(cls.__dict__.get(s, {}))                    elif s=='_constraints':                        for c in cls.__dict__.get(s, []):                            exist = False                            for c2 in range(len(new)):                                #For _constraints, we should check field and methods as well                                if new[c2][2]==c[2] and (new[c2][0] == c[0] \                                        or getattr(new[c2][0],'__name__', True) == \                                            getattr(c[0],'__name__', False)):                                    # If new class defines a constraint with                                    # same function name, we let it override                                    # the old one.                                    new[c2] = c                                    exist = True                                    break                            if not exist:                                new.append(c)                    else:                        new.extend(cls.__dict__.get(s, []))                    nattr[s] = new                # Keep links to non-inherited constraints, e.g. useful when exporting translations                nattr['_local_constraints'] = cls.__dict__.get('_constraints', [])                nattr['_local_sql_constraints'] = cls.__dict__.get('_sql_constraints', [])                # 调用元类构造函数                cls = type(name, (cls, parent_class), dict(nattr, _register=False))        else:            cls._local_constraints = getattr(cls, '_constraints', [])            cls._local_sql_constraints = getattr(cls, '_sql_constraints', [])        if not getattr(cls, '_original_module', None):            cls._original_module = cls._module        # 构造对象        obj = object.__new__(cls)        # 初始化对象        obj.__init__(pool, cr)        return obj

                parent_model = pool.get(parent_name)

    def get(self, model_name):        """ Return a model for a given name or None if it doesn't exist."""        return self.models.get(model_name)

    def __init__(self, pool, cr):        """ Initialize a model and make it part of the given registry.        - copy the stored fields' functions in the osv_pool,        - update the _columns with the fields found in ir_model_fields,        - ensure there is a many2one for each _inherits'd parent,        - update the children's _columns,        - give a chance to each field to initialize itself.        """        pool.add(self._name, self)        self.pool = pool

    def add(self, model_name, model):        """ Add or replace a model in the registry."""        self.models[model_name] = model