Queue

Job

class connector.queue.job.Job(func=None, model_name=None, args=None, kwargs=None, priority=None, eta=None, job_uuid=None, max_retries=None, description=None, channel=None, identity_key=None)

Bases : object

Un job est une tâche à exécuter.

uuid

Id (UUID) du job.

state

État du job, peut être en attente, en queue, démarré, terminé, échoué. L’état initial est en attente et l’état final est terminé.

retry

L’essai actuel, démarre à 0 et s’incrémente de 1 chaque fois que le job est exécuté.

max_retries

Le nombre maximum d’essais permis avant que le job soit considéré comme échoué.

func_name

Nom de la fonction (sous la forme module.nom_fonction).

args

Arguments transmis à la fonction pendant l’exécution.

kwargs

Arguments nommés transmis à la fonction pendant l’exécution.

func_string

Chaîne complète représentant la fonction à exécuter, càd module.fonction(args, kwargs)

description

Description du job à destination des utilisateurs.

func

La fonction Python elle-même.

model_name

Modèle OpenERP pour lequel le job va fonctionner.

priority

Priorité du job, 0 étant la plus haute priorité.

date_created

Date et heure de création du job.

date_enqueued

Date et heure de mise en queue du job.

date_started

Date et heure de démarrage du job.

date_done

Date et heure d’arrêt du job.

result

Une description du résultat (à destination des utilisateurs).

exc_info

