exports['version'] = function(beforeExit){
var n = 0;
mc.version(function(error, success){
n++;
assert.equal(error, null);
assert.length(success, 5);
});
beforeExit(function(){
assert.equal(1, n);
});
};
User.findOne(wheres, function(err, user) {
if (err || !user) {
console.log('permission denied : ' + err + ' : ' + email);
response('', 102);
} else if (password != user.password) {
console.log('password is incorrect :', password);
response('', 103);
} else {
//login successfully
console.log('login successfully then connect to memcache...:', email);
var token = jwt.encode(email, secret);
var memcache = require('memcache');
var client = new memcache.Client('11211', 'localhost');
client.connect();
client.set(token, JSON.stringify(user), null, 100 * 60 * 10);
console.log('login successfully token has been saved into memcache !', token);
response({
'token' : token,
'user' : user
}, 200);
}
});
mc.get('set2', function(r) {
// assert key is found
assert.equal('asdf2', r);
n++;
// delete key
mc.delete('set2', function() {
mc.get('set2', function(r) {
// assert key is null
assert.equal(null, r);
n++;
});
});
});
setInterval(function () {
memcacheConnection.get('lastData', function (error, result) {
if (lastData < result) {
lastData = result;
var dateTemp = new Date;
var unixtimeMs = dateTemp.getTime();
var unixtime = parseInt(unixtimeMs / 1000);
unixtime += 3600;
var graph = null;
memcacheConnection.get('backendInfo', function (error, result) {
var info = JSON.parse(result);
fs.writeFileSync("public/info.json", JSON.stringify(info), 'utf8');
})
memcacheConnection.get('backendData', function (error, result) {
var data = JSON.parse(result);
// do we need to graph?
if (nextGraph < unixtime) {
graph = 1;
nextGraph = unixtime + 10;
}
// generate full data block
data.graph = graph;
data.unixtime = unixtime;
// send data block on all sockets (to clients)
x.emit('data', data);
fs.writeFileSync("public/current.json", JSON.stringify(data), 'utf8');
// do we need to save history block?
if (nextSave < unixtime) {
historyData.push(data);
fs.writeFileSync("public/history.json", JSON.stringify(historyData), 'utf8');
nextSave = unixtime + 300;
};
});
}
})
}, 1000);
this._driver.decrement(key, 1, (error, res) => {
if (error === 'NOT_FOUND') {
this._driver.set(key, -1, () => {
}, this._maxAge);
debug('dec', key, '=>', -1);
return resolve(-1);
}
if (error) {
return reject(new Error(error));
}
res = parseInt(res) || 0;
debug('dec', key, '=>', res);
resolve(res);
});
return this._connecting = new Promise((resolve, reject) => {
this._driver.on('connect', ()=> {
this._connecting = null;
resolve();
});
this._driver.on('error', e => {
console.error(e.stack);
if (this._connecting) {
this._connecting = null;
this._driver.removeAllListeners();
this._driver.close();
reject(e);
}
});
this._driver.on('close', () => {
this._driver.removeAllListeners();
this._driver = null;
if (this._connecting) {
this._connecting = null;
reject();
}
});
this._driver.connect();
});
mc.set('inc_bad', 'HELLO', function(err, response){
assert.equal(response, 'STORED');
n++;
mc.increment('inc_bad', 2, function(err, ok){
n++;
assert.match(err, /^CLIENT_ERROR/);
assert.equal(ok, null);
});
mc.decrement('inc_bad', 3, function(err, ok){
n++;
assert.match(err, /^CLIENT_ERROR/);
assert.equal(ok, null);
});
mc.increment('inc_bad', null, function(err, ok){
n++;
assert.match(err, /^CLIENT_ERROR/);
assert.equal(ok, null);
});
mc.decrement('inc_bad', null, function(err, ok){
n++;
assert.match(err, /^CLIENT_ERROR/);
assert.equal(ok, null);
});
});
mc.set('set1', 'asdf1', function() {
n++;
mc.get('set1', function(err, r) {
// assert key is found
assert.equal('asdf1', r);
n++;
// assert key expires after 1s
setTimeout(function() {
mc.get('set1', function(r) {
mc.close();
assert.equal(null, r);
n++;
});
}, 1000);
});
}, 1);
return new Promise((resolve, reject) => {
this._driver.increment(key, 1, (error, res) => {
if (error === 'NOT_FOUND') {
this._driver.set(key, 1, () => {
}, this._maxAge);
debug('inc', key, '=>', 1);
return resolve(1);
}
if (error) {
return reject(new Error(error));
}
res = parseInt(res) || 0;
debug('inc', key, '=>', res);
resolve(res);
});
});
mc.increment('inc_good', 2, function(err, response){
n++;
assert.equal(response, 7);
mc.increment('inc_good', function(err, response){
n++;
assert.equal(response, 8);
mc.decrement('inc_good', function(err, response){
n++;
assert.equal(response, 7);
mc.decrement('inc_good', 4, function(err, response){
n++;
assert.equal(response, 3);
});
});
});
});
return new Promise((resolve, reject) => {
this._driver.get(key, (error, res) => {
if (error) {
return reject(new Error(error));
}
if (res !== null) {
try {
res = JSON.parse(res);
} catch (error) {
res = null;
}
}
debug('get', key, '=>', res);
resolve(res);
});
});
request.on('end', function() {
data = querystring.parse(data);
var key = data['key'];
if (key) {
var json = JSON.stringify(data);
mc.set('rr-' + key, json, 120); // Save for two minutes.
}
if (!nodb) {
db.run("insert into log (time, ip, useragent) values (?, ?, ?)",
[new Date().toISOString(), request.remote.ip, request.headers['user-agent']]);
}
// db.insert(key, request.headers['user-agent'], request.remote.ip);
response.writeHead(200, "OK", { "Content-Type" : "text/plain",
"Access-Control-Allow-Origin" : "*",
"Access-Control-Allow-Headers" : "origin, content-type"});
response.end("OK\n");
});
var generate_code = function(callback){
var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz123456789";
var string_length = 8;
var randomstring = '';
for (var i=0; i<string_length; i++) {
var rnum = Math.floor(Math.random() * chars.length);
randomstring += chars.substring(rnum,rnum+1);
}
client.get(randomstring, function(error, result){
if(result){
generate_code();
}else{
if(callback)
callback(randomstring);
}
});
}
+' WHERE `uid` = ?', [passwordHash, passwordSalt, uid], function(err, result) {
if(err) {
console.log(err2);
cb(err);
} else {
memcache.delete('pwd-u:'+uid);
console.log('invalidating memcache');
exports.getEmail(uid, function(err2, data) {
if(err2) {
console.log(err2);
cb(err2);
} else {
memcache.delete('pwd:'+data.email);
}
cb();//success
});
}
});
exports.checkEmailPwd = function(emailAddress, password, cb) {
memcache.get('pwd:'+emailAddress, function(err, valStr) {
var val;
try {
val = JSON.parse(valStr);
} catch(e) {
}
console.log('memcache', err, val);
if(val) {
var hash = crypto.createHash('sha256').update(password).update(val.passwordSalt).digest('hex');
if(val.passwordHash == hash) {
cb(null, val.uid);
} else {
cb('wrong email/pwd (cached)');
}
} else {
connection.query('SELECT `uid`, `status`, `password_hash`, `password_salt` FROM `customers`'
+' WHERE `email_address` = ?',
[emailAddress], function(err, rows) {
console.log(err, rows);
if(err) {
cb('internal database error');
} else {
if(rows.length>=1 && rows[0].status<=USER.MAXOPEN) {
memcache.set('pwd:'+emailAddress, JSON.stringify({
passwordHash: rows[0].password_hash,
passwordSalt: rows[0].password_salt,
uid: rows[0].uid
}));
var hash = crypto.createHash('sha256').update(password).update(rows[0].password_salt).digest('hex');
if(hash == rows[0].password_hash) {
cb(null, rows[0].uid);
} else {
cb('wrong email/pwd');
}
} else {
cb('first user not open');
}
}
});
}
});
};
app.use(function(req, res, next){
req.memcache = client;
req.generate_code = generate_code;
if(typeof req.headers[cfg.header.toLowerCase()] !== 'undefined'){
client.get(
req.headers[cfg.header.toLowerCase()],
function(error, result){
if(result){
req.user = parseInt(result.toString());
}
next();
}
);
}else{
next();
}
});
mc.set('inc_good', '5', function(err, response){
assert.equal(response, 'STORED');
n++;
mc.increment('inc_good', 2, function(err, response){
n++;
assert.equal(response, 7);
mc.increment('inc_good', function(err, response){
n++;
assert.equal(response, 8);
mc.decrement('inc_good', function(err, response){
n++;
assert.equal(response, 7);
mc.decrement('inc_good', 4, function(err, response){
n++;
assert.equal(response, 3);
});
});
});
});
});
exports['test set exist'] = function(beforeExit) {
var n = 0;
// set key
mc.set('existKey', 'asdf', function() {
n++;
mc.exist('existKey', function (err, r) {
// the key exists
assert.equal('EXISTS', r);
n++;
});
mc.exist('notFoundKey', function (err, r) {
// the key is not found
assert.equal('NOT_FOUND', r);
n++;
});
}, 0);
beforeExit(function() {
assert.equal(3, n);
});
};
[uid], function(err, rows) {
console.log(err, rows);
if(err) {
cb('internal database error');
} else {
if(rows.length>=1 && rows[0].status<=USER.MAXOPEN) {
memcache.set('pwd-u:'+uid, JSON.stringify({
passwordHash: rows[0].password_hash,
passwordSalt: rows[0].password_salt
}));
var hash = crypto.createHash('sha256').update(password).update(rows[0].password_salt).digest('hex');
if(hash == rows[0].password_hash) {
cb(null, uid);
} else {
cb('wrong user/pwd');
}
} else {
cb('first user not open');
}
}
});
io.set('authorization', function(data, callback)
{
var cookies = cookie.parse(data.headers.cookie);
console.log(cookies);
mcClient.get('sessions/' + cookies.PHPSESSID, function(error, result)
{
if (error)
{
console.log('error');
callback(error, false);
}
else if (result)
{
data.session = JSON.parse(result);
callback(null, true);
}
else
{
callback('Could not find session ID ' + cookies.PHPSESSID + ' in memcached', false);
}
});
});
initialize(callback) {
var configuration = this._configuration;
var client = new Memcache.Client(configuration.memcachePort, configuration.memcacheHost);
var connecting = true;
client.on('connect', (error) => {
if (!connecting) {
return;
}
connecting = false;
if (error) {
console.error("Connect error", error);
return callback(error);
}
debug("initialize", "Memcache connected");
this._memcacheClient = client;
callback();
});
client.on('error', (error) => {
console.error("Memcache error", error);
if (!connecting) {
return;
}
connecting = false;
callback(error);
});
client.on('close', () => {
debug("initialize", "Memcache closed");
this._memcacheClient = null;
});
client.on('timeout', () => {
console.error("Memcache timeout");
});
client.connect();
}
exports['test set, get, and expires'] = function(beforeExit) {
var n = 0;
// set key
mc.set('set1', 'asdf1', function() {
n++;
mc.get('set1', function(err, r) {
// assert key is found
assert.equal('asdf1', r);
n++;
// assert key expires after 1s
setTimeout(function() {
mc.get('set1', function(r) {
mc.close();
assert.equal(null, r);
n++;
});
}, 1000);
});
}, 1);
beforeExit(function() {
assert.equal(3, n);
});
};
load_userdata: function (callback) {
console.log("get from memcached", this.session_id);
memcached.get(this.session_id, function (err, result) {
console.log("get from memcached", this.session_id, "result", arguments);
if (err) {
return callback(err);
}
if (!result) {
return callback(new Error("session-not-found"));
}
var rjson;
try {
rjson = JSON.parse(result);
} catch (parse_err) {
return callback(parse_err);
}
this.userdata = rjson.data.userdata;
callback();
}.bind(this));
},
exports['test set del'] = function(beforeExit) {
var n = 0;
// set key
mc.set('set2', 'asdf2', function() {
n++;
mc.get('set2', function(err, r) {
// assert key is found
assert.equal('asdf2', r);
n++;
// delete key
mc.delete('set2', function() {
mc.get('set2', function(err, r) {
// assert key is null
assert.equal(null, r);
n++;
});
});
});
}, 0);
beforeExit(function() {
assert.equal(3, n);
});
};
console.log('created listener on port' + config.listenPort);
// bind views
app.get('/', function (req, res) { res.sendfile(__dirname + '/views/index.html'); });
app.get('/detail', function (req, res) { res.sendfile(__dirname + '/views/detail.html'); });
// creating socket io socket for connecting clients
io.on('connection', function () {
io.set('log level', 0);
io.set('transports', ['websocket', 'flashsocket', 'htmlfile', 'xhr-polling', 'jsonp-polling']);
});
// connect to memcache
var memcache = require('memcache');
var memcacheConnection = new memcache.Client(config.memcache.port, config.memcache.host);
memcacheConnection.connect();
var x = io.sockets.on('connection', function (socket) { /* nothing todo (yet) */ });
// save last graph generation and save time
var nextGraph = null;
var nextSave = null;
var lastData = null;
// check if history already exists (maybe node crashed)
try {
console.log("opening history");
var historyFile = fs.readFileSync("public/history.json", 'utf8');
var historyData = JSON.parse(historyFile);
} catch (err) {
// tyrant_delete.js
//
// Feb/15/2016
// -------------------------------------------------------------
var memcache = require('memcache')
// -------------------------------------------------------------
var onConnect = function()
{
client.delete (key_in,function(error, result){ })
client.close()
console.log("*** 終了 ***")
}
// -------------------------------------------------------------
var key_in=process.argv[2]
console.log("*** 開始 ***")
console.log (key_in)
var client = new memcache.Client (1978,'host_ubuntu')
client.connect()
client.addHandler(onConnect)
// -------------------------------------------------------------
var http = require('http');
var sqlite3 = require('sqlite3');
var exec = require('child_process').exec;
// var sys = require('sys');
var path = require('path');
var requestHandler = http.IncomingMessage.prototype;
var memcache = require('memcache');
var mc = new memcache.Client();
mc.connect();
var querystring = require('querystring');
var fs = require('fs')
/**
* Add a uniform interface for remote address in Node.js
*
* From: https://gist.github.com/3rd-Eden/1740741
* @api private
*/
requestHandler.__defineGetter__('remote', function remote () {
var connection = this.connection
, headers = this.headers
, socket = connection.socket;
// return early if we are behind a reverse proxy
if (headers['x-forwarded-for']) {
return {
ip: headers['x-forwarded-for']
, port: headers['x-forwarded-port']
}
}
var GitHubApi = require("github");
var memcache = require('memcache');
// github apiの設定
var github = new GitHubApi({
version: "3.0.0",
timeout: 5000
});
// memcached
var client = new memcache.Client(11211,'localhost');
client.connect();
exports.index = function(req, res){
if (req.query === undefined || req.query.user === undefined) {
res.json(500,{ status:false, message: "no user data" });
}
if (req.query.page === undefined) req.query.page = 1;
// キャッシュの読み込み
var cacheKey = "ghstr_" + req.query.user + "_" + req.query.page;
github.events.getFromUserPublic({'user':req.query.user,'page': req.query.page},function(err,json){
var message = 'data not found';
var stars = [];
if (err) {
message = JSON.parse(err.message);
mcClient.get('test', function(err, response) { //get一个key
console.log(response);
mcClient.close();
});
(function () {
'use strict';
/*
* WGlads.com | Powerfull light-weight chat system ^___^
* Copyright (c) Yuri Borunov, 2015
*/
var fs = require('fs'),
io = require('socket.io'),
wrap = require('wordwrap'),
memcache = require('memcache'),
redis = require('redis'),
notify = require('./notification.js'),
chatSockets,
mclient,
mclient_reconnect_id,
rclient,
secret_key = 'abcd',
users = {},
users_id = {},
users_gags = {},
libs = require('./libs.js')(mclient, users_gags),
sendMessage;
fs.writeFile(__dirname + "/chat.pid", process.pid, function (err) {
if (err) {
console.log(err);
} else {
console.log('The chat process pid was saved!');
}
});
// Run Socket.IO to listen on specific port
io.listen(9045, {'log level': 1});
// Selects all connection to specific channel
chatSockets = io.of('/chat');
notify.roomsModuleInit(chatSockets);
// Connect to Memcache
mclient = new memcache.Client(11312, 'localhost');
mclient.connect();
// Connect to Redis
rclient = redis.createClient(6379, 'localhost');
rclient.on('connect', function () {
// Listen system messages 30 seconds after start
setTimeout(function () {
rclient.subscribe('chat_system');
rclient.subscribe('sys_cmd');
}, 1000 * 30);
});
// Socket IO events
chatSockets.on('connection', function (socket) {
// Accept new connection
socket.emit('auth', { hello: 'Welcome to WGlads brand-new chat' });
// Accept authorization data from client
socket.on('save_auth', function (data) {
var user_md5,
got_key,
comms,
comms_arr,
commn_key,
count_users,
i;
console.log("Accept authorization data from client");
if (!data.login || !data.auth_key) {
console.log("Client sent wrong authorization data");
return false;
}
// create MD5 to verify secret_key
user_md5 = libs.make_md5(libs.convert_tocp1251(data.login));
got_key = libs.make_md5(secret_key + user_md5);
if (got_key !== data.auth_key) {
console.log("login: "******" = wrong md5");
socket.emit('error', { text: 'wrong auth key' });
return false;
}
// add user to system
users[data.login] = socket.id;
users_id[data.uid] = data.login;
// save extra data to socket
socket.uid = data.uid;
socket.login = data.login;
socket.level = data.level;
socket.locate = data.locate;
socket.color = data.color;
socket.join('global');
socket.join('loc_' + data.locate);
notify.addUser(data.uid, data.login, socket.id);
if (data.clan) {
socket.join('clan_' + data.clan);
if (data.clan === 'Magistratus') {
socket.join('clan_Senate');
}
}
if (data.communities !== 'underfined' && data.communities !== '') {
comms = data.communities.split(",");
comms_arr = [];
for (i = 0; i <= comms.length - 1; i += 1) {
commn_key = libs.make_md5(comms[i]);
socket.join('comms_' + commn_key);
console.log('join comm: "' + comms[i] + '", comms_' + commn_key);
comms_arr[comms_arr.length] = 'comms_' + commn_key;
}
socket.communities = comms_arr;
} else {
socket.communities = [];
}
count_users = users.length;
console.log('It\'s ' + count_users + ' users online for now');
});
// Accept authorization data from client
socket.on('switch_location', function (data) {
if (!socket.login) {
return;
}
console.log('User ' + socket.login + ' wish to switch location: ' + data.location);
socket.leave('loc_' + socket.locate);
socket.join('loc_' + data.location);
socket.locate = data.location;
//console.log(chatSockets.manager.roomClients[socket.id]);
});
// Accept authorization data from client
socket.on('save_communities', function (data) {
var i,
comms,
comms_new,
comms_arr,
commn_key;
if (!socket.login) {
return;
}
console.log('User ' + socket.login + ' save communities: ' + data.communities);
comms = socket.communities;
for (i = 0; i <= comms.length - 1; i += 1) {
socket.leave(comms[i]);
}
comms_new = data.communities.split(",");
comms_arr = [];
for (i = 0; i <= comms_new.length - 1; i += 1) {
commn_key = libs.make_md5(comms_new[i]);
socket.join('comms_' + commn_key);
comms_arr[comms_arr.length] = 'comms_' + commn_key;
}
socket.communities = comms_arr;
});
// Accept authorization data from client
socket.on('save_level', function (data) {
if (!socket.login) {
return;
}
console.log('User ' + socket.login + ' save level: ' + data.level);
socket.level = data.level;
});
// Accept new messages
socket.on('add_msg', function (data) {
var ts,
txt,
text,
words,
pattern,
pattern_txt,
logins_constr,
private_login,
communities,
comm_name,
commn_key,
clan_row,
i;
if (!socket.login) {
return;
}
// check if user got gag in mouth
ts = Math.round((new Date()).getTime() / 1000);
if (users_gags[socket.uid] && (users_gags[socket.uid] === 0 || users_gags[socket.uid] > ts)) {
txt = 'You have been blocked in chat, you will be able to chat only after ' + Math.ceil((users_gags[socket.uid] - ts) / 60) + ' min.';
sendMessage({
type: 'private',
to: socket.login,
from: 'Senator Gracchus',
text: 'private (' + socket.login + ') ' + txt,
color: 'black'
});
return true;
}
console.log('Accepted new message from user ' + socket.login);
text = data.text;
// filtering accepted message
text = text.replace(/^\s+|\s+$/g, ''); // trim
text = libs.escapeHtml(text); // remove html
// wrap big strings
words = text.split(' ');
for (i = 0; i <= words.length - 1; i += 1) {
words[i] = wrap.hard(70)(words[i]).split('\n').join(' ');
}
text = words.join(' ');
// replace internal links with text
text = text.replace(/http:\/\/wglads\.(com|ru)\/game\/[\-a-zA-Z0-9_\.?=\/&]+/i, '(prohibited link)');
// check if the message is advertising
pattern_txt = text.replace(/[^a-zA-Z]/i, "");
if (pattern_txt.match(/(gladiatorsru|fdworldsnet|vk\.com\/app)/i)) {
txt = 'This is prohibited link, don\'t add it to chat, please :thanks:';
sendMessage({
type: 'private',
to: socket.login,
from: 'Senator Gracchus',
text: 'private (' + socket.login + ') ' + txt,
color: 'black'
});
return true;
}
// if user's level less than 20 and he's writing in private chat
if (socket.level < 20 && (text.indexOf('private (') >= 0 || text.indexOf('communmity (') >= 0 || text.match(/clan \([a-zA-Z]+\)/i))) {
txt = 'it\'s too sad, however until 20 level you allowed to chat exclusively in common chat. We all once were in the same circumstances :zdarov: ';
sendMessage({
type: 'private',
to: socket.login,
from: 'Senator Gracchus',
text: 'private (' + socket.login + ') ' + txt,
color: 'black'
});
return true;
}
// if message contains private notation
if (text.indexOf('private (') >= 0) {
pattern = /private \(([\-a-zA-Zа-яА-Я0-9_\s]+)\)/g;
logins_constr = text.match(pattern);
console.log('- sending to private section');
if (logins_constr !== null) {
for (i = 0; i < logins_constr.length; i += 1) {
private_login = logins_constr[i].replace(pattern, "$1");
if (private_login !== socket.login) {
//console.log('login - '+private_login);
sendMessage({
type: 'private',
to: private_login,
from: socket.login,
text: text,
color: socket.color,
is_hidden: data.is_hidden
});
}
}
sendMessage({
type: 'private',
to: socket.login,
from: socket.login,
text: text,
color: socket.color,
is_hidden: data.is_hidden
});
return true;
}
return false;
}
// if message contain community address
if (text.indexOf('community (') >= 0) {
pattern = /community \(([\-a-zA-Zа-яА-Я\s\.]+)\)/g;
communities = text.match(pattern);
console.log('- sending to community section');
if (communities !== null) {
if (communities.length > 0) {
comm_name = communities[0].replace(pattern, "$1");
commn_key = libs.make_md5(comm_name);
sendMessage({
type: 'community',
to: 'comms_' + commn_key,
from: socket.login,
text: text,
color: socket.color,
is_hidden: data.is_hidden
});
}
return true;
}
return false;
}
// if message contain clan issue
if (text.indexOf('clan (') >= 0) {
console.log('clan section');
pattern = /clan \(([a-zA-Z]+)\)/i;
clan_row = pattern.exec(text);
//console.log(clan_row);
if (clan_row !== null) {
sendMessage({
type: 'clan',
to: 'clan_' + clan_row[1],
from: socket.login,
text: text,
color: socket.color,
is_hidden: socket.is_hidden
});
return true;
}
return false;
}
// if a message to a global chat
if (data.channel === 'global') {
sendMessage({
type: 'global',
to: 'global',
from: socket.login,
text: text,
color: socket.color,
is_hidden: data.is_hidden
});
return true;
}
// if just a regular message to current location chat
sendMessage({
type: 'locate',
to: 'loc_' + socket.locate,
from: socket.login,
text: text,
color: socket.color,
is_hidden: data.is_hidden
});
});
socket.on('disconnect', function () {
console.log('user ' + socket.login + ' disconnected :(');
notify.delUser(socket.uid);
//uid_todel[socket.uid] = Math.round((new Date()).getTime() / 1000);
//console.log(chatSockets.clients())
//delete users[socket.login];
//delete users_id[socket.uid];
});
});
sendMessage = function (data) {
var now = new Date(),
hours = (now.getHours() < 10) ? '0' + now.getHours() : now.getHours(),
minutes = (now.getMinutes() < 10) ? '0' + now.getMinutes() : now.getMinutes(),
time = hours + ':' + minutes, //+':'+now.getSeconds()
from = data.from,
to = data.to,
text = data.text,
color = data.color,
type = data.type,
is_hidden = data.is_hidden,
ready_data;
if (is_hidden === '1') {
from = 'unkown';
}
ready_data = {
'type': type,
'time': time,
'login': from,
'text': text,
'color': color
};
if (type === 'global' || type === 'locate' || type === 'clan' || type === 'community') {
console.log('send to: ' + type + ' - ' + data.to);
chatSockets.in(data.to).emit('message', ready_data);
return true;
}
if (type === 'private' || type === 'system') {
//console.log(users);
//console.log('to'+data.to);
//console.log('user '+users[data.to]);
if (!users[to]) {
return;
}
console.log('send to: private - ' + to);
chatSockets.socket(users[to]).emit('message', ready_data);
return true;
}
};
// Redis events
rclient.on('message', function (channel, rawMsgData) {
//console.log('get redis msg');
var msgData = JSON.parse(rawMsgData),
data,
id_list,
socket_id,
i;
if (channel === 'chat_system') {
if (msgData.type === 'system') {
//console.log('system msg');
if (!users[msgData.to]) {
return;
}
data = {
'type': 'system',
'from': 'system',
'to': msgData.to,
'text': msgData.text,
'color': 'black'
};
sendMessage(data);
//console.log('send redis system msg to chat');
}
if (msgData.type === 'locate') {
//console.log('locate msg');
data = {
'type': 'locate',
'from': msgData.from,
'to': 'loc_' + msgData.to,
'text': msgData.text,
'color': 'black'
};
sendMessage(data);
//console.log('send redis locate msg to chat: '+msgData.to);
}
if (msgData.type === 'private') {
//console.log('private msg');
data = {
'type': 'private',
'to': msgData.to,
'from': msgData.from,
'text': 'private (' + msgData.to + ') ' + msgData.text,
'color': 'black'
};
sendMessage(data);
//console.log('send redis private msg to chat: '+msgData.to);
}
if (msgData.type === 'refresh') {
console.log('refresh msg');
id_list = msgData.uid.split(',');
for (i = 0; i < id_list.length; i += 1) {
if (users_id[id_list[i]]) {
//console.log('send refresh to: '+id_list[i]);
socket_id = users[users_id[id_list[i]]];
chatSockets.socket(socket_id).emit('message', {
"type": "refresh"
});
}
}
}
return true;
}
if (channel === 'sys_cmd') {
if (msgData.cmd === 'gags_reload') {
libs.getUsersGags();
}
}
});
// Memcache events
mclient_reconnect_id = -1;
mclient.on('connect', function () {
console.log('Memcache connected');
libs.getUsersGags();
});
mclient.on('close', function () {
console.log('memcache disconnected');
if (mclient_reconnect_id > -1) {
clearTimeout(mclient_reconnect_id);
}
mclient_reconnect_id = setTimeout(function () {
console.log("trying to reconnect Memcache..");
mclient.connect();
}, 5000);
});
mclient.on('error', function () {
console.log('Memcache error');
});
}());