firebase
Coda Firebase

Come utilizzare la coda Firebase come back-end per l'applicazione

Firebase fornisce backend come servizio, come sviluppatore di applciation non hai la possibilità di avere il codice di back-end.

Questo esempio mostra come utilizzare la coda firebase, creare backend che funzioneranno nella parte superiore del database Firebase e servire da backend per l'applicazione frontend.

Prima di entrare nel codice, capiamo l'architettura, come funzionerà. Per brevità, supponiamo di utilizzare il sito Web come frontend e il server NodeJs come back-end

Prerequisiti

1. Crea un'applicazione Firebase usando il tuo account google

2. Aggiungi Firebase alla tua pagina web. Usa bower install firebase --save

3. Crea un account di servizio utilizzando il tuo nuovo account Firebase creato (Impostazioni-> Autorizzazioni -> Account servizio -> CREA ACCOUNT SERVIZIO -> (specifica il nome e spunta questa casella di controllo "Fornisci una nuova chiave privata") -> salva il file json, avremo bisogno quello dopo.

4. Configura il server NodeJs che può essere ospitato nel tuo ambiente preferito

5. Crea il seguente endpoint all'interno della queue/specs

   "richiedere risposta":

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

6. All'interno del server NodeJs installare la versione lato server firebase, npm install firebase --save e npm install firebase --save tuo account di servizio usando il file json che abbiamo ottenuto dal passaggio 3, assomiglia a questo

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

Architettura

Ecco l'intero ciclo come funziona.

Dal lato frontale farai questi passi

1. Utilizzando sdk di Firebase Web stai scrivendo le tue richieste direttamente nel database di Firebase nell'endpoint 'coda / attività', chiamiamo la tua richiesta che stai inviando al back-end.
2. dopo aver inserito l'attività si sta registrando il listener sulla queue/tasks/{taskKey} endpoint queue/tasks/{taskKey} che verrebbe chiamato quando il backend termina l'elaborazione della richiesta, scrivendo la risposta all'interno queue/tasks/{taskKey} precedente

Nel backend farai questi passi

1. Crea un server che ascolti infinitamente 'coda / attività'
2. Elabora i tuoi compiti e scrive i dati di risposta all'interno di queue/tasks/response
3. Rimuovi l'attività

Prima di tutto crea questa funzione di aiuto, che fornisce un modo per gestire insieme callback e promesse

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

Nel frontend avrai questa funzione

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

puoi usare questa funzione come sendRequest('CreateHouseFacade', {houseName:'Test'}) .

Il parametro gentile è per il backend, per sapere quale metodo chiamare per la richiesta di elaborazione. Params serve per passare informazioni aggiuntive sui parametri.

Ed ecco il codice back-end

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 funzione myService contiene il codice logico aziendale che CreateHouseFacade richiesta CreateHouseFacade .