redis-request-reply

extraRedis

for more information visit extraRedis site

redis api that provides lot of features :

• pub/sub - a simple api for publishing and subscribing messages without the needing to listen 'message' and to if your topic on it
• request/reply - the abiliy to publish message that the response will return directly to you with simple api based on promises .
• producer/consumer - now you can create simple job that will be sent to only one consumer at a time
• queryable - the ability to query your returned via verity of criteria based on rx observable
• merging multiple subscribers into one data stream- (in the next few days) an ability to limit the number of workers that will handle the job
• producer consumer improvements- (in the next few days) an ability to limit the number of workers that will handle the job More details below under the user instructions section

Usage instructions:

creating new object

 
var ERedis = new extraRedis({port:6379,host:"127.0.0.1"});

creating simple pub sub with multiple subscribers

 
ERedis.on('foo',(message)=>{
    console.log('foo -> '+message);
},guid=>{console.log('guidfoo-> '+guid)})
 
ERedis.on('foo',(message)=>{
    console.log('foo2 -> '+message);
},guid=>{console.log('guidfoo2-> '+guid)})
 
ERedis.emit('foo','bar');
 
// foo -> bar
// foo2 -> bar
 

creating request reply so only the sending emtier will get directly the message for his answer

ERedis.requestReply.on('reqReplyFoo',(message,func)=>{
    console.log('reqReplyFoo-> '+message);
    func('reqReplyOnBar');
})
 
ERedis.requestReply.emit('reqReplyFoo','reqReplyBar').then((message)=>{
    console.log('reqReplyOnFoo-> '+message);
 
}).catch((e)=>{ console.log('ERROR!!!! '+e)});
 
// reqReplyFoo-> reqReplyBar
// reqReplyOnFoo-> reqReplyOnBar
 

creating producer consumers so only one consumer get a job at a time

• job queue: if there is more jobs than ready for work consumers than job added to queue and waiting for available consumers
• keepAliveConsumerState: clear not available consumers in order to ignore unconsumed jobs

 
ERedis.producerConsumer.createJob('prodConsTest');
 
ERedis.producerConsumer.consume('prodConsTest', (message, finishFunction)=> {
    setTimeout(()=> {
        console.log(`message consumed -> ${message}`);
        finishFunction();
    }, 5000)
 
});
ERedis.producerConsumer.consume('prodConsTest', (message, finishFunction)=> {
    setTimeout(()=> {
        console.log(`message consumed -> ${message}`);
        finishFunction();
    }, 5000)
});
 
 
setTimeout(()=> {
    ERedis.producerConsumer.produce('produce job 1');
    ERedis.producerConsumer.produce('produce job 2');
    ERedis.producerConsumer.produce('produce job 3');
    console.log("sending job for producing")
}, 5000)
 
// message consumed -> produce job 1
// message consumed -> produce job 2
 

creating queryable instance based rx

 
ERedis.queryable.createQueryableInstance('foo')
                       .subscribe(message =>{
                           console.log(`queryable Instance -> ${message}`)
                       })
 
// queryable Instance -> bar
 

creating queryable instance with filter

 
ERedis.queryable.createQueryableInstance('foo')
    .filter((message)=>{
        return message.valueOf() =='bar'
    })
    .subscribe(message =>{
        console.log(`queryable Instance with filter -> ${message}`)
    })
// queryable Instance with filter -> bar