So verteilen Sie einzigartige Gutscheincodes mit 70 Anfragen/Sek. Mit Node.js

Question

Ich betreibe eine Gutscheinseite mit 50-70 Anfragen pro Sekunde, wenn wir unsere Angebote starten (wir starten mehr als 20 Angebote gleichzeitig mehrmals am Tag). Wenn die Deals live gehen, drücken unsere Nutzer einen Button, um einen Coupon für ein bestimmtes Produkt zu erhalten, der über eine Ajax-https-Anfrage einen einzigartigen Couponcode anbietet. Jeder Gutschein kann nur einmal eingelöst werden.

Mein Problem ist, dass mit so hohen Verkehrsaufkommen zu diesen Zeiten der gleiche Gutschein an mehrere Benutzer verteilt werden kann. Dies ist schlecht, da nur einer von ihnen in der Lage sein wird, den Coupon tatsächlich einzulösen, was zu einer schlechten Benutzererfahrung für den anderen führt.

Ich speichere alle Couponinformationen in Objekten im Speicher auf einem node.js-Server, der von IBM Bluemix gehostet wird. Ich dachte, dies würde mir erlauben, die Anfragen schnell zu bearbeiten.

Wie ich den Gutschein Informationen speichern:

global.coupons = {}; 

//the number of coupons given for each product 
global.given = {}; 

/* Setting the coupon information */ 

//....I query my database for the products to be given today 

for(var i = 0; i < results.length; i++){ 
    var product = results[i]; 

    //add only the coupons to give today to the array 
    var originalCoups = product.get('coupons'); 
    var numToTake = product.get('toGivePerDay'); 

     if(product.get('givenToday') > 0){ 
      numToTake = numToTake - product.get('givenToday'); 
     } 
     // Example coupon array [["VVXM-Q577J2-XRGHCC","VVLE-JJR364-5G5Q6B"]] 
     var couponArray = originalCoups[0].splice(product.get('given'), numToTake); 

     //set promo info 
     global.coupons[product.id] = couponArray; 
     global.given[product.id] = 0; 
} 

Griff Coupon anfordern:

app.post('/getCoupon', urlencodedParser, function(req, res){ 
    if (!req.body) return res.status(400).send("Bad Request"); 
    if (!req.body.category) return res.status(200).send("Please Refresh the Page."); 

     //Go grab a coupon 
     var coupon = getUserACoupon(req.body.objectId); 

     res.type('text/plain'); 
     res.status(200).send(coupon); 

     if(coupon != "Sold Out!" && coupon != "Bad Request: Object does not exist."){ 

      //Update user & product analytics 
      setStatsAfterCouponsSent(req.body.objectId, req.body.sellerProduct, req.body.userEmail, req.body.purchaseProfileId, coupon, req.body.category); 

     } 
}); 

//getCoupon logic 
function getUserACoupon(objectId){ 

    var coupToReturn; 

    // coupon array for the requseted product 
    var coupsArray = global.coupons[objectId]; 

    if(typeof coupsArray != 'undefined'){ 

     // grab the number of coupons already given for this product and increase by one 
     var num = global.given[objectId]; 
     global.given[objectId] = num+1; 

     if(num < coupsArray.length){ 
      if(coupsArray[num] != '' && typeof coupsArray[num] != 'undefined' && coupsArray[num] != 'undefined'){ 

       coupToReturn = coupsArray[num]; 

      }else{ 
       console.log("Error with the coupon for "+objectId + " the num is " + num); 
       coupToReturn = "Sold Out!"; 
       wasSoldOut(objectId); 
      } 
     }else{ 
      console.log("Sold out "+objectId+" with num " + num); 
      coupToReturn = "Sold Out!"; 
      wasSoldOut(objectId); 
     } 
    }else{ 
     coupToReturn = "Bad Request: Object does not exist."; 
     wasSoldOut(objectId); 
    } 
    return coupToReturn; 
} 

Ich habe nicht eine Tonne Verständnis von node.js Server und wie sie funktionieren.

Wie immer, danke für die Hilfe!

Answer 1

Das Problem liegt in der nicht blockierenden/asynchronen Natur von Node. Aufrufe derselben Funktion von gleichzeitigen Anforderungen warten nicht aufeinander ab. Viele Anfragen kommen und gleichzeitig Zugriff auf die globale Codes-Array.

