firebase
Cola de Firebase

Cómo usar la cola de base de fuego como un servidor para tu aplicación

Firebase proporciona backend como servicio, como desarrollador de aplicaciones, no tiene una opción para tener código de backend.

Este ejemplo muestra cómo usar la cola de base de fuego, crear un backend que operará en la parte superior de la base de datos de base de fuego y servir como un backend para su aplicación frontend.

Antes de entrar en el código, entendamos la arquitectura, cómo funcionará. Por brevedad, supongamos que estamos utilizando el sitio web como frontend y el servidor NodeJs como backend.

Prerrequisitos

1. Crea una aplicación Firebase usando tu cuenta de Google.

2. Agrega firebase a tu página web. Utilice la bower install firebase --save

3. Cree una cuenta de servicio usando su nueva cuenta de base de fuego creada (Configuración-> Permisos -> Cuentas de servicio -> CREAR CUENTA DE SERVICIO -> (especifique el nombre y marque esta casilla de verificación "Proporcionar una nueva clave privada") -> guardar el archivo json, necesitaremos que despues

4. Configure el servidor NodeJs que se puede alojar en su entorno preferido

5. Crear el siguiente punto final dentro de la queue/specs

   "solicitar respuesta":

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

6. Dentro del servidor NodeJs, npm install firebase --save versión del lado del servidor firebase, npm install firebase --save , y intialice su cuenta de servicio usando el archivo json que obtuvimos en el paso 3, se ve así

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

Arquitectura

Aquí está todo el ciclo de cómo funciona.

En el lado frontal vas a hacer estos pasos.

1. Usando firebase web sdk, está escribiendo sus solicitudes directamente en la base de datos de firebase en el punto final 'cola / tareas', le permite llamar a su solicitud que está enviando al backend.
2. después de insertar su tarea, está registrando el oyente en la queue/tasks/{taskKey} del punto final, que se llamará cuando el servidor finalice el procesamiento de su solicitud, escribiendo la respuesta dentro de la tarea anterior

En el lado de atrás vas a hacer estos pasos.

1. Crear un servidor que escuche infinitamente el punto final 'cola / tareas'
2. Procesa sus tareas y escribe datos de respuesta dentro de la queue/tasks/response
3. Quitar la tarea

En primer lugar, cree esta función auxiliar, que proporciona una forma de gestionar las devoluciones de llamada y las promesas en conjunto.

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

En la parte frontal vas a tener esta función.

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

puede usar esta función como sendRequest('CreateHouseFacade', {houseName:'Test'}) .

El parámetro tipo es para el backend, para saber qué método llamar para procesar la solicitud. Parámetros es para pasar información de parámetros adicionales.

Y aquí está el código de fondo

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 función myService contiene su código de lógica empresarial que CreateHouseFacade solicitud CreateHouseFacade .