firebase
File d'attente Firebase

Comment utiliser la file d'attente Firebase en tant que backend pour votre application

Firebase fournit un backend en tant que service, en tant que développeur d'applications, vous n'avez pas la possibilité d'avoir du code backend.

Cet exemple montre comment utiliser la file d'attente de firebase, créer un backend qui fonctionnera en haut de la base de données firebase et qui servira de backend pour votre application frontend.

Avant d'entrer dans le code, comprenons l'architecture, comment cela fonctionnera. Par souci de concision, supposons que nous utilisions un site Web en tant que serveur frontal et serveur NodeJ en tant que serveur principal.

Conditions préalables

1. Créez une application Firebase à l'aide de votre compte Google

2. Ajoutez une base de feu à votre page Web. Utilisez bower install firebase --save

3. Créez un compte de service à l'aide de votre nouveau compte Firebase créé (Paramètres-> Autorisations -> Comptes de service -> CRÉER UN COMPTE DE SERVICE -> (spécifiez le nom et cochez la case "Fournir une nouvelle clé privée") - cela plus tard.

4. Configurez le serveur NodeJs qui peut être hébergé dans votre environnement préféré

5. Créer le noeud final suivant dans la queue/specs

   "demande de réponse":

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

6. Dans le serveur NodeJs, npm install firebase --save version côté serveur de Firebase, npm install firebase --save , et intialize votre compte de service en utilisant le fichier json que nous avons obtenu à l’étape 3, cela ressemble à ceci:

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

Architecture

Voici le cycle complet comment ça marche.

Du côté du frontend tu vas faire ces étapes

1. En utilisant WebSdk Firebase, vous écrivez vos requêtes directement dans la base de données firebase dans la file d'attente / tâches du noeud final, appelons cela votre requête que vous envoyez au backend.
2. Après avoir inséré votre tâche, vous enregistrez l'écouteur dans la queue/tasks/{taskKey} du noeud final queue/tasks/{taskKey} qui sera appelée lorsque le serveur finit de traiter votre demande, en écrivant la réponse dans la tâche ci-dessus.

Dans le côté backend tu vas faire ces étapes

1. Créer un serveur qui écoute à l'infini les "files d'attente / tâches" des points d'extrémité
2. Traite vos tâches et écrit les données de réponse dans la queue/tasks/response
3. Supprimer la tâche

Tout d'abord créer cette fonction d'assistance, qui permet de gérer les rappels et les promesses ensemble

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;
}

Dans le côté frontal, vous aurez cette fonction

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;
  }

vous pouvez utiliser cette fonction comme sendRequest('CreateHouseFacade', {houseName:'Test'}) .

Le paramètre Kind est pour le backend, pour savoir quelle méthode appeler pour la demande de traitement. Les paramètres permettent de transmettre des informations supplémentaires sur les paramètres.

Et voici le code backend

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`);
    }
}

La fonction myService contient votre code de logique métier qui va CreateHouseFacade requête CreateHouseFacade .