Esempio n. 1
0
 def _acquire_job(self, db_name, cleanup=False):
     import odoo.addons.base as base
     acquired = base.ir.ir_cron.ir_cron._acquire_job(db_name)
     if cleanup:
         Registry.delete(db_name)
         close_db(db_name)
     return acquired
Esempio n. 2
0
def new_dump_db(db_name, stream, backup_format='zip', anonymized=True):
    if anonymized:
        with Registry.new(db_name).cursor() as cr:
            env = api.Environment(cr, SUPERUSER_ID, {})
            anon_query = env['ir.model.fields'].get_anonymization_query()
        if not anon_query:
            db._logger.info("No data to anonymize in database `%s`.", db_name)
        else:
            db._logger.info('Anonymize and dump database `%s`.', db_name)
            anon_db_name = '%s_anon_%s' % (db_name,
                                           time.strftime('%Y%m%d_%H%M%S'))
            db.exp_duplicate_database(db_name, anon_db_name)
            try:
                if backup_format == 'zip':
                    # To avoid to archive filestore
                    # with non-anonymized attachments
                    anon_fs = tools.config.filestore(anon_db_name)
                    shutil.rmtree(anon_fs, ignore_errors=True)
                with Registry.new(anon_db_name).cursor() as cr:
                    db._logger.info('ANONYMIZE DB: %s', anon_db_name)
                    cr.execute(anon_query)
            except Exception:
                db.exp_drop(anon_db_name)
            return NewDbDump(anon_db_name, stream, backup_format)
    return native_dump_db(db_name, stream, backup_format)
Esempio n. 3
0
 def install_modules(self):
     """Set all selected modules and actually install them."""
     self.ensure_one()
     self.module_ids.write({"state": "to install"})
     self.env.cr.commit()  # pylint: disable=invalid-commit
     Registry.new(self.env.cr.dbname, update_module=True)
     self.write({"state": "done"})
     return self.return_same_form_view()
Esempio n. 4
0
def export(ctx, language, db_name, module, fix):
    modules = module or ['all']

    from odoo.modules.registry import Registry
    from odooku.api import environment
    from odoo.tools import trans_export

    with tempfile.TemporaryFile() as t:

        # Perform checks (and possible fixes)
        registry = Registry(db_name)
        with registry.cursor() as cr:
            with environment(cr) as env:
                lang = env['res.lang'].with_context(
                    dict(active_test=False)).search([('code', '=', language)])
                if not lang:
                    raise ValueError("Language %s does not exist" % language)
                if not lang[0].active:
                    if not fix:
                        raise ValueError("Language %s is not activated" %
                                         language)
                    else:
                        installed = env['ir.module.module'].search([
                            ('state', '=', 'installed')
                        ])
                        installed._update_translations(language)

                if module:
                    installed = env['ir.module.module'].search([
                        ('name', 'in', module), ('state', '=', 'installed')
                    ])
                    missing = set(module) - set(
                        [mod.name for mod in installed])
                    if missing:
                        if not fix:
                            raise ValueError("Modules '%s' are not installed" %
                                             ", ".join(missing))
                        else:
                            ctx.obj['config']['init'] = {
                                module_name: 1
                                for module_name in module
                            }

        # Export
        registry = Registry.new(db_name, update_module=fix)
        with registry.cursor() as cr:
            with environment(cr) as env:
                trans_export(language, modules, t, 'po', cr)

        t.seek(0)
        # Pipe to stdout
        while True:
            chunk = t.read(CHUNK_SIZE)
            if not chunk:
                break
            sys.stdout.buffer.write(chunk)
Esempio n. 5
0
def newdbuuid(ctx, db_name):
    config = (ctx.obj['config'])

    from odoo.modules.registry import Registry
    from odooku.api import environment

    registry = Registry(db_name)
    with registry.cursor() as cr:
        with environment(cr) as env:
            env['ir.config_parameter'].init(force=True)
