odoo开发笔记 -- 借助模块queue_job实现异步方法调用

场景描述：

对比了几个定时调度的框架，发现各有优缺点；

celery 很强，异步定时调度，异步周期调度，也有延时调度的功能，但是延时调度的案例比较少，遂暂时不使用。

queue_job，一个odoo第三方应用模块，同样功能强大，可以满足日常的异步方法执行；

模块github地址：https://github.com/OCA/queue/tree/10.0/queue_job

但是我们的场景稍微有些不同，就是需要在异步调用的基础上增加一个延时(例5秒)；

一般的异步调度机制：异步执行避免了任务的阻塞，相当于将需要下一步执行的任务(函数or方法)，添加到了一个待执行的队列中，然后交给后台程序去慢慢处理，

处理的速度及性能，取决于服务器的硬件配置以及给相应任务开辟的进程数量。

回到我们的需求，通过分析queue_job模块的代码，大概找到我们需要定制修改的位置，即：在job开始执行前增加一个延时，下图为未修改之前：

修改后代码：

注意：这样虽然可以满足需求，但是会有新的问题，造成系统走到这里需要等待5秒时间，

实际生产环境，修改后，需要观察性能，如果处理效率满足不了实际情况，可以考虑适当增加服务器CPU配置，以及配置文件中的worker数，即多开辟进程。

顺便分享下，模块queue_job的基本使用及配置。

1. 模块介绍

2. 下载--根据自己odoo实际版本下载

第三方市场：https://www.odoo.com/apps/modules/10.0/queue_job/

github: https://github.com/OCA/queue/tree/10.0/queue_job

3. 配置

 This addon adds an integrated Job Queue to Odoo.

 It allows to postpone method calls executed asynchronously.

 Jobs are executed in the background by a Jobrunner, in their own transaction.

 Example:

 from odoo import models, fields, api
 from odoo.addons.queue_job.job import job

 class MyModel(models.Model):
    _name = 'my.model'

    @api.multi
    @job
    def my_method(self, a, k=None):
        _logger.info('executed with a: %s and k: %s', a, k)

 class MyOtherModel(models.Model):
     _name = 'my.other.model'

     @api.multi
     def button_do_stuff(self):
         self.env['my.model'].with_delay().my_method('a', k=2)
 In the snippet of code above, when we call button_do_stuff, a job capturing the method and arguments will be postponed. It will be executed as soon as the Jobrunner has a free bucket, which can be instantaneous if no other job is running.

 Features:

 Views for jobs, jobs are stored in PostgreSQL
 Jobrunner: execute the jobs, highly efficient thanks to PostgreSQL's NOTIFY
 Channels: give a capacity for the root channel and its sub-channels and segregate jobs in them. Allow for instance to restrict heavy jobs to be executed one at a time while little ones are executed 4 at a times.
 Retries: Ability to retry jobs by raising a type of exception
 Retry Pattern: the 3 first tries, retry after 10 seconds, the 5 next tries, retry after 1 minutes, ...
 Job properties: priorities, estimated time of arrival (ETA), custom description, number of retries
 Related Actions: link an action on the job view, such as open the record concerned by the job
 Table of contents

 Installation
 Configuration
 Usage
 Developers
 Known issues / Roadmap
 Changelog
 Next
 10.0.1.0.0
 Bug Tracker
 Credits
 Authors
 Contributors
 Maintainers
 Installation
 Be sure to have the requests library.

 Configuration
 Using environment variables and command line:
 Adjust environment variables (optional):
 ODOO_QUEUE_JOB_CHANNELS=root:4 or any other channels configuration. The default is root:1
 if xmlrpc_port is not set: ODOO_QUEUE_JOB_PORT=8069
 Start Odoo with --load=web,web_kanban,queue_job and --workers greater than 1. [1]
 Using the Odoo configuration file:
 [options]
 (...)
 workers = 6
 server_wide_modules = web,queue_job

 (...)
 [queue_job]
 channels = root:2
 Confirm the runner is starting correctly by checking the odoo log file:
 ...INFO...queue_job.jobrunner.runner: starting
 ...INFO...queue_job.jobrunner.runner: initializing database connections
 ...INFO...queue_job.jobrunner.runner: queue job runner ready for db <dbname>
 ...INFO...queue_job.jobrunner.runner: database connections ready
 Create jobs (eg using base_import_async) and observe they start immediately and in parallel.
 Tip: to enable debug logging for the queue job, use --log-handler=odoo.addons.queue_job:DEBUG
 [1]    It works with the threaded Odoo server too, although this way of running Odoo is obviously not for production purposes.
 Usage
 To use this module, you need to:

 Go to Job Queue menu
 Developers
 Bypass jobs on running Odoo

 When you are developing (ie: connector modules) you might want to bypass the queue job and run your code immediately.

 To do so you can set TEST_QUEUE_JOB_NO_DELAY=1 in your enviroment.

 Bypass jobs in tests

 When writing tests on job-related methods is always tricky to deal with delayed recordsets. To make your testing life easier you can set test_queue_job_no_delay=True in the context.

 Tip: you can do this at test case level like this

 @classmethod
 def setUpClass(cls):
     super().setUpClass()
     cls.env = cls.env(context=dict(
         cls.env.context,
         test_queue_job_no_delay=True,  # no jobs thanks
     ))
 Then all your tests execute the job methods synchronously without delaying any jobs.

官方说明

先配置odoo配置文件：

在odoo.conf中增加如下：

4. 使用

5. 查看结果