Meteor: Appel d'une fonction asynchrone à l'intérieur d'un Météore.méthode et renvoie le résultat

Je veux appeler une fonction d'asynchrone à l'intérieur d'un Météore méthode, puis retourner le résultat de cette fonction à un Météore.appel.

Comment est-ce possible?

Meteor.methods({
  my_function: function(arg1, arg2) {
    //Call other asynchronous function and return result or throw error
  }
});
InformationsquelleAutor Joseph Tura | 2012-09-24
  1. 19

    Andrew Mao est droit. Meteor a maintenant Meteor.wrapAsync() pour ce genre de situation.

    Voici la façon la plus simple de faire une charge par bande et aussi passer d'une fonction de rappel:

    var stripe = StripeAPI("key");    
Meteor.methods({

    yourMethod: function(callArg) {

        var charge = Meteor.wrapAsync(stripe.charges.create, stripe.charges);
        charge({
            amount: amount,
            currency: "usd",
            //I passed the stripe token in callArg
            card: callArg.stripeToken,
        }, function(err, charge) {
            if (err && err.type === 'StripeCardError') {
              //The card has been declined
              throw new Meteor.Error("stripe-charge-error", err.message);
            }

            //Insert your 'on success' code here

        });
    }
});

    J'ai trouvé ce post très utile:
    Meteor: Bonne utilisation du Météore.wrapAsync sur le serveur

    • si vous retourner une valeur dans la fonction de rappel de charge() qui va être le retour de charge()?
    • Pas évident lorsque vous êtes de retour d'une valeur qui est le point de la question d'origine
    • Ce post est très utile: themeteorchef.com/snippets/synchronous-methods
    InformationsquelleAutor jacksonkernion
  2. 36

    Utiliser un Avenir pour le faire. Comme ceci:

    Meteor.methods({
  my_function: function(arg1, arg2) {

    //Set up a future
    var fut = new Future();

    //This should work for any async method
    setTimeout(function() {

      //Return the results
      fut.ret(message + " (delayed for 3 seconds)");

    }, 3 * 1000);

    //Wait for async to finish before returning
    //the result
    return fut.wait();
  }
});

    Mise à jour:

    Pour une utilisation Future à partir de Meteor 0.5.1, vous devez exécuter le code suivant dans votre Bolide.méthode de démarrage:

    Meteor.startup(function () {
  var require = __meteor_bootstrap__.require
  Future = require('fibers/future');

  //use Future here
});

     
    Mise à jour 2:

    Pour une utilisation Future à partir de Meteor 0.6, vous devez exécuter le code suivant dans votre Bolide.méthode de démarrage:

    Meteor.startup(function () {
  Future = Npm.require('fibers/future');

  //use Future here
});

    et ensuite utiliser le return méthode au lieu de la ret méthode:

    Meteor.methods({
  my_function: function(arg1, arg2) {

    //Set up a future
    var fut = new Future();

    //This should work for any async method
    setTimeout(function() {

      //Return the results
      fut['return'](message + " (delayed for 3 seconds)");

    }, 3 * 1000);

    //Wait for async to finish before returning
    //the result
    return fut.wait();
  }
});

    Voir ce gist.

    • Merci, Joscha. Un avenir est exactement ce dont j'ai besoin.
    • bonjour, je suis Futur non défini erreur. Comment ajouter Avenir?
    • J'ai mis à jour ma réponse, voir ci-dessus. J'ai aussi fourchue la première essentiel d'inclure des informations: gist.github.com/4130605
    • Merci beaucoup pour votre solution! J'ai réussi à google il me. Future est un nom commun pour le paquet 🙂
    • voici un travail complet de démonstration de ceci: github.com/semateos/meteor-async-test
    • Que de la version 0.6.0, vous devez utiliser Future = Npm.require('fibers/future').
    • Que faire si vous voulez faire une Collection mise à jour/à insérer dans le rappel asynchrone?
    • Je vous ai envoyé un pull req. sur la démo, car il ne fonctionne pas avec post 0.6 plus
    • Pour moi, ce qui fonctionne c'est l'Avenir = Météore.require('fibres/futur").
    • fut.return(result) fonctionne pour moi; pourquoi ne pas suivre les ceci?

    InformationsquelleAutor Joscha
  3. 26

    Les versions récentes de Meteor ont fourni les sans-papiers Meteor._wrapAsync fonction qui transforme une fonction avec un standard (err, res) rappel dans une fonction synchrone, ce qui signifie que le courant de la Fibre de rendements jusqu'à ce que le callback retourne, et utilise ensuite un Météore.bindEnvironment pour s'assurer que vous maintenir le Météore variables d'environnement (comme Meteor.userId()).

    Une utilisation simple serait que les suivantes:

    asyncFunc = function(arg1, arg2, callback) {
  //callback has the form function (err, res) {}

};

Meteor.methods({
  "callFunc": function() {
     syncFunc = Meteor._wrapAsync(asyncFunc);

     res = syncFunc("foo", "bar"); //Errors will be thrown     
  }
});

    Vous pouvez aussi avoir besoin d'utiliser function#bind pour s'assurer que asyncFunc est appelée avec le bon contexte avant de l'emballer.

    Pour plus d'informations, voir: https://www.eventedmind.com/tracks/feed-archive/meteor-meteor-wrapasync

    InformationsquelleAutor Andrew Mao
  4. 5

    Une autre option est de cette package qui réalise des objectifs similaires.

    meteor add meteorhacks:async

    De l'emballage et du README:

    Asynchrone.wrap(fonction)

    Envelopper d'une fonction d'asynchrone et permettre de l'exécuter à l'intérieur de Meteor sans rappels.

    //declare a simple async function
function delayedMessge(delay, message, callback) {
  setTimeout(function() {
    callback(null, message);
  }, delay);
}

//wrapping
var wrappedDelayedMessage = Async.wrap(delayedMessge);

//usage
Meteor.methods({
  'delayedEcho': function(message) {
    var response = wrappedDelayedMessage(500, message);
    return response;
  }
});
    • plus simple solution. merci
    InformationsquelleAutor FullStack