Esempio n. 6
0
 def create_user(self, login_name, help_id, db_name):
     result = {}
     result['is_success'] = True
     registry = Registry(db_name)
     cr = registry.cursor()
     env = api.Environment(cr, SUPERUSER_ID, {})
     user_id = env['res.users'].create_wechat_mini_user(login_name, help_id)
     result['user_id'] = user_id
     cr.commit()
     cr.close()
     return json.dumps(result)
Esempio n. 7
0
    def test_02_uninstall(self):
        """ Check a few things showing the module is uninstalled. """
        with environment() as env:
            module = env['ir.module.module'].search([('name', '=', MODULE)])
            assert len(module) == 1
            module.button_uninstall()
        Registry.new(common.get_db_name(), update_module=True)

        with environment() as env:
            self.assertNotIn('test_uninstall.model', env.registry)
            self.assertFalse(env['ir.model.data'].search([('module', '=', MODULE)]))
            self.assertFalse(env['ir.model.fields'].search([('model', '=', MODEL)]))
Esempio n. 8
0
    def setUp(self):
        super(TestAdvisoryLock, self).setUp()
        self.registry2 = Registry(common.get_db_name())
        self.cr2 = self.registry2.cursor()
        self.env2 = api.Environment(self.cr2, self.env.uid, {})

        @self.addCleanup
        def reset_cr2():
            # rollback and close the cursor, and reset the environments
            self.env2.reset()
            self.cr2.rollback()
            self.cr2.close()
Esempio n. 9
0
    def test_01_install(self):
        """ Check a few things showing the module is installed. """
        with environment() as env:
            module = env["ir.module.module"].search([("name", "=", MODULE)])
            assert len(module) == 1
            module.button_install()
        Registry.new(common.get_db_name(), update_module=True)

        with environment() as env:
            self.assertIn("test_uninstall.model", env.registry)
            self.assertTrue(env["ir.model.data"].search([("module", "=", MODULE)]))
            self.assertTrue(env["ir.model.fields"].search([("model", "=", MODEL)]))
 def install_all(self):
     """ Main wizard step. Set all installable modules to install
     and actually install them. Exclude testing modules. """
     modules = self.env['ir.module.module'].search([
         ('state', 'not in', ['installed', 'uninstallable', 'unknown']),
         ('category_id.name', '!=', 'Tests'),
         ('name', 'not in', BLACKLIST_MODULES),
     ])
     if modules:
         modules.write({'state': 'to install'})
         self.env.cr.commit()
         Registry.new(self.env.cr.dbname, update_module=True)
         self.write({'state': 'ready'})
     return True
Esempio n. 11
0
    def generate(self):
        """ Main wizard step. Make sure that all modules are up-to-date,
        then reinitialize all installed modules.
        Equivalent of running the server with '-d <database> --init all'

        The goal of this is to fill the records table.

        TODO: update module list and versions, then update all modules? """
        # Truncate the records table
        if (openupgrade_tools.table_exists(
            self.env.cr, 'openupgrade_attribute') and
                openupgrade_tools.table_exists(
                    self.env.cr, 'openupgrade_record')):
            self.env.cr.execute(
                'TRUNCATE openupgrade_attribute, openupgrade_record;'
                )

        # Need to get all modules in state 'installed'
        modules = self.env['ir.module.module'].search(
            [('state', 'in', ['to install', 'to upgrade'])])
        if modules:
            self.env.cr.commit()
            Registry.new(self.env.cr.dbname, update_module=True)
        # Did we succeed above?
        modules = self.env['ir.module.module'].search(
            [('state', 'in', ['to install', 'to upgrade'])])
        if modules:
            raise UserError(
                "Cannot seem to install or upgrade modules %s" % (
                    ', '.join([module.name for module in modules])))
        # Now reinitialize all installed modules
        self.env['ir.module.module'].search(
            [('state', '=', 'installed')]).write(
                {'state': 'to install'})
        self.env.cr.commit()
        Registry.new(self.env.cr.dbname, update_module=True)

        # Set noupdate property from ir_model_data
        self.env.cr.execute(
            """ UPDATE openupgrade_record our
            SET noupdate = imd.noupdate
            FROM ir_model_data imd
            WHERE our.type = 'xmlid'
                AND our.model = imd.model
                AND our.name = imd.module || '.' || imd.name
            """)
        self.env.invalidate([
            (self.env['openupgrade.record']._fields['noupdate'], None),
        ])
        return self.write({'state': 'ready'})
