Olivier Dony
695716efb0
Now that we're closer to switching to P3 for good, these helpers have outlived their usefulness, and mostly add noise. All remaining dict.iter*() or dict.view*() must be converted to the normal keys(), values() or items() calls. Whenever the result is likely to be used for more than the scope of a loop, or when the dict needs to be modified during iteration, the calls must be wrapped in a ``list()``, to protect the new P3 semantics. Those cases are very exceptional. Also removed some dead code or improved the API to remove unnecessary conversions.
179 lines
6.1 KiB
Python
179 lines
6.1 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
""" Modules dependency graph. """
|
|
|
|
import itertools
|
|
import logging
|
|
|
|
import odoo
|
|
import odoo.tools as tools
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
class Graph(dict):
|
|
""" Modules dependency graph.
|
|
|
|
The graph is a mapping from module name to Nodes.
|
|
|
|
"""
|
|
|
|
def add_node(self, name, info):
|
|
max_depth, father = 0, None
|
|
for d in info['depends']:
|
|
n = self.get(d) or Node(d, self, None) # lazy creation, do not use default value for get()
|
|
if n.depth >= max_depth:
|
|
father = n
|
|
max_depth = n.depth
|
|
if father:
|
|
return father.add_child(name, info)
|
|
else:
|
|
return Node(name, self, info)
|
|
|
|
def update_from_db(self, cr):
|
|
if not len(self):
|
|
return
|
|
# update the graph with values from the database (if exist)
|
|
## First, we set the default values for each package in graph
|
|
additional_data = {key: {'id': 0, 'state': 'uninstalled', 'dbdemo': False, 'installed_version': None} for key in self.keys()}
|
|
## Then we get the values from the database
|
|
cr.execute('SELECT name, id, state, demo AS dbdemo, latest_version AS installed_version'
|
|
' FROM ir_module_module'
|
|
' WHERE name IN %s',(tuple(additional_data),)
|
|
)
|
|
|
|
## and we update the default values with values from the database
|
|
additional_data.update((x['name'], x) for x in cr.dictfetchall())
|
|
|
|
for package in self.values():
|
|
for k, v in additional_data[package.name].items():
|
|
setattr(package, k, v)
|
|
|
|
def add_module(self, cr, module, force=None):
|
|
self.add_modules(cr, [module], force)
|
|
|
|
def add_modules(self, cr, module_list, force=None):
|
|
if force is None:
|
|
force = []
|
|
packages = []
|
|
len_graph = len(self)
|
|
for module in module_list:
|
|
# This will raise an exception if no/unreadable descriptor file.
|
|
# NOTE The call to load_information_from_description_file is already
|
|
# done by db.initialize, so it is possible to not do it again here.
|
|
info = odoo.modules.module.load_information_from_description_file(module)
|
|
if info and info['installable']:
|
|
packages.append((module, info)) # TODO directly a dict, like in get_modules_with_version
|
|
elif module != 'studio_customization':
|
|
_logger.warning('module %s: not installable, skipped', module)
|
|
|
|
dependencies = dict([(p, info['depends']) for p, info in packages])
|
|
current, later = set([p for p, info in packages]), set()
|
|
|
|
while packages and current > later:
|
|
package, info = packages[0]
|
|
deps = info['depends']
|
|
|
|
# if all dependencies of 'package' are already in the graph, add 'package' in the graph
|
|
if all(dep in self for dep in deps):
|
|
if not package in current:
|
|
packages.pop(0)
|
|
continue
|
|
later.clear()
|
|
current.remove(package)
|
|
node = self.add_node(package, info)
|
|
for kind in ('init', 'demo', 'update'):
|
|
if package in tools.config[kind] or 'all' in tools.config[kind] or kind in force:
|
|
setattr(node, kind, True)
|
|
else:
|
|
later.add(package)
|
|
packages.append((package, info))
|
|
packages.pop(0)
|
|
|
|
self.update_from_db(cr)
|
|
|
|
for package in later:
|
|
unmet_deps = [p for p in dependencies[package] if p not in self]
|
|
_logger.error('module %s: Unmet dependencies: %s', package, ', '.join(unmet_deps))
|
|
|
|
return len(self) - len_graph
|
|
|
|
|
|
def __iter__(self):
|
|
level = 0
|
|
done = set(self.keys())
|
|
while done:
|
|
level_modules = sorted((name, module) for name, module in self.items() if module.depth==level)
|
|
for name, module in level_modules:
|
|
done.remove(name)
|
|
yield module
|
|
level += 1
|
|
|
|
def __str__(self):
|
|
return '\n'.join(str(n) for n in self if n.depth == 0)
|
|
|
|
class Node(object):
|
|
""" One module in the modules dependency graph.
|
|
|
|
Node acts as a per-module singleton. A node is constructed via
|
|
Graph.add_module() or Graph.add_modules(). Some of its fields are from
|
|
ir_module_module (setted by Graph.update_from_db()).
|
|
|
|
"""
|
|
def __new__(cls, name, graph, info):
|
|
if name in graph:
|
|
inst = graph[name]
|
|
else:
|
|
inst = object.__new__(cls)
|
|
graph[name] = inst
|
|
return inst
|
|
|
|
def __init__(self, name, graph, info):
|
|
self.name = name
|
|
self.graph = graph
|
|
self.info = info or getattr(self, 'info', {})
|
|
if not hasattr(self, 'children'):
|
|
self.children = []
|
|
if not hasattr(self, 'depth'):
|
|
self.depth = 0
|
|
|
|
@property
|
|
def data(self):
|
|
return self.info
|
|
|
|
def add_child(self, name, info):
|
|
node = Node(name, self.graph, info)
|
|
node.depth = self.depth + 1
|
|
if node not in self.children:
|
|
self.children.append(node)
|
|
for attr in ('init', 'update', 'demo'):
|
|
if hasattr(self, attr):
|
|
setattr(node, attr, True)
|
|
self.children.sort(key=lambda x: x.name)
|
|
return node
|
|
|
|
def __setattr__(self, name, value):
|
|
super(Node, self).__setattr__(name, value)
|
|
if name in ('init', 'update', 'demo'):
|
|
tools.config[name][self.name] = 1
|
|
for child in self.children:
|
|
setattr(child, name, value)
|
|
if name == 'depth':
|
|
for child in self.children:
|
|
setattr(child, name, value + 1)
|
|
|
|
def __iter__(self):
|
|
return itertools.chain(
|
|
self.children,
|
|
itertools.chain.from_iterable(self.children)
|
|
)
|
|
|
|
def __str__(self):
|
|
return self._pprint()
|
|
|
|
def _pprint(self, depth=0):
|
|
s = '%s\n' % self.name
|
|
for c in self.children:
|
|
s += '%s`-> %s' % (' ' * depth, c._pprint(depth+1))
|
|
return s
|