return new Promise(function(resolve) {
var io = new SocketIO(http, {serveClient: false});
if (config.socketIO.origins) {
io.origins(config.socketIO.origins);
}
SocketIOAuth(io, {
authenticate: authenticateUser,
timeout: 3000
});
resolve(io);
});
})(function (require, exports) {
"use strict";
var Agenda = require('agenda');
var bodyParser = require('body-parser');
var express = require('express');
var path = require('path');
var socketIo = require('socket.io');
var request = require('request');
var socketIoAuth = require('socketio-auth');
var app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(express.static(path.join(__dirname, 'public'), { maxAge: 86400 }));
app.use('/jspm_packages', express.static(path.join(__dirname, '../jspm_packages')));
var router = express.Router();
router.use(function (req, res, next) { return next(); });
router.route('/test').get(function (req, res) { return res.json({ test: 'ok' }); });
router.get('/config.js', function (req, res) { return res.sendFile(path.join(__dirname, '../config.js')); });
router.get('/socket.io-client.js', function (req, res) { return res.sendFile(path.join(__dirname, '../jspm_packages/npm/socket.io-client@1.4.6.js')); });
app.use('/', router);
var server = app.listen(3000, 'localhost', function () {
console.log('App listening at http://%s:%s', server.address().address, server.address().port);
console.log(__dirname);
});
var io = socketIo.listen(server);
socketIoAuth(io, {
authenticate: function (socket, data, callback) {
return callback(null, true);
}
});
io.sockets.on('connection', function (socket) {
console.log("user connected");
socket.emit('helloWorld', { hello: 'world' });
socket.on('refreshRepos', function (data) {
var url = "https://api.github.com/users/" + (data && data.user) + "/repos";
request(url, { json: true, headers: { 'user-agent': 'node.js' } }, function (err, response, data) {
socket.emit('reposRefreshed', data);
});
});
});
var mongoConnectionString = "mongodb://localhost/agenda";
var agenda = new Agenda({ db: { address: mongoConnectionString } });
agenda.define('test', function (job, done) {
console.log('agenda test');
done();
});
agenda.on('ready', function () {
agenda.every('10 minutes', 'test');
agenda.start();
});
});
var ios = io(server);
if (params.useClientPassword)
{
var auth = require('socketio-auth');
auth(ios,
{
authenticate: function (socket, password, callback)
{
mylog("authentication by client",1);
var connectionPassword = fs.readFileSync(params.connectionPasswordFile).toString().substr(0,64);
if (crypto.createHash('sha256').update(password).digest('hex') === connectionPassword)
{
mylog("authentication success",1);
return callback(null, true);
}
else
{
mylog("authentication failed",0);
return callback(new Error("Invalid connection password"),false);
}
},
timeout: 1000
});
}
// handle for the websocket connection from client
ios.sockets.on('connection', function(socket)
{
mylog("client connected",0);
function websocket(server) {
socketioAuth(SocketIO(server), {
authenticate: (socket, token, cb) => { cb(null, token == authToken) },
postAuthenticate: connection,
})
function connection(socket) {
function on(type, callback) {
socket.on(type, async function(args, respond) {
try {
let res = await callback(... args)
respond([null, res])
}
catch(err) {
console.error(err.stack || err)
respond([''+err])
}
})
}
function subscribe(type) {
function handler() {
socket.emit(type, ... arguments)
}
events.on(type, handler)
socket.on('disconnect', () => {
events.removeListener(type, handler)
})
}
on('addPeer', async (url) => {
return await getPeerByUrl(url)
})
on('deletePeer', async (peerId) => {
await deletePeerById(peerId)
})
on('updatePeerCard', async (peerId) => {
await updatePeerCard(peerId)
return await getPeer(peerId)
})
on('setPeerProps', async (peerId, props) => {
await setPeerProps(peerId, props)
})
on('getPeers', async () => {
let rows = await db('SELECT * FROM peer')
let peers = rows.map(loadPeer)
return peers
})
on('sendMessage', async (peerId, message) => {
let peer = await getPeer(peerId)
let envelope = {
type: 'Envelope',
box: createBox(message, keyPair.privateKey, peer.card.publicKey),
from: myPublicUrl,
to: peer.url,
}
await saveMessage(peer.id, message, true)
await send(peer.card.inboxUrl, envelope)
})
on('getMessages', async (peerId) => {
let peer = await getPeer(peerId)
let rows = await db(`SELECT * FROM message WHERE peer_id = ?
ORDER BY id DESC LIMIT 10`, peer.id)
return rows.map(loadMessage)
})
on('getPeersWithUnread', async () => {
return await getPeersWithUnread()
})
on('markAsRead', async (peerId) => {
await markAsRead(peerId)
events.emit('markAsRead', peerId)
})
subscribe('message')
subscribe('markAsRead')
}
return server
}