Esempio n. 12
0
    def setUp(self):
        super().setUp()
        self.registry2 = Registry(common.get_db_name())
        self.cr2 = self.registry2.cursor()
        self.env2 = api.Environment(self.cr2, self.env.uid, {})

        @self.addCleanup
        def reset_cr2():
            # rollback and close the cursor, and reset the environments
            self.env2.reset()
            self.cr2.rollback()
            self.cr2.close()

        self.backend2 = self.env2['infor.backend'].browse(self.backend.id)
Esempio n. 13
0
def authenticate(token):
    try:
        a = 4 - len(token) % 4
        if a != 0:
            token += '==' if a == 2 else '='
        SERVER, db, login, uid, ts = base64.urlsafe_b64decode(
            str(token)).split(',')
        if int(ts) + 60 * 60 * 24 * 7 * 10 < time.time():
            return False
        registry = Registry(db)
        cr = registry.cursor()
        env = api.Environment(cr, int(uid), {})
    except Exception as e:
        return str(e)
    return env
 def __enter__(self):
     """
     Context enter function.
     Temporarily add odoo 10 server path to system path and pop afterwards.
     Import odoo 10 server from path as library.
     Init logger, registry and environment.
     Add addons path to config.
     :returns Odoo10Context: This instance
     """
     sys.path.append(self.server_path)
     from odoo import netsvc, api
     from odoo.modules.registry import Registry
     from odoo.tools import trans_export, config, trans_load_data
     self.trans_export = trans_export
     self.trans_load_data = trans_load_data
     sys.path.pop()
     netsvc.init_logger()
     config['addons_path'] = (
         config.get('addons_path') + ',' + self.addons_path
     )
     registry = Registry.new(self.dbname)
     self.environment_manage = api.Environment.manage()
     self.environment_manage.__enter__()
     self.cr = registry.cursor()
     return self
Esempio n. 15
0
class TestLocker(InforTestCase):
    def setUp(self):
        super().setUp()
        self.registry2 = Registry(common.get_db_name())
        self.cr2 = self.registry2.cursor()
        self.env2 = api.Environment(self.cr2, self.env.uid, {})

        @self.addCleanup
        def reset_cr2():
            # rollback and close the cursor, and reset the environments
            self.env2.reset()
            self.cr2.rollback()
            self.cr2.close()

        self.backend2 = self.env2['infor.backend'].browse(self.backend.id)

    def test_lock(self):
        """Lock a record"""
        main_partner = self.env.ref('base.main_partner')
        work = WorkContext(model_name='res.partner', collection=self.backend)
        locker = work.component_by_name('infor.record.locker')
        locker.lock(main_partner)

        main_partner2 = self.env2.ref('base.main_partner')
        work2 = WorkContext(model_name='res.partner', collection=self.backend2)
        locker2 = work2.component_by_name('infor.record.locker')
        with self.assertRaises(RetryableJobError):
            locker2.lock(main_partner2)
Esempio n. 16
0
class TestLocker(TransactionComponentRegistryCase):
    def setUp(self):
        super().setUp()
        self.backend = mock.MagicMock(name="backend")
        self.backend.env = self.env

        self.registry2 = Registry(common.get_db_name())
        self.cr2 = self.registry2.cursor()
        self.env2 = api.Environment(self.cr2, self.env.uid, {})
        self.backend2 = mock.MagicMock(name="backend2")
        self.backend2.env = self.env2

        @self.addCleanup
        def reset_cr2():
            # rollback and close the cursor, and reset the environments
            self.env2.reset()
            self.cr2.rollback()
            self.cr2.close()

    def test_lock(self):
        """Lock a record"""
        main_partner = self.env.ref("base.main_partner")
        work = WorkContext(model_name="res.partner", collection=self.backend)
        work.component("record.locker").lock(main_partner)

        main_partner2 = self.env2.ref("base.main_partner")
        work2 = WorkContext(model_name="res.partner", collection=self.backend2)
        locker2 = work2.component("record.locker")
        with self.assertRaises(RetryableJobError):
            locker2.lock(main_partner2)
