Memcached Question posted in
A decent usage manual can be found here.

Memcached – How to control the flow of applications in NodeJS

I’m writing my first application in nodeJS. I’m writing a telegram bot, and i was wondering how to control the flow of the application given it asynchronous nature. I come from a php background where everything was simple, procedural, one after the other.

Lets say, in my bot, when any message is received, first the program must make sure the user details are in the cache or database before proceeding. After the check is done it can proceed.

I was going to do this by using a variable for a flag, but it cannot be done because of the asynchronous nature of javascript. I have no idea how to go about doing this. Do i assign listeners to an object and emit events to control the flow?

Here is my code

    const fs = require('fs');

// Establish connection with cache and database
const mysql = require('mysql-wrapper');
const Memcached = require('memcached');
const memcached = new Memcached('localhost:11211');
const bb = require('bot-brother');

var settings = {
    host: 'localhost',
    database: 'test',
    user: 'root',
};
var qb = require('node-querybuilder').QueryBuilder(settings, 'mysql', 'single');

//Load the database cache functions
const dbc = require("./dbc");
dbc.memcached = memcached;
dbc.mysqc = qb;

//Load the user handling functions 
const user = require("./user");
user.dbc = dbc;

const bot = bb({
    key : '331263599:AAHmLl4Zcg4sKGnz7GNzacgkJl1W8lwz33c',
    polling: { interval: 0, timeout: 1 }
});

//code that checks user existence in cache/db
bot.api.on('message', (msg)=>{
    console.log(msg.from);
    var userData = msg.from;
    var tid = userData.id;
    //Check if user is in cache 
    user.check_user_existence(tid,function(re){
        if(re < 2){
            user.complete_user_existence(re,userData,function(err,response){
                if(err){
                    bot.api.sendMessage(tid,"Sorry an unexpected error occured!");
                } else {
                    console.log('ha');
                    play = 1;
                }
            });
        } 

    });
});


//Code to be run after checking 
if(play==1){
    send_another_message();
    do_some_things();
}
Tags:

2

Answers


  1. 0

    You can use callbacks or promises
    You can use async module or mutexes

    If you need serialize some asynchronous functions you can use one of this approaches:

    Callback

    Native promises

    Bluebird promise

    Async module

    Callback and Promise mostly used for related functions which second function needs first function .bluebird is a module for creating promises and having full customize on it.

    Async module is good way to run functions asynchronous and get result of them together.

    Last way is Mutex if you had asynchronous write in single object or file you need lock-release approach

    Login or Signup to reply.
  2. 0

    You can run code synchronously via nsynjs. Your code may transform like this:

    Step 1. Wrap slow functions with callbacks into nsynjs-aware wrappers:

    // content of wrappers.js
user = require("./user");
exports.user_check_user_existence_wrapper = function (ctx, uid) {
    var res = {};

    user.check_user_existence(tid,function(re){
        res.re = re;
        ctx.resume();
    })

    return res;
};
exports.user_check_user_existence_wrapper.nsynjsHasCallback = true;

exports.user_complete_user_existence_wrapper = function(ctx, re, userData) {
    var res = {};

    user.complete_user_existence(tid,function(error,ue_response){
        res.error = error;
        res.ue_response = ue_response;
        ctx.resume(error); // if error is set, it will cause exception in the caller
    })

    return res;
};
exports.user_complete_user_existence_wrapper.nsynjsHasCallback = true;

    Step 2. Put your synchronous logic into function, use wrappers from above to execute slow functions:

    var synchronousCode = function(wrappers,msg) {
    console.log(msg.from);
    var userData = msg.from;
    var tid = userData.id;
    //Check if user is in cache 
    var re = wrappers.user_check_user_existence_wrapper(nsynjsCtx,tid).re;
    if(re < 2)
        try {
            var res = wrappers.user_complete_user_existence_wrapper(re,userData).ue_response;
            console.log('ha');
            play = 1;
        }
        catch (e) {
            bot.api.sendMessage(tid,"Sorry an unexpected error occured!",e);
        };
}

    Step 3. Run your synchronous function via nsynjs:

    var nsynjs = require('nsynjs');
var wrappers = require('./wrappers');
var synchronousCode = function(wrappers,msg) {
....
}

bot.api.on('message', function(msg) {
    nsynjs.run(synchronousCode,{},wrappers,msg,function(){
        console.log('synchronousCode finished');
    })
});

    Please see more examples here: https://github.com/amaksr/nsynjs/tree/master/examples/node-module-loading

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search