whatap 1.0.1 → 1.0.2

package/lib/util/paramsecurity.js

@@ -0,0 +1,80 @@
+
+var KeyGen  = require('./keygen'),
+    conf    = require('../conf/configure'),
+    fs      = require('fs'),
+    path    = require('path');
+var Buffer  = require('buffer').Buffer;
+
+var ParamSecurity = function () {
+    this.key = null;
+    this.reload();
+};
+
+ParamSecurity.prototype.getKey = function () {
+    var s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+    var buf = '';
+    for(var i=0; i<6; i++) {
+        var x = Math.abs(parseInt(KeyGen.next() % s.length));
+        buf += s.charAt(x);
+    }
+    return buf;
+};
+
+ParamSecurity.prototype.reload = function () {
+    var home = conf['app.root'];
+    if (home == null ) {
+        var self = this;
+        setTimeout(function () {
+            self.reload();
+        }, 5000);
+        return;
+    }
+
+    var file = path.join(home, 'security.conf');
+    var self = this;
+    try {
+        var stat = fs.statSync(file);
+        if(stat.size != 6) {
+            self.key = Buffer.from("WHATAP");
+            return;
+        }
+        var readable = fs.createReadStream(file, {flags : 'r'});
+        readable.on('readable', function () {
+            if(self.key !== null
+                && self.key !== undefined
+                && self.key.length === 0 ) { return; }
+            var chunk;
+            while (null !== (chunk = readable.read())) {
+                self.key = chunk;
+            }
+            self.key = Buffer.from(self.key);
+        });
+    } catch (e) {
+        // self.key = self.getKey();
+        self.key = 'WHATAP';
+        var printWriter = fs.createWriteStream(file, {flags : 'w'});
+        printWriter.write(self.key);
+        self.key = Buffer.from(self.key);
+    }
+};
+ParamSecurity.prototype.encrypt = function (b, crc) {
+    var self = this;
+    if(self.key == null || self.key.length === 0) {
+        self.reload();
+        return null;
+    }
+    for(var i=0, j=0; i<b.length; i++, j = (j + 1) % self.key.length) {
+        crc.value ^= b[i];
+        b[i] ^= self.key[j];
+    }
+
+    return b;
+};
+ParamSecurity.prototype.decrypt = function (b, crc, dkey) {
+    for(var i=0, j=0; i<b.length; i++, j = (j+1) % dkey.length) {
+        b[i] ^= dkey[j];
+        crc.value ^= b[i];
+    }
+    return b;
+};
+module.exports = new ParamSecurity();

package/lib/util/pre-process.js

@@ -0,0 +1,13 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+// config 파일 확인
+// 지원 되는 버전 확인 
+//(node version 확인)
+//(지원 되는 라이브러리 버전 확인 )
+
+// 라이센스 파일 확인
+// 라이센스 확인 

package/lib/util/process-seq.js

