firebase
Firebase wachtrij

De firebase-wachtrij gebruiken als backend voor uw toepassing

Firebase biedt backend als een service, als applciation-ontwikkelaar heeft u geen optie om backend-code te hebben.

Dit voorbeeld laat zien hoe met behulp van de firebase-wachtrij backend wordt gemaakt die boven aan de firebase-database zal werken en als backend voor uw frontend-toepassing zal dienen.

Voordat we ingaan op de code, laten we de architectuur begrijpen, hoe deze zal werken. Laten we kortheid veronderstellen dat we de website als een frontend gebruiken en de NodeJs-server als een backend

voorwaarden

1. Maak een firebase-toepassing met uw Google-account

2. Voeg firebase toe aan uw webpagina. Gebruik bower install firebase --save

3. Maak een serviceaccount met uw nieuw gemaakte firebase-account (Instellingen-> Machtigingen -> Serviceaccounts -> SERVICEACCOUNT MAKEN -> (geef een naam op en vink dit selectievakje "Een nieuwe persoonlijke sleutel inrichten" aan)> sla het json-bestand op, we hebben nodig dat later.

4. Configureer de NodeJs-server die in uw voorkeursomgeving kan worden gehost

5. Maak het volgende eindpunt in de queue/specs

   "aanvraag antwoord":

    {
        "error_state": "request_error_processing",
        "finished_state": "finished_state",
        "in_progress_state": "request_in_progress",
        "start_state": "request_started"
    }
   

6. Binnen NodeJs server installeer firebase server-side versie, npm install firebase --save bewaar en initialiseer uw serviceaccount met behulp van het json-bestand dat we van stap 3 hebben gekregen, het ziet er zo uit

   firebase.initializeApp ({serviceAccount: './your_file.json', databaseURL: 'get_from_firebase_account'});

architectuur

Hier is de hele cyclus hoe het werkt.

Aan de voorkant ga je deze stappen doen

1. Met behulp van firebase web sdk schrijft u uw verzoeken rechtstreeks in de firebase-database in het eindpunt 'wachtrij / taken', laten we uw verzoek dat u naar de backend verzendt aanroepen.
2. na het invoegen van uw taak registreert u de luisteraar in de eindpuntwachtrij queue/tasks/{taskKey} die zou worden aangeroepen wanneer de backend uw aanvraag verwerkt, en antwoord binnenin de taak schrijft

Aan de achterkant ga je deze stappen doen

1. Creëer server die eindeloos 'wachtrij / taken' luistert
2. Verwerkt uw taken en het terugschrijven van responsgegevens in de queue/tasks/response
3. Verwijder de taak

Maak allereerst deze helperfunctie, die een manier biedt om callbacks en beloftes samen af te handelen

function createPromiseCallback() {
    var cb;
    var promise = new Promise(function (resolve, reject) {
        cb = function (err, data) {
            if (err) return reject(err);
            return resolve(data);
        };
    });
    cb.promise = promise;
    return cb;
}

Aan de voorkant krijg je deze functie

function sendRequest(kind, params, cb) {

    cb = cb || createPromiseCallback();
    var requestObject = {
        kind: kind,
        params: params
    };
    var tasksRef = firebase.database().ref('queue/tasks');

    var requestKey = tasksRef.push().key;

    var requestRef = tasksRef.child(requestKey);

    function requestHandshake(snap) {
        if (snap && snap.exists() && (snap.val().response || snap.val()._state ===    config.firebase.task.finishState || snap.val()._error_details)) {
            var snapVal = snap.val();
            if (snapVal._error_details) {
                cb(snapVal._error_details.error);
            } else {
            cb(null, snapVal.response);
        }
        requestRef.off('value', requestHandshake);
    }
   }

   var bulkUpdate = {};
   bulkUpdate['queue/tasks/' + requestKey + '/request'] = requestObject;
   bulkUpdate['queue/tasks/' + requestKey + '/_state'] = config.firebase.task.startState;

   firebase.database().ref().update(bulkUpdate)
    .then(function (snap) {
        requestRef.on('value', requestHandshake);
    }).catch(function (err) {
        cb(err);
    });

   return cb.promise;
  }

u kunt deze functie gebruiken zoals sendRequest('CreateHouseFacade', {houseName:'Test'}) .

Soort parameter is voor backend, om te weten welke methode moet worden aangeroepen voor verwerkingsverzoek. Params is voor het doorgeven van aanvullende parameterinformatie.

En hier is de backend-code

const database = firebase.database();
const queueRef = database.ref('queue');

const queueOptions = {
    'specId': 'request_response',
    'sanitize': false,
    'suppressStack': false,
    'numWorkers': 3
};

function removeTask(task) {
    var taskRef = queueRef.child(`tasks/${task._id}`);
    return taskRef.remove();
}

function processTask(data, progress, resolve, reject) {
    try {
        requestHandler(data.request).then(response => {
            data.response = response || null;
            return resolve(data);
        }).catch(err => {
            return reject(err);
        }).then(snap => {
            removeTask(data);
        });
    } catch (err) {
        reject(err).then(snap => removeTask(data));
    }
}

function requestHandler(request) {
    if (!request || !request.kind) throw new Error('Absent Request or Kind');
    var deferredResponse = requestHandlerFactory(request.kind, request.params);
    return deferredResponse;
}

function requestHandlerFactory(kind, params) {
    // It includes mapping all your backend services
    switch (kind) {
        case 'CreateHouseFacade': return myService(params)
        default: throw new Error(`Invalid kind ${kind} was specified`);
    }
}

De functie myService bevat uw bedrijfslogica-code waarmee het CreateHouseFacade verzoek wordt uitgevoerd.