plan.save(function (err) {
if (err) {
pubsubError(err);
} else {
// Push out to all subscribers
message.propogate = false;
bayeux.getClient().publish('/' + plan_id, message);
}
});
var server = app.listen(process.env.PORT || 3000, function () {
bayeux.attach(server);
var host = server.address().address;
var port = server.address().port;
console.log('Collector at http://%s:%s', host, port);
});
hydroponicSerial.on('data', function (data) {
readDataHydroponic += data.toString();
// get rid of bytes left over in the ARD tx buffer
if (readDataHydroponic.indexOf('\r') != 0) {
readDataHydroponic = '';
} else if (readDataHydroponic.indexOf('\r') == 1) {
readDataHydroponic = readDataHydroponic.substring(readDataHydroponic.indexOf('\r')+1, readDataHydroponic.length);
}
var countCrHydroponic = readDataHydroponic.match(/\r/gi);
if (countCrHydroponic !== null && countCrHydroponic.length == 2) {
cleanDataHydroponic = readDataHydroponic.substring(readDataHydroponic.indexOf('\r')+1, readDataHydroponic.lastIndexOf('\r'));
readDataHydroponic = '';
try {
var hydroponic = JSON.parse(cleanDataHydroponic);
} catch (err) {
// error parsing
console.log("error parsing HY serial data");
}
if (typeof hydroponic == 'undefined') {
console.log("error, HY object not valid");
} else {
// save serial data to mongodb
if (hydroponic !== lastHydroponic) {
var hydroponicDataInstance = new hydroponicDataSample(hydroponic);
hydroponicDataInstance.save(function (err) {
if (err){
console.log('error writing to HY DB!');
} else {
//console.log('HY written to DB!');
}
});
}
console.log(hydroponicDataInstance);
// publish to faye clients
bayeux.getClient().publish('/hydroponic/live', JSON.stringify(hydroponicDataInstance));
// when a floodcycle is detected through solout == true, tell AQ to turn on pump
if (typeof lastHydroponic != 'undefined' && hydroponic.actor.solout.state == true && lastHydroponic.actor.solout.state == false) {
aquaponicSerial.write('{"ref":{"deb":1}}{"actor":{"pump":{"state":1}}}');
} else if (typeof lastHydroponic != 'undefined' && hydroponic.actor.solout.state == false && lastHydroponic.actor.solout.state == true) {
aquaponicSerial.write('{"ref":{"deb":0}}{"actor":{"pump":{"state":0}}}');
}
lastHydroponic = hydroponic;
}
} // END entire string check
}); // END on serial evend
bayeux.getClient().subscribe('/count', function(message) {
console.log('{ sender: %s, number: %d }',
message.sender, message.number);
if (message.sender != "server") {
bayeux.getClient().publish('/count', {
sender: "server",
number: message.number + 1
});
}
});
bayeux.getClient().subscribe('/service/user', function(message) {
if (!message) {
bayeux.getClient().publish('/service/user', {
"successful": true,
"user": {
"username": "******",
"isGuest": "true"
}
});
}
});
app.get('/parse', function( req, res ) {
var uid = connect.utils.uid(7);
//console.log( req.query );
if( typeof req.query.msg === 'undefined' ) {
res.end();
} else {
queue.push(uid);
messages[uid] = req.query.msg;
pubsub.getClient().publish('/cutie', {msg: 'incoming', data: {_id: uid, msg: req.query.msg}});
res.end();
}
});
var server = function(port, pathOptional){
var http = require('http'),
faye = require('faye');
var server = http.createServer();
var path = '';
if (pathOptional){
path += pathOptional;
}
var bayeux = new faye.NodeAdapter({
mount: '/'+path,
// timeout: Infinity // CHECK FOR THIS LINE - might cause errors.
});
bayeux.on('subscribe', function(clientId, channel) {
// console.log('subscribed', channel, clientId);
});
bayeux.on('unsubscribe', function(clientId, channel) {
// console.log('unsubscribed',channel, clientId);
});
bayeux.on('handshake', function(clientId){
// console.log("handshaked from:", clientId)
});
bayeux.on('disconnect', function(clientId){
// console.log("disconnected:", clientId);
});
bayeux.attach(server);
server.listen(port);
console.log('server listening on port '+port.toString() );
}
App.prototype.run = function(requestListener) {
requestListener = requestListener || options['requestListener'];
if (typeof requestListener == 'string') {
requestListener = require(prepareRequire(requestListener))(options);
}
var server = options['tls']
? https.createServer({ cert: options['cert'], key: options['key'] }, requestListener)
: http.createServer(requestListener);
bayeux.attach(server);
server.listen(Number(options['port']));
};
client.rpop("playlist", function (err, reply) {
console.log(reply);
var body = "";
if(reply)
body = reply;
bayeux.getClient().publish('/notification', {
command:"pop",
score: reply
});
res.setHeader('Content-Type', 'application/json');
res.setHeader('Access-Control-Allow-Origin', '*');
res.setHeader('Content-Length', body.length);
res.end(body);
});
aquaponicSerial.on('data', function (data) {
readDataAquaponic += data.toString();
// get rid of bytes left over in the ARD tx buffer
if (readDataAquaponic.indexOf('\r') != 0) {
readDataAquaponic = '';
} else if (readDataAquaponic.indexOf('\r') == 1) {
readDataAquaponic = readDataAquaponic.substring(readDataAquaponic.indexOf('\r')+1, readDataAquaponic.length);
}
var countCrAquaponic = readDataAquaponic.match(/\r/gi);
if (countCrAquaponic !== null && countCrAquaponic.length == 2) {
cleanDataAquaponic = readDataAquaponic.substring(readDataAquaponic.indexOf('\r')+1, readDataAquaponic.lastIndexOf('\r'));
readDataAquaponic = '';
try {
var aquaponic = JSON.parse(cleanDataAquaponic);
} catch (err) {
// error parsing
console.log("error parsing AQ serial data");
}
if (typeof aquaponic == 'undefined') {
console.log("error, AQ object not valid");
} else {
// save serial data to mongodb
if (aquaponic !== lastAquaponic) {
var aquaponicDataInstance = new aquaponicDataSample(aquaponic);
aquaponicDataInstance.save(function (err) {
if (err){
console.log('error writing to AQ DB!');
} else {
//console.log('AQ written to DB!');
}
});
}
console.log(aquaponicDataInstance);
// publish to faye clients
bayeux.getClient().publish('/aquaponic/live', JSON.stringify(aquaponicDataInstance));
lastAquaponic = aquaponic;
}
} // END entire string check
}); // END on serial evend
function publishResult( service, result, timestamp ) {
if( !knownServices[ service ] ) {
console.error( 'Not publishing result for unknown service "%s"', service );
return;
}
console.log( 'Publishing result for service "%s"', service );
var channel = '/services/' + service;
var message = {
data: result,
service: service,
timestamp: timestamp
};
bayeux.getClient().publish( channel, message );
}
function gameOver(game_id, game, draw, message, callback)
{
var winner;
if(game.score_1 == game.score_2 || draw)
winner = 0;
else if(game.score_1 > game.score_2)
winner = 1;
else
winner = 2;
var rating = [0, 0];
updateRatings(game, winner);
bayeux.getClient().publish('/game/' + game.channel, {type: 'gameover', id: 0, score_1: game.score_1, score_2: game.score_2, winner: winner});
db.hdel('games', game.channel);
db.del('game:' + game_id);
callback(message);
}
db.incr('posts', function(err, id){
var post = {
id: id,
name: name,
text: t.replace(/</g, '<').replace(/>/g, '>').replace(url, "<a href=\"$1\">$1</a>"),
time: +new Date(),
cc: 0,
image: i
};
db.hmset('post:' + id, post, function(err, status){
db.lrem('all', 0, id, function(){
db.lpush('all', id);
db.ltrim('all', 0, 50);
});
});
post.type = 'post';
post.comments = [];
r.getClient().publish('/all', post);
});
Ping.findOne({url: req.query.url }, function(err, ping) {
if (!ping) {
ping = new Ping({url: req.query.url});
} else {
var now = Date.now();
var week_ago = now - 432000000;
if (ping.instant > week_ago) {
ping.count = ping.count + 1;
} else {
ping.count = 1;
}
ping.instant = Date.now();
}
ping.save(function (err) {
if (!err) console.log('ping saved');
});
bayeux.getClient().publish('/channel', {ping: ping});
res.send(200);
});
relyingParty.verifyAssertion(req, function (error, result) {
var urlObj = url.parse(result.claimedIdentifier);
var pathArray = urlObj.pathname.split('/');
if (pathArray !== null && pathArray !== undefined && pathArray.length > 0) {
var steamid = pathArray[(pathArray.length - 1)];
//Generate a firebase token for our steam auth user info
var tokenGenerator = new FirebaseTokenGenerator(config.firebase.secret);
var token = tokenGenerator.createToken({ uid: "steam:" + steamid });
//Send token to the client
faye_server.getClient().publish('/steamSuccess',
{
pageName: 'sign-in.html',
steamid: steamid,
token: token
});
}
});
serverDomain.run(function () {
var httpServer = http.createServer(function (req, res) {
var reqd = domain.create();
reqd.add(req);
reqd.add(res);
// On error dispose of the domain
reqd.on('error', function (error) {
console.error('Error', error.code, error.message, req.url);
reqd.dispose();
})
// Pass the request to express
app(req, res);
});
bayeux.attach(httpServer);
httpServer.listen(port);
console.log("Express server listening on port %d in %s mode", port, app.get('env'));
})
var http = require('http'),
faye = require('faye');
var server = http.createServer(),
bayeux = new faye.NodeAdapter({mount: '/faye'});
var secret = 'woot';
bayeux.addExtension({
incoming: function(message, callback) {
if (!message.channel.match(/^\/meta\//)) {
var password = message.ext && message.ext.password;
if (password !== secret)
message.error = '403::Password required';
}
console.log(message);
callback(message);
},
outgoing: function(message, callback) {
if (message.ext) delete message.ext.password;
callback(message);
}
});
bayeux.attach(server);
server.listen(3000);
/* Simpler Server for Faye Messaging
*/
var Faye = require('faye'),
server = new Faye.NodeAdapter({mount: '/faye'});
server.bind('handshake', function(clientId) {
console.log('Got Handshake from ClientId == ' + clientId);
});
server.bind('subscribe', function(clientId, channel) {
console.log('Got Subscription, ClientId: ' + clientId + ' Channel: '
+ channel);
});
server.bind('publish', function(clientId, channel) {
console.log('Got Publish, ClientId: ' + clientId + ' Channel: '
+ channel);
});
server.listen(8000);
function spawnUsingFaye(config, userCodeCallback) {
var pubsub_port = config.pubsub_port;
var pubsub_mount = config.pubsub_mount;
var pubsub_channel = '/' + config.pubsub_channel;
var pubsub_teardown_delay_ms = config.storer_pubsub_server_teardown_delay_ms || 2000;
var app = express();
var healthzCallback = function() {
return 'STARTING'
};
var pendingCallback = function() {
return [];
};
var statsCallback = healthzCallback;
app.get('/', function(request, response) {
response.send(healthzCallback());
});
app.get('/pending', function(request, response) {
response.send(JSON.stringify(pendingCallback()));
});
app.get('/healthz', function(request, response) {
response.send(healthzCallback());
});
app.get('/statusz', function(request, response) {
var result = statsCallback();
response.format({
text: function() {
response.send(JSON.stringify(result));
},
html: function() {
response.writeHead(200, {
"Content-Type": "application/json"
});
response.write(JSON.stringify(result, null, 2));
response.end();
},
});
});
var server = http.createServer(app);
console.log('Faye: mount "' + pubsub_mount + '", channel "' + pubsub_channel + '", port ' + pubsub_port + '.');
var bayeux = new faye.NodeAdapter({
mount: pubsub_mount
});
bayeux.attach(server);
server.listen(pubsub_port, function() {
console.log('Faye: server started.');
healthzCallback = function() {
return 'OK';
};
var client = bayeux.getClient();
var publish = function(entry) {
client.publish(pubsub_channel, {
entry: entry
});
};
runStorer(config, userCodeCallback, function() {
console.log('Faye: stopping server.');
server.close(function() {
console.log('Faye: server stopped.');
process.exit(0);
});
// Need to explicitly terminate since some PubSub connections may still be open.
setTimeout(function() {
console.log('Faye: could not stop the server, likely due to persistent connections; terminating anyway.');
process.exit(0);
}, pubsub_teardown_delay_ms);
}, {
set_stats_callback: function(callback) {
statsCallback = callback;
},
set_pending_callback: function(callback) {
pendingCallback = callback;
},
publish: publish,
});
});
};
//Verbindung zur DB herstellen
var db = mongoDB.db('mongodb://localhost/planetendb?auto_reconnect=true', {save: true});
//Collection planeten "binden"
db.bind('planeten');
//Collection db.planeten als Objekt planeten speichern
var planeten = db.planeten;
//Express Objekt erstellen
var app = express();
//Server Objekt erstellen
var server = http.createServer(app);
//Node Adapter konfigurieren
var bayeux = new faye.NodeAdapter({
mount: '/faye',
timeout: 45
});
//Node Adapter mit HTTP-Server verbinden
bayeux.attach(server);
//PubSub Client erstellen
var pubClient = bayeux.getClient();
// /public zur default folder machen, wo die index.html liegt
app.use(express.static(__dirname + '/public'));
//damit body-parser JSON unterstützt
app.use(express.json());
//damit body-parser urlencoded unterstützt
app.use(express.urlencoded());
//Errorbehandlung
app.use(function(error, req, res, next) {
console.error(error.stack);
var faye = require('faye');
var bayeux = new faye.NodeAdapter({mount: '/faye', timeout: 45});
bayeux.on('handshake', function(clientId) {
console.log("handshake" + ":" + clientId);
});
bayeux.on('subscribe', function(clientId, channel) {
console.log("subscribe:" + clientId + ":" + channel);
});
bayeux.on('unsubscribe', function(clientId, channel) {
console.log("unsubscribe:" + clientId + ":" + channel);
});
bayeux.on('publish', function(clientId, channel, data) {
console.log("publish:" + clientId + ":" + channel + ":" + JSON.stringify(data));
});
bayeux.on('disconnect', function(clientId) {
console.log("disconnect:" + clientId);
});
module.exports = function (server) {
bayeux.attach(server);
var serverAuth = {
incoming: function(message, callback) {
// Let non-subscribe messages through
if (message.channel !== '/meta/subscribe')
return callback(message);
var http = require('http'),
faye = require('faye');
faye.logger = function (message) {
console.log('log', message);
}
var server = http.createServer(),
bayeux = new faye.NodeAdapter({mount: '/bayeux', timeout: 45});
var bayeuxClient = bayeux.getClient();
var timers = {};
var isTimer = function (channel) {
return channel.split('/').slice(1)[0] === 'timer';
}
var setTimer = function (channel) {
timers[channel] = setTimeout(function () {
var date = new Date();
bayeuxClient.publish(channel, {datetime: date.getTime(), type: 'TriggeredTime'});
setTimer(channel);
}, 5000);
}
bayeux.bind('subscribe', function (clientId, channel) {
if (isTimer(channel))
setTimer(channel);
});
bayeux.bind('unsubscribe', function (clientId, channel) {
var storeMessages = {
incoming: function(message, callback){
if(notMeta(message)){
var path = message.channel;
if(!parties[path]){
parties[path] = [];
saveListing();
}
updateParty(path, message.data);
}
callback(message);
}
};
var bayeux = new Faye.NodeAdapter({mount: '/bayeux'});
bayeux.addExtension(storeMessages);
/*
* Express
*/
var app = express();
app.use(cors());
app.get('*', function(req, res) {
var party = parties[req.params[0]] ? parties[req.params[0]] : [];
res.json(party);
});
/*
var drawIns = require('./model/drawIns');
var http = require('http');
var path = require('path');
//Mongoose connecting
var mongoose = require('mongoose');
mongoose.connect("localhost");
mongoose.connection.on('error', function() {
console.error('✗ MongoDB Connection Error. Please make sure MongoDB is running.');
});
//Get Faye module and create nodeAdapter
var faye = require('faye');
var bayeux = new faye.NodeAdapter({
mount: "/faye",
timeout: 45
});
var app = express();
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
app.use(express.cookieParser('your secret here'));
app.use(express.session());
var http = require('http'),
faye = require('faye'),
express = require('express'),
passport = require('passport'),
bodyParser = require('body-parser');
var nano = require('nano')('http://localhost:5984');
var dbPresistence = nano.use('qonversation_messages');
var dbUsers = nano.use('qonversation_users');
var ps = new faye.NodeAdapter({
mount: '/chat_server'
});
var app = express();
var server = http.createServer(app);
ps.attach(server);
app.use(bodyParser());
// Setup CORS
app.use(function(req, res, next) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Headers", "X-Requested-With");
next();
});
// Setup status routes
app.use(express.static(__dirname + '/public'));
options['extensions'].forEach(function(name) {
if (name.length) {
bayeux.addExtension(require(prepareRequire(name))(options, bayeux));
}
});
module.exports = function(options) {
var extend = function(target) {
var sources = [].slice.call(arguments, 1);
sources.forEach(function(source) {
for (var prop in source) {
target[prop] = source[prop];
}
});
return target;
};
var prepareRequire = function(str) {
return str.replace('./', process.cwd() + '/');
};
var defaultOptions = require(__dirname + '/options');
if (process.env.FAYE_OPTIONS) {
extend(
defaultOptions,
require(prepareRequire(process.env.FAYE_OPTIONS))
);
}
if (fs.existsSync(process.cwd() + '/options.js')) {
extend(
defaultOptions,
require(process.cwd() + '/options')
);
}
options = extend(
defaultOptions,
options || {}
);
var engine = options['engine'] || null;
if (typeof engine == 'string') {
engine = require(prepareRequire(engine))(options);
}
var bayeux = new faye.NodeAdapter({
mount: options['mount'],
timeout: Number(options['timeout']),
ping: options['ping'] ? Number(options['ping']) : null,
engine: engine
});
if (options['extensions']) {
if (typeof options['extensions'] == 'string') {
options['extensions'] = options['extensions'].split(',');
}
options['extensions'].forEach(function(name) {
if (name.length) {
bayeux.addExtension(require(prepareRequire(name))(options, bayeux));
}
});
}
if (options['monitoring']) {
if (typeof options['monitoring'] == 'string') {
options['monitoring'] = options['monitoring'].split(',');
}
options['monitoring'].forEach(function(name) {
if (name.length) {
require(prepareRequire(name))(options, bayeux);
}
});
}
var App = function() {};
App.prototype.getOptions = function() {
return options;
};
App.prototype.getAdapter = function() {
return bayeux;
};
App.prototype.run = function(requestListener) {
requestListener = requestListener || options['requestListener'];
if (typeof requestListener == 'string') {
requestListener = require(prepareRequire(requestListener))(options);
}
var server = options['tls']
? https.createServer({ cert: options['cert'], key: options['key'] }, requestListener)
: http.createServer(requestListener);
bayeux.attach(server);
server.listen(Number(options['port']));
};
return new App();
};
var http = require('http');
var faye = require("faye");
var server = http.createServer(function(req, res){});
var bayeux = new faye.NodeAdapter({mount: '/sync', timeout: 45 });
bayeux.attach(server);
bayeux.getClient().subscribe('/broadcast', function(data) {
bayeux.getClient().publish('/update', data);
});
server.listen(8008);
console.log('Server running at 8008');
var express = require("express");
var session = require("express-session");
var logfmt = require("logfmt");
var app = express();
var bodyParser = require("body-parser");
var cookieParser = require("cookie-parser");
var http = require("http");
var request = require("request");
var mongoose = require("mongoose");
var faye = require('faye');
var server = http.createServer(app);
global.setImmediate = global.setImmediate || process.nextTick.bind(process);
var bayeux = new faye.NodeAdapter({
mount: '/faye', timeout: 45
});
bayeux.attach(server);
bayeux.on('handshake', function(clientId){
console.log('Client connected', clientId);
});
bayeux.on('subscribe', function(clientId, channel){
console.log('Client subscribed to ' + channel + ': ' + clientId);
});
var bayeuxClient = bayeux.getClient();
var mUser = ''; //Mongoose login username
var mPwd = ''; //Mongoose login password
var mServer = ''; //Mongoose server/app URL
mongoose.connect('mongodb://'+mUser+':'+mPwd+'@' + mServer);
var db = mongoose.connection;
bayeux.getClient().subscribe('/broadcast', function(data) {
bayeux.getClient().publish('/update', data);
});