bonsaif 1.10.3

package/lib/hookup/redis.js

@@ -0,0 +1,622 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+ 'use strict';
+
+ const utl          = require('../utl');
+ let debug = false;
+ let tag = ` ::: B[]NSAIF() ::: => redis.js `;
+
+
+const scan=async(options,db, key)=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+    return new Promise((resolve, reject)=>{
+        try{
+          redisConn.select(db,function() { /* ... */ }); 
+          const redisScan = require('node-redis-scan');
+          const scanner = new redisScan(redisConn);
+           scanner.scan(key,  (err, matchingKeys) => {
+              if (err) throw(err);
+              const end = Date.now();
+              const time = end - start;
+              resolve({"count":matchingKeys.length, "keys":matchingKeys,  "time":utl.milisegundosASegundos(time)});
+
+              try{
+                exec.redisClose(redisConn);
+              }catch(e){
+                utl.log('err.scan '+e);
+              }
+          });
+        }catch(e){
+          utl.log('err scan: '+e);
+        }
+      })
+}
+
+const set=async(options, db, key, value, expire )=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  expire = expire!=null?expire*1:0;  // tls en segundo
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ }); 
+      redisConn.set(key, value, function (err, res) {
+        const end = Date.now();
+        const time = end - start;
+        if (expire>0){
+            redisConn.expire(key, expire, function(expErr,expRes){
+              resolve({"set":key, "expire":expire, "expRes":expRes, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+            });
+        }else{
+          resolve({"set":key, "expire":expire, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+        }
+        try{
+          exec.redisClose(redisConn);
+        }catch(e){
+          utl.log('err.set '+e);
+        }
+      });
+    }catch(e){
+      utl.log('err setKey'+e);
+    }
+  })
+}
+
+const get=async( options, db, key )=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);  
+  const start = Date.now();
+
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  
+      redisConn.get(key, function (err, res) {
+        const end = Date.now();
+        const time = end - start;
+
+        resolve({"get":key, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+        try{
+          exec.redisClose(redisConn);
+        }catch(e){
+          utl.log('err.get '+e);
+        }
+      });
+    }catch(e){
+      utl.log('err getKey'+e);
+    }
+  })
+}
+
+
+const incrby=async(options, db, key,value,expire, counter )=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);  
+  expire = expire!=null?expire*1:0;  // tls en segundo
+  counter = counter!=null?counter*1:0;  // incremental
+  value = value ? !isNaN(value) ? value*1: 1 :1;  // valor
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    get(options,db,key)
+    .then(r=>{
+      if (r.res==null){  // no existe
+          set(options,db,key,value,expire)
+          .then(r=>{
+            console.log({r});
+            const end = Date.now();
+            const time = end - start;
+            resolve({"set":key, "expire":expire, "err":null, "res":value, "counter":0,  "time":utl.milisegundosASegundos(time)});
+          });
+      }else{
+        redisConn.select(db,function() { /* ... */ });  
+        redisConn.incrby(key, counter, function (err, res) {
+          const end = Date.now();
+          const time = end - start;
+          resolve({"set":key, "expire":expire, "err":err, "res":res, "counter":counter,  "time":utl.milisegundosASegundos(time)});
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.incr '+e);
+          }
+        });
+      }
+    });
+  })
+}
+
+
+const incrbyfloat=async( options,db, key, value, expire, counter )=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);  
+  expire = expire!=null?expire*1:0;  // tls en segundo
+  counter = counter!=null?counter*1:0;  // incremental
+  value = value ? !isNaN(value) ? value*1: 1 :1; // valor
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    get(options,db,key)
+    .then(r=>{
+      if (r.res==null){  // no existe
+          set(options,db,key,value,expire)
+          .then(r=>{
+            console.log({r});
+            const end = Date.now();
+            const time = end - start;
+
+            resolve({"set":key, "expire":expire, "err":null, "res":value, "counter":0,  "time":utl.milisegundosASegundos(time)});
+          });
+      }else{
+        redisConn.select(db,function() { /* ... */ });  
+        redisConn.incrbyfloat(key,counter, function (err, res) {
+          const end = Date.now();
+          const time = end - start;
+
+          resolve({"set":key, "expire":expire, "err":err, "res":res, "counter":counter,  "time":utl.milisegundosASegundos(time)});
+
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.incr '+e);
+          }
+        });
+      }
+    });
+  })
+}
+
+const sadd=async(options, db, key, value )=>{  // SADD key member [member ...]
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+
+  if (typeof value === 'object'){
+    value = JSON.stringify(value);
+  }
+
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  
+      redisConn.sadd(key, value, function (err, res) {
+
+          const end = Date.now();
+          const time = end - start;
+
+          resolve({"sadd":key, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.sadd '+e);
+          }
+      });
+    }catch(e){
+      utl.log('err sadd'+e);
+    }
+  })
+}
+
+const srem=async( options,db, key, value )=>{  //key member [member ...]
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+
+  if (typeof value === 'object'){
+    value = JSON.stringify(value);
+  }
+  
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  //base 1
+      redisConn.srem(key, value,  function (err, res) {
+         const end = Date.now();
+         const time = end - start;
+
+          resolve({"srem":key, "value":value, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.srem '+e);
+          }
+      });
+    }catch(e){
+      utl.log('err del'+e);
+    }
+  })
+}
+
+const smembers=async( options, db, key, toJson )=>{  // SMEMBERS key
+  toJson = toJson!=null?toJson*1:0; 
+  const exec        = require("./exec");
+
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  //base 1
+      redisConn.smembers(key, function (err, res) {
+
+         const end = Date.now();
+         const time = end - start;
+         
+         resolve({"smembers":key, "err":err, "res":toJson==1?utl.ArraytoJson(res):res, "time":utl.milisegundosASegundos(time)});
+        try{
+            exec.redisClose(redisConn);
+        }catch(e){
+            utl.log('err.smembers '+e);
+        }
+      });
+    }catch(e){
+      utl.log('err smembers'+e);
+    }
+  })
+}
+
+const hset=async( options,db, key, values )=>{  // HSET key field value [ field value ...]
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  let Fields = new Array();
+  //Siempre el value debe estar en json 
+  for (const [key, value] of Object.entries(values)) {
+    Fields.push(key);
+    Fields.push(value);
+  }
+
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  //base 1
+      // hset con multiples campos esta depreciado en versiones mayores a node 6
+      redisConn.hmset(key, Fields, function (err, res) {
+         const end = Date.now();
+         const time = end - start;
+          resolve({"hset":key, "err":err, "res":res, "value":values, "time":utl.milisegundosASegundos(time)});
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.hset '+e);
+          }
+      });
+    }catch(e){
+      utl.log('err hset'+e);
+    }
+  })
+}
+
+const hgetall=async(options, db, key )=>{  // SMEMBERS key
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  //base 1
+      redisConn.hgetall(key, function (err, res) {
+        const end = Date.now();
+        const time = end - start;
+          resolve({"hgetall":key, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.hgetall '+e);
+          }
+      });
+    }catch(e){
+      utl.log('err hgetall'+e);
+    }
+  })
+}
+
+const del=async( options,db, key )=>{  //DEL key [key ...]
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ });  //base 1
+      redisConn.del(key, function (err, res) {
+         const end = Date.now();
+         const time = end - start;
+
+          resolve({"del":key, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+          try{
+            exec.redisClose(redisConn);
+          }catch(e){
+            utl.log('err.del '+e);
+          }
+      });
+    }catch(e){
+      utl.log('err del'+e);
+    }
+  })
+}
+
+// Busca llaves de un hash con la combinacion de busquedas similar a un where
+// 2022/04/26 VRSZ Se cambia la busqueda de rows 
+const hfind=async(options,db, key, filter, order, limit=100)=>{   
+  let {field:orderBy, val:orderVal} = getFirstField(order);
+  
+  //2022/10/14 VRSZ Se realiza regla para combinar sentencias IN, AND, y/o OR 
+  let query = ''; 
+  let qfilter = filter;
+  try{
+    for (let  key in filter){
+        if (query.length>0){
+          query = query + ` && `;
+        }
+        query = query + " (" +filtertoFind(qfilter,'json') +")";
+        delete qfilter[key];
+    }
+  }catch(e){
+    log('err.hfind.filter:'+e);
+  }
+  //console.log('query=>>>>>>>>>>',query);
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+    smembers(options,db, key)
+    .then(r=>{
+      // 2022/04/27 VRSZ Realizar busqueda con filtros o regresar toda la info
+      //let hfind = value=='*'?utl.ArraytoJson(r.res):utl.ArraytoJson(r.res).find(e=>e[field]==value);
+      let hfind = new Array();
+      let res = utl.ArraytoJson(r.res);
+
+      let irow=1;
+      res.map(r=>{
+        let json = r;
+        if (irow<=limit){
+          if (query!=''){
+            eval (` if (${query}) { hfind.push(r); irow++; } `);
+          }else{
+            hfind.push(r);
+            irow++;
+          }
+        } 
+      })
+      hfind = orderBy==""?hfind:utl.sort(hfind, orderBy, orderVal);
+      const end = Date.now();
+      const time = end - start;
+      resolve({"key":key, "filter":filter,  "time":utl.milisegundosASegundos(time), "hfind":hfind});
+    }
+    );
+  });
+}
+
+const upsert=async(options,db,key,json_obj,id,vid,expire)=>{
+  //2022/04/26 VRSZ Se cambia forma de guardar tablas de sql a redis
+  const start = Date.now();
+  return new Promise((resolve, reject)=>{
+  smembers(options,db,key)
+  .then(r=>{
+      let lt = r.res; //console.log(lt);
+      let keyId = '';  
+      for (let x of lt){
+        const xjson = JSON.parse(x);
+        try{
+          eval (" if (xjson."+id+"=='"+vid+"'){ keyId = x  } ");
+          if (keyId!=''){
+            break;
+          }
+        }catch(e){
+        }
+      }
+      //console.log(':::::::::: keyId ['+keyId+']');
+      if (keyId==''){
+        sadd(options,db,key,JSON.stringify(json_obj),expire)
+        .then(r=>{
+          const end = Date.now();
+          const time = end - start;
+          resolve({"upsert":key, "dml":"insert", "expire":expire, "err":null, "res":r, "time":utl.milisegundosASegundos(time)});
+        });
+      }else{
+        srem(options, db, key, keyId )
+        .then(r=>{
+            sadd(options,db,key,JSON.stringify(json_obj),0)
+            .then(r=>{
+              const end = Date.now();
+              const time = end - start;
+              resolve({"upsert":key, "dml":"update", "expire":expire, "err":null, "res":r, "time":utl.milisegundosASegundos(time)});
+            });
+        });
+      }
+  });
+  });
+}
+
+const expireat=async(options, db, key, expire )=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  expire = expire!=null?expire*1:0;  // tls en segundo
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ }); 
+      redisConn.expire(key, expire, function (err, res) {
+        const end = Date.now();
+        const time = end - start;
+        resolve({"expireat":key, "expire":expire, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+        try{
+          exec.redisClose(redisConn);
+        }catch(e){
+          utl.log('err.expireat:'+e);
+        }
+      });
+    }catch(e){
+      utl.log('err expireat:'+e);
+    }
+  })
+}
+
+const setnx=async(options, db, key, value, expire )=>{
+  const exec        = require("./exec");
+  const redisConn = await exec.redisConn(options);
+  const start = Date.now();
+  expire = expire!=null?expire*1:0;  // tls en segundo
+  return new Promise((resolve, reject)=>{
+    try{
+      redisConn.select(db,function() { /* ... */ }); 
+      redisConn.setnx(key, value, function (err, res) {
+        const end = Date.now();
+        const time = end - start;
+        if (expire>0){
+            redisConn.expire(key, expire, function(expErr,expRes){
+              resolve({"set":key, "expire":expire, "expRes":expRes, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+            });
+        }else{
+          resolve({"set":key, "expire":expire, "err":err, "res":res, "time":utl.milisegundosASegundos(time)});
+        }
+        try{
+          exec.redisClose(redisConn);
+        }catch(e){
+          utl.log('err.set '+e);
+        }
+      });
+    }catch(e){
+      utl.log('err setKey'+e);
+    }
+  })
+}
+
+const api=async(options, dbm, json)=>{
+  const exec        = require("./exec");
+
+  const start = Date.now();
+  let dml = '',  key='';
+  let expire = json.expire!=null ? json.expire:0;
+  let filter = json.filter!=null ? json.filter:{};
+  let value = json.value!=null ? json.value:{};
+  let order = json.order!=null ? json.order:{};
+  let counter  = json.counter!=null?json.counter:0; 
+  let toJson  = json.toJson!=null?json.toJson:0;
+  let limit  = json.limit!=null?json.limit:100;
+
+  let {field:id, val:vid} = getFirstField(filter);
+
+  let ltdml = ['hfind','upsert','set','get','scan','incrby','sadd','srem','smembers','hset','hgetall','del','incrbyfloat','expireat','setnx'];
+  for (let x of ltdml){
+    if (utl.ObjectEmpty(json,x)){
+      dml = x; break;
+    } 
+  }
+
+  try{ eval(`  key = json.${dml};  `); } catch(e){}
+
+  let r;
+  switch (dml){
+    case 'set':         r = await set(options,dbm,key,value,expire); break;
+    case 'get':         r = await get(options,dbm,key); break;
+    case 'hfind':       r = await hfind(options,dbm,key,filter,order,limit); break;
+    case 'upsert':      r = await upsert(options,dbm,key,value,id,vid,expire); break;
+    case 'scan':        r = await scan(options,dbm, key); break;
+    case 'incrby':      r = await incrby(options,dbm,key,value,expire,counter); break;
+    case 'sadd':        r = await sadd(options,dbm,key,value,expire); break;
+    case 'srem':        r = await srem(options,dbm,key,value); break;
+    case 'smembers':    r = await smembers(options,dbm,key,toJson); break;
+    case 'hset':        r = await hset(options,dbm,key,value,expire); break;
+    case 'hgetall':     r = await hgetall(options,dbm,key); break;
+    case 'del':         r = await del(options,dbm,key); break;
+    case 'incrbyfloat': r = await incrbyfloat(options,dbm,key,value,expire,counter); break;
+    case 'expireat':    r = await expireat(options,dbm,key,expire); break;
+    case 'setnx':       r = await setnx(options,dbm,key,value,expire); break;
+    default:            r = {"dml":"404", "err":"dml not found."};
+  }
+
+  return new Promise((resolve, reject)=>{ 
+    resolve(r);
+  })
+}
+
+const getFirstField=(o)=>{
+  let field = '', val ='';
+  try{
+    for (let x in o){
+      field = x; val = o[x];
+      break;
+    }
+  }catch(e){
+
+  }
+  return {field, val}
+}
+
+const filtertoFind=(o, njson)=>{
+  let query  = '', And = '', Or = '', In ='', type = '';
+  try{
+  /**
+  { "hfind":"cc2:aw_c_test",
+    "filter":{"$and":[{"id_usr":"2"},{"id_u":"3"}]},
+    "order":{"id_usr":"asc"} }
+  */
+  if (utl.ObjectEmpty(o, '$and')){
+    type = 'and';
+    And = o.$and;
+    for (let x of And){
+
+      let key = Object.keys(x);
+      if (query.length>0){
+        query = query + ' && ';
+      }
+      query = query + `\`\${${njson}.${key}}\` =='${x[key]}'`;
+    }
+  }
+  /** 
+   { "hfind":"cc2:aw_c_test",
+    "filter":{"$or":[{"id_usr":"2"},{"id_u":"3"}]},
+    "order":{"id_usr":"asc"} } 
+  */
+  if (utl.ObjectEmpty(o, '$or')){
+    type = 'or';
+    Or = o.$or;
+    for (let x of Or){
+      let key = Object.keys(x);
+      if (query.length>0){
+        query = query + ' || ';
+      }
+      query = query + `\`\${${njson}.${key}}\`=='${x[key]}'`;
+    }
+  }
+
+  /**
+   { "hfind":"cc2:aw_c_test",
+    "filter":{"id_usr":"2"},
+    "order":{"id_usr":"asc"} }
+   { "hfind":"cc2:aw_c_test",
+    "filter":{"id_usr":{"$in":[1,2]}} }
+   */
+  if (type==''){
+    for (let x in o){
+        let In = o[x];
+        if (utl.ObjectEmpty(In, '$in')){
+            query = ` utl.valueIn({'in':\`\${${njson}.${x}}\` , 'value':'${In.$in.join()}'}) `;
+        }
+        else{
+          if (o[x]=='*'){
+            query = ` 1==1 `;
+          }else{
+            query = ` \`\${${njson}.${x}}\`=='${o[x]}' `;
+          }
+        }
+    }
+  }
+  }catch(e){
+
+  }
+  //utl.log(query);
+  return query;
+}
+
+module.exports ={
+    scan,
+    set,
+    get,
+    incrby,
+    sadd,
+    srem,
+    smembers,
+    hset,
+    hgetall,
+    del,
+    hfind,
+    upsert,
+    api,
+    incrbyfloat,
+    expireat
+  }

package/lib/network.js

@@ -0,0 +1,57 @@
+/**
+ * ::: B[]NSAIF() ::: => 2022
+ */
+
+ 'use strict';
+const ping      = require("ping");
+const utl       = require('./utl');
+
+const failover = async (o) => {
+    let {uri='', timeout=1}=o;
+    timeout ? timeout*1:0;
+    const start = Date.now();
+    let results = new Array();
+    let uri_alive = '';
+    const parse_url = /^(?:([A-Za-z]+):)?(\/{0,3})([0-9.\-A-Za-z]+)(?::(\d+))?(?:\/([^?#]*))?(?:\?([^#]*))?(?:#(.*))?$/;
+    try{
+        let lturi= uri.split(",");
+        for (let u of lturi){      
+            if (u==''){
+                results.push({inputHost:"Not uri"});
+                break;
+            }
+            
+            let result = parse_url.exec(u);  //[url,scheme,slash,host,port,path,query,hash] 
+            let host = result[3];
+            if (host=='localhost'){
+                uri_alive = u;
+                results.push({inputHost:host, alive:true});
+                break;
+            }
+
+            result = await ping.promise.probe(host, {
+                timeout: timeout,
+                extra: ["-i", timeout],
+            });
+
+            results.push(result);
+
+            if (result.alive){
+                uri_alive = u;
+                break;
+            }
+        }
+    }catch(e){
+        utl.log('failover : '+e);
+    }
+
+    return new Promise((resolve, reject)=>{
+        const end = Date.now();
+        const time = end - start;
+        resolve({"uri_alive":uri_alive, "time":utl.milisegundosASegundos(time), "results":results});
+    });
+}
+
+module.exports={
+    failover
+}