@@ -0,0 +1,166 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+ var fs = require('fs'),
+ path = require('path'),
+ hahsUtil = require('../util/hashutil2'),
+ IPUtil      = require('../util/iputil');
+function isLiveProcess(pid) {
+if(!pid || pid.length === 0) return true;
+
+try {
+ return process.kill(pid,0)
+}
+catch (e) {
+ return e.code === 'EPERM'
+}
+}
+
+function LockCompetition(key){
+ this.MAIN_KEY = key;
+ var Configuration = require('./../conf/configure');
+ var root = Configuration['app.root'];
+ var cwd = process.cwd();
+ if(root == undefined) {
+	 root = cwd;
+ }
+ let gubun = hahsUtil.hash(IPUtil.getIp());
+ this.rootFolder = path.join(root,'SSwhatapSS').replace('SSwhatapSS',path.sep + '.'+key);
+ if(fs.existsSync(this.rootFolder) == false) {
+	fs.mkdirSync(this.rootFolder);
+ }
+ this.rootFolder += path.sep + gubun;
+ if(fs.existsSync(this.rootFolder) == false) {
+	fs.mkdirSync(this.rootFolder);
+ }
+ this.LOCK_FILE = path.join(this.rootFolder,this.MAIN_KEY+'.lock');
+ this.initComplete = false;
+}
+
+LockCompetition.prototype.init = function(cb){
+ if(this.initComplete) {
+	 if(cb) cb();
+ }
+ fs.mkdir( this.rootFolder, function(err){
+	 if(!err || err.code === 'EEXIST'){
+		 this.initComplete = true;
+		 if(cb) cb();
+	 }else{
+		 return console.error(err);
+	 }
+ });
+}
+
+LockCompetition.prototype.accessAuth = function(cb){
+ var self = this;		
+ self.init(function(){
+	 var i = setInterval(function(){
+		 self.createLockFile(path.join(self.LOCK_FILE), function(result){
+			 if(result){
+				 self.checkFileIndex(1, function(idx){
+					 self.releaseLockFile( function(result){
+						 if(result){
+							 cb(idx);		
+							 clearInterval(i);
+						 }
+					 })
+				 })
+			 }
+		 })
+	 },10)
+ });
+}
+
+LockCompetition.prototype.readLockFile = function(cb){
+ fs.readFile( this.LOCK_FILE, 'utf-8', function(err,data){
+	 if(cb) cb(err, data);
+ });
+}
+
+LockCompetition.prototype.createLockFile = function(file, cb){
+ var self = this;
+ self.readLockFile(function(err, data){
+	 if(err){
+		 fs.writeFile(file, process.pid + '', 'utf-8', function(err,data){
+			 if(err){
+				 if(cb) return cb(false);
+			 }else{
+				 self.readLockFile( function(err, data){
+					 if(err && cb) return cb(false);
+					 if(parseInt(data) === process.pid){
+						 if(cb) return cb(true);
+					 }else{
+						 if(cb) return cb(false);
+					 }
+				 });
+			 }
+		 });
+	 }else{
+		 if(isLiveProcess(data)){
+			 if(cb) return cb(false);
+		 }else{
+			 fs.unlink(self.LOCK_FILE, function(err){
+				 if(err){
+					 if(cb) return cb(false);
+				 }else{
+					 if(cb) return cb(true);
+				 }
+			 });
+		 }
+	 }
+ });
+}
+
+LockCompetition.prototype.releaseLockFile = function(cb){
+ var self = this;
+ fs.readFile(self.LOCK_FILE, 'utf-8', function(err,data){
+	 if(err && cb) return cb(err, data);
+
+	 if(parseInt(data) === process.pid){
+		 fs.unlink(self.LOCK_FILE, function(err){
+			 if(err){
+				 if(cb) return cb(false);
+			 }else{
+				 if(cb) return cb(true);
+			 }
+		 });
+	 }else{
+		 if(cb) return cb(false);
+	 }
+ });
+}
+
+LockCompetition.prototype.checkFileIndex = function(idx,cb){
+ var self = this;
+ idx = idx || 1;
+ fs.readFile(path.join(self.rootFolder, self.MAIN_KEY+idx), 'utf-8', function(err,data){
+	 if(err){
+		 fs.writeFile(path.join(self.rootFolder, self.MAIN_KEY+idx), process.pid + '', 'utf-8', function(err){
+			 if(err){
+				 self.checkFileIndex(++idx,cb);					
+			 }else{
+				 if(cb) cb(idx);
+			 }
+		 });
+	 }else{
+		 if( isLiveProcess(data) ){
+			 self.checkFileIndex(++idx,cb);
+		 }else{
+			 fs.writeFile(path.join(self.rootFolder, self.MAIN_KEY+idx), process.pid + '', 'utf-8', function(result){
+				 if(err){
+					 self.checkFileIndex(++idx,cb);
+				 }else{
+					 if(cb) cb(idx);
+				 }
+			 });
+		 }
+	 }
+ })
+}
+
+module.exports = function(key){
+ return new LockCompetition(key);
+};

package/lib/util/property-util.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var MapValue = require('./../value/map-value')
+
+module.exports = {
+    readProperty: function(str, spliter, type){
+        var result = undefined;
+        if(type && type.constructor === MapValue){
+            result = new MapValue();
+        }else{
+            result = {};
+        }
+
+        if(str.constructor === String){
+            var rowProps = str.split('\n');
+
+            for(var i = 0 ; i < rowProps.length; i++){
+                if(rowProps.indexOf('#') === 0 ) continue;
+
+                var p = rowProps[i].split(spliter);
+                if(p.length > 1){
+                    if(result.constructor === MapValue){
+                        result.put(p[0], p[1]);
+                    }else{
+                        result[p[0]] = p[1];
+                    }
+                }
+            }
+        }
+        return result;
+    }
+};

package/lib/util/request-queue.js

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var LinkedList = require('./linkedlist');
+
+function RequestQueue(capacity) {
+    this.capacity = capacity;
+    this.queue = new LinkedList();
+}
+
+RequestQueue.prototype.get = function () {
+    if(this.queue.size() > 0) {
+        return this.queue.removeFirst();
+    }
+    return null;
+};
+RequestQueue.prototype.getByTimeout = async function (timeout) {
+    try{
+        if (this.queue.size() > 0) {
+            return this.queue.removeFirst()
+        }
+        var timeto = Date.now() + timeout;
+        var time = timeout;
+        while (this.queue.size() === 0) {
+            try {
+                if (time > 0) {
+                    await new Promise(resolve => setTimeout(resolve, time));
+                }
+            } catch (e) {
+            }
+            time = timeto - Date.now();
+            if (time <= 0) {
+                break;
+            }
+        }
+        if (this.queue.size() > 0) {
+            return this.queue.removeFirst();
+        }
+        return null;
+    }catch (e) {
+        return null;
+    }
+};
+RequestQueue.prototype.put = function (o) {
+    if(this.capacity <= 0 || this.queue.size() < this.capacity) {
+        this.queue.add(o);
+        return true;
+    } else {
+        failed(o);
+        return false;
+    }
+};
+RequestQueue.prototype.size = function () {
+    return this.queue.size();
+};
+RequestQueue.prototype.clear = function () {
+    this.queue = new LinkedList();
+};
+
+var failed = function (v) {
+
+};
+var overflowed = function (v) {
+
+};
+
+module.exports = RequestQueue;

package/lib/util/requestdouble-queue.js

@@ -0,0 +1,72 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var LinkedList = require('./linkedlist');
+var RequestDoubleQueue = function(capacity1, capacity2){
+    this.capacity1 = capacity1;
+    this.capacity2 = capacity2;
+    this.queue1 = new LinkedList();
+    this.queue2 = new LinkedList();
+};
+RequestDoubleQueue.prototype.size=function(){
+    return {q1:this.queue1.size(), q2:this.queue2.size()};
+} 
+
+RequestDoubleQueue.prototype.get = function(){
+    if(this.queue1.size() > 0 ){
+        return this.queue1.removeFirst();
+    }
+
+    if(this.queue2.size() > 0){
+        return this.queue2.removeFirst();
+    }
+    return null;
+};
+RequestDoubleQueue.prototype.hasNext = function(){
+    if(this.queue1.hasNext() ||  this.queue2.hasNext()) return true;
+    return false;
+};
+RequestDoubleQueue.prototype.putForce1 = function(o) {
+    return this.putForce(this.queue1, this.capacity1, o);
+};
+RequestDoubleQueue.prototype.putForce2 = function(o) {
+    return this.putForce(this.queue2, this.capacity2, o);
+};
+RequestDoubleQueue.prototype.putForce = function(q /* LinkedList */, sz /* int */, o ) {
+    if(sz <= 0 || q.size() < this.capacity1){
+        q.add(o);
+        return true;
+    }else{
+        while (q.size() >= sz){
+            var v = q.removeFirst();
+            overflowed(v);
+        }
+        q.add(o);
+        return false;
+    }
+};
+RequestDoubleQueue.prototype.put = function(q /* LinkedList */, capacity /* int */, o ) {
+    if(capacity <= 0 || q.size() < capacity){
+        q.add(o);
+        return true;
+    }else{
+        failed(o);
+        return false;
+    }
+};
+RequestDoubleQueue.prototype.put1 = function(o) {
+    return this.put(this.queue1, this.capacity1, o);
+};
+RequestDoubleQueue.prototype.put2 = function(o) {
+    return this.put(this.queue2, this.capacity2, o);
+};
+var failed = function(v /* object */) {
+};
+var overflowed = function(v /* object */) {
+};
+
+module.exports = RequestDoubleQueue;
+

