Dépôt officiel du core SPIP * Anciennement présent sur svn://trac.rezo.net/spip * Les plugins-dist faisant partie de la distribution SPIP sont présents dans https://git.spip.net/SPIP/[nom du plugin dist] https://www.spip.net
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3642 lines
105 KiB

8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
8 years ago
3 years ago
7 years ago
7 years ago
7 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
8 years ago
8 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
8 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
Intégration d'une gestion de files de taches (initialement le plugin job_queue) en remplacement du système de cron periodique La declaration de taches periodiques reste identique a auparavant (pipeline taches_generales_cron) La balise #SPIP_CRON disparait, remplacee par un declenchement en fin de hit uniquement quand une tache est en attente. Pour le declenchement, on utilise preferentiellement un socket, et a defaut une image background comme avant. Lors d'un appel, le sequenceur execute autant de taches en attente que possible, dans la limite d'un temps donné. Des appels concurents peuvent se jouer, mais chaque tache est executee une unique fois par une seule instance. L'unicité de l'execution est garantie par un sql_delete. SI jamais le nombre de taches en attente depasse un seuil (10000 par defaut) la file est purgee par un appel en fin de hit, synchrone. Une page d'aministration est accesible aux administrateurs depuis le menu maintenance. L'API est /** * Ajout d'une tache dans la file d'attente * * @param $function * The function name to call. * @param $description * A human-readable description of the queued job. * @param $arguments * Optional array of arguments to pass to the function. * @param $file * Optional file path which needs to be included for $fucntion. * @param $no_duplicate * If TRUE, do not add the job to the queue if one with the same function and * arguments already exists. * @param $time * time for starting the job. If 0, job will start as soon as possible * @param $priority * -10 (low priority) to +10 (high priority), 0 is the default * @return int * id of job */ function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) /** * Supprimer une tache de la file d'attente * @param int $id_job * id of jonb to delete * @return bool */ function job_queue_remove($id_job) /** * Associer une tache a un/des objets de SPIP * @param int $id_job * id of job to link * @param array $objets * can be a simple array('objet'=>'article','id_objet'=>23) * or an array of simple array to link multiples objet in one time */ function job_queue_link($id_job,$objets)
10 years ago
15 years ago
15 years ago
15 years ago
15 years ago
15 years ago
8 years ago
8 years ago
8 years ago
11 years ago
15 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
Co-existence de plusieurs {{{type_urls}}} au cours du même processus. La fabrication des URL publiques des entités a toujours été modulable, mais pas dans un même processus, ce qui posait deux limitations: - la production de ces URLs publiques à partir de l'espace privé oblige à passer par un script de redirection, couteux, obscur et peu extensible; - dans le cas du multi-site, impossible d'avoir autant de nommages différents que de sites, les fonctions produisant les URLs portant le même nom dans tous les système de nommage. Cette restriction est à présent levée, apparamment sans problème de compatibilité: Les fonctions {{{generer_url_{article, auteur, breve, mot, rubique, site} }}} sont déclarées obsolètes et remplacées par: {{{ function generer_url_entite($id='', $entite='', $args='', $ancre='', prive='', $type='') }}} un appel comme {{{ generer_url_article(id, arg, ancre) }}} s'écrit à présent {{{{ generer_url_entite(id, 'article', arg, ancre) }}}. Cette transformation étant prise en charge par {{{vieilles_def.php}}}, tandis que le code de SPIP a déjà évacué ces appels. Le 5e argument permet de forcer la production d'une URL de lecture alors qu'on est dans l'espace d'écriture et inversement. Le 6e argument permet de forcer l'utilisation d'un jeu d'URL différent de celui spécifié par la meta {{{type_urls}}}. Ces argument rend superflu la fonction {{{charger_generer_url}}} qui disparait complètement. La fonction {{{generer_url_entite}}} ne fait que lire le fichier X ainsi spécifier puis passe la main soit aux fonctions {{{generer_url_ecrire_article}}} etc dans le cas des URLs en écriture, soit sinon à la fonction {{{urls_}}}X{{{_dist}}}. Celle-ci a un double rôle: si son deuxième argument est numérique (ou une chaîne interprétable ainsi) elle produit l'URL de l'entité SQL ainsi désignée, à sa manière (propre, arbo, html...); si son deuxième argument est une chaîne, c'est une URL à partir de laquelle la fonction retrouve la table SQL et le numéro de l'entité (comme auparavant). Pour ceux qui ont des jeux de fonctions {{{generer_url_...}}} personnels, il est normalement pas nécessaire de le réécrire pour en disposer, mais c'est préférable pour qu'il puisse co-exister avec les autres au besoin. A noter qu'on ne peut actuellement faire co-exister Propre et Arbo car elles déclarent le même pipeline ({{{creer_chaine_url}}}), il faudrait revoir ce code. Je laisse en test un moment avant de basculer sur la branche 2, d'autant qu'il faudrait statuer sur le fichier {{{tourner}}} qui au bord du fork.
13 years ago
Co-existence de plusieurs {{{type_urls}}} au cours du même processus. La fabrication des URL publiques des entités a toujours été modulable, mais pas dans un même processus, ce qui posait deux limitations: - la production de ces URLs publiques à partir de l'espace privé oblige à passer par un script de redirection, couteux, obscur et peu extensible; - dans le cas du multi-site, impossible d'avoir autant de nommages différents que de sites, les fonctions produisant les URLs portant le même nom dans tous les système de nommage. Cette restriction est à présent levée, apparamment sans problème de compatibilité: Les fonctions {{{generer_url_{article, auteur, breve, mot, rubique, site} }}} sont déclarées obsolètes et remplacées par: {{{ function generer_url_entite($id='', $entite='', $args='', $ancre='', prive='', $type='') }}} un appel comme {{{ generer_url_article(id, arg, ancre) }}} s'écrit à présent {{{{ generer_url_entite(id, 'article', arg, ancre) }}}. Cette transformation étant prise en charge par {{{vieilles_def.php}}}, tandis que le code de SPIP a déjà évacué ces appels. Le 5e argument permet de forcer la production d'une URL de lecture alors qu'on est dans l'espace d'écriture et inversement. Le 6e argument permet de forcer l'utilisation d'un jeu d'URL différent de celui spécifié par la meta {{{type_urls}}}. Ces argument rend superflu la fonction {{{charger_generer_url}}} qui disparait complètement. La fonction {{{generer_url_entite}}} ne fait que lire le fichier X ainsi spécifier puis passe la main soit aux fonctions {{{generer_url_ecrire_article}}} etc dans le cas des URLs en écriture, soit sinon à la fonction {{{urls_}}}X{{{_dist}}}. Celle-ci a un double rôle: si son deuxième argument est numérique (ou une chaîne interprétable ainsi) elle produit l'URL de l'entité SQL ainsi désignée, à sa manière (propre, arbo, html...); si son deuxième argument est une chaîne, c'est une URL à partir de laquelle la fonction retrouve la table SQL et le numéro de l'entité (comme auparavant). Pour ceux qui ont des jeux de fonctions {{{generer_url_...}}} personnels, il est normalement pas nécessaire de le réécrire pour en disposer, mais c'est préférable pour qu'il puisse co-exister avec les autres au besoin. A noter qu'on ne peut actuellement faire co-exister Propre et Arbo car elles déclarent le même pipeline ({{{creer_chaine_url}}}), il faudrait revoir ce code. Je laisse en test un moment avant de basculer sur la branche 2, d'autant qu'il faudrait statuer sur le fichier {{{tourner}}} qui au bord du fork.
13 years ago