openerp/modules/loading.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>).
   6 #    Copyright (C) 2010-2011 OpenERP s.a. (<http://openerp.com>).
   7 #
   8 #    This program is free software: you can redistribute it and/or modify
   9 #    it under the terms of the GNU Affero General Public License as
  10 #    published by the Free Software Foundation, either version 3 of the
  11 #    License, or (at your option) any later version.
  12 #
  13 #    This program is distributed in the hope that it will be useful,
  14 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 #    GNU Affero General Public License for more details.
  17 #
  18 #    You should have received a copy of the GNU Affero General Public License
  19 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 #
  21 ##############################################################################
  22
  23 """ Modules (also called addons) management.
  24
  25 """
  26
  27 import base64
  28 import imp
  29 import itertools
  30 import logging
  31 import os
  32 import re
  33 import sys
  34 import zipfile
  35 import zipimport
  36
  37 from cStringIO import StringIO
  38 from os.path import join as opj
  39 from zipfile import PyZipFile, ZIP_DEFLATED
  40
  41
  42 import openerp
  43 import openerp.modules.db
  44 import openerp.modules.graph
  45 import openerp.modules.migration
  46 import openerp.netsvc as netsvc
  47 import openerp.osv as osv
  48 import openerp.pooler as pooler
  49 import openerp.release as release
  50 import openerp.tools as tools
  51 import openerp.tools.osutil as osutil
  52
  53 from openerp.tools.safe_eval import safe_eval as eval
  54 from openerp.tools.translate import _
  55 from openerp.modules.module import \
  56     get_modules, get_modules_with_version, \
  57     load_information_from_description_file, \
  58     get_module_resource, zip_directory, \
  59     get_module_path, initialize_sys_path, \
  60     register_module_classes, init_module_models
  61
  62 logger = netsvc.Logger()
  63
  64
  65 def open_openerp_namespace():
  66     # See comment for open_openerp_namespace.
  67     if openerp.conf.deprecation.open_openerp_namespace:
  68         for k, v in list(sys.modules.items()):
  69             if k.startswith('openerp.') and sys.modules.get(k[8:]) is None:
  70                 sys.modules[k[8:]] = v
  71
  72
  73 def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=None, report=None):
  74     """Migrates+Updates or Installs all module nodes from ``graph``
  75        :param graph: graph of module nodes to load
  76        :param status: status dictionary for keeping track of progress
  77        :param perform_checks: whether module descriptors should be checked for validity (prints warnings
  78                               for same cases, and even raise osv_except if certificate is invalid)
  79        :param skip_modules: optional list of module names (packages) which have previously been loaded and can be skipped
  80        :return: list of modules that were installed or updated
  81     """
  82     logger = logging.getLogger('init.load')
  83     def process_sql_file(cr, fp):
  84         queries = fp.read().split(';')
  85         for query in queries:
  86             new_query = ' '.join(query.split())
  87             if new_query:
  88                 cr.execute(new_query)
  89
  90     load_init_xml = lambda *args: _load_data(cr, *args, kind='init_xml')
  91     load_update_xml = lambda *args: _load_data(cr, *args, kind='update_xml')
  92     load_demo_xml = lambda *args: _load_data(cr, *args, kind='demo_xml')
  93     load_data = lambda *args: _load_data(cr, *args, kind='data')
  94     load_demo = lambda *args: _load_data(cr, *args, kind='demo')
  95
  96     def load_test(module_name, idref, mode):
  97         cr.commit()
  98         if not tools.config.options['test_disable']:
  99             try:
 100                 _load_data(cr, module_name, idref, mode, 'test')
 101             except Exception, e:
 102                 logging.getLogger('init.test').exception(
 103                     'Tests failed to execute in module %s', module_name)
 104             finally:
 105                 if tools.config.options['test_commit']:
 106                     cr.commit()
 107                 else:
 108                     cr.rollback()
 109
 110     def _load_data(cr, module_name, idref, mode, kind):
 111         """
 112
 113         kind: data, demo, test, init_xml, update_xml, demo_xml.
 114
 115         noupdate is False, unless it is demo data or it is csv data in
 116         init mode.
 117
 118         """
 119         for filename in package.data[kind]:
 120             logger.info("module %s: loading %s", module_name, filename)
 121             _, ext = os.path.splitext(filename)
 122             pathname = os.path.join(module_name, filename)
 123             fp = tools.file_open(pathname)
 124             noupdate = False
 125             if kind in ('demo', 'demo_xml'):
 126                 noupdate = True
 127             try:
 128                 if ext == '.csv':
 129                     if kind in ('init', 'init_xml'):
 130                         noupdate = True
 131                     tools.convert_csv_import(cr, module_name, pathname, fp.read(), idref, mode, noupdate)
 132                 elif ext == '.sql':
 133                     process_sql_file(cr, fp)
 134                 elif ext == '.yml':
 135                     tools.convert_yaml_import(cr, module_name, fp, idref, mode, noupdate)
 136                 else:
 137                     tools.convert_xml_import(cr, module_name, fp, idref, mode, noupdate, report)
 138             finally:
 139                 fp.close()
 140
 141     if status is None:
 142         status = {}
 143
 144     processed_modules = []
 145     loaded_modules = []
 146     pool = pooler.get_pool(cr.dbname)
 147     migrations = openerp.modules.migration.MigrationManager(cr, graph)
 148     logger.debug('loading %d packages...', len(graph))
 149
 150     # get db timestamp
 151     cr.execute("select now()::timestamp")
 152     dt_before_load = cr.fetchone()[0]
 153
 154     # register, instantiate and initialize models for each modules
 155     for index, package in enumerate(graph):
 156         module_name = package.name
 157         module_id = package.id
 158
 159         if skip_modules and module_name in skip_modules:
 160             continue
 161
 162         logger.info('module %s: loading objects', package.name)
 163         migrations.migrate_module(package, 'pre')
 164         register_module_classes(package.name)
 165         models = pool.load(cr, package)
 166         loaded_modules.append(package.name)
 167         if hasattr(package, 'init') or hasattr(package, 'update') or package.state in ('to install', 'to upgrade'):
 168             init_module_models(cr, package.name, models)
 169
 170         status['progress'] = float(index) / len(graph)
 171
 172         # Can't put this line out of the loop: ir.module.module will be
 173         # registered by init_module_models() above.
 174         modobj = pool.get('ir.module.module')
 175
 176         if perform_checks:
 177             modobj.check(cr, 1, [module_id])
 178
 179         idref = {}
 180
 181         mode = 'update'
 182         if hasattr(package, 'init') or package.state == 'to install':
 183             mode = 'init'
 184
 185         if hasattr(package, 'init') or hasattr(package, 'update') or package.state in ('to install', 'to upgrade'):
 186             if package.state=='to upgrade':
 187                 # upgrading the module information
 188                 modobj.write(cr, 1, [module_id], modobj.get_values_from_terp(package.data))
 189             load_init_xml(module_name, idref, mode)
 190             load_update_xml(module_name, idref, mode)
 191             load_data(module_name, idref, mode)
 192             if hasattr(package, 'demo') or (package.dbdemo and package.state != 'installed'):
 193                 status['progress'] = (index + 0.75) / len(graph)
 194                 load_demo_xml(module_name, idref, mode)
 195                 load_demo(module_name, idref, mode)
 196                 cr.execute('update ir_module_module set demo=%s where id=%s', (True, module_id))
 197
 198                 # launch tests only in demo mode, as most tests will depend
 199                 # on demo data. Other tests can be added into the regular
 200                 # 'data' section, but should probably not alter the data,
 201                 # as there is no rollback.
 202                 load_test(module_name, idref, mode)
 203
 204             processed_modules.append(package.name)
 205
 206             migrations.migrate_module(package, 'post')
 207
 208             ver = release.major_version + '.' + package.data['version']
 209             # Set new modules and dependencies
 210             modobj.write(cr, 1, [module_id], {'state': 'installed', 'latest_version': ver})
 211             # Update translations for all installed languages
 212             modobj.update_translations(cr, 1, [module_id], None)
 213
 214             package.state = 'installed'
 215             for kind in ('init', 'demo', 'update'):
 216                 if hasattr(package, kind):
 217                     delattr(package, kind)
 218
 219         cr.commit()
 220
 221     # mark new res_log records as read
 222     cr.execute("update res_log set read=True where create_date >= %s", (dt_before_load,))
 223
 224     cr.commit()
 225
 226     return loaded_modules, processed_modules
 227
 228 def _check_module_names(cr, module_names):
 229     mod_names = set(module_names)
 230     if 'base' in mod_names:
 231         # ignore dummy 'all' module
 232         if 'all' in mod_names:
 233             mod_names.remove('all')
 234     if mod_names:
 235         cr.execute("SELECT count(id) AS count FROM ir_module_module WHERE name in %s", (tuple(mod_names),))
 236         if cr.dictfetchone()['count'] != len(mod_names):
 237             # find out what module name(s) are incorrect:
 238             cr.execute("SELECT name FROM ir_module_module")
 239             incorrect_names = mod_names.difference([x['name'] for x in cr.dictfetchall()])
 240             logging.getLogger('init').warning('invalid module names, ignored: %s', ", ".join(incorrect_names))
 241
 242 def load_marked_modules(cr, graph, states, force, progressdict, report, loaded_modules):
 243     """Loads modules marked with ``states``, adding them to ``graph`` and
 244        ``loaded_modules`` and returns a list of installed/upgraded modules."""
 245     processed_modules = []
 246     while True:
 247         cr.execute("SELECT name from ir_module_module WHERE state IN %s" ,(tuple(states),))
 248         module_list = [name for (name,) in cr.fetchall() if name not in graph]
 249         new_modules_in_graph = graph.add_modules(cr, module_list, force)
 250         logger.notifyChannel('init', netsvc.LOG_DEBUG, 'Updating graph with %d more modules' % (len(module_list)))
 251         loaded, processed = load_module_graph(cr, graph, progressdict, report=report, skip_modules=loaded_modules)
 252         processed_modules.extend(processed)
 253         loaded_modules.extend(loaded)
 254         if not processed: break
 255     return processed_modules
 256
 257
 258 def load_modules(db, force_demo=False, status=None, update_module=False):
 259     # TODO status['progress'] reporting is broken: used twice (and reset each
 260     # time to zero) in load_module_graph, not fine-grained enough.
 261     # It should be a method exposed by the pool.
 262     initialize_sys_path()
 263
 264     open_openerp_namespace()
 265
 266     force = []
 267     if force_demo:
 268         force.append('demo')
 269
 270     cr = db.cursor()
 271     try:
 272         if not openerp.modules.db.is_initialized(cr):
 273             logger.notifyChannel("init", netsvc.LOG_INFO, "init db")
 274             openerp.modules.db.initialize(cr)
 275             tools.config["init"]["all"] = 1
 276             tools.config['update']['all'] = 1
 277             if not tools.config['without_demo']:
 278                 tools.config["demo"]['all'] = 1
 279             update_module = True
 280
 281         # This is a brand new pool, just created in pooler.get_db_and_pool()
 282         pool = pooler.get_pool(cr.dbname)
 283
 284         report = tools.assertion_report()
 285         if 'base' in tools.config['update'] or 'all' in tools.config['update']:
 286             cr.execute("update ir_module_module set state=%s where name=%s and state=%s", ('to upgrade', 'base', 'installed'))
 287
 288         # STEP 1: LOAD BASE (must be done before module dependencies can be computed for later steps)
 289         graph = openerp.modules.graph.Graph()
 290         graph.add_module(cr, 'base', force)
 291         if not graph:
 292             logger.notifyChannel('init', netsvc.LOG_CRITICAL, 'module base cannot be loaded! (hint: verify addons-path)')
 293             raise osv.osv.except_osv(_('Could not load base module'), _('module base cannot be loaded! (hint: verify addons-path)'))
 294
 295         # processed_modules: for cleanup step after install
 296         # loaded_modules: to avoid double loading
 297         loaded_modules, processed_modules = load_module_graph(cr, graph, status, report=report)
 298
 299         if tools.config['load_language']:
 300             for lang in tools.config['load_language'].split(','):
 301                 tools.load_language(cr, lang)
 302
 303         # STEP 2: Mark other modules to be loaded/updated
 304         if update_module:
 305             modobj = pool.get('ir.module.module')
 306             if ('base' in tools.config['init']) or ('base' in tools.config['update']):
 307                 logger.notifyChannel('init', netsvc.LOG_INFO, 'updating modules list')
 308                 modobj.update_list(cr, 1)
 309
 310             _check_module_names(cr, itertools.chain(tools.config['init'].keys(), tools.config['update'].keys()))
 311
 312             mods = [k for k in tools.config['init'] if tools.config['init'][k]]
 313             if mods:
 314                 ids = modobj.search(cr, 1, ['&', ('state', '=', 'uninstalled'), ('name', 'in', mods)])
 315                 if ids:
 316                     modobj.button_install(cr, 1, ids)
 317
 318             mods = [k for k in tools.config['update'] if tools.config['update'][k]]
 319             if mods:
 320                 ids = modobj.search(cr, 1, ['&', ('state', '=', 'installed'), ('name', 'in', mods)])
 321                 if ids:
 322                     modobj.button_upgrade(cr, 1, ids)
 323
 324             cr.execute("update ir_module_module set state=%s where name=%s", ('installed', 'base'))
 325
 326
 327         # STEP 3: Load marked modules (skipping base which was done in STEP 1)
 328         # IMPORTANT: this is done in two parts, first loading all installed or
 329         #            partially installed modules (i.e. installed/to upgrade), to
 330         #            offer a consistent system to the second part: installing
 331         #            newly selected modules.
 332         states_to_load = ['installed', 'to upgrade']
 333         processed = load_marked_modules(cr, graph, states_to_load, force, status, report, loaded_modules)
 334         processed_modules.extend(processed)
 335         if update_module:
 336             states_to_load = ['to install']
 337             processed = load_marked_modules(cr, graph, states_to_load, force, status, report, loaded_modules)
 338             processed_modules.extend(processed)
 339
 340         # load custom models
 341         cr.execute('select model from ir_model where state=%s', ('manual',))
 342         for model in cr.dictfetchall():
 343             pool.get('ir.model').instanciate(cr, 1, model['model'], {})
 344
 345         # STEP 4: Finish and cleanup
 346         if processed_modules:
 347             cr.execute("""select model,name from ir_model where id NOT IN (select distinct model_id from ir_model_access)""")
 348             for (model, name) in cr.fetchall():
 349                 model_obj = pool.get(model)
 350                 if model_obj and not model_obj.is_transient():
 351                     logger.notifyChannel('init', netsvc.LOG_WARNING, 'Model %s (%s) has no access rules!' % (model, name))
 352
 353             # Temporary warning while we remove access rights on osv_memory objects, as they have
 354             # been replaced by owner-only access rights
 355             cr.execute("""select distinct mod.model, mod.name from ir_model_access acc, ir_model mod where acc.model_id = mod.id""")
 356             for (model, name) in cr.fetchall():
 357                 model_obj = pool.get(model)
 358                 if model_obj and model_obj.is_transient():
 359                     logger.notifyChannel('init', netsvc.LOG_WARNING, 'The transient model %s (%s) should not have explicit access rules!' % (model, name))
 360
 361             cr.execute("SELECT model from ir_model")
 362             for (model,) in cr.fetchall():
 363                 obj = pool.get(model)
 364                 if obj:
 365                     obj._check_removed_columns(cr, log=True)
 366                 else:
 367                     logger.notifyChannel('init', netsvc.LOG_WARNING, "Model %s is declared but cannot be loaded! (Perhaps a module was partially removed or renamed)" % model)
 368
 369             # Cleanup orphan records
 370             pool.get('ir.model.data')._process_end(cr, 1, processed_modules)
 371
 372         if report.get_report():
 373             logger.notifyChannel('init', netsvc.LOG_INFO, report)
 374
 375         for kind in ('init', 'demo', 'update'):
 376             tools.config[kind] = {}
 377
 378         cr.commit()
 379         if update_module:
 380             # Remove records referenced from ir_model_data for modules to be
 381             # removed (and removed the references from ir_model_data).
 382             cr.execute("select id,name from ir_module_module where state=%s", ('to remove',))
 383             for mod_id, mod_name in cr.fetchall():
 384                 cr.execute('select model,res_id from ir_model_data where noupdate=%s and module=%s order by id desc', (False, mod_name,))
 385                 for rmod, rid in cr.fetchall():
 386                     uid = 1
 387                     rmod_module= pool.get(rmod)
 388                     if rmod_module:
 389                         # TODO group by module so that we can delete multiple ids in a call
 390                         rmod_module.unlink(cr, uid, [rid])
 391                     else:
 392                         logger.notifyChannel('init', netsvc.LOG_ERROR, 'Could not locate %s to remove res=%d' % (rmod,rid))
 393                 cr.execute('delete from ir_model_data where noupdate=%s and module=%s', (False, mod_name,))
 394                 cr.commit()
 395
 396             # Remove menu items that are not referenced by any of other
 397             # (child) menu item, ir_values, or ir_model_data.
 398             # This code could be a method of ir_ui_menu.
 399             # TODO: remove menu without actions of children
 400             while True:
 401                 cr.execute('''delete from
 402                         ir_ui_menu
 403                     where
 404                         (id not IN (select parent_id from ir_ui_menu where parent_id is not null))
 405                     and
 406                         (id not IN (select res_id from ir_values where model='ir.ui.menu'))
 407                     and
 408                         (id not IN (select res_id from ir_model_data where model='ir.ui.menu'))''')
 409                 cr.commit()
 410                 if not cr.rowcount:
 411                     break
 412                 else:
 413                     logger.notifyChannel('init', netsvc.LOG_INFO, 'removed %d unused menus' % (cr.rowcount,))
 414
 415             # Pretend that modules to be removed are actually uninstalled.
 416             cr.execute("update ir_module_module set state=%s where state=%s", ('uninstalled', 'to remove',))
 417             cr.commit()
 418     finally:
 419         cr.close()
 420
 421
 422 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: