firebase
Kolejka Firebase

Jak używać kolejki firebase jako zaplecza dla aplikacji

Firebase zapewnia backend jako usługę, jako deweloper aplikacji nie masz opcji posiadania kodu backend.

Ten przykład pokazuje, jak za pomocą kolejki firebase utworzyć backend, który będzie działał na bazie bazy danych firebase i będzie służył jako backend dla aplikacji frontend.

Przed przystąpieniem do kodu pozwala zrozumieć architekturę, w jaki sposób będzie działać. Dla zwięzłości załóżmy, że używamy strony internetowej jako frontendu, a serwera NodeJs jako backendu

Wymagania wstępne

1. Utwórz aplikację firebase przy użyciu swojego konta Google

2. Dodaj bazę ogniową do swojej strony internetowej. Użyj bower install firebase --save

3. Utwórz konto usługi przy użyciu nowo utworzonego konta Firebase (Ustawienia-> Uprawnienia -> Konta usługi -> UTWÓRZ KONTO SERWISOWE -> (podaj nazwę i zaznacz to pole wyboru „Dostarcz nowy klucz prywatny”) -> zapisz plik json, będziemy potrzebować że później.

4. Skonfiguruj serwer NodeJs, który może być hostowany w preferowanym środowisku

5. Utwórz następujący punkt końcowy w queue/specs

   "wymagać odpowiedzi":

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

6. Wewnątrz serwera NodeJs zainstaluj firebase po stronie serwera, npm install firebase --save i zainicjalizuj swoje konto usługi przy użyciu pliku json, który otrzymaliśmy z kroku 3, wygląda to tak:

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

Architektura

Oto cały cykl, jak to działa.

Po stronie interfejsu wykonasz te kroki

1. Za pomocą firebase web sdk piszesz swoje żądania bezpośrednio do bazy danych firebase w punkcie końcowym „kolejka / zadania”, pozwala na wywołanie twojego żądania, które wysyłasz do backendu.
2. po wstawieniu zadania rejestrujesz nasłuchiwanie w queue/tasks/{taskKey} punktu końcowego, który byłby wywoływany, gdy backend zakończy przetwarzanie żądania, zapisując odpowiedź w ramach powyższego zadania

Po stronie zaplecza wykonasz te kroki

1. Utwórz serwer, który nieskończenie nasłuchuje „kolejki / zadań” punktu końcowego
2. Przetwarza zadania i zapisuje dane odpowiedzi w queue/tasks/response
3. Usuń zadanie

Najpierw stwórz tę funkcję pomocnika, która zapewnia sposób radzenia sobie z połączeniami zwrotnymi i obietnicami

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

Po stronie frontonu będziesz miał tę funkcję

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

możesz użyć tej funkcji jak sendRequest('CreateHouseFacade', {houseName:'Test'}) .

Dobrym parametrem jest backend, aby wiedzieć, jaką metodę wywołać w celu przetworzenia żądania. Parametry służą do przekazywania dodatkowych informacji o parametrach.

A oto kod zaplecza

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

Funkcja myService zawiera kod logiki biznesowej, który zrealizuje żądanie CreateHouseFacade .