2011-05-12 08:46:46 +00:00
|
|
|
# -*- 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/>.
|
|
|
|
#
|
|
|
|
##############################################################################
|
|
|
|
|
2011-05-19 07:39:35 +00:00
|
|
|
""" Models registries.
|
2011-05-12 08:46:46 +00:00
|
|
|
|
|
|
|
"""
|
2012-08-13 15:05:01 +00:00
|
|
|
from contextlib import contextmanager
|
2011-08-11 11:01:18 +00:00
|
|
|
import logging
|
2012-01-24 12:42:52 +00:00
|
|
|
import threading
|
2011-05-12 08:46:46 +00:00
|
|
|
|
|
|
|
import openerp.sql_db
|
2011-06-14 14:22:26 +00:00
|
|
|
import openerp.osv.orm
|
2011-07-13 15:35:21 +00:00
|
|
|
import openerp.tools
|
2011-07-22 08:10:30 +00:00
|
|
|
import openerp.modules.db
|
2011-08-11 11:01:18 +00:00
|
|
|
import openerp.tools.config
|
2012-11-02 13:47:32 +00:00
|
|
|
from openerp.tools import assertion_report
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2012-01-24 12:42:52 +00:00
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
class Registry(object):
|
|
|
|
""" Model registry for a particular database.
|
|
|
|
|
|
|
|
The registry is essentially a mapping between model names and model
|
|
|
|
instances. There is one registry instance per database.
|
|
|
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
def __init__(self, db_name):
|
2012-08-13 15:05:01 +00:00
|
|
|
self.models = {} # model name/model instance mapping
|
2011-06-14 14:22:26 +00:00
|
|
|
self._sql_error = {}
|
|
|
|
self._store_function = {}
|
|
|
|
self._init = True
|
|
|
|
self._init_parent = {}
|
2012-11-02 13:47:32 +00:00
|
|
|
self._assertion_report = assertion_report.assertion_report()
|
2012-08-13 15:05:01 +00:00
|
|
|
|
[IMP] modules, ir.ui.view: improve view validation + avoid validation errors during updates
As of 7.0, RNG validation is not possible for form views
that have a version attribute equal to "7.0", due to the
allowed usage of HTML syntax mixed with the regular OpenERP
view syntax. RNG validation is still enabled for regular
form views (@version missing or less than "7.0"), and for
all other views types.
Validation of 7.0 form views should be improved with the
addition of an assertion-based schema, still to be done.
The above is also complemented with an explicit call to fields_view_get()
during view installation, in order to immediately verify
that the updated view hierarchy does not cause any
issue when loaded along with its related views (i.e
parent and siblings, for inheriting views).
In addition to that, fields_view_get() will now only
consider loading views that belong to modules that have
already been loaded. This avoids a lot of validation errors
during a module update operation, which runs on top of
an existing database with all previous views visible,
even those whose module is not loaded yet.
bzr revid: odo@openerp.com-20120611122758-qcw9xdhupl24busq
2012-06-11 12:27:58 +00:00
|
|
|
# modules fully loaded (maintained during init phase by `loading` module)
|
|
|
|
self._init_modules = set()
|
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
self.db_name = db_name
|
|
|
|
self.db = openerp.sql_db.db_connect(db_name)
|
|
|
|
|
2012-12-09 17:04:47 +00:00
|
|
|
# In monoprocess cron jobs flag (pooljobs)
|
|
|
|
self.cron = False
|
|
|
|
|
2012-12-08 18:11:51 +00:00
|
|
|
# Inter-process signaling (used only when openerp.multi_process is True):
|
|
|
|
# The `base_registry_signaling` sequence indicates the whole registry
|
|
|
|
# must be reloaded.
|
|
|
|
# The `base_cache_signaling sequence` indicates all caches must be
|
|
|
|
# invalidated (i.e. cleared).
|
|
|
|
self.base_registry_signaling_sequence = 1
|
|
|
|
self.base_cache_signaling_sequence = 1
|
|
|
|
|
|
|
|
# Flag indicating if at least one model cache has been cleared.
|
|
|
|
# Useful only in a multi-process context.
|
|
|
|
self._any_cache_cleared = False
|
|
|
|
|
2011-07-22 08:10:30 +00:00
|
|
|
cr = self.db.cursor()
|
2011-08-11 11:01:18 +00:00
|
|
|
has_unaccent = openerp.modules.db.has_unaccent(cr)
|
|
|
|
if openerp.tools.config['unaccent'] and not has_unaccent:
|
2012-01-24 12:42:52 +00:00
|
|
|
_logger.warning("The option --unaccent was given but no unaccent() function was found in database.")
|
2011-08-11 11:01:18 +00:00
|
|
|
self.has_unaccent = openerp.tools.config['unaccent'] and has_unaccent
|
2011-07-22 08:10:30 +00:00
|
|
|
cr.close()
|
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
def do_parent_store(self, cr):
|
|
|
|
for o in self._init_parent:
|
|
|
|
self.get(o)._parent_store_compute(cr)
|
|
|
|
self._init = False
|
|
|
|
|
|
|
|
def obj_list(self):
|
|
|
|
""" Return the list of model names in this registry."""
|
|
|
|
return self.models.keys()
|
|
|
|
|
|
|
|
def add(self, model_name, model):
|
|
|
|
""" Add or replace a model in the registry."""
|
|
|
|
self.models[model_name] = model
|
|
|
|
|
|
|
|
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 __getitem__(self, model_name):
|
|
|
|
""" Return a model for a given name or raise KeyError if it doesn't exist."""
|
|
|
|
return self.models[model_name]
|
|
|
|
|
2011-09-02 13:27:12 +00:00
|
|
|
def load(self, cr, module):
|
|
|
|
""" Load a given module in the registry.
|
2011-06-14 14:22:26 +00:00
|
|
|
|
2011-09-02 13:27:12 +00:00
|
|
|
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.
|
2011-06-14 14:22:26 +00:00
|
|
|
|
2011-09-02 13:27:12 +00:00
|
|
|
"""
|
2011-06-14 14:22:26 +00:00
|
|
|
|
|
|
|
res = []
|
|
|
|
|
2011-08-31 09:13:25 +00:00
|
|
|
# Instantiate registered classes (via the MetaModel automatic discovery
|
|
|
|
# or via explicit constructor call), and add them to the pool.
|
2011-09-02 13:27:12 +00:00
|
|
|
for cls in openerp.osv.orm.MetaModel.module_to_models.get(module.name, []):
|
2011-08-31 09:13:25 +00:00
|
|
|
res.append(cls.create_instance(self, cr))
|
2011-06-15 16:01:23 +00:00
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
return res
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-07-14 15:11:13 +00:00
|
|
|
def schedule_cron_jobs(self):
|
|
|
|
""" Make the cron thread care about this registry/database jobs.
|
|
|
|
This will initiate the cron thread to check for any pending jobs for
|
2011-08-09 11:10:08 +00:00
|
|
|
this registry/database as soon as possible. Then it will continuously
|
|
|
|
monitor the ir.cron model for future jobs. See openerp.cron for
|
2011-07-14 15:11:13 +00:00
|
|
|
details.
|
|
|
|
"""
|
2012-12-09 17:04:47 +00:00
|
|
|
self.cron = True
|
2011-07-13 15:35:21 +00:00
|
|
|
|
2011-08-31 07:56:39 +00:00
|
|
|
def clear_caches(self):
|
2011-08-25 12:47:11 +00:00
|
|
|
""" Clear the caches
|
|
|
|
This clears the caches associated to methods decorated with
|
|
|
|
``tools.ormcache`` or ``tools.ormcache_multi`` for all the models.
|
|
|
|
"""
|
|
|
|
for model in self.models.itervalues():
|
|
|
|
model.clear_caches()
|
2012-12-08 18:11:51 +00:00
|
|
|
# Special case for ir_ui_menu which does not use openerp.tools.ormcache.
|
|
|
|
ir_ui_menu = self.models.get('ir.ui.menu')
|
|
|
|
if ir_ui_menu:
|
|
|
|
ir_ui_menu.clear_cache()
|
|
|
|
|
|
|
|
|
|
|
|
# Useful only in a multi-process context.
|
|
|
|
def reset_any_cache_cleared(self):
|
|
|
|
self._any_cache_cleared = False
|
|
|
|
|
|
|
|
# Useful only in a multi-process context.
|
|
|
|
def any_cache_cleared(self):
|
|
|
|
return self._any_cache_cleared
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def setup_multi_process_signaling(cls, cr):
|
|
|
|
if not openerp.multi_process:
|
|
|
|
return
|
|
|
|
|
|
|
|
# Inter-process signaling:
|
|
|
|
# The `base_registry_signaling` sequence indicates the whole registry
|
|
|
|
# must be reloaded.
|
|
|
|
# The `base_cache_signaling sequence` indicates all caches must be
|
|
|
|
# invalidated (i.e. cleared).
|
|
|
|
cr.execute("""SELECT sequence_name FROM information_schema.sequences WHERE sequence_name='base_registry_signaling'""")
|
|
|
|
if not cr.fetchall():
|
|
|
|
cr.execute("""CREATE SEQUENCE base_registry_signaling INCREMENT BY 1 START WITH 1""")
|
|
|
|
cr.execute("""SELECT nextval('base_registry_signaling')""")
|
|
|
|
cr.execute("""CREATE SEQUENCE base_cache_signaling INCREMENT BY 1 START WITH 1""")
|
|
|
|
cr.execute("""SELECT nextval('base_cache_signaling')""")
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2012-08-13 15:05:01 +00:00
|
|
|
@contextmanager
|
|
|
|
def cursor(self, auto_commit=True):
|
|
|
|
cr = self.db.cursor()
|
|
|
|
try:
|
|
|
|
yield cr
|
|
|
|
if auto_commit:
|
|
|
|
cr.commit()
|
|
|
|
finally:
|
|
|
|
cr.close()
|
|
|
|
|
|
|
|
|
2011-05-12 08:46:46 +00:00
|
|
|
class RegistryManager(object):
|
2011-05-19 07:39:35 +00:00
|
|
|
""" Model registries manager.
|
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
The manager is responsible for creation and deletion of model
|
2011-05-19 07:39:35 +00:00
|
|
|
registries (essentially database connection/model registry pairs).
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-05-19 07:39:35 +00:00
|
|
|
"""
|
2011-06-14 14:22:26 +00:00
|
|
|
# Mapping between db name and model registry.
|
|
|
|
# Accessed through the methods below.
|
|
|
|
registries = {}
|
2011-09-16 07:52:27 +00:00
|
|
|
registries_lock = threading.RLock()
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
@classmethod
|
|
|
|
def get(cls, db_name, force_demo=False, status=None, update_module=False,
|
2011-05-12 08:46:46 +00:00
|
|
|
pooljobs=True):
|
2011-06-14 14:22:26 +00:00
|
|
|
""" Return a registry for a given database name."""
|
2011-09-30 15:00:26 +00:00
|
|
|
try:
|
|
|
|
return cls.registries[db_name]
|
|
|
|
except KeyError:
|
|
|
|
return cls.new(db_name, force_demo, status,
|
|
|
|
update_module, pooljobs)
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
@classmethod
|
|
|
|
def new(cls, db_name, force_demo=False, status=None,
|
2011-05-12 08:46:46 +00:00
|
|
|
update_module=False, pooljobs=True):
|
2011-06-14 14:22:26 +00:00
|
|
|
""" Create and return a new registry for a given database name.
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
The (possibly) previous registry for that database name is discarded.
|
2011-05-12 08:46:46 +00:00
|
|
|
|
|
|
|
"""
|
|
|
|
import openerp.modules
|
2011-09-16 07:52:27 +00:00
|
|
|
with cls.registries_lock:
|
|
|
|
registry = Registry(db_name)
|
|
|
|
|
|
|
|
# Initializing a registry will call general code which will in turn
|
|
|
|
# call registries.get (this object) to obtain the registry being
|
|
|
|
# initialized. Make it available in the registries dictionary then
|
|
|
|
# remove it if an exception is raised.
|
|
|
|
cls.delete(db_name)
|
|
|
|
cls.registries[db_name] = 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
|
|
|
|
|
|
|
|
cr = registry.db.cursor()
|
|
|
|
try:
|
2012-12-08 18:11:51 +00:00
|
|
|
Registry.setup_multi_process_signaling(cr)
|
2011-09-16 07:52:27 +00:00
|
|
|
registry.do_parent_store(cr)
|
|
|
|
registry.get('ir.actions.report.xml').register_all(cr)
|
|
|
|
cr.commit()
|
|
|
|
finally:
|
|
|
|
cr.close()
|
|
|
|
|
2011-09-30 15:00:26 +00:00
|
|
|
if pooljobs:
|
|
|
|
registry.schedule_cron_jobs()
|
2011-09-16 07:52:27 +00:00
|
|
|
|
2011-09-30 15:00:26 +00:00
|
|
|
return registry
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-06-14 14:22:26 +00:00
|
|
|
@classmethod
|
|
|
|
def delete(cls, db_name):
|
2011-09-28 21:13:26 +00:00
|
|
|
"""Delete the registry linked to a given database.
|
2011-07-13 15:35:21 +00:00
|
|
|
|
|
|
|
This also cleans the associated caches. For good measure this also
|
|
|
|
cancels the associated cron job. But please note that the cron job can
|
|
|
|
be running and take some time before ending, and that you should not
|
|
|
|
remove a registry if it can still be used by some thread. So it might
|
2011-07-14 14:32:09 +00:00
|
|
|
be necessary to call yourself openerp.cron.Agent.cancel(db_name) and
|
2011-07-13 15:35:21 +00:00
|
|
|
and join (i.e. wait for) the thread.
|
|
|
|
"""
|
2011-09-16 07:52:27 +00:00
|
|
|
with cls.registries_lock:
|
|
|
|
if db_name in cls.registries:
|
2011-09-28 21:13:26 +00:00
|
|
|
cls.registries[db_name].clear_caches()
|
2011-09-16 07:52:27 +00:00
|
|
|
del cls.registries[db_name]
|
2011-09-28 21:13:26 +00:00
|
|
|
openerp.cron.cancel(db_name)
|
|
|
|
|
2011-07-13 15:35:21 +00:00
|
|
|
@classmethod
|
|
|
|
def delete_all(cls):
|
2011-09-28 21:13:26 +00:00
|
|
|
"""Delete all the registries. """
|
|
|
|
with cls.registries_lock:
|
|
|
|
for db_name in cls.registries.keys():
|
|
|
|
cls.delete(db_name)
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-08-25 12:47:11 +00:00
|
|
|
@classmethod
|
2011-08-31 07:56:39 +00:00
|
|
|
def clear_caches(cls, db_name):
|
2011-09-28 21:13:26 +00:00
|
|
|
"""Clear caches
|
2011-08-25 12:47:11 +00:00
|
|
|
|
|
|
|
This clears the caches associated to methods decorated with
|
|
|
|
``tools.ormcache`` or ``tools.ormcache_multi`` for all the models
|
|
|
|
of the given database name.
|
|
|
|
|
|
|
|
This method is given to spare you a ``RegistryManager.get(db_name)``
|
|
|
|
that would loads the given database if it was not already loaded.
|
|
|
|
"""
|
2011-09-16 07:52:27 +00:00
|
|
|
with cls.registries_lock:
|
|
|
|
if db_name in cls.registries:
|
|
|
|
cls.registries[db_name].clear_caches()
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2012-12-08 18:11:51 +00:00
|
|
|
@classmethod
|
|
|
|
def check_registry_signaling(cls, db_name):
|
|
|
|
if openerp.multi_process and db_name in cls.registries:
|
|
|
|
registry = cls.get(db_name, pooljobs=False)
|
|
|
|
cr = registry.db.cursor()
|
|
|
|
try:
|
|
|
|
cr.execute("""
|
|
|
|
SELECT base_registry_signaling.last_value,
|
|
|
|
base_cache_signaling.last_value
|
|
|
|
FROM base_registry_signaling, base_cache_signaling""")
|
|
|
|
r, c = cr.fetchone()
|
|
|
|
# Check if the model registry must be reloaded (e.g. after the
|
|
|
|
# database has been updated by another process).
|
|
|
|
if registry.base_registry_signaling_sequence != r:
|
|
|
|
_logger.info("Reloading the model registry after database signaling.")
|
|
|
|
# Don't run the cron in the Gunicorn worker.
|
|
|
|
registry = cls.new(db_name, pooljobs=False)
|
|
|
|
registry.base_registry_signaling_sequence = r
|
|
|
|
# Check if the model caches must be invalidated (e.g. after a write
|
|
|
|
# occured on another process). Don't clear right after a registry
|
|
|
|
# has been reload.
|
|
|
|
elif registry.base_cache_signaling_sequence != c:
|
|
|
|
_logger.info("Invalidating all model caches after database signaling.")
|
|
|
|
registry.base_cache_signaling_sequence = c
|
|
|
|
registry.clear_caches()
|
|
|
|
registry.reset_any_cache_cleared()
|
|
|
|
# One possible reason caches have been invalidated is the
|
|
|
|
# use of decimal_precision.write(), in which case we need
|
|
|
|
# to refresh fields.float columns.
|
|
|
|
for model in registry.models.values():
|
|
|
|
for column in model._columns.values():
|
|
|
|
if hasattr(column, 'digits_change'):
|
|
|
|
column.digits_change(cr)
|
|
|
|
finally:
|
|
|
|
cr.close()
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def signal_caches_change(cls, db_name):
|
|
|
|
if openerp.multi_process and db_name in cls.registries:
|
|
|
|
# Check the registries if any cache has been cleared and signal it
|
|
|
|
# through the database to other processes.
|
|
|
|
registry = cls.get(db_name, pooljobs=False)
|
|
|
|
if registry.any_cache_cleared():
|
|
|
|
_logger.info("At least one model cache has been cleared, signaling through the database.")
|
|
|
|
cr = registry.db.cursor()
|
|
|
|
r = 1
|
|
|
|
try:
|
|
|
|
cr.execute("select nextval('base_cache_signaling')")
|
|
|
|
r = cr.fetchone()[0]
|
|
|
|
finally:
|
|
|
|
cr.close()
|
|
|
|
registry.base_cache_signaling_sequence = r
|
|
|
|
registry.reset_any_cache_cleared()
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
def signal_registry_change(cls, db_name):
|
|
|
|
if openerp.multi_process and db_name in cls.registries:
|
|
|
|
registry = cls.get(db_name, pooljobs=False)
|
|
|
|
cr = registry.db.cursor()
|
|
|
|
r = 1
|
|
|
|
try:
|
|
|
|
cr.execute("select nextval('base_registry_signaling')")
|
|
|
|
r = cr.fetchone()[0]
|
|
|
|
finally:
|
|
|
|
cr.close()
|
|
|
|
registry.base_registry_signaling_sequence = r
|
2011-05-12 08:46:46 +00:00
|
|
|
|
2011-09-30 15:00:26 +00:00
|
|
|
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
|