Esempio n. 17
0
File: api.py Progetto: shreliu/odoo
    def __new__(cls, cr, uid, context, su=False):
        if uid == SUPERUSER_ID:
            su = True
        assert context is not None
        args = (cr, uid, context, su)

        # determine transaction object
        transaction = cr.transaction
        if transaction is None:
            transaction = cr.transaction = Transaction(Registry(cr.dbname))

        # if env already exists, return it
        for env in transaction.envs:
            if env.args == args:
                return env

        # otherwise create environment, and add it in the set
        self = object.__new__(cls)
        args = (cr, uid, frozendict(context), su)
        self.cr, self.uid, self.context, self.su = self.args = args

        self.transaction = self.all = transaction
        self.registry = transaction.registry
        self.cache = transaction.cache
        self._cache_key = {}                    # memo {field: cache_key}
        self._protected = transaction.protected
        transaction.envs.add(self)
        return self
Esempio n. 18
0
 def __enter__(self):
     """
     Context enter function.
     Temporarily add odoo 10 server path to system path and pop afterwards.
     Import odoo 10 server from path as library.
     Init logger, registry and environment.
     Add addons path to config.
     :returns Odoo10Context: This instance
     """
     sys.path.append(self.server_path)
     from odoo import netsvc, api
     from odoo.modules.registry import Registry
     from odoo.tools import trans_export, config, trans_load_data
     self.trans_export = trans_export
     self.trans_load_data = trans_load_data
     sys.path.pop()
     netsvc.init_logger()
     config['addons_path'] = (
         config.get('addons_path') + ',' + self.addons_path
     )
     registry = Registry.new(self.dbname)
     self.environment_manage = api.Environment.manage()
     self.environment_manage.__enter__()
     self.cr = registry.cursor()
     return self
Esempio n. 19
0
def update(ctx, db_name, module, language, overwrite):
    context = {'overwrite': overwrite}

    from odoo.modules.registry import Registry
    from odooku.api import environment

    domain = [('state', '=', 'installed')]
    if module:
        domain = [('name', 'in', module)]

    for db in db_name:
        registry = Registry(db)
        with registry.cursor() as cr:
            with environment(cr) as env:
                mods = env['ir.module.module'].search(domain)
                mods.with_context(
                    overwrite=overwrite)._update_translations(language)
Esempio n. 20
0
    def setUp(self):
        super().setUp()
        self.backend = mock.MagicMock(name="backend")
        self.backend.env = self.env

        self.registry2 = Registry(common.get_db_name())
        self.cr2 = self.registry2.cursor()
        self.env2 = api.Environment(self.cr2, self.env.uid, {})
        self.backend2 = mock.MagicMock(name="backend2")
        self.backend2.env = self.env2

        @self.addCleanup
        def reset_cr2():
            # rollback and close the cursor, and reset the environments
            self.env2.reset()
            self.cr2.rollback()
            self.cr2.close()
Esempio n. 21
0
 def _update_registry(self):
     """ Update the registry after a modification on action rules. """
     if self.env.registry.ready and not self.env.context.get('import_file'):
         # for the sake of simplicity, simply force the registry to reload
         self._cr.commit()
         self.env.reset()
         registry = Registry.new(self._cr.dbname)
         registry.registry_invalidated = True
Esempio n. 22
0
def shell(ctx, input_file, db_name):
    from odoo.modules.registry import Registry
    from odooku.api import environment
    registry = Registry(db_name)

    with registry.cursor() as cr:
        with environment(cr) as env:
            context = {
                'env': env,
                'self': env.user
            }

            args = []
            if input_file is not None:
                args = [input_file]

            bpython.embed(context, args=args, banner='Odooku shell')