Sie geben den gleichen Code mehrere Male, weil die counter is incremented by multiple requests concurrently so kann es passieren, dass mehr als eine Anfragen den gleichen Zählerstand sieht.

Ein Ansatz, die Gleichzeitigkeit Problem zu verwalten, ist nur ein Zugang zu ermöglichen (zu getUserACoupon in Ihrem Fall) zu einer Zeit, so dass ein Teil der Ausführung, wo ein Gutschein verbraucht ist synchronisiert oder sie gegenseitig ausschließende. Eine Möglichkeit, dies zu erreichen, ist ein Verriegelungsmechanismus. Wenn also eine Anforderung Zugriff auf die Sperre erhält, warten weitere Anforderungen, bis die Sperre aufgehoben wird. In Pseudo-Code könnte es etwa so aussehen:

wait until lock exists 
create lock 
if any left, consume one coupon 
remove lock 

Aber dieser Ansatz geht gegen die nicht-blockierende Natur von Knoten und führt auch das Problem, wer die Sperre erhält, wenn freigegeben, wenn mehr als eine Anforderung wartet.

Ein besserer Weg ist eher ein Warteschlangensystem. Es sollte so funktionieren ein Code wird nicht zum Zeitpunkt der Anforderung verbraucht, sondern in einer Warteschlange als eine abrufbar gestellt, warten auf den Anstoß. Sie können die Länge der Warteschlange lesen und keine neuen Anfragen mehr akzeptieren ("ausverkauft"). Dies ist jedoch immer noch gleichzeitig über eine globale Warteschlange/einen globalen Zähler, so dass Sie möglicherweise einige mehr in der Warteschlange befindliche Elemente als Gutscheine haben kein Problem, weil die Warteschlange synchron verarbeitet wird so kann genau bestimmt werden, wenn die Anzahl der zugewiesenen Coupons erreicht werden und nur "ausverkauft" an den Rest geben, wenn überhaupt und, noch wichtiger, sicherstellen, dass jeder Code nur einmal serviert wird .

Mit temporal, könnte es ganz einfach sein, eine linear zu erstellen, verzögerte Aufgabenliste:

var temporal = require("temporal"); 
global.queues = {}; 

---

app.post('/getCoupon', urlencodedParser, function(req, res){ 
    if (!req.body) return res.status(400).send("Bad Request"); 
    if (!req.body.category) return res.status(200).send("Please Refresh the Page."); 

    // Create global queue at first request or return to it. 
    var queue; 
    if(!global.queues[req.body.objectId]) { 
     queue = global.queues[req.body.objectId] = temporal.queue([]); 
    } 
    else { 
     queue = global.queues[req.body.objectId]; 
    } 

    // Prevent queuing after limit 
    // This will be still concurrent access so in case of large 
    // number of requests a few more may end up queued 
    if(global.given[objectId] >= global.coupons[objectId].length) { 
     res.type('text/plain'); 
     res.status(200).send("Sold out!"); 
     return; 
    } 

    queue.add([{ 
     delay: 200, 
     task: function() { 
     //Go grab a coupon 
     var coupon = getUserACoupon(req.body.objectId); 

     res.type('text/plain'); 
     res.status(200).send(coupon); 

     if(coupon != "Sold Out!" && coupon != "Bad Request: Object does not exist."){ 

      //Update user & product analytics 
      setStatsAfterCouponsSent(req.body.objectId, req.body.sellerProduct, req.body.userEmail, req.body.purchaseProfileId, coupon, req.body.category); 

     } 
     } 
    }]); 
}); 

Ein wichtiger Punkt ist hier, dass Zeitlichen die Aufgaben nacheinander Addieren der Verzögerungen führt, Wenn also die Verzögerung größer ist als für die Ausführung der Aufgabe, greift nicht mehr als eine Aufgabe gleichzeitig auf das Counter/Code-Array zu.

Sie könnten Ihre eigene Lösung basierend auf dieser Logik auch mit zeitgesteuerter Queue-Verarbeitung implementieren, aber zeitlich scheint einen Versuch wert.

Answer 2

Haben Sie in Betracht gezogen, die HTTP-Anfragen in die Warteschlange einzureihen, wenn sie eintreffen, um ihre Reihenfolge wie in dieser Frage zu erhalten. How to queue http get requests in Nodejs in order to control their rate?