package/lib/util/resourceprofile.js

@@ -0,0 +1,157 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var platform = process.platform,
+    arch     = process.arch,
+    version  = parseFloat(process.version.slice(1));
+
+var os      = require('os'),
+    v8      = require('v8'),
+    // gcstat  =  require('../../bindings/'+platform+'/'+arch+'/whatap.node'),
+    Long    = require('long'),
+    df      = require('df'),
+    pusage  = require('pidusage');
+
+function ResourceProfile() {
+    var self = this;
+    self.gc_count = 0;
+    self.gc_time =0;
+    self.cpu_info = {
+        times   : 0,
+        usage   : 0,
+        core    : 0,
+        proc    : 0
+    };
+
+    /** Disk usage */
+    if(os.type() != 'Windows_NT'){
+        setInterval(function () {
+            df(function (err, table) {
+                if(err || table == null) {
+                    return self.disk = 0;
+                }
+                table.forEach(function(n, i){
+                    if(n.mountpoint === '/'){
+                        self.disk = n.percent;
+                    }
+                });
+            });
+        }, 1000);
+    }
+
+    /** Process cpu */
+    setInterval(function () {
+        pusage.stat(process.pid, function(err, stat) {
+            if(err || stat == null) return;
+            self.pcpu = stat.cpu;
+            self.cpu_info.proc = stat.cpu;
+        });
+    }, 1000);
+
+    /** Machine CPU */
+    self.setCPUUsage();
+    // gcstat.startMonitor(function (starttime, duration, type, flag) {
+    //     // starttime => second
+    //     if(self.gc_count == null) {
+    //         self.gc_count = 0;
+    //         self.gc_time = 0;
+    //     }
+    //     self.gc_count = self.gc_count.add(1);
+    //     self.gc_time = self.gc_time.add(Number(duration));
+    // });
+}
+ResourceProfile.prototype.setCPUUsage = function () {
+    var self = this;
+    var before = self.getCPUInfo();
+
+    setTimeout(function () {
+
+        var after = self.getCPUInfo();
+
+        var idle = after.idle - before.idle;
+        var total = after.total - before.total;
+
+        var percent = idle / total * 100;
+        self.cpu_info.times = total;
+        self.cpu_info.usage = 100 - percent;
+        self.cpu_info.core = os.cpus().length;
+
+        setTimeout(function () {
+            self.setCPUUsage();
+        }, 100);
+
+    }, 1000);
+
+};
+ResourceProfile.prototype.getCPUInfo = function () {
+    var cpus = os.cpus();
+
+    var user = 0;
+    var nice = 0;
+    var sys = 0;
+    var idle = 0;
+    var irq = 0;
+    var total = 0;
+
+    for(var cpu in cpus){
+        if (!cpus.hasOwnProperty(cpu)) continue;
+        user += cpus[cpu].times.user;
+        nice += cpus[cpu].times.nice;
+        sys += cpus[cpu].times.sys;
+        irq += cpus[cpu].times.irq;
+        idle += cpus[cpu].times.idle;
+    }
+
+    var total = user + nice + sys + idle + irq;
+
+    return {
+        'user' : user,
+        'idle': idle,
+        'total': total
+    };
+};
+ResourceProfile.prototype.getCPU = function(){
+    return this.cpu_info;
+};
+ResourceProfile.prototype.getMemory = function(){
+    var stat = v8.getHeapStatistics();
+    var data = {};
+    data.heap_total = parseInt(stat.total_heap_size/1024);
+    data.heap_used = parseInt(stat.used_heap_size/1024);
+    data.usage = (os.totalmem() - os.freemem()) * 100/os.totalmem();
+
+    return data;
+};
+ResourceProfile.prototype.getMemoryV2 = function(){
+    var stat = v8.getHeapStatistics();
+    var data = {};
+    data.heap_total = parseInt(stat.total_heap_size);
+    data.heap_used = parseInt(stat.used_heap_size);
+    data.usage = (os.totalmem() - os.freemem()) * 100/os.totalmem();
+
+    return data;
+};
+ResourceProfile.prototype.getDisk = function(){
+    return {'usage' : this.disk};
+};
+ResourceProfile.prototype.getCPUTime = function () {
+    var total = 0;
+    var cpus = os.cpus();
+    cpus.forEach(function(n){
+        total += n.times['user'];
+    });
+    total = parseInt(total / cpus.length );
+    return total;
+};
+ResourceProfile.prototype.getUsedHeapSize = function () {
+    var stat = v8.getHeapStatistics();
+    return stat.used_heap_size;
+};
+ResourceProfile.prototype.getCurrentProcGcInfo = function () {
+    return [this.gc_count, this.gc_time];
+};
+
+module.exports = new ResourceProfile();

package/lib/util/stop-watch.js

@@ -0,0 +1,30 @@
+var DateUtil = require('./../util/dateutil')
+
+var StopWatch = function(){
+    this.stime = DateUtil.currentTime();
+    this.etime = 0;
+}
+
+StopWatch.prototype.start = function(){
+    this.stime = DateUtil.currentTime();
+    this.etime = 0;
+}
+
+StopWatch.prototype.getTime = function(){
+    if(this.etime === 0){
+        var now = DateUtil.currentTime();
+        return now - this.stime;
+    }else{
+        return this.etime = this.stime;
+    }
+}
+
+StopWatch.prototype.stop = function(){
+    if(this.etime === 0){
+        this.etime = DateUtil.currentTime()
+    }
+
+    return this.etime - this.stime;
+}
+
+module.exports = StopWatch;

package/lib/util/system-util.js

@@ -0,0 +1,10 @@
+var fs = require('fs')
+    ;
+
+var SystemUtil = {
+    IS_LINUX: process.platform == 'linux' ? true : false, 
+    loadContainerId: function(){
+    }
+}
+
+module.exports = SystemUtil;

package/lib/util/userid-util.js

@@ -0,0 +1,57 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+const WHATAP_R = "WHATAP";
+
+var conf        = require('../conf/configure'),
+    HashUtil    = require('./hashutil'),
+    Hexa32      = require('./hexa32'),
+    KeyGen      = require('./keygen'),
+    Long        = require('long'),
+    Logger      = require('../logger');
+
+var getUserId = function (req, res, defValue) {
+    try {
+        if (conf.user_header_ticket_enabled === true) {
+                var ticket = req.headers[conf.user_header_ticket];
+                if (ticket != null && ticket.length > 0) {
+                    return Long.fromNumber(HashUtil.hash(ticket));
+                }
+        }        
+        var cookie = req.headers.cookie;
+        if (cookie != null) {
+            if (cookie.length >= conf.trace_user_cookie_limit) {
+                return defValue;
+            }
+            var x1 = cookie.indexOf(WHATAP_R);
+            if (x1 >= 0) {
+                var value = '';
+                var x2 = cookie.indexOf(';', x1);
+                if (x2 > 0) {
+                    value = cookie.substring(x1 + WHATAP_R.length + 1, x2);
+                } else {
+                    value = cookie.substring(x1 + WHATAP_R.length + 1);
+                }
+                try {
+                    return Hexa32.toLong32(value);
+                } catch (th) {
+                }
+            }
+        }
+        var expires= new Date(Date.now() + (86409000*365*5)).toUTCString();
+        var cookie_str = WHATAP_R + "=" + Hexa32.toString32(KeyGen.next()) + "; expires=" + expires +"; path=/";
+        res.setHeader("Set-Cookie", cookie_str);
+    } catch (e) {
+        Logger.printError('WHATAP-193', 'UserIdUtil Error', e);
+    }
+    return Long.ZERO;
+};
+
+var UserIdUtil = {
+    getUserId : getUserId
+};
+
+module.exports = UserIdUtil;