Esempio n. 23
0
 def _update_registry(self):
     """ Update the registry after a modification on action rules. """
     if self.env.registry.ready:
         # for the sake of simplicity, simply force the registry to reload
         self._cr.commit()
         self.env.reset()
         registry = Registry.new(self._cr.dbname)
         registry.signal_registry_change()
Esempio n. 24
0
 def _update_registry(self):
     """ Update the registry after a modification on action rules. """
     if self.env.registry.ready:
         # for the sake of simplicity, simply force the registry to reload
         self._cr.commit()
         self.env.reset()
         registry = Registry.new(self._cr.dbname)
         registry.signal_registry_change()
Esempio n. 25
0
 def _update_registry(self):
     """ Update the registry after a modification on action rules. """
     if self.env.registry.ready and not self.env.context.get('import_file'):
         # for the sake of simplicity, simply force the registry to reload
         self._cr.commit()
         self.env.reset()
         registry = Registry.new(self._cr.dbname)
         registry.registry_invalidated = True
class TestAdvisoryLock(TransactionComponentCase):
    def setUp(self):
        super(TestAdvisoryLock, self).setUp()
        self.registry2 = Registry(common.get_db_name())
        self.cr2 = self.registry2.cursor()
        self.env2 = api.Environment(self.cr2, self.env.uid, {})

        @self.addCleanup
        def reset_cr2():
            # rollback and close the cursor, and reset the environments
            self.env2.reset()
            self.cr2.rollback()
            self.cr2.close()

    def test_concurrent_lock(self):
        """ 2 concurrent transactions cannot acquire the same lock """
        # the lock is based on a string, a second transaction trying
        # to acquire the same lock won't be able to acquire it
        lock = 'import_record({}, {}, {}, {})'.format(
            'backend.name',
            1,
            'res.partner',
            '999999',
        )
        acquired = pg_try_advisory_lock(self.env, lock)
        self.assertTrue(acquired)
        # we test the base function
        inner_acquired = pg_try_advisory_lock(self.env2, lock)
        self.assertFalse(inner_acquired)

    def test_concurrent_import_lock(self):
        """ A 2nd concurrent transaction must retry """
        # the lock is based on a string, a second transaction trying
        # to acquire the same lock won't be able to acquire it
        lock = 'import_record({}, {}, {}, {})'.format(
            'backend.name',
            1,
            'res.partner',
            '999999',
        )

        backend = mock.MagicMock()
        backend.env = self.env
        work = WorkContext(model_name='res.partner', collection=backend)
        # we test the function through a Component instance
        component = work.component_by_name('base.connector')
        # acquire the lock
        component.advisory_lock_or_retry(lock)

        # instanciate another component using a different odoo env
        # hence another PG transaction
        backend2 = mock.MagicMock()
        backend2.env = self.env2
        work2 = WorkContext(model_name='res.partner', collection=backend2)
        component2 = work2.component_by_name('base.connector')
        with self.assertRaises(RetryableJobError) as cm:
            component2.advisory_lock_or_retry(lock, retry_seconds=3)
            self.assertEqual(cm.exception.seconds, 3)
Esempio n. 27
0
    def cenit_post(self, action, root=None):
        status_code = 400
        environ = request.httprequest.headers.environ.copy()

        key = environ.get('HTTP_X_USER_ACCESS_KEY', False)
        token = environ.get('HTTP_X_USER_ACCESS_TOKEN', False)
        db_name = environ.get('HTTP_TENANT_DB', False)

        if not db_name:
            host = environ.get('HTTP_HOST', "")
            db_name = host.replace(".", "_").split(":")[0]

        registry = Registry(db_name)
        with registry.cursor() as cr:
            connection_model = registry['cenit.connection']
            domain = [('key', '=', key), ('token', '=', token)]
            _logger.info(
                "Searching for a 'cenit.connection' with key '%s' and "
                "matching token", key)
            rc = connection_model.search(cr, SUPERUSER_ID, domain)
            _logger.info("Candidate connections: %s", rc)
            if rc:
                p = inflect.engine()
                flow_model = registry['cenit.flow']
                context = {'sender': 'client', 'action': action}

                if root is None:
                    for root, data in request.jsonrequest.items():
                        root = p.singular_noun(root) or root
                        rc = flow_model.receive(cr, SUPERUSER_ID, root, data,
                                                context)
                        if rc:
                            status_code = 200
                else:
                    root = p.singular_noun(root) or root
                    rc = flow_model.receive(cr, SUPERUSER_ID, root,
                                            request.jsonrequest, context)
                    if rc:
                        status_code = 200
            else:
                status_code = 404

        return {'status': status_code}
