+
+
+
+
+
+
+
diff --git a/openerp/addons/base/res/res_partner.py b/openerp/addons/base/res/res_partner.py
index 9115ccae481..46f0218e21f 100644
--- a/openerp/addons/base/res/res_partner.py
+++ b/openerp/addons/base/res/res_partner.py
@@ -209,6 +209,7 @@ class res_partner(osv.osv, format_address):
context = dict(context or {})
context.pop('show_address', None)
context.pop('show_address_only', None)
+ context.pop('show_email', None)
return dict(self.name_get(cr, uid, ids, context=context))
# indirections to avoid passing a copy of the overridable method when declaring the function field
@@ -349,6 +350,7 @@ class res_partner(osv.osv, format_address):
def copy(self, cr, uid, id, default=None, context=None):
if default is None:
default = {}
+ default['user_ids'] = False
name = self.read(cr, uid, [id], ['name'], context)[0]['name']
default.update({'name': _('%s (copy)') % name})
return super(res_partner, self).copy(cr, uid, id, default, context)
diff --git a/openerp/addons/base/res/res_users.py b/openerp/addons/base/res/res_users.py
index ad017381409..1668cbda3c5 100644
--- a/openerp/addons/base/res/res_users.py
+++ b/openerp/addons/base/res/res_users.py
@@ -3,7 +3,7 @@
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2009 Tiny SPRL ().
-# Copyright (C) 2010-2013 OpenERP s.a. ().
+# Copyright (C) 2010-2014 OpenERP s.a. ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
@@ -169,8 +169,9 @@ class res_users(osv.osv):
}
def on_change_login(self, cr, uid, ids, login, context=None):
- v = {'email': login} if tools.single_email_re.match(login) else {}
- return {'value': v}
+ if login and tools.single_email_re.match(login):
+ return {'value': {'email': login}}
+ return {}
def onchange_state(self, cr, uid, ids, state_id, context=None):
partner_ids = [user.partner_id.id for user in self.browse(cr, uid, ids, context=context)]
@@ -899,16 +900,22 @@ class change_password_wizard(osv.TransientModel):
}))
return {'user_ids': res}
-
def change_password_button(self, cr, uid, id, context=None):
wizard = self.browse(cr, uid, id, context=context)[0]
- user_ids = []
- for user in wizard.user_ids:
- user_ids.append(user.id)
- self.pool.get('change.password.user').change_password_button(cr, uid, user_ids, context=context)
- return {
- 'type': 'ir.actions.act_window_close',
- }
+ need_reload = any(uid == user.user_id.id for user in wizard.user_ids)
+ line_ids = [user.id for user in wizard.user_ids]
+
+ self.pool.get('change.password.user').change_password_button(cr, uid, line_ids, context=context)
+ # don't keep temporary password copies in the database longer than necessary
+ self.pool.get('change.password.user').write(cr, uid, line_ids, {'new_passwd': False}, context=context)
+
+ if need_reload:
+ return {
+ 'type': 'ir.actions.client',
+ 'tag': 'reload'
+ }
+
+ return {'type': 'ir.actions.act_window_close'}
class change_password_user(osv.TransientModel):
"""
diff --git a/openerp/addons/base/res/res_users_view.xml b/openerp/addons/base/res/res_users_view.xml
index 9c84d4326f4..8a3f372af7a 100644
--- a/openerp/addons/base/res/res_users_view.xml
+++ b/openerp/addons/base/res/res_users_view.xml
@@ -231,7 +231,7 @@
res.users
-
+
@@ -282,7 +282,7 @@
-
diff --git a/openerp/addons/base/tests/__init__.py b/openerp/addons/base/tests/__init__.py
index 6358dffa45b..2e55989ba19 100644
--- a/openerp/addons/base/tests/__init__.py
+++ b/openerp/addons/base/tests/__init__.py
@@ -20,7 +20,6 @@ import test_res_config
import test_res_lang
import test_search
import test_translate
-import test_ui
#import test_uninstall
import test_view_validation
import test_views
diff --git a/openerp/addons/base/tests/test_base.py b/openerp/addons/base/tests/test_base.py
index 20382737529..bbc5b21d1fb 100644
--- a/openerp/addons/base/tests/test_base.py
+++ b/openerp/addons/base/tests/test_base.py
@@ -9,6 +9,7 @@ class test_base(common.TransactionCase):
super(test_base,self).setUp()
self.res_partner = self.registry('res.partner')
self.res_users = self.registry('res.users')
+ self.res_partner_title = self.registry('res.partner.title')
# samples use effective TLDs from the Mozilla public suffix
# list at http://publicsuffix.org
@@ -285,18 +286,99 @@ class test_base(common.TransactionCase):
def test_60_read_group(self):
cr, uid = self.cr, self.uid
- for user_data in [
- {'name': 'Alice', 'login': 'alice', 'color': 1, 'function': 'Friend'},
- {'name': 'Bob', 'login': 'bob', 'color': 2, 'function': 'Friend'},
- {'name': 'Eve', 'login': 'eve', 'color': 3, 'function': 'Eavesdropper'},
- ]:
- self.res_users.create(cr, uid, user_data)
+ title_sir = self.res_partner_title.create(cr, uid, {'name': 'Sir', 'domain': 'contact'})
+ title_lady = self.res_partner_title.create(cr, uid, {'name': 'Lady', 'domain': 'contact'})
+ test_users = [
+ {'name': 'Alice', 'login': 'alice', 'color': 1, 'function': 'Friend', 'date': '2015-03-28', 'title': title_lady},
+ {'name': 'Alice', 'login': 'alice2', 'color': 0, 'function': 'Friend', 'date': '2015-01-28', 'title': title_lady},
+ {'name': 'Bob', 'login': 'bob', 'color': 2, 'function': 'Friend', 'date': '2015-03-02', 'title': title_sir},
+ {'name': 'Eve', 'login': 'eve', 'color': 3, 'function': 'Eavesdropper', 'date': '2015-03-20', 'title': title_lady},
+ {'name': 'Nab', 'login': 'nab', 'color': -3, 'function': '5$ Wrench', 'date': '2014-09-10', 'title': title_sir},
+ {'name': 'Nab', 'login': 'nab-she', 'color': 6, 'function': '5$ Wrench', 'date': '2014-01-02', 'title': title_lady},
+ ]
+ ids = [self.res_users.create(cr, uid, u) for u in test_users]
+ domain = [('id', 'in', ids)]
- groups_data = self.res_users.read_group(cr, uid, domain=[('login', 'in', ('alice', 'bob', 'eve'))], fields=['name', 'color', 'function'], groupby='function')
- self.assertEqual(len(groups_data), 2, "Incorrect number of results when grouping on a field")
+ # group on local char field without domain and without active_test (-> empty WHERE clause)
+ groups_data = self.res_users.read_group(cr, uid, [], fields=['login'], groupby=['login'], orderby='login DESC', context={'active_test': False})
+ self.assertGreater(len(groups_data), 6, "Incorrect number of results when grouping on a field")
+
+ # group on local char field with limit
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['login'], groupby=['login'], orderby='login DESC', limit=3, offset=3)
+ self.assertEqual(len(groups_data), 3, "Incorrect number of results when grouping on a field with limit")
+ self.assertEqual(['bob', 'alice2', 'alice'], [g['login'] for g in groups_data], 'Result mismatch')
+
+ # group on inherited char field, aggregate on int field (second groupby ignored on purpose)
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['name', 'color', 'function'], groupby=['function', 'login'])
+ self.assertEqual(len(groups_data), 3, "Incorrect number of results when grouping on a field")
+ self.assertEqual(['5$ Wrench', 'Eavesdropper', 'Friend'], [g['function'] for g in groups_data], 'incorrect read_group order')
for group_data in groups_data:
- self.assertIn('color', group_data, "Aggregated data for the column 'color' is not present in read_group return values")
- self.assertEqual(group_data['color'], 3, "Incorrect sum for aggregated data for the column 'color'")
+ self.assertIn('color', group_data, "Aggregated data for the column 'color' is not present in read_group return values")
+ self.assertEqual(group_data['color'], 3, "Incorrect sum for aggregated data for the column 'color'")
+
+ # group on inherited char field, reverse order
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['name', 'color'], groupby='name', orderby='name DESC')
+ self.assertEqual(['Nab', 'Eve', 'Bob', 'Alice'], [g['name'] for g in groups_data], 'Incorrect ordering of the list')
+
+ # group on int field, default ordering
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['color'], groupby='color')
+ self.assertEqual([-3, 0, 1, 2, 3, 6], [g['color'] for g in groups_data], 'Incorrect ordering of the list')
+
+ # multi group, second level is int field, should still be summed in first level grouping
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['name', 'color'], groupby=['name', 'color'], orderby='name DESC')
+ self.assertEqual(['Nab', 'Eve', 'Bob', 'Alice'], [g['name'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([3, 3, 2, 1], [g['color'] for g in groups_data], 'Incorrect ordering of the list')
+
+ # group on inherited char field, multiple orders with directions
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['name', 'color'], groupby='name', orderby='color DESC, name')
+ self.assertEqual(len(groups_data), 4, "Incorrect number of results when grouping on a field")
+ self.assertEqual(['Eve', 'Nab', 'Bob', 'Alice'], [g['name'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([1, 2, 1, 2], [g['name_count'] for g in groups_data], 'Incorrect number of results')
+
+ # group on inherited date column (res_partner.date) -> Year-Month, default ordering
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['function', 'color', 'date'], groupby=['date'])
+ self.assertEqual(len(groups_data), 4, "Incorrect number of results when grouping on a field")
+ self.assertEqual(['January 2014', 'September 2014', 'January 2015', 'March 2015'], [g['date'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([1, 1, 1, 3], [g['date_count'] for g in groups_data], 'Incorrect number of results')
+
+ # group on inherited date column (res_partner.date) -> Year-Month, custom order
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['function', 'color', 'date'], groupby=['date'], orderby='date DESC')
+ self.assertEqual(len(groups_data), 4, "Incorrect number of results when grouping on a field")
+ self.assertEqual(['March 2015', 'January 2015', 'September 2014', 'January 2014'], [g['date'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([3, 1, 1, 1], [g['date_count'] for g in groups_data], 'Incorrect number of results')
+
+ # group on inherited many2one (res_partner.title), default order
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['function', 'color', 'title'], groupby=['title'])
+ self.assertEqual(len(groups_data), 2, "Incorrect number of results when grouping on a field")
+ # m2o is returned as a (id, label) pair
+ self.assertEqual([(title_lady, 'Lady'), (title_sir, 'Sir')], [g['title'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([4, 2], [g['title_count'] for g in groups_data], 'Incorrect number of results')
+ self.assertEqual([10, -1], [g['color'] for g in groups_data], 'Incorrect aggregation of int column')
+
+ # group on inherited many2one (res_partner.title), reversed natural order
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['function', 'color', 'title'], groupby=['title'], orderby="title desc")
+ self.assertEqual(len(groups_data), 2, "Incorrect number of results when grouping on a field")
+ # m2o is returned as a (id, label) pair
+ self.assertEqual([(title_sir, 'Sir'), (title_lady, 'Lady')], [g['title'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([2, 4], [g['title_count'] for g in groups_data], 'Incorrect number of results')
+ self.assertEqual([-1, 10], [g['color'] for g in groups_data], 'Incorrect aggregation of int column')
+
+ # group on inherited many2one (res_partner.title), multiple orders with m2o in second position
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['function', 'color', 'title'], groupby=['title'], orderby="color desc, title desc")
+ self.assertEqual(len(groups_data), 2, "Incorrect number of results when grouping on a field")
+ # m2o is returned as a (id, label) pair
+ self.assertEqual([(title_lady, 'Lady'), (title_sir, 'Sir')], [g['title'] for g in groups_data], 'Incorrect ordering of the result')
+ self.assertEqual([4, 2], [g['title_count'] for g in groups_data], 'Incorrect number of results')
+ self.assertEqual([10, -1], [g['color'] for g in groups_data], 'Incorrect aggregation of int column')
+
+ # group on inherited many2one (res_partner.title), ordered by other inherited field (color)
+ groups_data = self.res_users.read_group(cr, uid, domain, fields=['function', 'color', 'title'], groupby=['title'], orderby='color')
+ self.assertEqual(len(groups_data), 2, "Incorrect number of results when grouping on a field")
+ # m2o is returned as a (id, label) pair
+ self.assertEqual([(title_sir, 'Sir'), (title_lady, 'Lady')], [g['title'] for g in groups_data], 'Incorrect ordering of the list')
+ self.assertEqual([2, 4], [g['title_count'] for g in groups_data], 'Incorrect number of results')
+ self.assertEqual([-1, 10], [g['color'] for g in groups_data], 'Incorrect aggregation of int column')
+
class test_partner_recursion(common.TransactionCase):
@@ -375,6 +457,59 @@ class test_translation(common.TransactionCase):
fr_context_cat = self.res_category.browse(cr, uid, self.new_fr_cat_id, context={'lang':'fr_FR'})
self.assertEqual(fr_context_cat.name, 'Clients (copie)', "Did not used default value for translated value")
+test_state = None
+#: Stores state information across multiple test classes
+def setUpModule():
+ global test_state
+ test_state = {}
+def tearDownModule():
+ global test_state
+ test_state = None
+
+class TestPhaseInstall00(unittest2.TestCase):
+ """
+ WARNING: Relies on tests being run in alphabetical order
+ """
+ @classmethod
+ def setUpClass(cls):
+ cls.state = None
+
+ def test_00_setup(self):
+ type(self).state = 'init'
+
+ @common.at_install(False)
+ def test_01_no_install(self):
+ type(self).state = 'error'
+
+ def test_02_check(self):
+ self.assertEqual(
+ self.state, 'init',
+ "Testcase state should not have been transitioned from 00")
+
+class TestPhaseInstall01(unittest2.TestCase):
+ at_install = False
+
+ def test_default_norun(self):
+ self.fail("An unmarket test in a non-at-install case should not run")
+
+ @common.at_install(True)
+ def test_set_run(self):
+ test_state['set_at_install'] = True
+
+class TestPhaseInstall02(unittest2.TestCase):
+ """
+ Can't put the check for test_set_run in the same class: if
+ @common.at_install does not work for test_set_run, it won't work for
+ the other one either. Thus move checking of whether test_set_run has
+ correctly run indeed to a separate class.
+
+ Warning: relies on *classes* being run in alphabetical order in test
+ modules
+ """
+ def test_check_state(self):
+ self.assertTrue(
+ test_state.get('set_at_install'),
+ "The flag should be set if local overriding of runstate")
if __name__ == '__main__':
unittest2.main()
diff --git a/openerp/addons/base/tests/test_fields.py b/openerp/addons/base/tests/test_fields.py
index 6dd016ccaf9..ce34bceb014 100644
--- a/openerp/addons/base/tests/test_fields.py
+++ b/openerp/addons/base/tests/test_fields.py
@@ -120,4 +120,110 @@ class TestRelatedField(common.TransactionCase):
# restore res.partner fields
self.partner._columns = old_columns
-# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
+
+class TestPropertyField(common.TransactionCase):
+
+ def setUp(self):
+ super(TestPropertyField, self).setUp()
+ self.user = self.registry('res.users')
+ self.partner = self.registry('res.partner')
+ self.company = self.registry('res.company')
+ self.country = self.registry('res.country')
+ self.property = self.registry('ir.property')
+ self.imd = self.registry('ir.model.data')
+
+ def test_1_property_multicompany(self):
+ cr, uid = self.cr, self.uid
+
+ parent_company_id = self.imd.get_object_reference(cr, uid, 'base', 'main_company')[1]
+ country_be = self.imd.get_object_reference(cr, uid, 'base', 'be')[1]
+ country_fr = self.imd.get_object_reference(cr, uid, 'base', 'fr')[1]
+ group_partner_manager = self.imd.get_object_reference(cr, uid, 'base', 'group_partner_manager')[1]
+ group_multi_company = self.imd.get_object_reference(cr, uid, 'base', 'group_multi_company')[1]
+
+ sub_company = self.company.create(cr, uid, {'name': 'MegaCorp', 'parent_id': parent_company_id})
+ alice = self.user.create(cr, uid, {'name': 'Alice',
+ 'login':'alice',
+ 'email':'alice@youcompany.com',
+ 'company_id':parent_company_id,
+ 'company_ids':[(6, 0, [parent_company_id, sub_company])],
+ 'country_id':country_be,
+ 'groups_id': [(6, 0, [group_partner_manager, group_multi_company])]
+ })
+ bob = self.user.create(cr, uid, {'name': 'Bob',
+ 'login':'bob',
+ 'email':'bob@megacorp.com',
+ 'company_id':sub_company,
+ 'company_ids':[(6, 0, [parent_company_id, sub_company])],
+ 'country_id':country_fr,
+ 'groups_id': [(6, 0, [group_partner_manager, group_multi_company])]
+ })
+
+ self.partner._columns = dict(self.partner._columns)
+ self.partner._columns.update({
+ 'property_country': fields.property(type='many2one', relation="res.country", string="Country by company"),
+ })
+ self.partner._all_columns.update({
+ 'property_country': fields.column_info('property_country', self.partner._columns['property_country'], None, None, None),
+ })
+ self.partner._field_create(cr)
+
+ partner_id = self.partner.create(cr, alice, {
+ 'name': 'An International Partner',
+ 'email': 'partner@example.com',
+ 'company_id': parent_company_id,
+ })
+ self.partner.write(cr, bob, [partner_id], {'property_country': country_fr})
+ self.assertEqual(self.partner.browse(cr, bob, partner_id).property_country.id, country_fr, "Bob does not see the value he has set on the property field")
+
+ self.partner.write(cr, alice, [partner_id], {'property_country': country_be})
+ self.assertEqual(self.partner.browse(cr, alice, partner_id).property_country.id, country_be, "Alice does not see the value he has set on the property field")
+ self.assertEqual(self.partner.browse(cr, bob, partner_id).property_country.id, country_fr, "Changes made by Alice have overwritten Bob's value")
+
+
+class TestHtmlField(common.TransactionCase):
+
+ def setUp(self):
+ super(TestHtmlField, self).setUp()
+ self.partner = self.registry('res.partner')
+
+ def test_00_sanitize(self):
+ cr, uid, context = self.cr, self.uid, {}
+ old_columns = self.partner._columns
+ self.partner._columns = dict(old_columns)
+ self.partner._columns.update({
+ 'comment': fields.html('Secure Html', sanitize=False),
+ })
+ some_ugly_html = """
Oops this should maybe be sanitized
+% if object.some_field and not object.oriented:
+
+ % if object.other_field:
+
+ ${object.mako_thing}
+
+
+ % endif
+
+%if object.dummy_field:
+
Youpie
+%endif"""
+
+ pid = self.partner.create(cr, uid, {
+ 'name': 'Raoul Poilvache',
+ 'comment': some_ugly_html,
+ }, context=context)
+ partner = self.partner.browse(cr, uid, pid, context=context)
+ self.assertEqual(partner.comment, some_ugly_html, 'Error in HTML field: content was sanitized but field has sanitize=False')
+
+ self.partner._columns.update({
+ 'comment': fields.html('Unsecure Html', sanitize=True),
+ })
+ self.partner.write(cr, uid, [pid], {
+ 'comment': some_ugly_html,
+ }, context=context)
+ partner = self.partner.browse(cr, uid, pid, context=context)
+ # sanitize should have closed tags left open in the original html
+ self.assertIn('
', partner.comment, 'Error in HTML field: content does not seem to have been sanitized despise sanitize=True')
+ self.assertIn('', partner.comment, 'Error in HTML field: content does not seem to have been sanitized despise sanitize=True')
+
+ self.partner._columns = old_columns
diff --git a/openerp/addons/base/tests/test_ir_actions.py b/openerp/addons/base/tests/test_ir_actions.py
index 04f67617ad6..baea8299f9e 100644
--- a/openerp/addons/base/tests/test_ir_actions.py
+++ b/openerp/addons/base/tests/test_ir_actions.py
@@ -97,7 +97,8 @@ class TestServerActions(TestServerActionsBase):
self.ir_actions_server.write(cr, uid, self.act_id, {
'state': 'code',
'code': """partner_name = obj.name + '_code'
-self.pool["res.partner"].create(cr, uid, {"name": partner_name}, context=context)"""
+self.pool["res.partner"].create(cr, uid, {"name": partner_name}, context=context)
+workflow"""
})
run_res = self.ir_actions_server.run(cr, uid, [self.act_id], context=self.context)
self.assertFalse(run_res, 'ir_actions_server: code server action correctly finished should return False')
diff --git a/openerp/addons/base/tests/test_ir_attachment.py b/openerp/addons/base/tests/test_ir_attachment.py
index 4d96ec42b28..891b38b7dc3 100644
--- a/openerp/addons/base/tests/test_ir_attachment.py
+++ b/openerp/addons/base/tests/test_ir_attachment.py
@@ -1,89 +1,92 @@
import hashlib
import os
-import unittest2
-
import openerp
import openerp.tests.common
-class test_ir_attachment(openerp.tests.common.TransactionCase):
+HASH_SPLIT = 2 # FIXME: testing implementations detail is not a good idea
- def test_00_attachment_flow(self):
+class test_ir_attachment(openerp.tests.common.TransactionCase):
+ def setUp(self):
+ super(test_ir_attachment, self).setUp()
registry, cr, uid = self.registry, self.cr, self.uid
- root_path = openerp.tools.config['root_path']
- ira = registry('ir.attachment')
+ self.ira = registry('ir.attachment')
+ self.filestore = self.ira._filestore(cr, uid)
# Blob1
- blob1 = 'blob1'
- blob1_b64 = blob1.encode('base64')
- blob1_hash = hashlib.sha1(blob1).hexdigest()
- blob1_fname = blob1_hash[:3] + '/' + blob1_hash
+ self.blob1 = 'blob1'
+ self.blob1_b64 = self.blob1.encode('base64')
+ blob1_hash = hashlib.sha1(self.blob1).hexdigest()
+ self.blob1_fname = blob1_hash[:HASH_SPLIT] + '/' + blob1_hash
# Blob2
blob2 = 'blob2'
- blob2_b64 = blob2.encode('base64')
- blob2_hash = hashlib.sha1(blob2).hexdigest()
- blob2_fname = blob2_hash[:3] + '/' + blob2_hash
+ self.blob2_b64 = blob2.encode('base64')
+
+ def test_01_store_in_db(self):
+ registry, cr, uid = self.registry, self.cr, self.uid
+
+ # force storing in database
+ registry('ir.config_parameter').set_param(cr, uid, 'ir_attachment.location', 'db')
# 'ir_attachment.location' is undefined test database storage
- a1 = ira.create(cr, uid, {'name': 'a1', 'datas': blob1_b64})
- a1_read = ira.read(cr, uid, [a1], ['datas'])
- self.assertEqual(a1_read[0]['datas'], blob1_b64)
+ a1 = self.ira.create(cr, uid, {'name': 'a1', 'datas': self.blob1_b64})
+ a1_read = self.ira.read(cr, uid, [a1], ['datas'])
+ self.assertEqual(a1_read[0]['datas'], self.blob1_b64)
- cr.execute("select id,db_datas from ir_attachment where id = %s", (a1,) )
- a1_db_datas = str(cr.fetchall()[0][1])
- self.assertEqual(a1_db_datas, blob1_b64)
+ a1_db_datas = self.ira.browse(cr, uid, a1).db_datas
+ self.assertEqual(a1_db_datas, self.blob1_b64)
- # define a location for filestore
- registry('ir.config_parameter').set_param(cr, uid, 'ir_attachment.location', 'file:///filestore')
+ def test_02_store_on_disk(self):
+ registry, cr, uid = self.registry, self.cr, self.uid
- # Test file storage
- a2 = ira.create(cr, uid, {'name': 'a2', 'datas': blob1_b64})
- a2_read = ira.read(cr, uid, [a2], ['datas'])
- self.assertEqual(a2_read[0]['datas'], blob1_b64)
+ a2 = self.ira.create(cr, uid, {'name': 'a2', 'datas': self.blob1_b64})
+ a2_store_fname = self.ira.browse(cr, uid, a2).store_fname
- cr.execute("select id,store_fname from ir_attachment where id = %s", (a2,) )
- a2_store_fname = cr.fetchall()[0][1]
- self.assertEqual(a2_store_fname, blob1_fname)
+ self.assertEqual(a2_store_fname, self.blob1_fname)
+ self.assertTrue(os.path.isfile(os.path.join(self.filestore, a2_store_fname)))
- a2_fn = os.path.join(root_path, 'filestore', cr.dbname, blob1_hash[:3], blob1_hash)
- fc = file(a2_fn).read()
- self.assertEqual(fc, blob1)
+ def test_03_no_duplication(self):
+ registry, cr, uid = self.registry, self.cr, self.uid
- # create a3 with same blob
- a3 = ira.create(cr, uid, {'name': 'a3', 'datas': blob1_b64})
- a3_read = ira.read(cr, uid, [a3], ['datas'])
- self.assertEqual(a3_read[0]['datas'], blob1_b64)
+ a2 = self.ira.create(cr, uid, {'name': 'a2', 'datas': self.blob1_b64})
+ a2_store_fname = self.ira.browse(cr, uid, a2).store_fname
+
+ a3 = self.ira.create(cr, uid, {'name': 'a3', 'datas': self.blob1_b64})
+ a3_store_fname = self.ira.browse(cr, uid, a3).store_fname
- cr.execute("select id,store_fname from ir_attachment where id = %s", (a3,) )
- a3_store_fname = cr.fetchall()[0][1]
self.assertEqual(a3_store_fname, a2_store_fname)
- # create a4 blob2
- a4 = ira.create(cr, uid, {'name': 'a4', 'datas': blob2_b64})
- a4_read = ira.read(cr, uid, [a4], ['datas'])
- self.assertEqual(a4_read[0]['datas'], blob2_b64)
+ def test_04_keep_file(self):
+ registry, cr, uid = self.registry, self.cr, self.uid
- a4_fn = os.path.join(root_path, 'filestore', cr.dbname, blob2_hash[:3], blob2_hash)
- self.assertTrue(os.path.isfile(a4_fn))
+ a2 = self.ira.create(cr, uid, {'name': 'a2', 'datas': self.blob1_b64})
+ a3 = self.ira.create(cr, uid, {'name': 'a3', 'datas': self.blob1_b64})
- # delete a3 but file stays
- ira.unlink(cr, uid, [a3])
+ a2_store_fname = self.ira.browse(cr, uid, a2).store_fname
+ a2_fn = os.path.join(self.filestore, a2_store_fname)
+
+ self.ira.unlink(cr, uid, [a3])
self.assertTrue(os.path.isfile(a2_fn))
# delete a2 it is unlinked
- ira.unlink(cr, uid, [a2])
+ self.ira.unlink(cr, uid, [a2])
self.assertFalse(os.path.isfile(a2_fn))
- # update a4 blob2 by blob1
- ira.write(cr, uid, [a4], {'datas': blob1_b64})
- a4_read = ira.read(cr, uid, [a4], ['datas'])
- self.assertEqual(a4_read[0]['datas'], blob1_b64)
+ def test_05_change_data_change_file(self):
+ registry, cr, uid = self.registry, self.cr, self.uid
+
+ a2 = self.ira.create(cr, uid, {'name': 'a2', 'datas': self.blob1_b64})
+ a2_store_fname = self.ira.browse(cr, uid, a2).store_fname
+ a2_fn = os.path.join(self.filestore, a2_store_fname)
- # file of a4 disapear and a2 reappear
- self.assertFalse(os.path.isfile(a4_fn))
self.assertTrue(os.path.isfile(a2_fn))
- # everybody applause
+ self.ira.write(cr, uid, [a2], {'datas': self.blob2_b64})
+ self.assertFalse(os.path.isfile(a2_fn))
+ new_a2_store_fname = self.ira.browse(cr, uid, a2).store_fname
+ self.assertNotEqual(a2_store_fname, new_a2_store_fname)
+ new_a2_fn = os.path.join(self.filestore, new_a2_store_fname)
+ self.assertTrue(os.path.isfile(new_a2_fn))
diff --git a/openerp/addons/base/tests/test_ir_sequence.py b/openerp/addons/base/tests/test_ir_sequence.py
index bc428d7f647..e925fffa3b1 100644
--- a/openerp/addons/base/tests/test_ir_sequence.py
+++ b/openerp/addons/base/tests/test_ir_sequence.py
@@ -8,6 +8,7 @@
# OPENERP_DATABASE=yy PYTHONPATH=../:. unit2 test_ir_sequence
# This assume an existing database.
import psycopg2
+import psycopg2.errorcodes
import unittest2
import openerp
@@ -111,11 +112,11 @@ class test_ir_sequence_no_gap(unittest2.TestCase):
cr0 = cursor()
cr1 = cursor()
cr1._default_log_exceptions = False # Prevent logging a traceback
- msg_re = '^could not obtain lock on row in relation "ir_sequence"$'
- with self.assertRaisesRegexp(psycopg2.OperationalError, msg_re):
+ with self.assertRaises(psycopg2.OperationalError) as e:
n0 = registry('ir.sequence').next_by_code(cr0, ADMIN_USER_ID, 'test_sequence_type_2', {})
assert n0
n1 = registry('ir.sequence').next_by_code(cr1, ADMIN_USER_ID, 'test_sequence_type_2', {})
+ self.assertEqual(e.exception.pgcode, psycopg2.errorcodes.LOCK_NOT_AVAILABLE, msg="postgresql returned an incorrect errcode")
cr0.close()
cr1.close()
diff --git a/openerp/addons/base/tests/test_qweb.py b/openerp/addons/base/tests/test_qweb.py
index 71beaab605a..ca1503a0c24 100644
--- a/openerp/addons/base/tests/test_qweb.py
+++ b/openerp/addons/base/tests/test_qweb.py
@@ -14,7 +14,8 @@ class TestQWebTField(common.TransactionCase):
self.engine = self.registry('ir.qweb')
def context(self, values):
- return ir_qweb.QWebContext(self.cr, self.uid, values)
+ return ir_qweb.QWebContext(
+ self.cr, self.uid, values, context={'inherit_branding': True})
def test_trivial(self):
field = document.createElement('span')
diff --git a/openerp/addons/base/tests/test_ui.py b/openerp/addons/base/tests/test_ui.py
deleted file mode 100644
index 63136b36a31..00000000000
--- a/openerp/addons/base/tests/test_ui.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-
-import openerp
-
-class TestUi(openerp.tests.HttpCase):
- def test_js(self):
- self.phantom_js('/',"console.log('ok')","console", login=None)
-
- def test_jsfile(self):
- self.phantom_jsfile(os.path.join(os.path.dirname(__file__), 'test_ui_hello.js'))
-
-# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
diff --git a/openerp/addons/base/tests/test_ui_hello.js b/openerp/addons/base/tests/test_ui_hello.js
deleted file mode 100644
index 6a453e947aa..00000000000
--- a/openerp/addons/base/tests/test_ui_hello.js
+++ /dev/null
@@ -1,5 +0,0 @@
-console.log("hello from test_phantom_hello.js");
-console.log("ok");
-// For a failure use:
-//console.log("error");
-phantom.exit();
diff --git a/openerp/addons/base/tests/test_views.py b/openerp/addons/base/tests/test_views.py
index d93734f48cb..06030a84792 100644
--- a/openerp/addons/base/tests/test_views.py
+++ b/openerp/addons/base/tests/test_views.py
@@ -1,6 +1,8 @@
# -*- encoding: utf-8 -*-
from functools import partial
+import unittest2
+
from lxml import etree as ET
from lxml.builder import E
@@ -8,6 +10,24 @@ from openerp.tests import common
Field = E.field
+class ViewCase(common.TransactionCase):
+ def setUp(self):
+ super(ViewCase, self).setUp()
+ self.addTypeEqualityFunc(ET._Element, self.assertTreesEqual)
+
+ def assertTreesEqual(self, n1, n2, msg=None):
+ self.assertEqual(n1.tag, n2.tag)
+ self.assertEqual((n1.text or '').strip(), (n2.text or '').strip(), msg)
+ self.assertEqual((n1.tail or '').strip(), (n2.tail or '').strip(), msg)
+
+ # Because lxml uses ordereddicts in which order is important to
+ # equality (!?!?!?!)
+ self.assertEqual(dict(n1.attrib), dict(n2.attrib), msg)
+
+ for c1, c2 in zip(n1, n2):
+ self.assertTreesEqual(c1, c2, msg)
+
+
class TestNodeLocator(common.BaseCase):
"""
The node locator returns None when it can not find a node, and the first
@@ -98,7 +118,7 @@ class TestNodeLocator(common.BaseCase):
E.foo(attr='1', version='3'))
self.assertIsNone(node)
-class TestViewInheritance(common.TransactionCase):
+class TestViewInheritance(ViewCase):
def arch_for(self, name, view_type='form', parent=None):
""" Generates a trivial view of the specified ``view_type``.
@@ -206,7 +226,7 @@ class TestViewInheritance(common.TransactionCase):
self.View.default_view(
self.cr, self.uid, model=self.model, view_type='graph'))
-class TestApplyInheritanceSpecs(common.TransactionCase):
+class TestApplyInheritanceSpecs(ViewCase):
""" Applies a sequence of inheritance specification nodes to a base
architecture. IO state parameters (cr, uid, model, context) are used for
error reporting
@@ -230,8 +250,8 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
spec, None)
self.assertEqual(
- ET.tostring(self.base_arch),
- ET.tostring(E.form(Field(name="replacement"), string="Title")))
+ self.base_arch,
+ E.form(Field(name="replacement"), string="Title"))
def test_delete(self):
spec = Field(name="target", position="replace")
@@ -241,8 +261,8 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
spec, None)
self.assertEqual(
- ET.tostring(self.base_arch),
- ET.tostring(E.form(string="Title")))
+ self.base_arch,
+ E.form(string="Title"))
def test_insert_after(self):
spec = Field(
@@ -254,12 +274,12 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
spec, None)
self.assertEqual(
- ET.tostring(self.base_arch),
- ET.tostring(E.form(
+ self.base_arch,
+ E.form(
Field(name="target"),
Field(name="inserted"),
string="Title"
- )))
+ ))
def test_insert_before(self):
spec = Field(
@@ -271,11 +291,11 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
spec, None)
self.assertEqual(
- ET.tostring(self.base_arch),
- ET.tostring(E.form(
+ self.base_arch,
+ E.form(
Field(name="inserted"),
Field(name="target"),
- string="Title")))
+ string="Title"))
def test_insert_inside(self):
default = Field(Field(name="inserted"), name="target")
@@ -289,13 +309,13 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
spec, None)
self.assertEqual(
- ET.tostring(self.base_arch),
- ET.tostring(E.form(
+ self.base_arch,
+ E.form(
Field(
Field(name="inserted"),
Field(name="inserted 2"),
name="target"),
- string="Title")))
+ string="Title"))
def test_unpack_data(self):
spec = E.data(
@@ -310,15 +330,15 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
spec, None)
self.assertEqual(
- ET.tostring(self.base_arch),
- ET.tostring(E.form(
+ self.base_arch,
+ E.form(
Field(
Field(name="inserted 0"),
Field(name="inserted 1"),
Field(name="inserted 2"),
Field(name="inserted 3"),
name="target"),
- string="Title")))
+ string="Title"))
def test_invalid_position(self):
spec = Field(
@@ -350,18 +370,18 @@ class TestApplyInheritanceSpecs(common.TransactionCase):
self.base_arch,
spec, None)
-class TestApplyInheritedArchs(common.TransactionCase):
+class TestApplyInheritedArchs(ViewCase):
""" Applies a sequence of modificator archs to a base view
"""
-class TestViewCombined(common.TransactionCase):
+class TestViewCombined(ViewCase):
"""
Test fallback operations of View.read_combined:
* defaults mapping
* ?
"""
-class TestNoModel(common.TransactionCase):
+class TestNoModel(ViewCase):
def test_create_view_nomodel(self):
View = self.registry('ir.ui.view')
view_id = View.create(self.cr, self.uid, {
@@ -411,14 +431,186 @@ class TestNoModel(common.TransactionCase):
'value': translated_text,
})
sarch = View.translate_qweb(self.cr, self.uid, None, self.arch, 'fr_FR')
-
+
self.text_para.text = translated_text
+ self.assertEqual(sarch, self.arch)
+
+class TestTemplating(ViewCase):
+ def setUp(self):
+ import openerp.modules
+ super(TestTemplating, self).setUp()
+ self._pool = openerp.modules.registry.RegistryManager.get(common.DB)
+ self._init = self._pool._init
+ # fuck off
+ self._pool._init = False
+
+ def tearDown(self):
+ self._pool._init = self._init
+ super(TestTemplating, self).tearDown()
+
+ def test_branding_inherit(self):
+ Views = self.registry('ir.ui.view')
+ id = Views.create(self.cr, self.uid, {
+ 'name': "Base view",
+ 'type': 'qweb',
+ 'arch': """
+
+
+ """
+ })
+ id2 = Views.create(self.cr, self.uid, {
+ 'name': "Extension",
+ 'type': 'qweb',
+ 'inherit_id': id,
+ 'arch': """
+
+
+ """
+ })
+
+ arch_string = Views.read_combined(
+ self.cr, self.uid, id, fields=['arch'],
+ context={'inherit_branding': True})['arch']
+
+ arch = ET.fromstring(arch_string)
+ Views.distribute_branding(arch)
+
+ [initial] = arch.xpath('//item[@order=1]')
self.assertEqual(
- ET.tostring(sarch, encoding='utf-8'),
- ET.tostring(self.arch, encoding='utf-8'))
+ str(id),
+ initial.get('data-oe-id'),
+ "initial should come from the root view")
+ self.assertEqual(
+ '/root[1]/item[1]',
+ initial.get('data-oe-xpath'),
+ "initial's xpath should be within the root view only")
+ [second] = arch.xpath('//item[@order=2]')
+ self.assertEqual(
+ str(id2),
+ second.get('data-oe-id'),
+ "second should come from the extension view")
-class test_views(common.TransactionCase):
+ def test_branding_distribute_inner(self):
+ """ Checks that the branding is correctly distributed within a view
+ extension
+ """
+ Views = self.registry('ir.ui.view')
+ id = Views.create(self.cr, self.uid, {
+ 'name': "Base view",
+ 'type': 'qweb',
+ 'arch': """
+
+ """
+ })
+ id2 = Views.create(self.cr, self.uid, {
+ 'name': "Extension",
+ 'type': 'qweb',
+ 'inherit_id': id,
+ 'arch': """
+
+ bar
+
+ """
+ })
+
+ arch_string = Views.read_combined(
+ self.cr, self.uid, id, fields=['arch'],
+ context={'inherit_branding': True})['arch']
+
+ arch = ET.fromstring(arch_string)
+ Views.distribute_branding(arch)
+
+ self.assertEqual(
+ arch,
+ E.root(
+ E.item(
+ E.content("bar", {
+ 't-att-href': "foo",
+ 'data-oe-model': 'ir.ui.view',
+ 'data-oe-id': str(id2),
+ 'data-oe-field': 'arch',
+ 'data-oe-xpath': '/xpath/item/content[1]',
+ }), {
+ 'order': '2',
+ 'data-oe-source-id': str(id)
+ }),
+ E.item({
+ 'order': '1',
+ 'data-oe-model': 'ir.ui.view',
+ 'data-oe-id': str(id),
+ 'data-oe-field': 'arch',
+ 'data-oe-xpath': '/root[1]/item[1]'
+ })
+ )
+ )
+
+ def test_esc_no_branding(self):
+ Views = self.registry('ir.ui.view')
+ id = Views.create(self.cr, self.uid, {
+ 'name': "Base View",
+ 'type': 'qweb',
+ 'arch': """
+
+ """,
+ })
+
+ arch_string = Views.read_combined(
+ self.cr, self.uid, id, fields=['arch'],
+ context={'inherit_branding': True})['arch']
+ arch = ET.fromstring(arch_string)
+ Views.distribute_branding(arch)
+
+ self.assertEqual(arch, E.root(E.item(E.span({'t-esc': "foo"}))))
+
+ def test_ignore_unbrand(self):
+ Views = self.registry('ir.ui.view')
+ id = Views.create(self.cr, self.uid, {
+ 'name': "Base view",
+ 'type': 'qweb',
+ 'arch': """
+
+
+
+ """
+ })
+ id2 = Views.create(self.cr, self.uid, {
+ 'name': "Extension",
+ 'type': 'qweb',
+ 'inherit_id': id,
+ 'arch': """
+
+ bar
+
+ """
+ })
+
+ arch_string = Views.read_combined(
+ self.cr, self.uid, id, fields=['arch'],
+ context={'inherit_branding': True})['arch']
+
+ arch = ET.fromstring(arch_string)
+ Views.distribute_branding(arch)
+
+ self.assertEqual(
+ arch,
+ E.root(
+ E.item(
+ {'t-ignore': 'true', 'order': '1'},
+ E.t({'t-esc': 'foo'}),
+ E.item(
+ {'order': '2', 'data-oe-source-id': str(id)},
+ E.content(
+ {'t-att-href': 'foo'},
+ "bar")
+ )
+ )
+ ),
+ "t-ignore should apply to injected sub-view branding, not just to"
+ " the main view's"
+ )
+
+class test_views(ViewCase):
def test_nonexistent_attribute_removal(self):
Views = self.registry('ir.ui.view')
@@ -534,16 +726,17 @@ class test_views(common.TransactionCase):
})
self.assertEqual(view['type'], 'form')
self.assertEqual(
- ET.tostring(ET.fromstring(
+ ET.fromstring(
view['arch'],
parser=ET.XMLParser(remove_blank_text=True)
- )),
- '')
+ ),
+ E.form(
+ E.p("Replacement data"),
+ E.footer(
+ E.button(name="action_next", type="object", string="New button"),
+ thing="bob"
+ ),
+ string="Replacement title", version="7.0"))
def test_view_inheritance_divergent_models(self):
Views = self.registry('ir.ui.view')
@@ -601,14 +794,13 @@ class test_views(common.TransactionCase):
})
self.assertEqual(view['type'], 'form')
self.assertEqual(
- ET.tostring(ET.fromstring(
+ ET.fromstring(
view['arch'],
parser=ET.XMLParser(remove_blank_text=True)
- )),
- '')
-
+ ),
+ E.form(
+ E.p("Replacement data"),
+ E.footer(
+ E.button(name="action_next", type="object", string="New button")),
+ string="Replacement title", version="7.0"
+ ))
diff --git a/openerp/addons/base/tests/test_xmlrpc.py b/openerp/addons/base/tests/test_xmlrpc.py
index ab1d3821c40..854e345078a 100644
--- a/openerp/addons/base/tests/test_xmlrpc.py
+++ b/openerp/addons/base/tests/test_xmlrpc.py
@@ -3,26 +3,23 @@ import time
import unittest2
import xmlrpclib
-from openerp.tests import common
+import openerp
-DB = common.DB
-ADMIN_USER = common.ADMIN_USER
-ADMIN_USER_ID = common.ADMIN_USER_ID
-ADMIN_PASSWORD = common.ADMIN_PASSWORD
+DB = openerp.tests.common.DB
-class test_xmlrpc(common.HttpCase):
+class test_xmlrpc(openerp.tests.common.HttpCase):
def test_01_xmlrpc_login(self):
""" Try to login on the common service. """
- uid = self.xmlrpc_common.login(DB, ADMIN_USER, ADMIN_PASSWORD)
- self.assertTrue(uid == ADMIN_USER_ID)
+ uid = self.xmlrpc_common.login(DB, 'admin', 'admin')
+ self.assertTrue(uid == 1)
def test_xmlrpc_ir_model_search(self):
""" Try a search on the object service. """
o = self.xmlrpc_object
- ids = o.execute(DB, ADMIN_USER_ID, ADMIN_PASSWORD, 'ir.model', 'search', [])
+ ids = o.execute(DB, 1, 'admin', 'ir.model', 'search', [])
self.assertIsInstance(ids, list)
- ids = o.execute(DB, ADMIN_USER_ID, ADMIN_PASSWORD, 'ir.model', 'search', [], {})
+ ids = o.execute(DB, 1, 'admin', 'ir.model', 'search', [], {})
self.assertIsInstance(ids, list)
# This test was written to test the creation of a new RPC endpoint, not
diff --git a/openerp/addons/test_converter/tests/test_html.py b/openerp/addons/test_converter/tests/test_html.py
index 2f0896990ea..3ef6566e829 100644
--- a/openerp/addons/test_converter/tests/test_html.py
+++ b/openerp/addons/test_converter/tests/test_html.py
@@ -112,11 +112,14 @@ class TestCurrencyExport(TestExport):
'widget': 'monetary',
'display_currency': 'c2'
}
+ context = dict(inherit_branding=True)
converted = converter.to_html(
self.cr, self.uid, 'value', obj, options,
doc.createElement('span'),
{'field': 'obj.value', 'field-options': json.dumps(options)},
- '', ir_qweb.QWebContext(self.cr, self.uid, {'obj': obj, 'c2': dest, }))
+ '', ir_qweb.QWebContext(self.cr, self.uid, {'obj': obj, 'c2': dest, }),
+ context=context,
+ )
return converted
def test_currency_post(self):
diff --git a/openerp/addons/test_impex/tests/test_export.py b/openerp/addons/test_impex/tests/test_export.py
index 26219b36d3b..995d69471d6 100644
--- a/openerp/addons/test_impex/tests/test_export.py
+++ b/openerp/addons/test_impex/tests/test_export.py
@@ -309,8 +309,9 @@ class test_m2o(CreatorCase):
def test_external_id(self):
integer_id = self.registry('export.integer').create(
self.cr, openerp.SUPERUSER_ID, {'value': 42})
- # __export__.$class.$id
- external_id = u'__export__.export_many2one_%d' % integer_id
+ # Expecting the m2o target model name in the external id,
+ # not this model's name
+ external_id = u'__export__.export_integer_%d' % integer_id
self.assertEqual(
self.export(integer_id, fields=['value/id']),
[[external_id]])
diff --git a/openerp/cli/server.py b/openerp/cli/server.py
index 004cb1ab8bb..42d920da9aa 100644
--- a/openerp/cli/server.py
+++ b/openerp/cli/server.py
@@ -72,7 +72,7 @@ def report_configuration():
"""
config = openerp.tools.config
_logger.info("OpenERP version %s", __version__)
- for name, value in [('addons paths', config['addons_path']),
+ for name, value in [('addons paths', openerp.modules.module.ad_paths),
('database hostname', config['db_host'] or 'localhost'),
('database port', config['db_port'] or '5432'),
('database user', config['db_user'])]:
diff --git a/openerp/http.py b/openerp/http.py
index fe5b113d286..4f6a6cdd86a 100644
--- a/openerp/http.py
+++ b/openerp/http.py
@@ -129,12 +129,14 @@ class WebRequest(object):
self.session_id = httprequest.session.sid
self.disable_db = False
self.uid = None
- self.func = None
- self.func_arguments = {}
+ self.endpoint = None
self.auth_method = None
self._cr_cm = None
self._cr = None
- self.func_request_type = None
+
+ # prevents transaction commit, use when you catch an exception during handling
+ self._failed = None
+
# set db/uid trackers - they're cleaned up at the WSGI
# dispatching phase in openerp.service.wsgi_server.application
if self.db:
@@ -168,9 +170,9 @@ class WebRequest(object):
"""
# some magic to lazy create the cr
if not self._cr:
- if openerp.tools.config['test_enable'] and self.session_id in openerp.tests.common.HTTP_SESSION:
- self._cr = openerp.tests.common.HTTP_SESSION[self.session_id]
- else:
+ # Test cursors
+ self._cr = openerp.tests.common.acquire_test_cursor(self.session_id)
+ if not self._cr:
self._cr = self.registry.db.cursor()
return self._cr
@@ -180,49 +182,53 @@ class WebRequest(object):
def __exit__(self, exc_type, exc_value, traceback):
_request_stack.pop()
- if self._cr and not (openerp.tools.config['test_enable'] and self.session_id in openerp.tests.common.HTTP_SESSION):
- if exc_type is None:
- self._cr.commit()
- self._cr.close()
+
+ if self._cr:
+ # Dont close test cursors
+ if not openerp.tests.common.release_test_cursor(self._cr):
+ if exc_type is None and not self._failed:
+ self._cr.commit()
+ else:
+ # just to be explicit - happens at close() anyway
+ self._cr.rollback()
+ self._cr.close()
# just to be sure no one tries to re-use the request
self.disable_db = True
self.uid = None
- def set_handler(self, func, arguments, auth):
+ def set_handler(self, endpoint, arguments, auth):
# is this needed ?
arguments = dict((k, v) for k, v in arguments.iteritems()
if not k.startswith("_ignored_"))
- self.func = func
- self.func_request_type = func.routing['type']
- self.func_arguments = arguments
+ endpoint.arguments = arguments
+ self.endpoint = endpoint
self.auth_method = auth
def _call_function(self, *args, **kwargs):
request = self
- if self.func_request_type != self._request_type:
+ if self.endpoint.routing['type'] != self._request_type:
raise Exception("%s, %s: Function declared as capable of handling request of type '%s' but called with a request of type '%s'" \
- % (self.func, self.httprequest.path, self.func_request_type, self._request_type))
+ % (self.endpoint.original, self.httprequest.path, self.endpoint.routing['type'], self._request_type))
- kwargs.update(self.func_arguments)
+ kwargs.update(self.endpoint.arguments)
# Backward for 7.0
- if getattr(self.func.method, '_first_arg_is_req', False):
+ if self.endpoint.first_arg_is_req:
args = (request,) + args
+
# Correct exception handling and concurency retry
@service_model.check
def checked_call(___dbname, *a, **kw):
- return self.func(*a, **kw)
-
- # FIXME: code and rollback management could be cleaned
- try:
- if self.db:
- return checked_call(self.db, *args, **kwargs)
- return self.func(*args, **kwargs)
- except Exception:
+ # The decorator can call us more than once if there is an database error. In this
+ # case, the request cursor is unusable. Rollback transaction to create a new one.
if self._cr:
self._cr.rollback()
- raise
+ return self.endpoint(*a, **kw)
+
+ if self.db:
+ return checked_call(self.db, *args, **kwargs)
+ return self.endpoint(*args, **kwargs)
@property
def debug(self):
@@ -262,8 +268,23 @@ def route(route=None, **kw):
else:
routes = [route]
routing['routes'] = routes
- f.routing = routing
- return f
+ @functools.wraps(f)
+ def response_wrap(*args, **kw):
+ response = f(*args, **kw)
+ if isinstance(response, Response) or f.routing_type == 'json':
+ return response
+ elif isinstance(response, werkzeug.wrappers.BaseResponse):
+ response = Response.force_type(response)
+ response.set_default()
+ return response
+ elif isinstance(response, basestring):
+ return Response(response)
+ else:
+ _logger.warn(" returns an invalid response type for an http request" % (f.__module__, f.__name__))
+ return response
+ response_wrap.routing = routing
+ response_wrap.original_func = f
+ return response_wrap
return decorator
class JsonRequest(WebRequest):
@@ -347,21 +368,25 @@ class JsonRequest(WebRequest):
response['id'] = self.jsonrequest.get('id')
response["result"] = self._call_function(**self.params)
except AuthenticationError, e:
- _logger.exception("Exception during JSON request handling.")
+ _logger.exception("JSON-RPC AuthenticationError in %s.", self.httprequest.path)
se = serialize_exception(e)
error = {
'code': 100,
'message': "OpenERP Session Invalid",
'data': se
}
+ self._failed = e # prevent tx commit
except Exception, e:
- _logger.exception("Exception during JSON request handling.")
+ # Mute test cursor error for runbot
+ if not (openerp.tools.config['test_enable'] and isinstance(e, psycopg2.OperationalError)):
+ _logger.exception("JSON-RPC Exception in %s.", self.httprequest.path)
se = serialize_exception(e)
error = {
'code': 200,
'message': "OpenERP Server Error",
'data': se
}
+ self._failed = e # prevent tx commit
if error:
response["error"] = error
@@ -376,7 +401,7 @@ class JsonRequest(WebRequest):
mime = 'application/json'
body = simplejson.dumps(response)
- r = werkzeug.wrappers.Response(body, headers=[('Content-Type', mime), ('Content-Length', len(body))])
+ r = Response(body, headers=[('Content-Type', mime), ('Content-Length', len(body))])
return r
def serialize_exception(e):
@@ -434,23 +459,16 @@ class HttpRequest(WebRequest):
self.params = params
def dispatch(self):
- # TODO: refactor this correctly. This is a quick fix for pos demo.
- if request.httprequest.method == 'OPTIONS' and request.func and request.func.routing.get('cors'):
- response = werkzeug.wrappers.Response(status=200)
- response.headers.set('Access-Control-Allow-Origin', request.func.routing['cors'])
- methods = 'GET, POST'
- if request.func_request_type == 'json':
- methods = 'POST'
- elif request.func.routing.get('methods'):
- methods = ', '.join(request.func.routing['methods'])
- response.headers.set('Access-Control-Allow-Methods', methods)
- response.headers.set('Access-Control-Max-Age',60*60*24)
- response.headers.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept')
- return response
+ if request.httprequest.method == 'OPTIONS' and request.endpoint and request.endpoint.routing.get('cors'):
+ headers = {
+ 'Access-Control-Max-Age': 60 * 60 * 24,
+ 'Access-Control-Allow-Headers': 'Origin, X-Requested-With, Content-Type, Accept'
+ }
+ return Response(status=200, headers=headers)
r = self._call_function(**self.params)
if not r:
- r = werkzeug.wrappers.Response(status=204) # no content
+ r = Response(status=204) # no content
return r
def make_response(self, data, headers=None, cookies=None):
@@ -467,12 +485,24 @@ class HttpRequest(WebRequest):
:type headers: ``[(name, value)]``
:param collections.Mapping cookies: cookies to set on the client
"""
- response = werkzeug.wrappers.Response(data, headers=headers)
+ response = Response(data, headers=headers)
if cookies:
for k, v in cookies.iteritems():
response.set_cookie(k, v)
return response
+ def render(self, template, qcontext=None, **kw):
+ """ Lazy render of QWeb template.
+
+ The actual rendering of the given template will occur at then end of
+ the dispatching. Meanwhile, the template and/or qcontext can be
+ altered or even replaced by a static response.
+
+ :param basestring template: template to render
+ :param dict qcontext: Rendering context to use
+ """
+ return Response(template=template, qcontext=qcontext, **kw)
+
def not_found(self, description=None):
""" Helper for 404 response, return its result from the method
"""
@@ -527,7 +557,15 @@ class Controller(object):
class EndPoint(object):
def __init__(self, method, routing):
self.method = method
+ self.original = getattr(method, 'original_func', method)
self.routing = routing
+ self.arguments = {}
+
+ @property
+ def first_arg_is_req(self):
+ # Backward for 7.0
+ return getattr(self.method, '_first_arg_is_req', False)
+
def __call__(self, *args, **kw):
return self.method(*args, **kw)
@@ -550,9 +588,19 @@ def routing_map(modules, nodb_only, converters=None):
if inspect.ismethod(mv) and hasattr(mv, 'routing'):
routing = dict(type='http', auth='user', methods=None, routes=None)
methods_done = list()
+ routing_type = None
for claz in reversed(mv.im_class.mro()):
fn = getattr(claz, mv.func_name, None)
if fn and hasattr(fn, 'routing') and fn not in methods_done:
+ fn_type = fn.routing.get('type')
+ if not routing_type:
+ routing_type = fn_type
+ else:
+ if fn_type and routing_type != fn_type:
+ _logger.warn("Subclass re-defines with different type than original."
+ " Will use original type: %r", fn.__module__, fn.__name__, routing_type)
+ fn.routing['type'] = routing_type
+ fn.original_func.routing_type = routing_type
methods_done.append(fn)
routing.update(fn.routing)
if not nodb_only or nodb_only == (routing['auth'] == "none"):
@@ -595,7 +643,7 @@ class Service(object):
class Model(object):
"""
.. deprecated:: 8.0
- Use the resistry and cursor in ``openerp.addons.web.http.request`` instead.
+ Use the resistry and cursor in ``openerp.http.request`` instead.
"""
def __init__(self, session, model):
self.session = session
@@ -695,7 +743,7 @@ class OpenERPSession(werkzeug.contrib.sessions.Session):
self.setdefault("uid", None)
self.setdefault("login", None)
self.setdefault("password", None)
- self.setdefault("context", {'tz': "UTC", "uid": None})
+ self.setdefault("context", {})
def get_context(self):
"""
@@ -889,19 +937,51 @@ mimetypes.add_type('application/font-woff', '.woff')
mimetypes.add_type('application/vnd.ms-fontobject', '.eot')
mimetypes.add_type('application/x-font-ttf', '.ttf')
-class LazyResponse(werkzeug.wrappers.Response):
- """ Lazy werkzeug response.
- API not yet frozen"""
+class Response(werkzeug.wrappers.Response):
+ """ Response object passed through controller route chain.
- def __init__(self, callback, status_code=None, **kwargs):
- super(LazyResponse, self).__init__(mimetype='text/html')
- if status_code:
- self.status_code = status_code
- self.callback = callback
- self.params = kwargs
- def process(self):
- response = self.callback(**self.params)
- self.response.append(response)
+ In addition to the werkzeug.wrappers.Response parameters, this
+ classe's constructor can take the following additional parameters
+ for QWeb Lazy Rendering.
+
+ :param basestring template: template to render
+ :param dict qcontext: Rendering context to use
+ :param int uid: User id to use for the ir.ui.view render call
+ """
+ default_mimetype = 'text/html'
+ def __init__(self, *args, **kw):
+ template = kw.pop('template', None)
+ qcontext = kw.pop('qcontext', None)
+ uid = kw.pop('uid', None)
+ super(Response, self).__init__(*args, **kw)
+ self.set_default(template, qcontext, uid)
+
+ def set_default(self, template=None, qcontext=None, uid=None):
+ self.template = template
+ self.qcontext = qcontext or dict()
+ self.uid = uid
+ # Support for Cross-Origin Resource Sharing
+ if request.endpoint and 'cors' in request.endpoint.routing:
+ self.headers.set('Access-Control-Allow-Origin', request.endpoint.routing['cors'])
+ methods = 'GET, POST'
+ if request.endpoint.routing['type'] == 'json':
+ methods = 'POST'
+ elif request.endpoint.routing.get('methods'):
+ methods = ', '.join(request.endpoint.routing['methods'])
+ self.headers.set('Access-Control-Allow-Methods', methods)
+
+ @property
+ def is_qweb(self):
+ return self.template is not None
+
+ def render(self):
+ view_obj = request.registry["ir.ui.view"]
+ uid = self.uid or request.uid or openerp.SUPERUSER_ID
+ return view_obj.render(request.cr, uid, self.template, self.qcontext, context=request.context)
+
+ def flatten(self):
+ self.response.append(self.render())
+ self.template = None
class DisableCacheMiddleware(object):
def __init__(self, app):
@@ -925,33 +1005,12 @@ class DisableCacheMiddleware(object):
start_response(status, new_headers)
return self.app(environ, start_wrapped)
-def session_path():
- try:
- import pwd
- username = pwd.getpwuid(os.geteuid()).pw_name
- except ImportError:
- try:
- username = getpass.getuser()
- except Exception:
- username = "unknown"
- path = os.path.join(tempfile.gettempdir(), "oe-sessions-" + username)
- try:
- os.mkdir(path, 0700)
- except OSError as exc:
- if exc.errno == errno.EEXIST:
- # directory exists: ensure it has the correct permissions
- # this will fail if the directory is not owned by the current user
- os.chmod(path, 0700)
- else:
- raise
- return path
-
class Root(object):
"""Root WSGI application for the OpenERP Web Client.
"""
def __init__(self):
# Setup http sessions
- path = session_path()
+ path = openerp.tools.config.session_dir
_logger.debug('HTTP sessions stored in: %s', path)
self.session_store = werkzeug.contrib.sessions.FilesystemSessionStore(path, session_class=OpenERPSession)
@@ -1036,9 +1095,9 @@ class Root(object):
return HttpRequest(httprequest)
def get_response(self, httprequest, result, explicit_session):
- if isinstance(result, LazyResponse):
+ if isinstance(result, Response) and result.is_qweb:
try:
- result.process()
+ result.flatten()
except(Exception), e:
if request.db:
result = request.registry['ir.http']._handle_exception(e)
@@ -1046,7 +1105,7 @@ class Root(object):
raise
if isinstance(result, basestring):
- response = werkzeug.wrappers.Response(result, mimetype='text/html')
+ response = Response(result, mimetype='text/html')
else:
response = result
@@ -1061,16 +1120,6 @@ class Root(object):
if not explicit_session and hasattr(response, 'set_cookie'):
response.set_cookie('session_id', httprequest.session.sid, max_age=90 * 24 * 60 * 60)
- # Support for Cross-Origin Resource Sharing
- if request.func and 'cors' in request.func.routing:
- response.headers.set('Access-Control-Allow-Origin', request.func.routing['cors'])
- methods = 'GET, POST'
- if request.func_request_type == 'json':
- methods = 'POST'
- elif request.func.routing.get('methods'):
- methods = ', '.join(request.func.routing['methods'])
- response.headers.set('Access-Control-Allow-Methods', methods)
-
return response
def dispatch(self, environ, start_response):
@@ -1129,7 +1178,7 @@ def db_list(force=False, httprequest=None):
def db_filter(dbs, httprequest=None):
httprequest = httprequest or request.httprequest
- h = httprequest.environ['HTTP_HOST'].split(':')[0]
+ h = httprequest.environ.get('HTTP_HOST', '').split(':')[0]
d = h.split('.')[0]
r = openerp.tools.config['dbfilter'].replace('%h', h).replace('%d', d)
dbs = [i for i in dbs if re.match(r, i)]
@@ -1171,11 +1220,6 @@ class CommonController(Controller):
""" Method used by client APIs to contact OpenERP. """
return openerp.netsvc.dispatch_rpc(service, method, args)
- @route('/gen_session_id', type='json', auth="none")
- def gen_session_id(self):
- nsession = root.session_store.new()
- return nsession.sid
-
root = None
def wsgi_postload():
diff --git a/openerp/modules/loading.py b/openerp/modules/loading.py
index 7ca0a6785d6..681d8534c05 100644
--- a/openerp/modules/loading.py
+++ b/openerp/modules/loading.py
@@ -187,6 +187,10 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
# Yamel test
report.record_result(load_test(module_name, idref, mode))
# Python tests
+ ir_http = registry['ir.http']
+ if hasattr(ir_http, '_routing_map'):
+ # Force routing map to be rebuilt between each module test suite
+ del(ir_http._routing_map)
report.record_result(openerp.modules.module.run_unit_tests(module_name, cr.dbname))
processed_modules.append(package.name)
diff --git a/openerp/modules/module.py b/openerp/modules/module.py
index e3b8e10cc97..8958813baa2 100644
--- a/openerp/modules/module.py
+++ b/openerp/modules/module.py
@@ -3,7 +3,7 @@
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2009 Tiny SPRL ().
-# Copyright (C) 2010-2012 OpenERP s.a. ().
+# Copyright (C) 2010-2014 OpenERP s.a. ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
@@ -20,15 +20,14 @@
#
##############################################################################
-import base64
+import functools
import imp
import itertools
import logging
import os
import re
import sys
-import types
-from cStringIO import StringIO
+import unittest
from os.path import join as opj
import unittest2
@@ -39,10 +38,6 @@ import openerp.release as release
from openerp.tools.safe_eval import safe_eval as eval
_logger = logging.getLogger(__name__)
-_test_logger = logging.getLogger('openerp.tests')
-
-# addons path ','.joined
-_ad = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'addons') # default addons path (base)
# addons path as a list
ad_paths = []
@@ -50,8 +45,6 @@ ad_paths = []
# Modules already loaded
loaded = []
-_logger = logging.getLogger(__name__)
-
class AddonsImportHook(object):
"""
Import hook to load OpenERP addons from multiple paths.
@@ -70,13 +63,10 @@ class AddonsImportHook(object):
return self # We act as a loader too.
def load_module(self, module_name):
+ if module_name in sys.modules:
+ return sys.modules[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]
-
+ _1, _2, module_part = module_name.split('.')
# Note: we don't support circular import.
f, path, descr = imp.find_module(module_part, ad_paths)
mod = imp.load_module('openerp.addons.' + module_part, f, path, descr)
@@ -96,8 +86,13 @@ def initialize_sys_path():
if ad_paths:
return
- ad_paths = map(lambda m: os.path.abspath(tools.ustr(m.strip())), tools.config['addons_path'].split(','))
- ad_paths.append(os.path.abspath(_ad)) # for get_module_path
+ ad_paths = [tools.config.addons_data_dir]
+ ad_paths += map(lambda m: os.path.abspath(tools.ustr(m.strip())), tools.config['addons_path'].split(','))
+
+ # add base module path
+ base_path = os.path.abspath(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'addons'))
+ ad_paths += [base_path]
+
sys.meta_path.append(AddonsImportHook())
def get_module_path(module, downloaded=False, display_warning=True):
@@ -114,7 +109,7 @@ def get_module_path(module, downloaded=False, display_warning=True):
return opj(adp, module)
if downloaded:
- return opj(_ad, module)
+ return opj(tools.config.addons_data_dir, module)
if display_warning:
_logger.warning('module %s: module not found', module)
return False
@@ -328,7 +323,7 @@ def get_test_modules(module):
# Try to import the module
module = 'openerp.addons.' + module + '.tests'
try:
- m = __import__(module)
+ __import__(module)
except Exception, e:
# If module has no `tests` sub-module, no problem.
if str(e) != 'No module named tests':
@@ -336,15 +331,16 @@ def get_test_modules(module):
return []
# include submodules too
- result = []
- for name in sys.modules:
- if name.startswith(module) and sys.modules[name]:
- result.append(sys.modules[name])
+ result = [mod_obj for name, mod_obj in sys.modules.iteritems()
+ if mod_obj # mod_obj can be None
+ if name.startswith(module)
+ if re.search(r'test_\w+$', name)]
return result
# Use a custom stream object to log the test executions.
class TestStream(object):
- def __init__(self):
+ def __init__(self, logger_name='openerp.tests'):
+ self.logger = logging.getLogger(logger_name)
self.r = re.compile(r'^-*$|^ *... *$|^ok$')
def flush(self):
pass
@@ -356,24 +352,74 @@ class TestStream(object):
if not first:
c = '` ' + c
first = False
- _test_logger.info(c)
+ self.logger.info(c)
+
+current_test = None
def run_unit_tests(module_name, dbname):
"""
- Return True or False if some tests were found and succeeded or failed.
- Return None if no test was found.
+ :returns: ``True`` if all of ``module_name``'s tests succeeded, ``False``
+ if any of them failed.
+ :rtype: bool
"""
+ global current_test
+ current_test = module_name
mods = get_test_modules(module_name)
r = True
for m in mods:
- suite = unittest2.TestSuite()
- for t in unittest2.TestLoader().loadTestsFromModule(m):
- suite.addTest(t)
- _logger.log(logging.INFO, 'module %s: running test %s.', module_name, m.__name__)
- result = unittest2.TextTestRunner(verbosity=2, stream=TestStream()).run(suite)
+ tests = unwrap_suite(unittest2.TestLoader().loadTestsFromModule(m))
+ suite = unittest2.TestSuite(itertools.ifilter(runs_at_install, tests))
+ _logger.info('running %s tests.', m.__name__)
+
+ result = unittest2.TextTestRunner(verbosity=2, stream=TestStream(m.__name__)).run(suite)
+
if not result.wasSuccessful():
r = False
- _logger.error('module %s: at least one error occurred in a test', module_name)
+ _logger.error("Module %s: %d failures, %d errors",
+ module_name, len(result.failures), len(result.errors))
+ current_test = None
return r
+def runs_at(test, hook, default):
+ # by default, tests do not run post install
+ test_runs = getattr(test, hook, default)
+
+ # for a test suite, we're done
+ if not isinstance(test, unittest.TestCase):
+ return test_runs
+
+ # otherwise check the current test method to see it's been set to a
+ # different state
+ method = getattr(test, test._testMethodName)
+ return getattr(method, hook, test_runs)
+
+runs_at_install = functools.partial(runs_at, hook='at_install', default=True)
+runs_post_install = functools.partial(runs_at, hook='post_install', default=False)
+
+def unwrap_suite(test):
+ """
+ Attempts to unpack testsuites (holding suites or cases) in order to
+ generate a single stream of terminals (either test cases or customized
+ test suites). These can then be checked for run/skip attributes
+ individually.
+
+ An alternative would be to use a variant of @unittest2.skipIf with a state
+ flag of some sort e.g. @unittest2.skipIf(common.runstate != 'at_install'),
+ but then things become weird with post_install as tests should *not* run
+ by default there
+ """
+ if isinstance(test, unittest.TestCase):
+ yield test
+ return
+
+ subtests = list(test)
+ # custom test suite (no test cases)
+ if not len(subtests):
+ yield test
+ return
+
+ for item in itertools.chain.from_iterable(
+ itertools.imap(unwrap_suite, subtests)):
+ yield item
+
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
diff --git a/openerp/modules/registry.py b/openerp/modules/registry.py
index a277d4f6402..78b7e5caeab 100644
--- a/openerp/modules/registry.py
+++ b/openerp/modules/registry.py
@@ -209,15 +209,6 @@ class TestRLock(object):
def __exit__(self, type, value, traceback):
self.release()
-# def __enter__(self, *l, **kw):
-# if openerp.tools.config['test_enable']:
-# return
-# return super(TestRlock, self).__enter__(*l, **kw)
-# def __exit__(self, *l, **kw):
-# if openerp.tools.config['test_enable']:
-# return
-# return super(TestRlock, self).__exit__(*l, **kw)
-
class RegistryManager(object):
""" Model registries manager.
diff --git a/openerp/netsvc.py b/openerp/netsvc.py
index 755f6513b25..1e2407a7faf 100644
--- a/openerp/netsvc.py
+++ b/openerp/netsvc.py
@@ -2,7 +2,7 @@
##############################################################################
#
# OpenERP, Open Source Management Solution
-# Copyright (C) 2004-2012 OpenERP SA ()
+# Copyright (C) 2004-2014 OpenERP SA ()
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
@@ -89,7 +89,13 @@ class ColoredFormatter(DBFormatter):
record.levelname = COLOR_PATTERN % (30 + fg_color, 40 + bg_color, record.levelname)
return DBFormatter.format(self, record)
+_logger_init = False
def init_logger():
+ global _logger_init
+ if _logger_init:
+ return
+ _logger_init = True
+
from tools.translate import resetlocale
resetlocale()
@@ -137,6 +143,8 @@ def init_logger():
formatter = DBFormatter(format)
handler.setFormatter(formatter)
+ logging.getLogger().addHandler(handler)
+
# Configure handlers
pseudo_config = PSEUDOCONFIG_MAPPER.get(tools.config['log_level'], [])
@@ -147,11 +155,7 @@ def init_logger():
loggername, level = logconfig_item.split(':')
level = getattr(logging, level, logging.INFO)
logger = logging.getLogger(loggername)
- logger.handlers = []
logger.setLevel(level)
- logger.addHandler(handler)
- if loggername != '':
- logger.propagate = False
for logconfig_item in logging_configurations:
_logger.debug('logger level set: "%s"', logconfig_item)
diff --git a/openerp/osv/fields.py b/openerp/osv/fields.py
index 190453d477a..d5d0ee0fa30 100644
--- a/openerp/osv/fields.py
+++ b/openerp/osv/fields.py
@@ -236,15 +236,24 @@ class char(_column):
class text(_column):
_type = 'text'
+
class html(text):
_type = 'html'
_symbol_c = '%s'
- def _symbol_f(x):
- if x is None or x == False:
+
+ def _symbol_set_html(self, value):
+ if value is None or value is False:
return None
- return html_sanitize(x)
-
- _symbol_set = (_symbol_c, _symbol_f)
+ if not self._sanitize:
+ return value
+ return html_sanitize(value)
+
+ def __init__(self, string='unknown', sanitize=True, **args):
+ super(html, self).__init__(string=string, **args)
+ self._sanitize = sanitize
+ # symbol_set redefinition because of sanitize specific behavior
+ self._symbol_f = self._symbol_set_html
+ self._symbol_set = (self._symbol_c, self._symbol_f)
import __builtin__
@@ -1461,11 +1470,9 @@ class property(function):
def _get_by_id(self, obj, cr, uid, prop_name, ids, context=None):
prop = obj.pool.get('ir.property')
vids = [obj._name + ',' + str(oid) for oid in ids]
- def_id = self._field_get(cr, uid, obj._name, prop_name[0])
- company = obj.pool.get('res.company')
- cid = company._company_default_get(cr, uid, obj._name, def_id, context=context)
- domain = [('fields_id.model', '=', obj._name), ('fields_id.name', 'in', prop_name), ('company_id', '=', cid)]
- #domain = prop._get_domain(cr, uid, prop_name, obj._name, context)
+ domain = [('fields_id.model', '=', obj._name), ('fields_id.name', 'in', prop_name)]
+ if context and context.get('company_id'):
+ domain += [('company_id', '=', context.get('company_id'))]
if vids:
domain = [('res_id', 'in', vids)] + domain
return prop.search(cr, uid, domain, context=context)
@@ -1475,7 +1482,12 @@ class property(function):
if context is None:
context = {}
- nids = self._get_by_id(obj, cr, uid, [prop_name], [id], context)
+ def_id = self._field_get(cr, uid, obj._name, prop_name)
+ company = obj.pool.get('res.company')
+ cid = company._company_default_get(cr, uid, obj._name, def_id, context=context)
+ # TODO for trunk: add new parameter company_id to _get_by_id method
+ context_company = dict(context, company_id=cid)
+ nids = self._get_by_id(obj, cr, uid, [prop_name], [id], context_company)
if nids:
cr.execute('DELETE FROM ir_property WHERE id IN %s', (tuple(nids),))
@@ -1489,10 +1501,6 @@ class property(function):
property_create = True
if property_create:
- def_id = self._field_get(cr, uid, obj._name, prop_name)
- company = obj.pool.get('res.company')
- cid = company._company_default_get(cr, uid, obj._name, def_id,
- context=context)
propdef = obj.pool.get('ir.model.fields').browse(cr, uid, def_id,
context=context)
prop = obj.pool.get('ir.property')
diff --git a/openerp/osv/orm.py b/openerp/osv/orm.py
index 6ac65125620..64fa06783ab 100644
--- a/openerp/osv/orm.py
+++ b/openerp/osv/orm.py
@@ -75,7 +75,7 @@ _schema = logging.getLogger(__name__ + '.schema')
# List of etree._Element subclasses that we choose to ignore when parsing XML.
from openerp.tools import SKIPPED_ELEMENT_TYPES
-regex_order = re.compile('^(([a-z0-9_]+|"[a-z0-9_]+")( *desc| *asc)?( *, *|))+$', re.I)
+regex_order = re.compile('^( *([a-z0-9_]+|"[a-z0-9_]+")( *desc| *asc)?( *, *|))+$', re.I)
regex_object_name = re.compile(r'^[a-z0-9_.]+$')
AUTOINIT_RECALCULATE_STORED_FIELDS = 1000
@@ -770,8 +770,6 @@ class BaseModel(object):
(name_id, context['module'], 'ir.model', model_id)
)
- cr.commit()
-
cr.execute("SELECT * FROM ir_model_fields WHERE model=%s", (self._name,))
cols = {}
for rec in cr.dictfetchall():
@@ -838,7 +836,6 @@ class BaseModel(object):
for key, val in vals.items():
if cols[k][key] != vals[key]:
cr.execute('update ir_model_fields set field_description=%s where model=%s and name=%s', (vals['field_description'], vals['model'], vals['name']))
- cr.commit()
cr.execute("""UPDATE ir_model_fields SET
model_id=%s, field_description=%s, ttype=%s, relation=%s,
select_level=%s, readonly=%s ,required=%s, selectable=%s, relation_field=%s, translate=%s, serialization_field_id=%s
@@ -849,7 +846,6 @@ class BaseModel(object):
vals['select_level'], bool(vals['readonly']), bool(vals['required']), bool(vals['selectable']), vals['relation_field'], bool(vals['translate']), vals['serialization_field_id'], vals['model'], vals['name']
))
break
- cr.commit()
#
# Goal: try to apply inheritance at the instanciation level and
@@ -1128,7 +1124,7 @@ class BaseModel(object):
def _get_xml_id(self, cr, uid, r):
model_data = self.pool.get('ir.model.data')
- data_ids = model_data.search(cr, uid, [('model', '=', r._table_name), ('res_id', '=', r['id'])])
+ data_ids = model_data.search(cr, uid, [('model', '=', r._model._name), ('res_id', '=', r['id'])])
if len(data_ids):
d = model_data.read(cr, uid, data_ids, ['name', 'module'])[0]
if d['module']:
@@ -1138,13 +1134,13 @@ class BaseModel(object):
else:
postfix = 0
while True:
- n = self._table+'_'+str(r['id']) + (postfix and ('_'+str(postfix)) or '' )
+ n = r._model._table+'_'+str(r['id']) + (postfix and ('_'+str(postfix)) or '' )
if not model_data.search(cr, uid, [('name', '=', n)]):
break
postfix += 1
model_data.create(cr, SUPERUSER_ID, {
'name': n,
- 'model': self._name,
+ 'model': r._model._name,
'res_id': r['id'],
'module': '__export__',
})
@@ -2189,6 +2185,43 @@ class BaseModel(object):
r['__fold'] = folded.get(r[groupby] and r[groupby][0], False)
return result
+ def _read_group_prepare(self, orderby, aggregated_fields, groupby, qualified_groupby_field, query, groupby_type=None):
+ """
+ Prepares the GROUP BY and ORDER BY terms for the read_group method. Adds the missing JOIN clause
+ to the query if order should be computed against m2o field.
+ :param orderby: the orderby definition in the form "%(field)s %(order)s"
+ :param aggregated_fields: list of aggregated fields in the query
+ :param groupby: the current groupby field name
+ :param qualified_groupby_field: the fully qualified SQL name for the grouped field
+ :param osv.Query query: the query under construction
+ :param groupby_type: the type of the grouped field
+ :return: (groupby_terms, orderby_terms)
+ """
+ orderby_terms = []
+ groupby_terms = [qualified_groupby_field] if groupby else []
+ if not orderby:
+ return groupby_terms, orderby_terms
+
+ self._check_qorder(orderby)
+ for order_part in orderby.split(','):
+ order_split = order_part.split()
+ order_field = order_split[0]
+ if order_field == groupby:
+ if groupby_type == 'many2one':
+ order_clause = self._generate_order_by(order_part, query).replace('ORDER BY ', '')
+ if order_clause:
+ orderby_terms.append(order_clause)
+ groupby_terms += [order_term.split()[0] for order_term in order_clause.split(',')]
+ else:
+ orderby_terms.append(order_part)
+ elif order_field in aggregated_fields:
+ orderby_terms.append(order_part)
+ else:
+ # Cannot order by a field that will not appear in the results (needs to be grouped or aggregated)
+ _logger.warn('%s: read_group order by `%s` ignored, cannot sort on empty columns (not grouped/aggregated)',
+ self._name, order_part)
+ return groupby_terms, orderby_terms
+
def read_group(self, cr, uid, domain, fields, groupby, offset=0, limit=None, context=None, orderby=False):
"""
Get the list of records in list view grouped by the given ``groupby`` fields
@@ -2248,9 +2281,9 @@ class BaseModel(object):
# TODO it seems fields_get can be replaced by _all_columns (no need for translation)
fget = self.fields_get(cr, uid, fields)
- flist = ''
- group_count = group_by = groupby
group_by_params = {}
+ select_terms = []
+ groupby_type = None
if groupby:
if fget.get(groupby):
groupby_type = fget[groupby]['type']
@@ -2278,12 +2311,9 @@ class BaseModel(object):
timezone = context.get('tz', 'UTC')
qualified_groupby_field = "timezone('%s', timezone('UTC',%s))" % (timezone, qualified_groupby_field)
qualified_groupby_field = "date_trunc('%s', %s)" % (interval, qualified_groupby_field)
- flist = "%s as %s " % (qualified_groupby_field, groupby)
elif groupby_type == 'boolean':
qualified_groupby_field = "coalesce(%s,false)" % qualified_groupby_field
- flist = "%s as %s " % (qualified_groupby_field, groupby)
- else:
- flist = qualified_groupby_field
+ select_terms.append("%s as %s " % (qualified_groupby_field, groupby))
else:
# Don't allow arbitrary values, as this would be a SQL injection vector!
raise except_orm(_('Invalid group_by'),
@@ -2291,39 +2321,58 @@ class BaseModel(object):
aggregated_fields = [
f for f in fields
- if f not in ('id', 'sequence')
+ if f not in ('id', 'sequence', groupby)
if fget[f]['type'] in ('integer', 'float')
if (f in self._all_columns and getattr(self._all_columns[f].column, '_classic_write'))]
for f in aggregated_fields:
group_operator = fget[f].get('group_operator', 'sum')
- if flist:
- flist += ', '
qualified_field = self._inherits_join_calc(f, query)
- flist += "%s(%s) AS %s" % (group_operator, qualified_field, f)
+ select_terms.append("%s(%s) AS %s" % (group_operator, qualified_field, f))
- gb = groupby and (' GROUP BY ' + qualified_groupby_field) or ''
+ order = orderby or groupby or ''
+ groupby_terms, orderby_terms = self._read_group_prepare(order, aggregated_fields, groupby, qualified_groupby_field, query, groupby_type)
from_clause, where_clause, where_clause_params = query.get_sql()
- where_clause = where_clause and ' WHERE ' + where_clause
- limit_str = limit and ' limit %d' % limit or ''
- offset_str = offset and ' offset %d' % offset or ''
if len(groupby_list) < 2 and context.get('group_by_no_leaf'):
- group_count = '_'
- cr.execute('SELECT min(%s.id) AS id, count(%s.id) AS %s_count' % (self._table, self._table, group_count) + (flist and ',') + flist + ' FROM ' + from_clause + where_clause + gb + limit_str + offset_str, where_clause_params)
+ count_field = '_'
+ else:
+ count_field = groupby
+
+ prefix_terms = lambda prefix, terms: (prefix + " " + ",".join(terms)) if terms else ''
+ prefix_term = lambda prefix, term: ('%s %s' % (prefix, term)) if term else ''
+
+ query = """
+ SELECT min(%(table)s.id) AS id, count(%(table)s.id) AS %(count_field)s_count
+ %(extra_fields)s
+ FROM %(from)s
+ %(where)s
+ %(groupby)s
+ %(orderby)s
+ %(limit)s
+ %(offset)s
+ """ % {
+ 'table': self._table,
+ 'count_field': count_field,
+ 'extra_fields': prefix_terms(',', select_terms),
+ 'from': from_clause,
+ 'where': prefix_term('WHERE', where_clause),
+ 'groupby': prefix_terms('GROUP BY', groupby_terms),
+ 'orderby': prefix_terms('ORDER BY', orderby_terms),
+ 'limit': prefix_term('LIMIT', int(limit) if limit else None),
+ 'offset': prefix_term('OFFSET', int(offset) if limit else None),
+ }
+ cr.execute(query, where_clause_params)
alldata = {}
- groupby = group_by
- for r in cr.dictfetchall():
+ fetched_data = cr.dictfetchall()
+
+ data_ids = []
+ for r in fetched_data:
for fld, val in r.items():
if val is None: r[fld] = False
alldata[r['id']] = r
+ data_ids.append(r['id'])
del r['id']
- order = orderby or groupby
- data_ids = self.search(cr, uid, [('id', 'in', alldata.keys())], order=order, context=context)
-
- # the IDs of records that have groupby field value = False or '' should be included too
- data_ids += set(alldata.keys()).difference(data_ids)
-
if groupby:
data = self.read(cr, uid, data_ids, [groupby], context=context)
# restore order of the search as read() uses the default _order (this is only for groups, so the footprint of data should be small):
@@ -2694,7 +2743,7 @@ class BaseModel(object):
f_pg_notnull = res['attnotnull']
if isinstance(f, fields.function) and not f.store and\
not getattr(f, 'nodrop', False):
- _logger.info('column %s (%s) in table %s removed: converted to a function !\n',
+ _logger.info('column %s (%s) converted to a function, removed from table %s',
k, f.string, self._table)
cr.execute('ALTER TABLE "%s" DROP COLUMN "%s" CASCADE' % (self._table, k))
cr.commit()
@@ -2716,10 +2765,16 @@ class BaseModel(object):
('float8', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
]
if f_pg_type == 'varchar' and f._type == 'char' and ((f.size is None and f_pg_size) or f_pg_size < f.size):
- cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
- cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, pg_varchar(f.size)))
- cr.execute('UPDATE "%s" SET "%s"=temp_change_size::%s' % (self._table, k, pg_varchar(f.size)))
- cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
+ try:
+ with cr.savepoint():
+ cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" TYPE %s' % (self._table, k, pg_varchar(f.size)))
+ except psycopg2.NotSupportedError:
+ # In place alter table cannot be done because a view is depending of this field.
+ # Do a manual copy. This will drop the view (that will be recreated later)
+ cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
+ cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, pg_varchar(f.size)))
+ cr.execute('UPDATE "%s" SET "%s"=temp_change_size::%s' % (self._table, k, pg_varchar(f.size)))
+ cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
cr.commit()
_schema.debug("Table '%s': column '%s' (type varchar) changed size from %s to %s",
self._table, k, f_pg_size or 'unlimited', f.size or 'unlimited')
@@ -2727,10 +2782,10 @@ class BaseModel(object):
if (f_pg_type==c[0]) and (f._type==c[1]):
if f_pg_type != f_obj_type:
ok = True
- cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
+ cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO __temp_type_cast' % (self._table, k))
cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, c[2]))
- cr.execute(('UPDATE "%s" SET "%s"=temp_change_size'+c[3]) % (self._table, k))
- cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
+ cr.execute(('UPDATE "%s" SET "%s"= __temp_type_cast'+c[3]) % (self._table, k))
+ cr.execute('ALTER TABLE "%s" DROP COLUMN __temp_type_cast CASCADE' % (self._table,))
cr.commit()
_schema.debug("Table '%s': column '%s' changed type from %s to %s",
self._table, k, c[0], c[1])
@@ -2807,7 +2862,7 @@ class BaseModel(object):
msg = "Table '%s': dropping index for column '%s' of type '%s' as it is not required anymore"
_schema.debug(msg, self._table, k, f._type)
- if isinstance(f, fields.many2one):
+ if isinstance(f, fields.many2one) or (isinstance(f, fields.function) and f._type == 'many2one' and f.store):
dest_model = self.pool[f._obj]
if dest_model._table != 'ir_actions':
self._m2o_fix_foreign_key(cr, self._table, k, dest_model, f.ondelete)
@@ -2842,7 +2897,7 @@ class BaseModel(object):
todo_end.append((order, self._update_store, (f, k)))
# and add constraints if needed
- if isinstance(f, fields.many2one):
+ if isinstance(f, fields.many2one) or (isinstance(f, fields.function) and f._type == 'many2one' and f.store):
if f._obj not in self.pool:
raise except_orm('Programming Error', 'There is no reference available for %s' % (f._obj,))
dest_model = self.pool[f._obj]
@@ -4622,24 +4677,22 @@ class BaseModel(object):
blacklist_given_fields(self)
- fields_to_read = [f for f in self.check_field_access_rights(cr, uid, 'read', None)
- if f not in blacklist]
- data = self.read(cr, uid, [id], fields_to_read, context=context)
+
+ fields_to_copy = dict((f,fi) for f, fi in self._all_columns.iteritems()
+ if f not in default
+ if f not in blacklist
+ if not isinstance(fi.column, fields.function))
+
+ data = self.read(cr, uid, [id], fields_to_copy.keys(), context=context)
if data:
data = data[0]
else:
- raise IndexError(_("Record #%d of %s not found, cannot copy!") % (id, self._name))
+ raise IndexError( _("Record #%d of %s not found, cannot copy!") %( id, self._name))
res = dict(default)
- for f, colinfo in self._all_columns.items():
+ for f, colinfo in fields_to_copy.iteritems():
field = colinfo.column
- if f in default:
- pass
- elif f in blacklist:
- pass
- elif isinstance(field, fields.function):
- pass
- elif field._type == 'many2one':
+ if field._type == 'many2one':
res[f] = data[f] and data[f][0]
elif field._type == 'one2many':
other = self.pool[field._obj]
diff --git a/openerp/release.py b/openerp/release.py
index 8670ef50abc..1a9c863660c 100644
--- a/openerp/release.py
+++ b/openerp/release.py
@@ -30,9 +30,9 @@ RELEASE_LEVELS_DISPLAY = {ALPHA: ALPHA,
# properly comparable using normal operarors, for example:
# (6,1,0,'beta',0) < (6,1,0,'candidate',1) < (6,1,0,'candidate',2)
# (6,1,0,'candidate',2) < (6,1,0,'final',0) < (6,1,2,'final',0)
-version_info = (7, 'saas~3', 0, FINAL, 0)
+version_info = (8, 0, 0, ALPHA, 1)
version = '.'.join(map(str, version_info[:2])) + RELEASE_LEVELS_DISPLAY[version_info[3]] + str(version_info[4] or '')
-serie = major_version = '.'.join(map(str, version_info[:2]))
+series = serie = major_version = '.'.join(map(str, version_info[:2]))
description = 'OpenERP Server'
long_desc = '''OpenERP is a complete ERP and CRM. The main features are accounting (analytic
@@ -50,6 +50,6 @@ author = 'OpenERP S.A.'
author_email = 'info@openerp.com'
license = 'AGPL-3'
-nt_service_name = "openerp-server-" + serie
+nt_service_name = "openerp-server-" + series
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
diff --git a/openerp/report/render/rml2pdf/trml2pdf.py b/openerp/report/render/rml2pdf/trml2pdf.py
index ad1ff656e1d..aaed9ddf4c6 100644
--- a/openerp/report/render/rml2pdf/trml2pdf.py
+++ b/openerp/report/render/rml2pdf/trml2pdf.py
@@ -982,7 +982,7 @@ class _rml_template(object):
}
pageSize = A4
if self.localcontext.get('company'):
- pageSize = pagesize_map.get(self.localcontext.get('company').paper_format, A4)
+ pageSize = pagesize_map.get(self.localcontext.get('company').rml_paper_format, A4)
if node.get('pageSize'):
ps = map(lambda x:x.strip(), node.get('pageSize').replace(')', '').replace('(', '').split(','))
pageSize = ( utils.unit_get(ps[0]),utils.unit_get(ps[1]) )
diff --git a/openerp/service/db.py b/openerp/service/db.py
index fa1bc1336fc..f10f39aab9b 100644
--- a/openerp/service/db.py
+++ b/openerp/service/db.py
@@ -1,12 +1,15 @@
# -*- coding: utf-8 -*-
-
-import base64
-import contextlib
+from contextlib import closing
+from functools import wraps
import logging
import os
+import shutil
import threading
import traceback
-from contextlib import contextmanager, closing
+import tempfile
+import zipfile
+
+import psycopg2
import openerp
from openerp import SUPERUSER_ID
@@ -28,7 +31,8 @@ def _initialize_db(id, db_name, demo, lang, user_password):
self_actions[id]['progress'] = 0
db = openerp.sql_db.db_connect(db_name)
with closing(db.cursor()) as cr:
- openerp.modules.db.initialize(cr) # TODO this should be removed as it is done by RegistryManager.new().
+ # TODO this should be removed as it is done by RegistryManager.new().
+ openerp.modules.db.initialize(cr)
openerp.tools.config['lang'] = lang
cr.commit()
@@ -55,14 +59,13 @@ def _initialize_db(id, db_name, demo, lang, user_password):
self_actions[id]['traceback'] = traceback.format_exc()
def dispatch(method, params):
- if method in [ 'create', 'get_progress', 'drop', 'dump',
- 'restore', 'rename',
- 'change_admin_password', 'migrate_databases',
- 'create_database', 'duplicate_database' ]:
+ if method in ['create', 'get_progress', 'drop', 'dump', 'restore', 'rename',
+ 'change_admin_password', 'migrate_databases',
+ 'create_database', 'duplicate_database']:
passwd = params[0]
params = params[1:]
security.check_super(passwd)
- elif method in [ 'db_exist', 'list', 'list_lang', 'server_version' ]:
+ elif method in ['db_exist', 'list', 'list_lang', 'server_version']:
# params = params
# No security check for these methods
pass
@@ -78,9 +81,9 @@ def _create_empty_database(name):
cr.execute("SELECT datname FROM pg_database WHERE datname = %s",
(name,))
if cr.fetchall():
- raise openerp.exceptions.Warning(" %s database already exists!" % name )
+ raise openerp.exceptions.Warning("database %r already exists!" % (name,))
else:
- cr.autocommit(True) # avoid transaction block
+ cr.autocommit(True) # avoid transaction block
cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "%s" """ % (name, chosen_template))
def exp_create(db_name, demo, lang, user_password='admin'):
@@ -96,7 +99,7 @@ def exp_create(db_name, demo, lang, user_password='admin'):
_logger.info('CREATE DATABASE %s', db_name.lower())
create_thread = threading.Thread(target=_initialize_db,
- args=(id, db_name, demo, lang, user_password))
+ args=(id, db_name, demo, lang, user_password))
create_thread.start()
self_actions[id]['thread'] = create_thread
return id
@@ -121,14 +124,14 @@ def exp_duplicate_database(db_original_name, db_name):
openerp.sql_db.close_db(db_original_name)
db = openerp.sql_db.db_connect('postgres')
with closing(db.cursor()) as cr:
- cr.autocommit(True) # avoid transaction block
+ cr.autocommit(True) # avoid transaction block
cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "%s" """ % (db_name, db_original_name))
return True
def exp_get_progress(id):
if self_actions[id]['thread'].isAlive():
# return openerp.modules.init_progress[db_name]
- return min(self_actions[id].get('progress', 0),0.95), []
+ return min(self_actions[id].get('progress', 0), 0.95), []
else:
clean = self_actions[id]['clean']
if clean:
@@ -140,9 +143,9 @@ def exp_get_progress(id):
self_actions.pop(id)
return 1.0, users
else:
- e = self_actions[id]['exception'] # TODO this seems wrong: actions[id]['traceback'] is set, but not 'exception'.
- self_actions.pop(id)
- raise Exception, e
+ a = self_actions.pop(id)
+ exc, tb = a['exception'], a['traceback']
+ raise Exception, exc, tb
def exp_drop(db_name):
if db_name not in exp_list(True):
@@ -152,18 +155,17 @@ def exp_drop(db_name):
db = openerp.sql_db.db_connect('postgres')
with closing(db.cursor()) as cr:
- cr.autocommit(True) # avoid transaction block
+ cr.autocommit(True) # avoid transaction block
# Try to terminate all other connections that might prevent
# dropping the database
try:
-
# PostgreSQL 9.2 renamed pg_stat_activity.procpid to pid:
# http://www.postgresql.org/docs/9.2/static/release-9-2.html#AEN110389
pid_col = 'pid' if cr._cnx.server_version >= 90200 else 'procpid'
cr.execute("""SELECT pg_terminate_backend(%(pid_col)s)
FROM pg_stat_activity
- WHERE datname = %%s AND
+ WHERE datname = %%s AND
%(pid_col)s != pg_backend_pid()""" % {'pid_col': pid_col},
(db_name,))
except Exception:
@@ -178,94 +180,140 @@ def exp_drop(db_name):
_logger.info('DROP DB: %s', db_name)
return True
-@contextlib.contextmanager
-def _set_pg_password_in_environment():
+def _set_pg_password_in_environment(func):
""" On systems where pg_restore/pg_dump require an explicit
password (i.e. when not connecting via unix sockets, and most
importantly on Windows), it is necessary to pass the PG user
password in the environment or in a special .pgpass file.
- This context management method handles setting
+ This decorator handles setting
:envvar:`PGPASSWORD` if it is not already
set, and removing it afterwards.
See also http://www.postgresql.org/docs/8.4/static/libpq-envars.html
-
+
.. note:: This is not thread-safe, and should never be enabled for
SaaS (giving SaaS users the super-admin password is not a good idea
anyway)
"""
- if os.environ.get('PGPASSWORD') or not openerp.tools.config['db_password']:
- yield
- else:
- os.environ['PGPASSWORD'] = openerp.tools.config['db_password']
- try:
- yield
- finally:
- del os.environ['PGPASSWORD']
-
+ @wraps(func)
+ def wrapper(*args, **kwargs):
+ if os.environ.get('PGPASSWORD') or not openerp.tools.config['db_password']:
+ return func(*args, **kwargs)
+ else:
+ os.environ['PGPASSWORD'] = openerp.tools.config['db_password']
+ try:
+ return func(*args, **kwargs)
+ finally:
+ del os.environ['PGPASSWORD']
+ return wrapper
def exp_dump(db_name):
- with _set_pg_password_in_environment():
- cmd = ['pg_dump', '--format=c', '--no-owner']
+ with tempfile.TemporaryFile() as t:
+ dump_db(db_name, t)
+ t.seek(0)
+ return t.read().encode('base64')
+
+@_set_pg_password_in_environment
+def dump_db(db, stream):
+ """Dump database `db` into file-like object `stream`"""
+ with openerp.tools.osutil.tempdir() as dump_dir:
+ registry = openerp.modules.registry.RegistryManager.get(db)
+ with registry.cursor() as cr:
+ filestore = registry['ir.attachment']._filestore(cr, SUPERUSER_ID)
+ if os.path.exists(filestore):
+ shutil.copytree(filestore, os.path.join(dump_dir, 'filestore'))
+
+ dump_file = os.path.join(dump_dir, 'dump.sql')
+ cmd = ['pg_dump', '--format=p', '--no-owner', '--file=' + dump_file]
if openerp.tools.config['db_user']:
cmd.append('--username=' + openerp.tools.config['db_user'])
if openerp.tools.config['db_host']:
cmd.append('--host=' + openerp.tools.config['db_host'])
if openerp.tools.config['db_port']:
cmd.append('--port=' + str(openerp.tools.config['db_port']))
- cmd.append(db_name)
+ cmd.append(db)
- stdin, stdout = openerp.tools.exec_pg_command_pipe(*tuple(cmd))
- stdin.close()
- data = stdout.read()
- res = stdout.close()
+ if openerp.tools.exec_pg_command(*cmd):
+ _logger.error('DUMP DB: %s failed! Please verify the configuration of the database '
+ 'password on the server. You may need to create a .pgpass file for '
+ 'authentication, or specify `db_password` in the server configuration '
+ 'file.', db)
+ raise Exception("Couldn't dump database")
- if not data or res:
- _logger.error(
- 'DUMP DB: %s failed! Please verify the configuration of the database password on the server. '
- 'You may need to create a .pgpass file for authentication, or specify `db_password` in the '
- 'server configuration file.\n %s', db_name, data)
- raise Exception, "Couldn't dump database"
- _logger.info('DUMP DB successful: %s', db_name)
+ openerp.tools.osutil.zip_dir(dump_dir, stream, include_dir=False)
- return base64.encodestring(data)
+ _logger.info('DUMP DB successful: %s', db)
-def exp_restore(db_name, data):
- with _set_pg_password_in_environment():
- if exp_db_exist(db_name):
- _logger.warning('RESTORE DB: %s already exists', db_name)
- raise Exception, "Database already exists"
+def exp_restore(db_name, data, copy=False):
+ data_file = tempfile.NamedTemporaryFile(delete=False)
+ try:
+ data_file.write(data.decode('base64'))
+ data_file.close()
+ restore_db(db_name, data_file.name, copy=copy)
+ finally:
+ os.unlink(data_file.name)
+ return True
- _create_empty_database(db_name)
+@_set_pg_password_in_environment
+def restore_db(db, dump_file, copy=False):
+ assert isinstance(db, basestring)
+ if exp_db_exist(db):
+ _logger.warning('RESTORE DB: %s already exists', db)
+ raise Exception("Database already exists")
- cmd = ['pg_restore', '--no-owner']
+ _create_empty_database(db)
+
+ filestore_path = None
+ with openerp.tools.osutil.tempdir() as dump_dir:
+ if zipfile.is_zipfile(dump_file):
+ # v8 format
+ with zipfile.ZipFile(dump_file, 'r') as z:
+ # only extract known members!
+ filestore = [m for m in z.namelist() if m.startswith('filestore/')]
+ z.extractall(dump_dir, ['dump.sql'] + filestore)
+
+ if filestore:
+ filestore_path = os.path.join(dump_dir, 'filestore')
+
+ pg_cmd = 'psql'
+ pg_args = ['-q', '-f', os.path.join(dump_dir, 'dump.sql')]
+
+ else:
+ # <= 7.0 format (raw pg_dump output)
+ pg_cmd = 'pg_restore'
+ pg_args = ['--no-owner', dump_file]
+
+ args = []
if openerp.tools.config['db_user']:
- cmd.append('--username=' + openerp.tools.config['db_user'])
+ args.append('--username=' + openerp.tools.config['db_user'])
if openerp.tools.config['db_host']:
- cmd.append('--host=' + openerp.tools.config['db_host'])
+ args.append('--host=' + openerp.tools.config['db_host'])
if openerp.tools.config['db_port']:
- cmd.append('--port=' + str(openerp.tools.config['db_port']))
- cmd.append('--dbname=' + db_name)
- args2 = tuple(cmd)
+ args.append('--port=' + str(openerp.tools.config['db_port']))
+ args.append('--dbname=' + db)
+ pg_args = args + pg_args
- buf=base64.decodestring(data)
- if os.name == "nt":
- tmpfile = (os.environ['TMP'] or 'C:\\') + os.tmpnam()
- file(tmpfile, 'wb').write(buf)
- args2=list(args2)
- args2.append(tmpfile)
- args2=tuple(args2)
- stdin, stdout = openerp.tools.exec_pg_command_pipe(*args2)
- if not os.name == "nt":
- stdin.write(base64.decodestring(data))
- stdin.close()
- res = stdout.close()
- if res:
- raise Exception, "Couldn't restore database"
- _logger.info('RESTORE DB: %s', db_name)
+ if openerp.tools.exec_pg_command(pg_cmd, *pg_args):
+ raise Exception("Couldn't restore database")
- return True
+ registry = openerp.modules.registry.RegistryManager.new(db)
+ with registry.cursor() as cr:
+ if copy:
+ # if it's a copy of a database, force generation of a new dbuuid
+ registry['ir.config_parameter'].init(cr, force=True)
+ if filestore_path:
+ filestore_dest = registry['ir.attachment']._filestore(cr, SUPERUSER_ID)
+ shutil.move(filestore_path, filestore_dest)
+
+ if openerp.tools.config['unaccent']:
+ try:
+ with cr.savepoint():
+ cr.execute("CREATE EXTENSION unaccent")
+ except psycopg2.Error:
+ pass
+
+ _logger.info('RESTORE DB: %s', db)
def exp_rename(old_name, new_name):
openerp.modules.registry.RegistryManager.delete(old_name)
@@ -273,20 +321,16 @@ def exp_rename(old_name, new_name):
db = openerp.sql_db.db_connect('postgres')
with closing(db.cursor()) as cr:
- cr.autocommit(True) # avoid transaction block
+ cr.autocommit(True) # avoid transaction block
try:
cr.execute('ALTER DATABASE "%s" RENAME TO "%s"' % (old_name, new_name))
+ _logger.info('RENAME DB: %s -> %s', old_name, new_name)
except Exception, e:
_logger.error('RENAME DB: %s -> %s failed:\n%s', old_name, new_name, e)
raise Exception("Couldn't rename database %s to %s: %s" % (old_name, new_name, e))
- else:
- fs = os.path.join(openerp.tools.config['root_path'], 'filestore')
- if os.path.exists(os.path.join(fs, old_name)):
- os.rename(os.path.join(fs, old_name), os.path.join(fs, new_name))
-
- _logger.info('RENAME DB: %s -> %s', old_name, new_name)
return True
+@openerp.tools.mute_logger('openerp.sql_db')
def exp_db_exist(db_name):
## Not True: in fact, check if connection to database is possible. The database may exists
return bool(openerp.sql_db.db_connect(db_name))
@@ -311,7 +355,7 @@ def exp_list(document=False):
cr.execute("select datname from pg_database where datdba=(select usesysid from pg_user where usename=%s) and datname not in %s order by datname", (db_user, templates_list))
else:
cr.execute("select datname from pg_database where datname not in %s order by datname", (templates_list,))
- res = [str(name) for (name,) in cr.fetchall()]
+ res = [openerp.tools.ustr(name) for (name,) in cr.fetchall()]
except Exception:
res = []
res.sort()
diff --git a/openerp/service/server.py b/openerp/service/server.py
index 5372459cd41..f9db66a28ef 100644
--- a/openerp/service/server.py
+++ b/openerp/service/server.py
@@ -9,8 +9,10 @@ import os.path
import platform
import psutil
import random
-import re
-import resource
+if os.name == 'posix':
+ import resource
+else:
+ resource = None
import select
import signal
import socket
@@ -32,15 +34,14 @@ except ImportError:
setproctitle = lambda x: None
import openerp
-import openerp.tools.config as config
+from openerp.modules.registry import RegistryManager
from openerp.release import nt_service_name
+import openerp.tools.config as config
from openerp.tools.misc import stripped_sys_argv, dumpstacks
-import wsgi_server
-
_logger = logging.getLogger(__name__)
-SLEEP_INTERVAL = 60 # 1 min
+SLEEP_INTERVAL = 60 # 1 min
#----------------------------------------------------------
# Werkzeug WSGI servers patched
@@ -110,15 +111,14 @@ class AutoReload(object):
self.handler = EventHandler(self)
self.notifier = pyinotify.Notifier(self.wm, self.handler, timeout=0)
mask = pyinotify.IN_MODIFY | pyinotify.IN_CREATE # IN_MOVED_FROM, IN_MOVED_TO ?
- for path in openerp.tools.config.options["addons_path"].split(','):
+ for path in openerp.modules.modules.ad_paths:
_logger.info('Watching addons folder %s', path)
self.wm.add_watch(path, mask, rec=True)
def process_data(self, files):
xml_files = [i for i in files if i.endswith('.xml')]
- addons_path = openerp.tools.config.options["addons_path"].split(',')
for i in xml_files:
- for path in addons_path:
+ for path in openerp.modules.modules.ad_paths:
if i.startswith(path):
# find out wich addons path the file belongs to
# and extract it's module name
@@ -126,7 +126,7 @@ class AutoReload(object):
if len(right) < 2:
continue
module = right[0]
- self.modules[module]=1
+ self.modules[module] = 1
if self.modules:
_logger.info('autoreload: xml change detected, autoreload activated')
restart()
@@ -146,7 +146,7 @@ class AutoReload(object):
if py_errors:
_logger.info('autoreload: python code change detected, errors found')
for i in py_errors:
- _logger.info('autoreload: SyntaxError %s',i)
+ _logger.info('autoreload: SyntaxError %s', i)
else:
_logger.info('autoreload: python code updated, autoreload activated')
restart()
@@ -213,7 +213,7 @@ class ThreadedServer(CommonServer):
self.httpd = None
def signal_handler(self, sig, frame):
- if sig in [signal.SIGINT,signal.SIGTERM]:
+ if sig in [signal.SIGINT, signal.SIGTERM]:
# shutdown on kill -INT or -TERM
self.quit_signals_received += 1
if self.quit_signals_received > 1:
@@ -227,7 +227,7 @@ class ThreadedServer(CommonServer):
def cron_thread(self, number):
while True:
- time.sleep(SLEEP_INTERVAL + number) # Steve Reich timing style
+ time.sleep(SLEEP_INTERVAL + number) # Steve Reich timing style
registries = openerp.modules.registry.RegistryManager.registries
_logger.debug('cron%d polling for jobs', number)
for db_name, registry in registries.items():
@@ -257,13 +257,15 @@ class ThreadedServer(CommonServer):
_logger.debug("cron%d started!" % i)
def http_thread(self):
- def app(e,s):
- return self.app(e,s)
+ def app(e, s):
+ return self.app(e, s)
self.httpd = ThreadedWSGIServerReloadable(self.interface, self.port, app)
self.httpd.serve_forever()
def http_spawn(self):
- threading.Thread(target=self.http_thread).start()
+ t = threading.Thread(target=self.http_thread, name="openerp.service.httpd")
+ t.setDaemon(True)
+ t.start()
_logger.info('HTTP service (werkzeug) running on %s:%s', self.interface, self.port)
def start(self):
@@ -276,7 +278,7 @@ class ThreadedServer(CommonServer):
signal.signal(signal.SIGQUIT, dumpstacks)
elif os.name == 'nt':
import win32api
- win32api.SetConsoleCtrlHandler(lambda sig: signal_handler(sig, None), 1)
+ win32api.SetConsoleCtrlHandler(lambda sig: self.signal_handler(sig, None), 1)
self.cron_spawn()
self.http_spawn()
@@ -286,8 +288,9 @@ class ThreadedServer(CommonServer):
_logger.info("Initiating shutdown")
_logger.info("Hit CTRL-C again or send a second signal to force the shutdown.")
- self.httpd.shutdown()
- self.close_socket(self.httpd.socket)
+ if self.httpd:
+ self.httpd.shutdown()
+ self.close_socket(self.httpd.socket)
# Manually join() all threads before calling sys.exit() to allow a second signal
# to trigger _force_quit() in case some non-daemon threads won't exit cleanly.
@@ -316,12 +319,11 @@ class ThreadedServer(CommonServer):
"""
self.start()
- preload_registries(preload)
+ rc = preload_registries(preload)
if stop:
self.stop()
- return
-
+ return rc
# 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.
@@ -438,7 +440,7 @@ class PreforkServer(CommonServer):
sys.exit(0)
def long_polling_spawn(self):
- nargs = stripped_sys_argv('--pidfile','--workers')
+ nargs = stripped_sys_argv('--pidfile', '--workers')
cmd = nargs[0]
cmd = os.path.join(os.path.dirname(cmd), "openerp-gevent")
nargs[0] = cmd
@@ -447,10 +449,10 @@ class PreforkServer(CommonServer):
def worker_pop(self, pid):
if pid in self.workers:
- _logger.debug("Worker (%s) unregistered",pid)
+ _logger.debug("Worker (%s) unregistered", pid)
try:
- self.workers_http.pop(pid,None)
- self.workers_cron.pop(pid,None)
+ self.workers_http.pop(pid, None)
+ self.workers_cron.pop(pid, None)
u = self.workers.pop(pid)
u.close()
except OSError:
@@ -466,7 +468,7 @@ class PreforkServer(CommonServer):
def process_signals(self):
while len(self.queue):
sig = self.queue.pop(0)
- if sig in [signal.SIGINT,signal.SIGTERM]:
+ if sig in [signal.SIGINT, signal.SIGTERM]:
raise KeyboardInterrupt
elif sig == signal.SIGHUP:
# restart on kill -HUP
@@ -502,8 +504,8 @@ class PreforkServer(CommonServer):
def process_timeout(self):
now = time.time()
for (pid, worker) in self.workers.items():
- if (worker.watchdog_timeout is not None) and \
- (now - worker.watchdog_time >= worker.watchdog_timeout):
+ if worker.watchdog_timeout is not None and \
+ (now - worker.watchdog_time) >= worker.watchdog_timeout:
_logger.error("Worker (%s) timeout", pid)
self.worker_kill(pid, signal.SIGKILL)
@@ -518,7 +520,7 @@ class PreforkServer(CommonServer):
def sleep(self):
try:
# map of fd -> worker
- fds = dict([(w.watchdog_pipe[0],w) for k,w in self.workers.items()])
+ fds = dict([(w.watchdog_pipe[0], w) for k, w in self.workers.items()])
fd_in = fds.keys() + [self.pipe[0]]
# check for ping or internal wakeups
ready = select.select(fd_in, [], [], self.beat)
@@ -558,11 +560,12 @@ class PreforkServer(CommonServer):
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.setblocking(0)
self.socket.bind(self.address)
- self.socket.listen(8*self.population)
+ self.socket.listen(8 * self.population)
def stop(self, graceful=True):
if self.long_polling_pid is not None:
- self.worker_kill(self.long_polling_pid, signal.SIGKILL) # FIXME make longpolling process handle SIGTERM correctly
+ # FIXME make longpolling process handle SIGTERM correctly
+ self.worker_kill(self.long_polling_pid, signal.SIGKILL)
self.long_polling_pid = None
if graceful:
_logger.info("Stopping gracefully")
@@ -581,11 +584,11 @@ class PreforkServer(CommonServer):
def run(self, preload, stop):
self.start()
- preload_registries(preload)
+ rc = preload_registries(preload)
if stop:
self.stop()
- return
+ return rc
_logger.debug("Multiprocess starting")
while 1:
@@ -600,7 +603,7 @@ class PreforkServer(CommonServer):
_logger.debug("Multiprocess clean stop")
self.stop()
break
- except Exception,e:
+ except Exception, e:
_logger.exception(e)
self.stop(False)
return -1
@@ -632,12 +635,14 @@ class Worker(object):
def sleep(self):
try:
- ret = select.select([self.multi.socket], [], [], self.multi.beat)
+ select.select([self.multi.socket], [], [], self.multi.beat)
except select.error, e:
if e[0] not in [errno.EINTR]:
raise
def process_limit(self):
+ if resource is None:
+ return
# If our parent changed sucide
if self.ppid != os.getppid():
_logger.info("Worker (%s) Parent changed", self.pid)
@@ -650,7 +655,7 @@ class Worker(object):
rss, vms = psutil.Process(os.getpid()).get_memory_info()
if vms > config['limit_memory_soft']:
_logger.info('Worker (%d) virtual memory limit (%s) reached.', self.pid, vms)
- self.alive = False # Commit suicide after the request.
+ self.alive = False # Commit suicide after the request.
# VMS and RLIMIT_AS are the same thing: virtual memory, a.k.a. address space
soft, hard = resource.getrlimit(resource.RLIMIT_AS)
@@ -698,7 +703,7 @@ class Worker(object):
self.process_work()
_logger.info("Worker (%s) exiting. request_count: %s.", self.pid, self.request_count)
self.stop()
- except Exception,e:
+ except Exception:
_logger.exception("Worker (%s) Exception occured, exiting..." % self.pid)
# should we use 3 to abort everything ?
sys.exit(1)
@@ -716,7 +721,7 @@ class WorkerHTTP(Worker):
# tolerate broken pipe when the http client closes the socket before
# receiving the full reply
try:
- self.server.process_request(client,addr)
+ self.server.process_request(client, addr)
except IOError, e:
if e.errno != errno.EPIPE:
raise
@@ -747,7 +752,7 @@ class WorkerCron(Worker):
def sleep(self):
# Really sleep once all the databases have been processed.
if self.db_index == 0:
- interval = SLEEP_INTERVAL + self.pid % 10 # chorus effect
+ interval = SLEEP_INTERVAL + self.pid % 10 # chorus effect
time.sleep(interval)
def _db_list(self):
@@ -769,7 +774,7 @@ class WorkerCron(Worker):
if rpc_request_flag:
start_time = time.time()
start_rss, start_vms = psutil.Process(os.getpid()).get_memory_info()
-
+
import openerp.addons.base as base
base.ir.ir_cron.ir_cron._acquire_job(db_name)
openerp.modules.registry.RegistryManager.delete(db_name)
@@ -778,16 +783,18 @@ class WorkerCron(Worker):
if len(db_names) > 1:
openerp.sql_db.close_db(db_name)
if rpc_request_flag:
- end_time = time.time()
+ run_time = time.time() - start_time
end_rss, end_vms = psutil.Process(os.getpid()).get_memory_info()
- logline = '%s time:%.3fs mem: %sk -> %sk (diff: %sk)' % (db_name, end_time - start_time, start_vms / 1024, end_vms / 1024, (end_vms - start_vms)/1024)
+ vms_diff = (end_vms - start_vms) / 1024
+ logline = '%s time:%.3fs mem: %sk -> %sk (diff: %sk)' % \
+ (db_name, run_time, start_vms / 1024, end_vms / 1024, vms_diff)
_logger.debug("WorkerCron (%s) %s", self.pid, logline)
self.request_count += 1
if self.request_count >= self.request_max and self.request_max < len(db_names):
_logger.error("There are more dabatases to process than allowed "
- "by the `limit_request` configuration variable: %s more.",
- len(db_names) - self.request_max)
+ "by the `limit_request` configuration variable: %s more.",
+ len(db_names) - self.request_max)
else:
self.db_index = 0
@@ -820,18 +827,17 @@ def _reexec(updated_modules=None):
subprocess.call('net stop {0} && net start {0}'.format(nt_service_name), shell=True)
exe = os.path.basename(sys.executable)
args = stripped_sys_argv()
- args += ["-u", ','.join(updated_modules)]
+ args += ["-u", ','.join(updated_modules)]
if not args or args[0] != exe:
args.insert(0, exe)
os.execv(sys.executable, args)
-def load_test_file_yml(test_file):
- cr = registry.db.cursor()
- openerp.tools.convert_yaml_import(cr, 'base', file(test_file), 'test', {}, 'test', True)
- cr.rollback()
- cr.close()
+def load_test_file_yml(registry, test_file):
+ with registry.cursor() as cr:
+ openerp.tools.convert_yaml_import(cr, 'base', file(test_file), 'test', {}, 'test', True)
+ cr.rollback()
-def load_test_file_py(test_file):
+def load_test_file_py(registry, test_file):
# Locate python module based on its filename and run the tests
test_path, _ = os.path.splitext(os.path.abspath(test_file))
for mod_name, mod_mod in sys.modules.items():
@@ -842,9 +848,12 @@ def load_test_file_py(test_file):
for t in unittest2.TestLoader().loadTestsFromModule(mod_mod):
suite.addTest(t)
_logger.log(logging.INFO, 'running tests %s.', mod_mod.__name__)
- result = unittest2.TextTestRunner(verbosity=2, stream=openerp.modules.module.TestStream()).run(suite)
- if not result.wasSuccessful():
- r = False
+ stream = openerp.modules.module.TestStream()
+ result = unittest2.TextTestRunner(verbosity=2, stream=stream).run(suite)
+ success = result.wasSuccessful()
+ if hasattr(registry._assertion_report,'report_result'):
+ registry._assertion_report.report_result(success)
+ if not success:
_logger.error('%s: at least one error occurred in a test', test_file)
def preload_registries(dbnames):
@@ -853,20 +862,25 @@ def preload_registries(dbnames):
config = openerp.tools.config
test_file = config['test_file']
dbnames = dbnames or []
+ rc = 0
for dbname in dbnames:
try:
update_module = config['init'] or config['update']
- registry = openerp.modules.registry.RegistryManager.new(dbname, update_module=update_module)
+ registry = RegistryManager.new(dbname, update_module=update_module)
# run test_file if provided
if test_file:
_logger.info('loading test file %s', test_file)
if test_file.endswith('yml'):
- load_test_file_yml(test_file)
+ load_test_file_yml(registry, test_file)
elif test_file.endswith('py'):
- load_test_file_py(test_file)
+ load_test_file_py(registry, test_file)
+
+ if registry._assertion_report.failures:
+ rc += 1
except Exception:
- _logger.exception('Failed to initialize database `%s`.', dbname)
- return
+ _logger.critical('Failed to initialize database `%s`.', dbname, exc_info=True)
+ return -1
+ return rc
def start(preload=None, stop=False):
""" Start the openerp http server and cron processor.
diff --git a/openerp/sql_db.py b/openerp/sql_db.py
index de9d21dcd82..59841656d8c 100644
--- a/openerp/sql_db.py
+++ b/openerp/sql_db.py
@@ -3,7 +3,7 @@
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2009 Tiny SPRL ().
-# Copyright (C) 2010-2013 OpenERP s.a. ().
+# Copyright (C) 2010-2014 OpenERP s.a. ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
@@ -27,8 +27,11 @@ the database, *not* a database abstraction toolkit. Database abstraction is what
the ORM does, in fact.
"""
+from contextlib import contextmanager
from functools import wraps
import logging
+import time
+import uuid
import psycopg2.extensions
from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT, ISOLATION_LEVEL_READ_COMMITTED, ISOLATION_LEVEL_REPEATABLE_READ
from psycopg2.pool import PoolError
@@ -145,7 +148,7 @@ class Cursor(object):
def check(f):
@wraps(f)
def wrapper(self, *args, **kwargs):
- if self.__closed:
+ if self._closed:
msg = 'Unable to use a closed cursor.'
if self.__closer:
msg += ' It was closed at %s, line %s' % self.__closer
@@ -162,7 +165,7 @@ class Cursor(object):
self.sql_log = _logger.isEnabledFor(logging.DEBUG)
self.sql_log_count = 0
- self.__closed = True # avoid the call of close() (by __del__) if an exception
+ self._closed = True # avoid the call of close() (by __del__) if an exception
# is raised by any of the following initialisations
self._pool = pool
self.dbname = dbname
@@ -177,7 +180,7 @@ class Cursor(object):
self.__caller = frame_codeinfo(currentframe(),2)
else:
self.__caller = False
- self.__closed = False # real initialisation value
+ self._closed = False # real initialisation value
self.autocommit(False)
self.__closer = False
@@ -186,7 +189,7 @@ class Cursor(object):
self.cache = {}
def __del__(self):
- if not self.__closed and not self._cnx.closed:
+ if not self._closed and not self._cnx.closed:
# Oops. 'self' has not been closed explicitly.
# The cursor will be deleted by the garbage collector,
# but the database connection is not put back into the connection
@@ -299,7 +302,7 @@ class Cursor(object):
# collected as fast as they should). The problem is probably due in
# part because browse records keep a reference to the cursor.
del self._obj
- self.__closed = True
+ self._closed = True
# Clean the underlying connection.
self._cnx.rollback()
@@ -344,6 +347,19 @@ class Cursor(object):
"""
return self._cnx.rollback()
+ @contextmanager
+ @check
+ def savepoint(self):
+ """context manager entering in a new savepoint"""
+ name = uuid.uuid1().hex
+ self.execute('SAVEPOINT "%s"' % name)
+ try:
+ yield
+ self.execute('RELEASE SAVEPOINT "%s"' % name)
+ except:
+ self.execute('ROLLBACK TO SAVEPOINT "%s"' % name)
+ raise
+
@check
def __getattr__(self, name):
return getattr(self._obj, name)
diff --git a/openerp/tests/common.py b/openerp/tests/common.py
index dd0350aa7ca..a53a8d82240 100644
--- a/openerp/tests/common.py
+++ b/openerp/tests/common.py
@@ -4,17 +4,20 @@ The module :mod:`openerp.tests.common` provides unittest2 test cases and a few
helpers and classes to write tests.
"""
+import errno
import json
import logging
import os
import select
import subprocess
-import sys
import threading
import time
import unittest2
-import uuid
+import urllib2
import xmlrpclib
+from datetime import datetime, timedelta
+
+import werkzeug
import openerp
@@ -25,20 +28,57 @@ ADDONS_PATH = openerp.tools.config['addons_path']
HOST = '127.0.0.1'
PORT = openerp.tools.config['xmlrpc_port']
DB = openerp.tools.config['db_name']
-
# If the database name is not provided on the command-line,
# use the one on the thread (which means if it is provided on
# the command-line, this will break when installing another
# database from XML-RPC).
if not DB and hasattr(threading.current_thread(), 'dbname'):
DB = threading.current_thread().dbname
-
-ADMIN_USER = 'admin'
+# Useless constant, tests are aware of the content of demo data
ADMIN_USER_ID = openerp.SUPERUSER_ID
-ADMIN_PASSWORD = 'admin'
+# Magic session_id, unfortunately we have to serialize access to the cursors to
+# serialize requests. We first tried to duplicate the database for each tests
+# but this proved too slow. Any idea to improve this is welcome.
HTTP_SESSION = {}
+def acquire_test_cursor(session_id):
+ if openerp.tools.config['test_enable']:
+ cr = HTTP_SESSION.get(session_id)
+ if cr:
+ cr._test_lock.acquire()
+ return cr
+
+def release_test_cursor(cr):
+ if openerp.tools.config['test_enable']:
+ if hasattr(cr, '_test_lock'):
+ cr._test_lock.release()
+ return True
+ return False
+
+def at_install(flag):
+ """ Sets the at-install state of a test, the flag is a boolean specifying
+ whether the test should (``True``) or should not (``False``) run during
+ module installation.
+
+ By default, tests are run at install.
+ """
+ def decorator(obj):
+ obj.at_install = flag
+ return obj
+ return decorator
+def post_install(flag):
+ """ Sets the post-install state of a test. The flag is a boolean
+ specifying whether the test should or should not run after a set of
+ module installations.
+
+ By default, tests are *not* run after installation.
+ """
+ def decorator(obj):
+ obj.post_install = flag
+ return obj
+ return decorator
+
class BaseCase(unittest2.TestCase):
"""
Subclass of TestCase for common OpenERP-specific code.
@@ -113,7 +153,7 @@ class SingleTransactionCase(BaseCase):
class HttpCase(TransactionCase):
- """ Transactionnal HTTP TestCase with a phantomjs helper.
+ """ Transactionnal HTTP TestCase with url_open and phantomjs helpers.
"""
def __init__(self, methodName='runTest'):
@@ -126,13 +166,25 @@ class HttpCase(TransactionCase):
def setUp(self):
super(HttpCase, self).setUp()
- self.session_id = uuid.uuid4().hex
+ # setup a magic session_id that will be rollbacked
+ self.session = openerp.http.root.session_store.new()
+ self.session_id = self.session.sid
+ self.session.db = DB
+ openerp.http.root.session_store.save(self.session)
+ self.cr._test_lock = threading.RLock()
HTTP_SESSION[self.session_id] = self.cr
def tearDown(self):
del HTTP_SESSION[self.session_id]
super(HttpCase, self).tearDown()
+ def url_open(self, url, data=None, timeout=10):
+ opener = urllib2.build_opener()
+ opener.addheaders.append(('Cookie', 'session_id=%s' % self.session_id))
+ if url.startswith('/'):
+ url = "http://localhost:%s%s" % (PORT, url)
+ return opener.open(url, data, timeout)
+
def phantom_poll(self, phantom, timeout):
""" Phantomjs Test protocol.
@@ -144,44 +196,64 @@ class HttpCase(TransactionCase):
Other lines are relayed to the test log.
"""
- t0 = time.time()
- buf = ''
- while 1:
+ t0 = datetime.now()
+ td = timedelta(seconds=timeout)
+ buf = bytearray()
+ while True:
# timeout
- if time.time() > t0 + timeout:
- raise Exception("phantomjs test timeout (%ss)" % timeout)
+ self.assertLess(datetime.now() - t0, td,
+ "PhantomJS tests should take less than %s seconds" % timeout)
# read a byte
- ready, _, _ = select.select([phantom.stdout], [], [], 0.5)
+ try:
+ ready, _, _ = select.select([phantom.stdout], [], [], 0.5)
+ except select.error, e:
+ # In Python 2, select.error has no relation to IOError or
+ # OSError, and no errno/strerror/filename, only a pair of
+ # unnamed arguments (matching errno and strerror)
+ err, _ = e.args
+ if err == errno.EINTR:
+ continue
+ raise
+
if ready:
s = phantom.stdout.read(1)
- if s:
- buf += s
- else:
+ if not s:
break
+ buf.append(s)
# process lines
if '\n' in buf:
line, buf = buf.split('\n', 1)
+ line = str(line)
+
+ # relay everything from console.log, even 'ok' or 'error...' lines
_logger.info("phantomjs: %s", line)
+
if line == "ok":
- _logger.info("phantomjs test successful")
- return
- if line == "error":
- raise Exception("phantomjs test failed")
+ break
+ if line.startswith("error"):
+ line_ = line[6:]
+ # when error occurs the execution stack may be sent as as JSON
+ try:
+ line_ = json.loads(line_)
+ except ValueError:
+ pass
+ self.fail(line_ or "phantomjs test failed")
def phantom_run(self, cmd, timeout):
- _logger.info('executing %s', cmd)
+ _logger.info('phantom_run executing %s', ' '.join(cmd))
try:
phantom = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
except OSError:
- _logger.info("phantomjs not found, test %s skipped", jsfile)
+ raise unittest2.SkipTest("PhantomJS not found")
try:
self.phantom_poll(phantom, timeout)
finally:
# kill phantomjs if phantom.exit() wasn't called in the test
if phantom.poll() is None:
phantom.terminate()
+ _logger.info("phantom_run execution finished")
def phantom_jsfile(self, jsfile, timeout=30, **kw):
options = {
@@ -197,8 +269,9 @@ class HttpCase(TransactionCase):
cmd = ['phantomjs', jsfile, phantomtest, json.dumps(options)]
self.phantom_run(cmd, timeout)
- def phantom_js(self, url_path, code, ready="window", timeout=30, **kw):
+ def phantom_js(self, url_path, code, ready="window", login=None, timeout=30, **kw):
""" Test js code running in the browser
+ - optionnally log as 'login'
- load page given by url_path
- wait for ready object to be available
- eval(code) inside the page
@@ -212,17 +285,17 @@ class HttpCase(TransactionCase):
If neither are done before timeout test fails.
"""
options = {
+ 'port': PORT,
+ 'db': DB,
'url_path': url_path,
'code': code,
'ready': ready,
'timeout' : timeout,
- 'port': PORT,
- 'db': DB,
- 'login': ADMIN_USER,
- 'password': ADMIN_PASSWORD,
+ 'login' : login,
'session_id': self.session_id,
}
options.update(kw)
+ options.setdefault('password', options.get('login'))
phantomtest = os.path.join(os.path.dirname(__file__), 'phantomtest.js')
cmd = ['phantomjs', phantomtest, json.dumps(options)]
self.phantom_run(cmd, timeout)
diff --git a/openerp/tests/phantomtest.js b/openerp/tests/phantomtest.js
index 9e8baae512a..63a3b2e33ff 100644
--- a/openerp/tests/phantomtest.js
+++ b/openerp/tests/phantomtest.js
@@ -2,62 +2,57 @@
function waitFor (ready, callback, timeout, timeoutMessageCallback) {
timeout = timeout || 10000;
- var start = new Date().getTime();
- var condition = ready();
- var interval = setInterval(function() {
- if ((new Date().getTime() - start < timeout) && !condition ) {
- condition = ready();
+ var start = new Date;
+
+ (function waitLoop() {
+ if(new Date - start > timeout) {
+ error(timeoutMessageCallback ? timeoutMessageCallback() : "Timeout after "+timeout+" ms");
+ } else if (ready()) {
+ callback();
} else {
- if(!condition) {
- var message = timeoutMessageCallback ? timeoutMessageCallback() : "Timeout after "+timeout+" ms";
- console.log(message);
- console.log("Waiting for " + ready);
- console.log("error");
- phantom.exit(1);
- } else {
- clearInterval(interval);
- callback();
- }
+ setTimeout(waitLoop, 250);
}
- }, 250);
+ }());
}
+function error(message) {
+ console.log('error', message);
+ phantom.exit(1);
+}
function PhantomTest() {
var self = this;
- if(phantom.args.length === 1) {
- this.options = JSON.parse(phantom.args[0]);
- } else {
- this.options = JSON.parse(phantom.args[1]);
- }
- this.inject = [];
+ this.options = JSON.parse(phantom.args[phantom.args.length-1]);
+ this.inject = this.options.inject || [];
this.timeout = this.options.timeout ? Math.round(parseFloat(this.options.timeout)*1000 - 5000) : 10000;
this.origin = 'http://localhost';
this.origin += this.options.port ? ':' + this.options.port : '';
// ----------------------------------------------------
- // test reporting
+ // configure phantom and page
// ----------------------------------------------------
- this.error = function(message) {
- console.log(message);
- console.log("error");
- phantom.exit(1);
- };
-
- // ----------------------------------------------------
- // configure page
- // ----------------------------------------------------
- this.page = require('webpage').create();
- this.page.viewportSize = { width: 1366, height: 768 };
- this.page.addCookie({
+ phantom.addCookie({
'domain': 'localhost',
'name': 'session_id',
'value': this.options.session_id,
});
+ this.page = require('webpage').create();
+ this.page.viewportSize = { width: 1366, height: 768 };
this.page.onError = function(message, trace) {
- self.error(message + " " + trace);
+ var msg = [message];
+ if (trace && trace.length) {
+ msg.push.apply(msg, trace.map(function (frame) {
+ var result = [' at ', frame.file, ':', frame.line];
+ if (frame.function) {
+ result.push(' (in ', frame.function, ')');
+ }
+ return result.join('');
+ }));
+ msg.push('(leaf frame on top)')
+ }
+ error(JSON.stringify(msg.join('\n')));
};
this.page.onAlert = function(message) {
- self.error(message);
+ error(message);
};
this.page.onConsoleMessage = function(message) {
console.log(message);
@@ -65,8 +60,26 @@ function PhantomTest() {
this.page.onLoadFinished = function(status) {
if (status === "success") {
for (var k in self.inject) {
- if(!page.injectJs(self.inject[k])) {
- self.error("Can't inject " + self.inject[k]);
+ var found = false;
+ var v = self.inject[k];
+ var need = v;
+ var src = v;
+ if (v[0]) {
+ need = v[0];
+ src = v[1];
+ found = self.page.evaluate(function(code) {
+ try {
+ return !!eval(code);
+ } catch (e) {
+ return false;
+ }
+ }, need);
+ }
+ if(!found) {
+ console.log('Injecting', src, 'needed for', need);
+ if(!self.page.injectJs(src)) {
+ error("Cannot inject " + src);
+ }
}
}
}
@@ -76,7 +89,7 @@ function PhantomTest() {
var message = ("Timeout\nhref: " + window.location.href
+ "\nreferrer: " + document.referrer
+ "\n\n" + document.body.innerHTML).replace(/[^a-z0-9\s~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, "*");
- self.error(message);
+ error(message);
});
}, self.timeout);
@@ -85,33 +98,37 @@ function PhantomTest() {
// ----------------------------------------------------
this.run = function(url_path, code, ready) {
if(self.options.login) {
- qp = [];
+ var qp = [];
qp.push('db=' + self.options.db);
qp.push('login=' + self.options.login);
qp.push('key=' + self.options.password);
qp.push('redirect=' + encodeURIComponent(url_path));
- var url_path = "/web/login?" + qp.join('&');
+ url_path = "/login?" + qp.join('&');
}
var url = self.origin + url_path;
self.page.open(url, function(status) {
if (status !== 'success') {
- self.error("failed to load " + url)
+ error("failed to load " + url)
} else {
console.log('loaded', url, status);
// process ready
waitFor(function() {
- return self.page.evaluate(function (ready) {
+ console.log("PhantomTest.run: wait for condition: " + ready);
+ return self.page.evaluate(function (ready) {
var r = false;
try {
+ console.log("page.evaluate eval expr:", ready);
r = !!eval(ready);
- } catch(ex) {
- console.log("waiting for page " + ready)
- };
+ } catch(ex) {
+ }
+ console.log("page.evaluate eval result:", r);
return r;
}, ready);
// run test
}, function() {
+ console.log("PhantomTest.run: condition statified, executing: " + code);
self.page.evaluate(function (code) { return eval(code); }, code);
+ console.log("PhantomTest.run: execution launched, waiting for console.log('ok')...");
});
}
});
diff --git a/openerp/tools/__init__.py b/openerp/tools/__init__.py
index 18dab088440..03e2eda038a 100644
--- a/openerp/tools/__init__.py
+++ b/openerp/tools/__init__.py
@@ -21,6 +21,7 @@
import copy
import win32
+import appdirs
from config import config
from misc import *
from convert import *
diff --git a/openerp/tools/appdirs.py b/openerp/tools/appdirs.py
new file mode 100644
index 00000000000..1d24dd8586a
--- /dev/null
+++ b/openerp/tools/appdirs.py
@@ -0,0 +1,477 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+"""Utilities for determining application-specific dirs.
+
+See for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+# http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version_info__ = (1, 3, 0)
+__version__ = '.'.join(map(str, __version_info__))
+
+
+import sys
+import os
+
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+ unicode = str
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+ r"""Return full path to the user-specific data dir for this application.
+
+ "appname" is the name of application.
+ If None, just the system directory is returned.
+ "appauthor" (only required and used on Windows) is the name of the
+ appauthor or distributing body for this application. Typically
+ it is the owning company name. This falls back to appname.
+ "version" is an optional version path element to append to the
+ path. You might want to use this if you want multiple versions
+ of your app to be able to run independently. If used, this
+ would typically be ".".
+ Only applied when appname is present.
+ "roaming" (boolean, default False) can be set True to use the Windows
+ roaming appdata directory. That means that for users on a Windows
+ network setup for roaming profiles, this user data will be
+ sync'd on login. See
+
+ for a discussion of issues.
+
+ Typical user data directories are:
+ Mac OS X: ~/Library/Application Support/
+ Unix: ~/.local/share/ # or in $XDG_DATA_HOME, if defined
+ Win XP (not roaming): C:\Documents and Settings\\Application Data\\
+ Win XP (roaming): C:\Documents and Settings\\Local Settings\Application Data\\
+ Win 7 (not roaming): C:\Users\\AppData\Local\\
+ Win 7 (roaming): C:\Users\\AppData\Roaming\\
+
+ For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+ That means, by deafult "~/.local/share/".
+ """
+ if sys.platform == "win32":
+ if appauthor is None:
+ appauthor = appname
+ const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+ path = os.path.normpath(_get_win_folder(const))
+ if appname:
+ path = os.path.join(path, appauthor, appname)
+ elif sys.platform == 'darwin':
+ path = os.path.expanduser('~/Library/Application Support/')
+ if appname:
+ path = os.path.join(path, appname)
+ else:
+ path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+ if appname:
+ path = os.path.join(path, appname)
+ if appname and version:
+ path = os.path.join(path, version)
+ return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+ """Return full path to the user-shared data dir for this application.
+
+ "appname" is the name of application.
+ If None, just the system directory is returned.
+ "appauthor" (only required and used on Windows) is the name of the
+ appauthor or distributing body for this application. Typically
+ it is the owning company name. This falls back to appname.
+ "version" is an optional version path element to append to the
+ path. You might want to use this if you want multiple versions
+ of your app to be able to run independently. If used, this
+ would typically be ".".
+ Only applied when appname is present.
+ "multipath" is an optional parameter only applicable to *nix
+ which indicates that the entire list of data dirs should be
+ returned. By default, the first item from XDG_DATA_DIRS is
+ returned, or '/usr/local/share/',
+ if XDG_DATA_DIRS is not set
+
+ Typical user data directories are:
+ Mac OS X: /Library/Application Support/
+ Unix: /usr/local/share/ or /usr/share/
+ Win XP: C:\Documents and Settings\All Users\Application Data\\
+ Vista: (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+ Win 7: C:\ProgramData\\ # Hidden, but writeable on Win 7.
+
+ For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+ WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+ """
+ if sys.platform == "win32":
+ if appauthor is None:
+ appauthor = appname
+ path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+ if appname:
+ path = os.path.join(path, appauthor, appname)
+ elif sys.platform == 'darwin':
+ path = os.path.expanduser('/Library/Application Support')
+ if appname:
+ path = os.path.join(path, appname)
+ else:
+ # XDG default for $XDG_DATA_DIRS
+ # only first, if multipath is False
+ path = os.getenv('XDG_DATA_DIRS',
+ os.pathsep.join(['/usr/local/share', '/usr/share']))
+ pathlist = [ os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep) ]
+ if appname:
+ if version:
+ appname = os.path.join(appname, version)
+ pathlist = [ os.sep.join([x, appname]) for x in pathlist ]
+
+ if multipath:
+ path = os.pathsep.join(pathlist)
+ else:
+ path = pathlist[0]
+ return path
+
+ if appname and version:
+ path = os.path.join(path, version)
+ return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+ r"""Return full path to the user-specific config dir for this application.
+
+ "appname" is the name of application.
+ If None, just the system directory is returned.
+ "appauthor" (only required and used on Windows) is the name of the
+ appauthor or distributing body for this application. Typically
+ it is the owning company name. This falls back to appname.
+ "version" is an optional version path element to append to the
+ path. You might want to use this if you want multiple versions
+ of your app to be able to run independently. If used, this
+ would typically be ".".
+ Only applied when appname is present.
+ "roaming" (boolean, default False) can be set True to use the Windows
+ roaming appdata directory. That means that for users on a Windows
+ network setup for roaming profiles, this user data will be
+ sync'd on login. See
+
+ for a discussion of issues.
+
+ Typical user data directories are:
+ Mac OS X: same as user_data_dir
+ Unix: ~/.config/ # or in $XDG_CONFIG_HOME, if defined
+ Win *: same as user_data_dir
+
+ For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+ That means, by deafult "~/.local/share/".
+ """
+ if sys.platform in [ "win32", "darwin" ]:
+ path = user_data_dir(appname, appauthor, None, roaming)
+ else:
+ path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+ if appname:
+ path = os.path.join(path, appname)
+ if appname and version:
+ path = os.path.join(path, version)
+ return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+ """Return full path to the user-shared data dir for this application.
+
+ "appname" is the name of application.
+ If None, just the system directory is returned.
+ "appauthor" (only required and used on Windows) is the name of the
+ appauthor or distributing body for this application. Typically
+ it is the owning company name. This falls back to appname.
+ "version" is an optional version path element to append to the
+ path. You might want to use this if you want multiple versions
+ of your app to be able to run independently. If used, this
+ would typically be ".".
+ Only applied when appname is present.
+ "multipath" is an optional parameter only applicable to *nix
+ which indicates that the entire list of config dirs should be
+ returned. By default, the first item from XDG_CONFIG_DIRS is
+ returned, or '/etc/xdg/', if XDG_CONFIG_DIRS is not set
+
+ Typical user data directories are:
+ Mac OS X: same as site_data_dir
+ Unix: /etc/xdg/ or $XDG_CONFIG_DIRS[i]/ for each value in
+ $XDG_CONFIG_DIRS
+ Win *: same as site_data_dir
+ Vista: (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+ For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+ WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+ """
+ if sys.platform in [ "win32", "darwin" ]:
+ path = site_data_dir(appname, appauthor)
+ if appname and version:
+ path = os.path.join(path, version)
+ else:
+ # XDG default for $XDG_CONFIG_DIRS
+ # only first, if multipath is False
+ path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+ pathlist = [ os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep) ]
+ if appname:
+ if version:
+ appname = os.path.join(appname, version)
+ pathlist = [ os.sep.join([x, appname]) for x in pathlist ]
+
+ if multipath:
+ path = os.pathsep.join(pathlist)
+ else:
+ path = pathlist[0]
+ return path
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+ r"""Return full path to the user-specific cache dir for this application.
+
+ "appname" is the name of application.
+ If None, just the system directory is returned.
+ "appauthor" (only required and used on Windows) is the name of the
+ appauthor or distributing body for this application. Typically
+ it is the owning company name. This falls back to appname.
+ "version" is an optional version path element to append to the
+ path. You might want to use this if you want multiple versions
+ of your app to be able to run independently. If used, this
+ would typically be ".".
+ Only applied when appname is present.
+ "opinion" (boolean) can be False to disable the appending of
+ "Cache" to the base app data dir for Windows. See
+ discussion below.
+
+ Typical user cache directories are:
+ Mac OS X: ~/Library/Caches/
+ Unix: ~/.cache/ (XDG default)
+ Win XP: C:\Documents and Settings\\Local Settings\Application Data\\\Cache
+ Vista: C:\Users\\AppData\Local\\\Cache
+
+ On Windows the only suggestion in the MSDN docs is that local settings go in
+ the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+ app data dir (the default returned by `user_data_dir` above). Apps typically
+ put cache data somewhere *under* the given dir here. Some examples:
+ ...\Mozilla\Firefox\Profiles\\Cache
+ ...\Acme\SuperApp\Cache\1.0
+ OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+ This can be disabled with the `opinion=False` option.
+ """
+ if sys.platform == "win32":
+ if appauthor is None:
+ appauthor = appname
+ path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+ if appname:
+ path = os.path.join(path, appauthor, appname)
+ if opinion:
+ path = os.path.join(path, "Cache")
+ elif sys.platform == 'darwin':
+ path = os.path.expanduser('~/Library/Caches')
+ if appname:
+ path = os.path.join(path, appname)
+ else:
+ path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+ if appname:
+ path = os.path.join(path, appname)
+ if appname and version:
+ path = os.path.join(path, version)
+ return path
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+ r"""Return full path to the user-specific log dir for this application.
+
+ "appname" is the name of application.
+ If None, just the system directory is returned.
+ "appauthor" (only required and used on Windows) is the name of the
+ appauthor or distributing body for this application. Typically
+ it is the owning company name. This falls back to appname.
+ "version" is an optional version path element to append to the
+ path. You might want to use this if you want multiple versions
+ of your app to be able to run independently. If used, this
+ would typically be ".".
+ Only applied when appname is present.
+ "opinion" (boolean) can be False to disable the appending of
+ "Logs" to the base app data dir for Windows, and "log" to the
+ base cache dir for Unix. See discussion below.
+
+ Typical user cache directories are:
+ Mac OS X: ~/Library/Logs/
+ Unix: ~/.cache//log # or under $XDG_CACHE_HOME if defined
+ Win XP: C:\Documents and Settings\\Local Settings\Application Data\\\Logs
+ Vista: C:\Users\\AppData\Local\\\Logs
+
+ On Windows the only suggestion in the MSDN docs is that local settings
+ go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+ examples of what some windows apps use for a logs dir.)
+
+ OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+ value for Windows and appends "log" to the user cache dir for Unix.
+ This can be disabled with the `opinion=False` option.
+ """
+ if sys.platform == "darwin":
+ path = os.path.join(
+ os.path.expanduser('~/Library/Logs'),
+ appname)
+ elif sys.platform == "win32":
+ path = user_data_dir(appname, appauthor, version); version=False
+ if opinion:
+ path = os.path.join(path, "Logs")
+ else:
+ path = user_cache_dir(appname, appauthor, version); version=False
+ if opinion:
+ path = os.path.join(path, "log")
+ if appname and version:
+ path = os.path.join(path, version)
+ return path
+
+
+class AppDirs(object):
+ """Convenience wrapper for getting application dirs."""
+ def __init__(self, appname, appauthor=None, version=None,
+ roaming=False, multipath=False):
+ self.appname = appname
+ self.appauthor = appauthor
+ self.version = version
+ self.roaming = roaming
+ self.multipath = multipath
+ @property
+ def user_data_dir(self):
+ return user_data_dir(self.appname, self.appauthor,
+ version=self.version, roaming=self.roaming)
+ @property
+ def site_data_dir(self):
+ return site_data_dir(self.appname, self.appauthor,
+ version=self.version, multipath=self.multipath)
+ @property
+ def user_config_dir(self):
+ return user_config_dir(self.appname, self.appauthor,
+ version=self.version, roaming=self.roaming)
+ @property
+ def site_config_dir(self):
+ return site_data_dir(self.appname, self.appauthor,
+ version=self.version, multipath=self.multipath)
+ @property
+ def user_cache_dir(self):
+ return user_cache_dir(self.appname, self.appauthor,
+ version=self.version)
+ @property
+ def user_log_dir(self):
+ return user_log_dir(self.appname, self.appauthor,
+ version=self.version)
+
+
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+ """This is a fallback technique at best. I'm not sure if using the
+ registry for this guarantees us the correct answer for all CSIDL_*
+ names.
+ """
+ import _winreg
+
+ shell_folder_name = {
+ "CSIDL_APPDATA": "AppData",
+ "CSIDL_COMMON_APPDATA": "Common AppData",
+ "CSIDL_LOCAL_APPDATA": "Local AppData",
+ }[csidl_name]
+
+ key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
+ r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
+ dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+ return dir
+
+def _get_win_folder_with_pywin32(csidl_name):
+ from win32com.shell import shellcon, shell
+ dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+ # Try to make this a unicode path because SHGetFolderPath does
+ # not return unicode strings when there is unicode data in the
+ # path.
+ try:
+ dir = unicode(dir)
+
+ # Downgrade to short path name if have highbit chars. See
+ # .
+ has_high_char = False
+ for c in dir:
+ if ord(c) > 255:
+ has_high_char = True
+ break
+ if has_high_char:
+ try:
+ import win32api
+ dir = win32api.GetShortPathName(dir)
+ except ImportError:
+ pass
+ except UnicodeError:
+ pass
+ return dir
+
+def _get_win_folder_with_ctypes(csidl_name):
+ import ctypes
+
+ csidl_const = {
+ "CSIDL_APPDATA": 26,
+ "CSIDL_COMMON_APPDATA": 35,
+ "CSIDL_LOCAL_APPDATA": 28,
+ }[csidl_name]
+
+ buf = ctypes.create_unicode_buffer(1024)
+ ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+ # Downgrade to short path name if have highbit chars. See
+ # .
+ has_high_char = False
+ for c in buf:
+ if ord(c) > 255:
+ has_high_char = True
+ break
+ if has_high_char:
+ buf2 = ctypes.create_unicode_buffer(1024)
+ if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+ buf = buf2
+
+ return buf.value
+
+if sys.platform == "win32":
+ try:
+ import win32com.shell
+ _get_win_folder = _get_win_folder_with_pywin32
+ except ImportError:
+ try:
+ import ctypes
+ _get_win_folder = _get_win_folder_with_ctypes
+ except ImportError:
+ _get_win_folder = _get_win_folder_from_registry
+
+
+
+#---- self test code
+
+if __name__ == "__main__":
+ appname = "MyApp"
+ appauthor = "MyCompany"
+
+ props = ("user_data_dir", "site_data_dir",
+ "user_config_dir", "site_config_dir",
+ "user_cache_dir", "user_log_dir")
+
+ print("-- app dirs (with optional 'version')")
+ dirs = AppDirs(appname, appauthor, version="1.0")
+ for prop in props:
+ print("%s: %s" % (prop, getattr(dirs, prop)))
+
+ print("\n-- app dirs (without optional 'version')")
+ dirs = AppDirs(appname, appauthor)
+ for prop in props:
+ print("%s: %s" % (prop, getattr(dirs, prop)))
+
+ print("\n-- app dirs (without optional 'appauthor')")
+ dirs = AppDirs(appname)
+ for prop in props:
+ print("%s: %s" % (prop, getattr(dirs, prop)))
+
diff --git a/openerp/tools/config.py b/openerp/tools/config.py
index 91fdbca86ad..255a065aa4f 100644
--- a/openerp/tools/config.py
+++ b/openerp/tools/config.py
@@ -3,7 +3,7 @@
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2009 Tiny SPRL ().
-# Copyright (C) 2010-2012 OpenERP s.a. ().
+# Copyright (C) 2010-2014 OpenERP s.a. ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
@@ -29,6 +29,7 @@ import openerp.conf
import openerp.loglevels as loglevels
import logging
import openerp.release as release
+import appdirs
class MyOption (optparse.Option, object):
""" optparse Option with two additional attributes.
@@ -59,6 +60,9 @@ def check_ssl():
DEFAULT_LOG_HANDLER = [':INFO']
+def _get_default_datadir():
+ return appdirs.user_data_dir(appname='OpenERP', appauthor=release.author)
+
class configmanager(object):
def __init__(self, fname=None):
# Options not exposed on the command line. Command line options will be added
@@ -106,6 +110,9 @@ class configmanager(object):
help="specify additional addons paths (separated by commas).",
action="callback", callback=self._check_addons_path, nargs=1, type="string")
group.add_option("--load", dest="server_wide_modules", help="Comma-separated list of server-wide modules default=web")
+
+ group.add_option("-D", "--data-dir", dest="data_dir", my_default=_get_default_datadir(),
+ help="Directory where to store OpenERP data")
parser.add_option_group(group)
# XML-RPC / HTTP
@@ -245,7 +252,8 @@ class configmanager(object):
# Advanced options
group = optparse.OptionGroup(parser, "Advanced options")
- group.add_option('--auto-reload', dest='auto_reload', action='store_true', my_default=False, help='enable auto reload')
+ if os.name == 'posix':
+ group.add_option('--auto-reload', dest='auto_reload', action='store_true', my_default=False, help='enable auto reload')
group.add_option('--debug', dest='debug_mode', action='store_true', my_default=False, help='enable debug mode')
group.add_option("--stop-after-init", action="store_true", dest="stop_after_init", my_default=False,
help="stop the server after its initialization")
@@ -267,27 +275,28 @@ class configmanager(object):
help="Use the unaccent function provided by the database when available.")
parser.add_option_group(group)
- group = optparse.OptionGroup(parser, "Multiprocessing options")
- # TODO sensible default for the three following limits.
- group.add_option("--workers", dest="workers", my_default=0,
- help="Specify the number of workers, 0 disable prefork mode.",
- type="int")
- group.add_option("--limit-memory-soft", dest="limit_memory_soft", my_default=640 * 1024 * 1024,
- help="Maximum allowed virtual memory per worker, when reached the worker be reset after the current request (default 671088640 aka 640MB).",
- type="int")
- group.add_option("--limit-memory-hard", dest="limit_memory_hard", my_default=768 * 1024 * 1024,
- help="Maximum allowed virtual memory per worker, when reached, any memory allocation will fail (default 805306368 aka 768MB).",
- type="int")
- group.add_option("--limit-time-cpu", dest="limit_time_cpu", my_default=60,
- help="Maximum allowed CPU time per request (default 60).",
- type="int")
- group.add_option("--limit-time-real", dest="limit_time_real", my_default=120,
- help="Maximum allowed Real time per request (default 120).",
- type="int")
- group.add_option("--limit-request", dest="limit_request", my_default=8192,
- help="Maximum number of request to be processed per worker (default 8192).",
- type="int")
- parser.add_option_group(group)
+ if os.name == 'posix':
+ group = optparse.OptionGroup(parser, "Multiprocessing options")
+ # TODO sensible default for the three following limits.
+ group.add_option("--workers", dest="workers", my_default=0,
+ help="Specify the number of workers, 0 disable prefork mode.",
+ type="int")
+ group.add_option("--limit-memory-soft", dest="limit_memory_soft", my_default=2048 * 1024 * 1024,
+ help="Maximum allowed virtual memory per worker, when reached the worker be reset after the current request (default 671088640 aka 640MB).",
+ type="int")
+ group.add_option("--limit-memory-hard", dest="limit_memory_hard", my_default=2560 * 1024 * 1024,
+ help="Maximum allowed virtual memory per worker, when reached, any memory allocation will fail (default 805306368 aka 768MB).",
+ type="int")
+ group.add_option("--limit-time-cpu", dest="limit_time_cpu", my_default=60,
+ help="Maximum allowed CPU time per request (default 60).",
+ type="int")
+ group.add_option("--limit-time-real", dest="limit_time_real", my_default=120,
+ help="Maximum allowed Real time per request (default 120).",
+ type="int")
+ group.add_option("--limit-request", dest="limit_request", my_default=8192,
+ help="Maximum number of request to be processed per worker (default 8192).",
+ type="int")
+ parser.add_option_group(group)
# Copy all optparse options (i.e. MyOption) into self.options.
for group in parser.option_groups:
@@ -348,6 +357,7 @@ class configmanager(object):
# (../etc from the server)
# if the server is run by an unprivileged user, he has to specify location of a config file where he has the rights to write,
# else he won't be able to save the configurations, or even to start the server...
+ # TODO use appdirs
if os.name == 'nt':
rcfilepath = os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])), 'openerp-server.conf')
else:
@@ -358,7 +368,6 @@ class configmanager(object):
or os.environ.get('OPENERP_SERVER') or rcfilepath)
self.load()
-
# Verify that we want to log or not, if not the output will go to stdout
if self.options['logfile'] in ('None', 'False'):
self.options['logfile'] = False
@@ -387,7 +396,6 @@ class configmanager(object):
elif isinstance(self.options[arg], basestring) and self.casts[arg].type in optparse.Option.TYPE_CHECKER:
self.options[arg] = optparse.Option.TYPE_CHECKER[self.casts[arg].type](self.casts[arg], arg, self.options[arg])
-
if isinstance(self.options['log_handler'], basestring):
self.options['log_handler'] = self.options['log_handler'].split(',')
@@ -399,11 +407,22 @@ class configmanager(object):
'list_db', 'xmlrpcs', 'proxy_mode',
'test_file', 'test_enable', 'test_commit', 'test_report_directory',
'osv_memory_count_limit', 'osv_memory_age_limit', 'max_cron_threads', 'unaccent',
- 'workers', 'limit_memory_hard', 'limit_memory_soft', 'limit_time_cpu', 'limit_time_real', 'limit_request', 'auto_reload'
+ 'data_dir',
]
+ posix_keys = [
+ 'auto_reload', 'workers',
+ 'limit_memory_hard', 'limit_memory_soft',
+ 'limit_time_cpu', 'limit_time_real', 'limit_request',
+ ]
+
+ if os.name == 'posix':
+ keys += posix_keys
+ else:
+ self.options.update(dict.fromkeys(posix_keys, None))
+
+ # Copy the command-line arguments...
for arg in keys:
- # Copy the command-line argument...
if getattr(opt, arg) is not None:
self.options[arg] = getattr(opt, arg)
# ... or keep, but cast, the config file value.
@@ -617,6 +636,24 @@ class configmanager(object):
def __getitem__(self, key):
return self.options[key]
+ @property
+ def addons_data_dir(self):
+ d = os.path.join(self['data_dir'], 'addons', release.series)
+ if not os.path.exists(d):
+ os.makedirs(d, 0700)
+ else:
+ os.chmod(d, 0700)
+ return d
+
+ @property
+ def session_dir(self):
+ d = os.path.join(self['data_dir'], 'sessions', release.series)
+ if not os.path.exists(d):
+ os.makedirs(d, 0700)
+ else:
+ os.chmod(d, 0700)
+ return d
+
config = configmanager()
diff --git a/openerp/tools/image.py b/openerp/tools/image.py
index 5e5055f252d..08c2fd91f21 100644
--- a/openerp/tools/image.py
+++ b/openerp/tools/image.py
@@ -25,14 +25,14 @@ except ImportError:
import StringIO
from PIL import Image
-from PIL import ImageOps
+from PIL import ImageEnhance
from random import randint
# ----------------------------------------
# Image resizing
# ----------------------------------------
-def image_resize_image(base64_source, size=(1024, 1024), encoding='base64', filetype='PNG', avoid_if_small=False):
+def image_resize_image(base64_source, size=(1024, 1024), encoding='base64', filetype=None, avoid_if_small=False):
""" Function to resize an image. The image will be resized to the given
size, while keeping the aspect ratios, and holes in the image will be
filled with transparent background. The image will not be stretched if
@@ -58,7 +58,8 @@ def image_resize_image(base64_source, size=(1024, 1024), encoding='base64', file
height mean an automatically computed value based respectivelly
on height or width of the source image.
:param encoding: the output encoding
- :param filetype: the output filetype
+ :param filetype: the output filetype, by default the source image's
+ :type filetype: str, any PIL image format (supported for creation)
:param avoid_if_small: do not resize if image height and width
are smaller than the expected size.
"""
@@ -68,6 +69,8 @@ def image_resize_image(base64_source, size=(1024, 1024), encoding='base64', file
return base64_source
image_stream = StringIO.StringIO(base64_source.decode(encoding))
image = Image.open(image_stream)
+ # store filetype here, as Image.new below will lose image.format
+ filetype = filetype or image.format
asked_width, asked_height = size
if asked_width is None:
@@ -81,8 +84,13 @@ def image_resize_image(base64_source, size=(1024, 1024), encoding='base64', file
return base64_source
if image.size != size:
- # If you need faster thumbnails you may use use Image.NEAREST
- image = ImageOps.fit(image, size, Image.ANTIALIAS)
+ # create a thumbnail: will resize and keep ratios, then sharpen for better looking result
+ image.thumbnail(size, Image.ANTIALIAS)
+ sharpener = ImageEnhance.Sharpness(image.convert('RGBA'))
+ resized_image = sharpener.enhance(2.0)
+ # create a transparent image for background and paste the image on it
+ image = Image.new('RGBA', size, (255, 255, 255, 0))
+ image.paste(resized_image, ((size[0] - resized_image.size[0]) / 2, (size[1] - resized_image.size[1]) / 2))
if image.mode not in ["1", "L", "P", "RGB", "RGBA"]:
image = image.convert("RGB")
@@ -90,21 +98,21 @@ def image_resize_image(base64_source, size=(1024, 1024), encoding='base64', file
image.save(background_stream, filetype)
return background_stream.getvalue().encode(encoding)
-def image_resize_image_big(base64_source, size=(1204, 1204), encoding='base64', filetype='PNG', avoid_if_small=True):
+def image_resize_image_big(base64_source, size=(1204, 1024), encoding='base64', filetype=None, avoid_if_small=True):
""" Wrapper on image_resize_image, to resize images larger than the standard
'big' image size: 1024x1024px.
:param size, encoding, filetype, avoid_if_small: refer to image_resize_image
"""
return image_resize_image(base64_source, size, encoding, filetype, avoid_if_small)
-def image_resize_image_medium(base64_source, size=(128, 128), encoding='base64', filetype='PNG', avoid_if_small=False):
+def image_resize_image_medium(base64_source, size=(128, 128), encoding='base64', filetype=None, avoid_if_small=False):
""" Wrapper on image_resize_image, to resize to the standard 'medium'
image size: 180x180.
:param size, encoding, filetype, avoid_if_small: refer to image_resize_image
"""
return image_resize_image(base64_source, size, encoding, filetype, avoid_if_small)
-def image_resize_image_small(base64_source, size=(64, 64), encoding='base64', filetype='PNG', avoid_if_small=False):
+def image_resize_image_small(base64_source, size=(64, 64), encoding='base64', filetype=None, avoid_if_small=False):
""" Wrapper on image_resize_image, to resize to the standard 'small' image
size: 50x50.
:param size, encoding, filetype, avoid_if_small: refer to image_resize_image
diff --git a/openerp/tools/osutil.py b/openerp/tools/osutil.py
index b5cff6b2646..94684d34673 100644
--- a/openerp/tools/osutil.py
+++ b/openerp/tools/osutil.py
@@ -23,8 +23,12 @@
Some functions related to the os and os.path module
"""
+from contextlib import contextmanager
import os
from os.path import join as opj
+import shutil
+import tempfile
+import zipfile
if os.name == 'nt':
import ctypes
@@ -61,6 +65,30 @@ def walksymlinks(top, topdown=True, onerror=None):
if not topdown:
yield dirpath, dirnames, filenames
+@contextmanager
+def tempdir():
+ tmpdir = tempfile.mkdtemp()
+ try:
+ yield tmpdir
+ finally:
+ shutil.rmtree(tmpdir)
+
+def zip_dir(path, stream, include_dir=True): # TODO add ignore list
+ path = os.path.normpath(path)
+ len_prefix = len(os.path.dirname(path)) if include_dir else len(path)
+ if len_prefix:
+ len_prefix += 1
+
+ with zipfile.ZipFile(stream, 'w', compression=zipfile.ZIP_DEFLATED, allowZip64=True) as zipf:
+ for dirpath, dirnames, filenames in os.walk(path):
+ for fname in filenames:
+ bname, ext = os.path.splitext(fname)
+ ext = ext or bname
+ if ext not in ['.pyc', '.pyo', '.swp', '.DS_Store']:
+ path = os.path.normpath(os.path.join(dirpath, fname))
+ if os.path.isfile(path):
+ zipf.write(path, path[len_prefix:])
+
if os.name != 'nt':
getppid = os.getppid
diff --git a/openerp/tools/safe_eval.py b/openerp/tools/safe_eval.py
index b64b401a71c..508a072a3b2 100644
--- a/openerp/tools/safe_eval.py
+++ b/openerp/tools/safe_eval.py
@@ -1,6 +1,6 @@
# -*- coding: utf-8 -*-
##############################################################################
-# Copyright (C) 2004-2012 OpenERP s.a. ().
+# Copyright (C) 2004-2014 OpenERP s.a. ().
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
@@ -225,9 +225,14 @@ def safe_eval(expr, globals_dict=None, locals_dict=None, mode="eval", nocopy=Fal
'False': False,
'None': None,
'str': str,
+ 'unicode': unicode,
'globals': locals,
'locals': locals,
'bool': bool,
+ 'int': int,
+ 'float': float,
+ 'long': long,
+ 'enumerate': enumerate,
'dict': dict,
'list': list,
'tuple': tuple,
@@ -235,15 +240,23 @@ def safe_eval(expr, globals_dict=None, locals_dict=None, mode="eval", nocopy=Fal
'abs': abs,
'min': min,
'max': max,
+ 'sum': sum,
'reduce': reduce,
'filter': filter,
'round': round,
'len': len,
- 'set': set,
'repr': repr,
- 'int': int,
- 'float': float,
+ 'set': set,
+ 'all': all,
+ 'any': any,
+ 'ord': ord,
+ 'chr': chr,
+ 'cmp': cmp,
+ 'divmod': divmod,
+ 'isinstance': isinstance,
'range': range,
+ 'xrange': xrange,
+ 'zip': zip,
}
)
if locals_builtins:
diff --git a/openerp/tools/translate.py b/openerp/tools/translate.py
index 58eefc92df4..6f5b22f4f53 100644
--- a/openerp/tools/translate.py
+++ b/openerp/tools/translate.py
@@ -778,49 +778,32 @@ def trans_generate(lang, modules, cr):
if model_obj._sql_constraints:
push_local_constraints(module, model_obj, 'sql_constraints')
- def get_module_from_path(path, mod_paths=None):
- if not mod_paths:
- # First, construct a list of possible paths
- def_path = os.path.abspath(os.path.join(config.config['root_path'], 'addons')) # default addons path (base)
- ad_paths= map(lambda m: os.path.abspath(m.strip()),config.config['addons_path'].split(','))
- mod_paths=[def_path]
- for adp in ad_paths:
- mod_paths.append(adp)
- if not os.path.isabs(adp):
- mod_paths.append(adp)
- elif adp.startswith(def_path):
- mod_paths.append(adp[len(def_path)+1:])
- for mp in mod_paths:
- if path.startswith(mp) and (os.path.dirname(path) != mp):
- path = path[len(mp)+1:]
- return path.split(os.path.sep)[0]
- return 'base' # files that are not in a module are considered as being in 'base' module
modobj = registry['ir.module.module']
installed_modids = modobj.search(cr, uid, [('state', '=', 'installed')])
installed_modules = map(lambda m: m['name'], modobj.read(cr, uid, installed_modids, ['name']))
- root_path = os.path.join(config.config['root_path'], 'addons')
-
- apaths = map(os.path.abspath, map(str.strip, config.config['addons_path'].split(',')))
- if root_path in apaths:
- path_list = apaths
- else :
- path_list = [root_path,] + apaths
-
+ path_list = list(openerp.modules.module.ad_paths)
# Also scan these non-addon paths
for bin_path in ['osv', 'report' ]:
path_list.append(os.path.join(config.config['root_path'], bin_path))
_logger.debug("Scanning modules at paths: ", path_list)
- mod_paths = []
+ mod_paths = list(path_list)
+
+ def get_module_from_path(path):
+ for mp in mod_paths:
+ if path.startswith(mp) and (os.path.dirname(path) != mp):
+ path = path[len(mp)+1:]
+ return path.split(os.path.sep)[0]
+ return 'base' # files that are not in a module are considered as being in 'base' module
def verified_module_filepaths(fname, path, root):
fabsolutepath = join(root, fname)
frelativepath = fabsolutepath[len(path):]
display_path = "addons%s" % frelativepath
- module = get_module_from_path(fabsolutepath, mod_paths=mod_paths)
+ module = get_module_from_path(fabsolutepath)
if ('all' in modules or module in modules) and module in installed_modules:
return module, fabsolutepath, frelativepath, display_path
return None, None, None, None
diff --git a/openerpcommand/initialize.py b/openerpcommand/initialize.py
index 3723e9f5c01..cf4e54bfb82 100644
--- a/openerpcommand/initialize.py
+++ b/openerpcommand/initialize.py
@@ -9,26 +9,6 @@ import time
import common
-def install_openerp(database_name, create_database_flag, module_names, install_demo_data):
- import openerp
- config = openerp.tools.config
-
- if create_database_flag:
- with lock_file('/tmp/global_openerp_create_database.lock'):
- create_database(database_name)
-
- config['init'] = dict.fromkeys(module_names, 1)
-
- # Install the import hook, to import openerp.addons..
- openerp.modules.module.initialize_sys_path()
-
- print
-
- registry = openerp.modules.registry.RegistryManager.get(
- database_name, update_module=True, force_demo=install_demo_data)
-
- return registry
-
# From http://code.activestate.com/recipes/576572/
@contextlib.contextmanager
def lock_file(path, wait_delay=.1, max_try=600):
@@ -52,21 +32,6 @@ def lock_file(path, wait_delay=.1, max_try=600):
os.close(fd)
os.unlink(path)
-# TODO turn template1 in a parameter
-# This should be exposed from openerp (currently in
-# openerp/service/web_services.py).
-def create_database(database_name):
- import openerp
- db = openerp.sql_db.db_connect('template1')
- cr = db.cursor() # TODO `with db as cr:`
- try:
- cr.autocommit(True)
- cr.execute("""CREATE DATABASE "%s"
- ENCODING 'unicode' TEMPLATE "template1" """ \
- % (database_name,))
- finally:
- cr.close()
-
def run(args):
assert args.database
assert not (args.module and args.all_modules)
@@ -74,11 +39,14 @@ def run(args):
import openerp
config = openerp.tools.config
+ config['db_name'] = args.database
if args.tests:
config['log_handler'] = [':INFO']
config['test_enable'] = True
config['without_demo'] = False
+ if args.port:
+ config['xmlrpc_port'] = int(args.port)
else:
config['log_handler'] = [':CRITICAL']
config['test_enable'] = False
@@ -90,14 +58,13 @@ def run(args):
args.addons = []
config['addons_path'] = ','.join(args.addons)
- print "MY addons path is", config['addons_path']
-
if args.all_modules:
module_names = common.get_addons_from_paths(args.addons, args.exclude)
elif args.module:
module_names = args.module
else:
module_names = ['base']
+ config['init'] = dict.fromkeys(module_names, 1)
if args.coverage:
import coverage
@@ -106,17 +73,22 @@ def run(args):
cov = coverage.coverage(branch=True, include='*.py')
cov.start()
openerp.netsvc.init_logger()
- registry = install_openerp(args.database, not args.no_create, module_names, not config['without_demo'])
+
+ if not args.no_create:
+ with lock_file('/tmp/global_openerp_create_database.lock'):
+ openerp.service.db._create_empty_database(args.database)
+
+ config['workers'] = False
+
+ rc = openerp.service.server.start(preload=[args.database], stop=True)
+
if args.coverage:
cov.stop()
cov.html_report(directory='coverage')
# If we wanted the report on stdout:
# cov.report()
- # The `_assertion_report` attribute was added on the registry during the
- # OpenERP 7.0 development.
- if hasattr(registry, '_assertion_report'):
- sys.exit(1 if registry._assertion_report.failures else 0)
+ sys.exit(rc)
def add_parser(subparsers):
parser = subparsers.add_parser('initialize',
@@ -124,6 +96,8 @@ def add_parser(subparsers):
parser.add_argument('-d', '--database', metavar='DATABASE',
**common.required_or_default('DATABASE', 'the database to create'))
common.add_addons_argument(parser)
+ parser.add_argument('-P', '--port', metavar='PORT',
+ **common.required_or_default('PORT', 'the server port'))
parser.add_argument('--module', metavar='MODULE', action='append',
help='specify a module to install'
' (this option can be repeated)')
diff --git a/setup.py b/setup.py
index 05178fb12ac..a44e26fd36f 100644
--- a/setup.py
+++ b/setup.py
@@ -75,7 +75,7 @@ def py2exe_options():
"skip_archive": 1,
"optimize": 0, # keep the assert running, because the integrated tests rely on them.
"dist_dir": 'dist',
- "packages": [ "DAV", "HTMLParser", "PIL", "asynchat", "asyncore", "commands", "dateutil", "decimal", "docutils", "email", "encodings", "imaplib", "jinja2", "lxml", "lxml._elementpath", "lxml.builder", "lxml.etree", "lxml.objectify", "mako", "openerp", "poplib", "pychart", "pydot", "pyparsing", "pytz", "reportlab", "select", "simplejson", "smtplib", "uuid", "vatnumber", "vobject", "xml", "xml.dom", "yaml", ],
+ "packages": ["HTMLParser", "PIL", "asynchat", "asyncore", "commands", "dateutil", "decimal", "docutils", "email", "encodings", "imaplib", "jinja2", "lxml", "lxml._elementpath", "lxml.builder", "lxml.etree", "lxml.objectify", "mako", "openerp", "poplib", "pychart", "pydot", "pyparsing", "pytz", "reportlab", "select", "simplejson", "smtplib", "uuid", "vatnumber", "vobject", "xml", "xml.dom", "yaml", ],
"excludes" : ["Tkconstants","Tkinter","tcl"],
}
}