Informations sur l”Exception (`traceback”) ayant causé l’échec du job

user_id

Id de l’utilisateur OpenERP qui a créé le job

eta

Heure estimée de lancement (ETA) du job. Il ne sera pas exécuté avant cette date/heure.

channel

The complete name of the channel to use to process the job. If provided it overrides the one defined on the job’s function.

description

eta

func

func_string

identity_key

perform(session)

Exécute le job.

Le job est exécuté avec l’utilisateur qui l’a initié.

Paramètres:session (ConnectorSession) – session d’exécution du job

postpone(result=None, seconds=None)

Écrit un heure estimée de lancement dans n secondes. Utilisé quand une Exception non fatale souhaite relancer un job.

related_action(session)

set_done(result=None)

set_enqueued()

set_failed(exc_info=None)

set_pending(result=None, reset_retry=True)

set_started()

uuid

Id du job, c’est un UUID

class connector.queue.job.JobStorage

Bases : object

Interface pour le stockage des jobs

exists(job_uuid)

Indique si un job existe encore dans l’espace de stockage.

load(job_uuid)

Lit les donnés du job dans l’espace de stockage

store(job_)

Stocke un job

class connector.queue.job.OpenERPJobStorage(session)

Bases : connector.queue.job.JobStorage

Stocke un job dans OpenERP

db_record(job_)

db_record_from_uuid(job_uuid)

enqueue(func, model_name=None, args=None, kwargs=None, priority=None, eta=None, max_retries=None, description=None, channel=None, identity_key=None)

Crée un job et le met en queue. Renvoie le UUID du job.

S’attend à ce que les arguments spécifiques au job soient déjà extraites de ceux à passer à la fonction du job.

enqueue_resolve_args(func, *args, **kwargs)

Crée un job et le met en queue. Renvoie le UUID du job.

exists(job_uuid)

Indique si un job existe encore dans l’espace de stockage.

job_record_with_same_identity_key(identity_key)

Check if a job to be executed with the same key exists.

load(job_uuid)

Lit un job depuis la base de données

store(job_)

Stocke le job

connector.queue.job.identity_exact(job_)

Identity function using the model, method and all arguments as key When used, this identity key will have the effect that when a job should be created and a pending job with the exact same recordset and arguments, the second will not be created. It should be used with the identity_key argument: .. python:

from odoo.addons.connector.queue.job import identity_exact
# [...]
    my_delayable_export_record_method.delay(
        session, "my.model", self.id, force=True,
        identity_key=identity_exact)

Alternative identity keys can be built using the various fields of the job. For example, you could compute a hash using only some arguments of the job. .. python:

def identity_example(job_):
    hasher = hashlib.sha1()
    hasher.update(str(job_.args))
    hasher.update(str(job_.kwargs.get('foo', '')))
    return hasher.hexdigest()

Usually you will probably always want to include at least the name of the model and method.

connector.queue.job.job(func=None, default_channel='root', retry_pattern=None)

Décorateur pour les jobs.

Optional argument:

Paramètres:

• default_channel – the channel wherein the job will be assigned. This channel is set at the installation of the module and can be manually changed later using the views.
• retry_pattern (dict(retry_count,retry_eta_seconds)) – The retry pattern to use for postponing a job. If a job is postponed and there is no eta specified, the eta will be determined from the dict in retry_pattern. When no retry pattern is provided, jobs will be retried after RETRY_INTERVAL seconds.

Ajoute un attribut delay sur la fonction décorée.

Quand delay est appelée, la fonction est transformée en job et stockée dans le modèle OpenERP queue.job. Les arguments positionnels et nommés transmis à delay seront les arguments utilisés par la fonction décorée lorsqu’elle sera exécutée.

retry_pattern is a dict where keys are the count of retries and the values are the delay to postpone a job.

La fonction delay() d’un job reçoit les arguments suivants :

session

ConnectorSession en cours

model_name

nom du modèle sur lequel le job a quelque chose à faire

*args et **kargs

Arguments positionnels et nommés qui seront transmis à la fonction une fois que le job est exécuté. Ils doivent être « pickle-able ».

There are 5 special and reserved keyword arguments that you can use:

• priority : priorité du job, une valeur plus petite étant prioritaire.

  10 par défaut.

• max_retries : nombre maximal d’essais avant d’abandonner et définir

  l’état du job à échoué. Une valeur de 0 signifie un nombre infini d’essais. Par défaut la valeur est 5.

• eta : le job ne peut être exécuté qu’après cette datetime

  (ou maintenant + timedelta si un timedelta ou un entier est fourni)

• description : a human description of the job,

  destinée à différencier les instances de job (Par défaut func.__doc__ ou

  “Function %s” % func.__name__)

• channel : The complete name of the channel to use to process the job. If

  provided it overrides the one defined on the job’s function.

Exemple :

@job
def export_one_thing(session, model_name, one_thing):
    # work
    # export one_thing

export_one_thing(session, 'a.model', the_thing_to_export)
# => normal and synchronous function call

export_one_thing.delay(session, 'a.model', the_thing_to_export)
# => the job will be executed as soon as possible

export_one_thing.delay(session, 'a.model', the_thing_to_export,
                       priority=30, eta=60*60*5)
# => the job will be executed with a low priority and not before a
# delay of 5 hours from now

@job(default_channel='root.subchannel')
def export_one_thing(session, model_name, one_thing):
    # work
    # export one_thing

@job(retry_pattern={1: 10 * 60,
                    5: 20 * 60,
                    10: 30 * 60,
                    15: 12 * 60 * 60})
def retryable_example(session):
    # 5 first retries postponed 10 minutes later
    # retries 5 to 10 postponed 20 minutes later
    # retries 10 to 15 postponed 30 minutes later
    # all subsequent retries postponed 12 hours later
    raise RetryableJobError('Must be retried later')

retryable_example.delay(session)

Voir aussi : related_action() une action connexe peut être attachée à un job

connector.queue.job.related_action(action=<function <lambda>>, **kwargs)

Attache une action connexe à un job

Un action connexe apparaîtra comme un bouton dans la vue OpenERP. Le bouton exécutera l’action, habituellement une ouverture de formulaire de l’enregistrement lié au job.

L”action doit être un objet callable qui prends les arguments

session, job, **kwargs

Exemple d’utilisation :

def related_action_partner(session, job):
    model = job.args[0]
    partner_id = job.args[1]
    # eventually get the real ID if partner_id is a binding ID
    action = {
        'name': _("Partner"),
        'type': 'ir.actions.act_window',
        'res_model': model,
        'view_type': 'form',
        'view_mode': 'form',
        'res_id': partner_id,
    }
    return action

@job
@related_action(action=related_action_partner)
def export_partner(session, model_name, partner_id):
    # ...

Les kwargs sont transmis à l’action :

def related_action_product(session, job, extra_arg=1):
    assert extra_arg == 2
    model = job.args[0]
    product_id = job.args[1]

@job
@related_action(action=related_action_product, extra_arg=2)
def export_product(session, model_name, product_id):
    # ...

connector.queue.job.whitelist_unpickle_global(fn_or_class)

Allow a function or class to be used in jobs

By default, the only types allowed to be used in job arguments are:

• the builtins: str/unicode, int/long, float, bool, tuple, list, dict, None
• the pre-registered: datetime.datetime datetime.timedelta

If you need to use an argument in a job which is not in this whitelist, you can add it by using:

whitelist_unpickle_global(fn_or_class_to_register)

Worker

Queue

Modèles