Esempio n. 28
0
File: api.py Progetto: shreliu/odoo
 def reset(self):
     """ Reset the transaction.  This clears the transaction, and reassigns
         the registry on all its environments.  This operation is strongly
         recommended after reloading the registry.
     """
     self.registry = Registry(self.registry.db_name)
     for env in self.envs:
         env.registry = self.registry
         lazy_property.reset_all(env)
     self.clear()
Esempio n. 29
0
def preload(ctx, db_name, module, demo_data):
    config = (ctx.obj['config'])

    from odoo.modules.registry import Registry

    if module:
        modules = {module_name: 1 for module_name in module}
        config['init'] = dict(modules)

    registry = Registry.new(db_name, force_demo=demo_data, update_module=True)
Esempio n. 30
0
def update(ctx, db_name, module, init):
    config = (ctx.obj['config'])

    from odoo.modules.registry import Registry
    config['init' if init else 'update'] = {
        module_name: 1
        for module_name in module or ['all']
    }

    for db in db_name:
        registry = Registry.new(db, update_module=True)
 def cron_folder_auto_classification(self,
                                     path=False,
                                     processing_path=False,
                                     limit=False):
     if not path:
         path = (self.env["ir.config_parameter"].sudo().get_param(
             "document_quick_access_auto_classification.path",
             default=False))
     if not path:
         return False
     if not processing_path and not self.env.context.get(
             "ignore_process_path"):
         processing_path = (
             self.env["ir.config_parameter"].sudo().get_param(
                 "document_quick_access_auto_classification.process_path",
                 default=False,
             ))
     elements = [
         os.path.join(path, f) for f in os.listdir(path)
         if os.path.isfile(os.path.join(path, f))
     ]
     if limit:
         elements = elements[:limit]
     for element in elements:
         obj = self
         new_element = element
         if processing_path:
             new_cr = Registry(self.env.cr.dbname).cursor()
         try:
             if processing_path:
                 new_element = os.path.join(processing_path,
                                            os.path.basename(element))
                 shutil.copy(element, new_element)
                 obj = (api.Environment(
                     new_cr, self.env.uid,
                     self.env.context)[self._name].browse().with_delay(
                         **self._delay_vals()))
             obj._process_document(new_element)
             if processing_path:
                 new_cr.commit()
         except Exception:
             if processing_path:
                 os.unlink(new_element)
                 new_cr.rollback()
             raise
         finally:
             if processing_path:
                 new_cr.close()
         if processing_path:
             os.unlink(element)
     return True
Esempio n. 32
0
def execute(conf_attrs, dbname, uid, obj, method, *args, **kwargs):
    _logger.info(str([dbname, uid, obj, method, args, kwargs]))

    if conf_attrs and len(conf_attrs.keys()) > 1:
        for attr, value in conf_attrs.items():
            odoo.tools.config[attr] = value
    with Environment.manage():
        registry = Registry(dbname)
        cr = registry.cursor()
        context = 'context' in kwargs and kwargs.pop('context') or {}
        env = Environment(cr, uid, context)
        cr.autocommit(True)
        # odoo.api.Environment._local.environments = env
        try:
            Model = env[obj]
            args = list(args)
            _logger.info('>>> %s' % str(args))
            ids = args.pop(0)
            if ids:
                target = Model.search([('id', 'in', ids)])
            else:
                target = Model
            getattr(env.registry[obj], method)(target, *args, **kwargs)
            # Commit only when function finish
            # env.cr.commit()
        except Exception as exc:
            env.cr.rollback()
            import traceback
            traceback.print_exc()
            raise exc
            #try:
            #    raise execute.retry(
            #        queue=execute.request.delivery_info['routing_key'],
            #        exc=exc, countdown=(execute.request.retries + 1) * 60,
            #        max_retries=5)
            #except Exception as retry_exc:
            #    raise retry_exc
        finally:
            env.cr.close()
    return True
