Le package delay permet d'exécuter du code hors du champ de la requête d'un utilisateur par le biais de l'API Task Queue.
Pour déclarer une fonction pouvant être exécutée ultérieurement, appelez "Func" dans un contexte d'affectation de niveau supérieur en lui transmettant une clé de chaîne arbitraire et une fonction dont le premier argument est de type "context.Context". La clé permet de rechercher la fonction afin de pouvoir l'appeler ultérieurement.
var laterFunc = delay.Func("key", myFunc)
Il est également possible d'utiliser un littéral de fonction.
var laterFunc = delay.Func("key", func(c context.Context, x string) { // ... })
Pour appeler une fonction, invoquez sa méthode Call.
laterFunc.Call(c, "something")
Une fonction peut être appelée autant de fois que nécessaire. Si la fonction a des arguments de retour et que le dernier est de type "error", la fonction peut renvoyer une erreur non nulle pour signaler que la fonction doit être essayée à nouveau.
Les arguments des fonctions peuvent être de n'importe quel type, à condition qu'il soit encodable par le package gob. Si un argument est de type "interface", il incombe au client de s'enregistrer auprès du package gob, et ce, quel que soit le type concret pouvant être transmis pour cet argument. Voir http://golang.org/pkg/gob/#Register pour plus de détails.
Les erreurs détectées au cours de l'initialisation ou de l'exécution d'une fonction sont consignées dans les journaux des applications. Les journaux d'erreur créés au cours d'une initialisation sont associés à la requête qui a invoqué la méthode Call.
L'état de l'invocation d'une fonction dont l'exécution n'a pas encore réussi est conservé en combinant le nom du fichier dans lequel il est déclaré avec la clé de chaîne transmise à la fonction Func. La mise à jour d'une application avec des invocations de fonction en attente ne présente aucun risque tant que la combinaison (nom de fichier, clé) des fonctions pertinentes est conservée. Le nom du fichier est analysé selon ces règles:
- Les chemins d'accès dans le package main sont raccourcis pour ne correspondre qu'au nom du fichier (github.com/foo/foo.go -> foo.go)
- Les chemins d'accès sont simplement supprimés pour les packages (/go/src/github.com/foo/bar.go -> github.com/foo/bar.go)
- Les versions de modules sont supprimées (/go/pkg/mod/github.com/foo/bar@v0.0.0-20181026220418-f595d03440dc/baz.go -> github.com/foo/bar/baz.go)
Il existe un risque inhérent de perte des appels de fonction en attente lors d'une mise à jour contenant des modifications importantes. Par exemple, le passage de GOPATH à go.mod est une modification importante qui peut entraîner une modification accidentelle des chemins d'accès des fichiers.
Le package delay utilise l'API Task Queue pour créer des tâches qui appellent le chemin d'accès à l'application réservé "/_ah/queue/go/delay". Ce chemin d'accès ne doit pas porter le marquage "login: required" dans app.yaml. Il doit porter le marquage "login: admin" ou n'avoir aucune restriction d'accès.
Fonctions
func RequestHeaders
func RequestHeaders(c context.Context) (*taskqueue.RequestHeaders, error)La fonction RequestHeaders renvoie les en-têtes de requête HTTP de file d'attente de tâches spéciales pour le gestionnaire de files d'attente de tâches actuel. Renvoie une erreur si elle est appelée en dehors de delay.Func.
Function
type Function struct {
// contains filtered or unexported fields
}Function représente une fonction dont l'invocation peut être retardée.
func Func
Func déclare une nouvelle fonction. Le second argument doit être une fonction dont le premier argument est de type "context.Context". Cette fonction doit être appelée au moment de l'initialisation d'un programme. Cela signifie qu'elle doit être appelée dans le cadre d'une déclaration de variable globale ou depuis une fonction init. Cette restriction est nécessaire, car l'instance qui retarde un appel de fonction ne doit pas être celle qui l'exécute. Seul le code exécuté au moment de l'initialisation d'un programme est sûr d'être exécuté par une instance avant la réception d'une requête.
func (*Function) Call
Call invoque une fonction retardée.
err := f.Call(c, ...)
est équivalent à :
t, _ := f.Task(...)
_, err := taskqueue.Add(c, t, "")
func (*Function) Task
Task crée une tâche qui invoquera la fonction. Ses paramètres peuvent être modifiés avant qu'elle ne soit ajoutée à une file d’attente. Les utilisateurs ne doivent pas modifier les champs de chemin d'accès ou de charge utile de la tâche renvoyée.