Esempio n. 33
0
 def cron_move_documents(self, limit=False, path=False):
     if not path:
         path = (self.env["ir.config_parameter"].sudo().get_param(
             "hash_search_document_scanner_queue.preprocess_path",
             default=False,
         ))
     dest_path = (self.env["ir.config_parameter"].sudo().get_param(
         "hash_search_document_scanner.path", default=False))
     if not path or not dest_path:
         return False
     elements = [
         os.path.join(path, f) for f in os.listdir(path)
         if os.path.isfile(os.path.join(path, f))
     ]
     if limit:
         elements = elements[:limit]
     min_time = int(time.time()) - 60
     single_commit = self.env.context.get("scanner_single_commit", False)
     for element in elements:
         if os.path.getmtime(
                 element) > min_time and not self.env.context.get(
                     "scanner_ignore_time", False):
             continue
         filename = os.path.basename(element)
         new_element = os.path.join(dest_path, filename)
         shutil.copy(element, new_element)
         if not single_commit:
             new_cr = Registry(self.env.cr.dbname).cursor()
         try:
             if not single_commit:
                 obj = (api.Environment(
                     new_cr, self.env.uid,
                     self.env.context)[self._name].browse().with_delay())
             else:
                 obj = self.env[self._name].browse()
             obj.process_document(new_element)
             if not single_commit:
                 new_cr.commit()
         except Exception:
             os.unlink(new_element)
             if not single_commit:
                 new_cr.rollback()  # error, rollback everything atomically
             raise
         finally:
             if not single_commit:
                 new_cr.close()
         os.unlink(element)
     return True
Esempio n. 34
0
def import_(ctx, language, db_name, overwrite):
    context = {'overwrite': overwrite}

    from odoo.modules.registry import Registry
    from odooku.api import environment
    from odoo.tools import trans_load

    with tempfile.NamedTemporaryFile(suffix='.po', delete=False) as t:
        registry = Registry(db_name)

        # Read from stdin
        while True:
            chunk = sys.stdin.buffer.read(CHUNK_SIZE)
            if not chunk:
                break
            t.write(chunk)
        t.close()

        with registry.cursor() as cr:
            with environment(cr) as env:
                trans_load(cr, t.name, language, context=context)

        os.unlink(t.name)
Esempio n. 35
0
File: server.py Progetto: befks/odoo
def preload_registries(dbnames):
    """ Preload a registries, possibly run a test file."""
    # TODO: move all config checks to args dont check tools.config here
    dbnames = dbnames or []
    rc = 0
    for dbname in dbnames:
        try:
            update_module = config['init'] or config['update']
            registry = Registry.new(dbname, update_module=update_module)

            # run test_file if provided
            if config['test_file']:
                test_file = config['test_file']
                _logger.info('loading test file %s', test_file)
                with odoo.api.Environment.manage():
                    if test_file.endswith('yml'):
                        load_test_file_yml(registry, test_file)
                    elif test_file.endswith('py'):
                        load_test_file_py(registry, test_file)

            # run post-install tests
            if config['test_enable']:
                t0 = time.time()
                t0_sql = odoo.sql_db.sql_counter
                module_names = (registry.updated_modules if update_module else
                                registry._init_modules)
                with odoo.api.Environment.manage():
                    for module_name in module_names:
                        result = run_unit_tests(module_name, registry.db_name,
                                                position=runs_post_install)
                        registry._assertion_report.record_result(result)
                _logger.info("All post-tested in %.2fs, %s queries",
                             time.time() - t0, odoo.sql_db.sql_counter - t0_sql)

            if registry._assertion_report.failures:
                rc += 1
        except Exception:
            _logger.critical('Failed to initialize database `%s`.', dbname, exc_info=True)
            return -1
    return rc