/*
* @author https://github.com/zz85
*/
"use strict";
var websockets_port = 20143;
// Start contact.js Websocket Server
var WebSocketServer = require('ws').Server,
wss = new WebSocketServer({port: websockets_port});
var fs = require('fs')
var connections = [];
var receivers = [];
var transmitters = [];
var captures = []; // Captured emotions
var CAPTURES_FILE = 'captures.json';
var TYPE_RECEIVER = 'receiver', // Canvas App
TYPE_TRANSMITTER = 'transmitter'; // Emo App
// Recover data after restart
try {
var json = fs.readFileSync(CAPTURES_FILE, 'utf8');
captures = JSON.parse(json);
} catch (e) {
}
req.on('data', function (data) {
wsServerThermal.broadcast(data, { binary: true });
});
var server = require('http').createServer()
, url = require('url')
, WebSocketServer = require('ws').Server
, wss = new WebSocketServer({ server: server })
, express = require('express')
, app = express()
, port = 4081;
app.use(function (req, res) {
res.send({ msg: "hello" });
});
wss.on('connection', function connection(ws) {
var location = url.parse(ws.upgradeReq.url, true);
ws.on('message', function incoming(message) {
console.log('received: %s', message);
});
ws.send('something from server 192.168.0.252:4081');
});
server.on('request', app);
server.listen({port: port, host: '192.168.0.252'}, function (
) { console.log('Listening on ' + server.address().port) });
second quaternion:
Aligned and adjusted Quaternion of the wearable body tracker, it is placed on upper human body
*/
var clientQuaternions;
function crateSerialPortData(array) {
var buf = new Buffer(4);
buf[0] = 0xFF;
for (var i = 1; i < buf.length; i++) {
buf[i] = array[i - 1];
};
return buf;
}
var arduinoPort;
var WebSocketServer = require('ws').Server, wss = new WebSocketServer({
port : 8089
});
wss.on('connection', function (ws) {
ws.on('message', function (message) {
try {
clientQuaternions = getQuaternionsFromBuffer(message);
} catch (e) {
console.log(e);
}
if (clientQuaternions.length === 2) {
//set the two quaternion to the OrientationProcessor module
controls.setCameraWorldQuaternion(clientQuaternions[0]);
controls.setBodyWorldQuaternion(clientQuaternions[1]);
} else {
console.log("Unknown format from Websocket. Expect two quaternions");
}
/**
* Created by WQ on 2015/5/27.
*/
var http = require( 'http' );
var httpServer = http.createServer( function ( req, res ) {
console.log( "http connect" );
res.writeHead( 200, {'Content-Type' : 'text/plain'} );
res.end( 'var a=23' );
} );
httpServer.listen( 8383 );
var WebSocketServer = require( 'ws' ).Server,
wss = new WebSocketServer( {
server : httpServer
} );
wss.on( 'connection', function connection( ws ) {
console.log( "ws connect" );
ws.on( 'message', function incoming( message ) {
console.log( 'received: %s', message );
} );
ws.send( 'something' );
} );
error: err
});
});
}
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
var WebSocketServer = require('ws').Server, wss = new WebSocketServer({port: 8080});
console.log('Websocket server started on 8080');
var rabbit = {x:0, y:0};
var players = {};
wss.on('connection', function(ws) {
ws.on('message', function(message) {
var incommingMsg = JSON.parse(message);
players[incommingMsg.uuid] = {x: incommingMsg.x, y: incommingMsg.y};
for(var i in wss.clients) {
wss.clients[i].send(JSON.stringify(players));
}
ws.on('message', function(message) {
// Broadcast any received message to all clients
wss.broadcast(message);
});
bws.on('pong', () => {
bws.close()
wss.close(done)
})
bws.on('error', (err) => {
assert.equal(err.event, 'auth')
bws.close()
wss.close(done)
})
bws.once('unsubscribed', (data) => {
assert.equal(data.status, 'OK')
assert.equal(data.chanId, channelId)
bws.close()
wss.close(done)
})
bws.on('subscribed', (data) => {
assert.equal(data.channel, 'trades')
assert.equal(data.pair, 'BTCUSD')
bws.close()
wss.close(done)
})
response.json({ status: http.STATUS_CODES[200] });
});
app.use('/', router);
app.use(function(request, response, next) {
response.status(404);
response.json({ status: http.STATUS_CODES[404] });
});
var server = http.createServer(app)
server.listen(port)
logger.info("http server listening on %d", port)
// WebSocket server setting
var wss = new WebSocketServer({ server: server, path: '/ws' })
var ws_connections = [];
wss.on("connection", function(ws) {
var location = url.parse(ws.upgradeReq.url, true);
logger.info(location);
logger.info(ws.upgradeReq.headers);
ws_connections.push(ws);
logger.info("websocket connection open");
ws.on('message', function(data) {
var obj = JSON.parse(data);
logger.info("received message");
logger.info(obj);
sendResponse(obj);
var WebSocketServer = require('ws').Server;
var wss = new WebSocketServer({ port: parseInt(process.argv[2]) });
wss.on('connection', function connection(ws) {
ws.on('message', function incoming(message, flags) {
ws.send(message, flags);
});
});
/**
* Attaches a WebSocket based connection to the Packager to expose
* Hot Module Replacement updates to the simulator.
*/
function attachHMRServer({httpServer, path, packagerServer}) {
let client = null;
function disconnect() {
client = null;
packagerServer.setHMRFileChangeListener(null);
}
// For the give platform and entry file, returns a promise with:
// - The full list of dependencies.
// - The shallow dependencies each file on the dependency list has
// - Inverse shallow dependencies map
function getDependencies(platform, bundleEntry) {
return packagerServer.getDependencies({
platform: platform,
dev: true,
entryFile: bundleEntry,
}).then(response => {
// for each dependency builds the object:
// `{path: '/a/b/c.js', deps: ['modA', 'modB', ...]}`
return Promise.all(Object.values(response.dependencies).map(dep => {
return dep.getName().then(depName => {
if (dep.isAsset() || dep.isAsset_DEPRECATED() || dep.isJSON()) {
return Promise.resolve({path: dep.path, deps: []});
}
return packagerServer.getShallowDependencies(dep.path)
.then(deps => {
return {
path: dep.path,
name: depName,
deps,
};
});
});
}))
.then(deps => {
// list with all the dependencies' filenames the bundle entry has
const dependenciesCache = response.dependencies.map(dep => dep.path);
// map from module name to path
const moduleToFilenameCache = Object.create(null);
deps.forEach(dep => moduleToFilenameCache[dep.name] = dep.path);
// map that indicates the shallow dependency each file included on the
// bundle has
const shallowDependencies = Object.create(null);
deps.forEach(dep => shallowDependencies[dep.path] = dep.deps);
// map from module name to the modules' dependencies the bundle entry
// has
const dependenciesModulesCache = Object.create(null);
return Promise.all(response.dependencies.map(dep => {
return dep.getName().then(depName => {
dependenciesModulesCache[depName] = dep;
});
})).then(() => {
return getInverseDependencies(response)
.then(inverseDependenciesCache => {
return {
dependenciesCache,
dependenciesModulesCache,
shallowDependencies,
inverseDependenciesCache,
resolutionResponse: response,
};
});
});
});
});
}
const WebSocketServer = require('ws').Server;
const wss = new WebSocketServer({
server: httpServer,
path: path,
});
console.log('[Hot Module Replacement] Server listening on', path);
wss.on('connection', ws => {
console.log('[Hot Module Replacement] Client connected');
const params = querystring.parse(url.parse(ws.upgradeReq.url).query);
getDependencies(params.platform, params.bundleEntry)
.then(({
dependenciesCache,
dependenciesModulesCache,
shallowDependencies,
inverseDependenciesCache,
}) => {
client = {
ws,
platform: params.platform,
bundleEntry: params.bundleEntry,
dependenciesCache,
dependenciesModulesCache,
shallowDependencies,
inverseDependenciesCache,
};
packagerServer.setHMRFileChangeListener((filename, stat) => {
if (!client) {
return;
}
console.log(
`[Hot Module Replacement] File change detected (${time()})`
);
client.ws.send(JSON.stringify({type: 'update-start'}));
stat.then(() => {
return packagerServer.getShallowDependencies(filename)
.then(deps => {
if (!client) {
return [];
}
// if the file dependencies have change we need to invalidate the
// dependencies caches because the list of files we need to send
// to the client may have changed
const oldDependencies = client.shallowDependencies[filename];
if (arrayEquals(deps, oldDependencies)) {
// Need to create a resolution response to pass to the bundler
// to process requires after transform. By providing a
// specific response we can compute a non recursive one which
// is the least we need and improve performance.
return packagerServer.getDependencies({
platform: client.platform,
dev: true,
entryFile: filename,
recursive: true,
}).then(response => {
const module = packagerServer.getModuleForPath(filename);
return response.copy({dependencies: [module]});
});
}
// if there're new dependencies compare the full list of
// dependencies we used to have with the one we now have
return getDependencies(client.platform, client.bundleEntry)
.then(({
dependenciesCache,
dependenciesModulesCache,
shallowDependencies,
inverseDependenciesCache,
resolutionResponse,
}) => {
if (!client) {
return {};
}
// build list of modules for which we'll send HMR updates
const modulesToUpdate = [packagerServer.getModuleForPath(filename)];
Object.keys(dependenciesModulesCache).forEach(module => {
if (!client.dependenciesModulesCache[module]) {
modulesToUpdate.push(dependenciesModulesCache[module]);
}
});
// invalidate caches
client.dependenciesCache = dependenciesCache;
client.dependenciesModulesCache = dependenciesModulesCache;
client.shallowDependencies = shallowDependencies;
return resolutionResponse.copy({
dependencies: modulesToUpdate
});
});
})
.then((resolutionResponse) => {
if (!client) {
return;
}
// make sure the file was modified is part of the bundle
if (!client.shallowDependencies[filename]) {
return;
}
const httpServerAddress = httpServer.address();
// Sanitize the value from the HTTP server
let packagerHost = 'localhost';
if (httpServer.address().address &&
httpServer.address().address !== '::' &&
httpServer.address().address !== '') {
packagerHost = httpServerAddress.address;
}
let packagerPort = httpServerAddress.port;
return packagerServer.buildBundleForHMR({
entryFile: client.bundleEntry,
platform: client.platform,
resolutionResponse,
}, packagerHost, packagerPort);
})
.then(bundle => {
if (!client || !bundle || bundle.isEmpty()) {
return;
}
return JSON.stringify({
type: 'update',
body: {
modules: bundle.getModulesNamesAndCode(),
inverseDependencies: inverseDependenciesCache,
sourceURLs: bundle.getSourceURLs(),
sourceMappingURLs: bundle.getSourceMappingURLs(),
},
});
})
.catch(error => {
// send errors to the client instead of killing packager server
let body;
if (error.type === 'TransformError' ||
error.type === 'NotFoundError' ||
error.type === 'UnableToResolveError') {
body = {
type: error.type,
description: error.description,
filename: error.filename,
lineNumber: error.lineNumber,
};
} else {
console.error(error.stack || error);
body = {
type: 'InternalError',
description: 'react-packager has encountered an internal error, ' +
'please check your terminal error output for more details',
};
}
return JSON.stringify({type: 'error', body});
})
.then(update => {
if (!client || !update) {
return;
}
console.log(
'[Hot Module Replacement] Sending HMR update to client (' +
time() + ')'
);
client.ws.send(update);
});
},
() => {
// do nothing, file was removed
},
).finally(() => {
client.ws.send(JSON.stringify({type: 'update-done'}));
});
});
client.ws.on('error', e => {
console.error('[Hot Module Replacement] Unexpected error', e);
disconnect();
});
client.ws.on('close', () => disconnect());
})
.done();
});
}
var ws = require('ws');
var express = require('express');
var pty = require('pty.js');
var app = express();
var server = require('http').createServer(app);
var wsServer = new ws.Server({
server: server,
path: '/ws'
});
var net = require('net');
var controlSock = new net.Socket({
fd: 3, readable: true, writable: true
});
controlSock.on('error', function(){});
app.use(express.static(__dirname + '/public'));
wsServer.on('connection', function(sock) {
var term = null;
sock.on('message', function(message) {
message = JSON.parse(message);
if (message.init) {
term = pty.spawn(
process.env.SHELL ? process.env.SHELL : '/bin/sh', [], {
name: message.type,
rows: message.rows,
cols: message.cols,
cwd: process.env.HOME,
env: process.env
});
rabbit.createChannel().then(channel => {
wss.on("connection", socket => {
const { url } = socket.upgradeReq;
const queryParameters = querystring.parse(url.substr(2));
const { name } = queryParameters;
let consumerTag;
if(DEBUG)
console.log("Client connected: %s", name);
connections[name] = socket;
channel.assertExchange(MESSAGES_EXCHANGE_NAME, "topic", {
durable: true
}).then(() => {
socket.on("message", data => {
try {
const decoded = JSON.parse(data);
const { type } = decoded;
let to;
let forwardedMessage;
switch(type) {
case "MESSAGE_SENT":
const { message: { conversationId, to: messageTo, text } } = decoded;
to = messageTo;
forwardedMessage = {
type: "MESSAGE_SENT",
message: {
conversationId, from: name, text
}
};
break;
case "CONVERSATION_CREATED":
const { conversation: { id, participants: [a, b] } } = decoded;
to = name === a ? b : a;
forwardedMessage = {
type: "CONVERSATION_CREATED",
conversation: {
id, participants: [a, b]
}
};
break;
}
if(DEBUG)
console.log("to queue %s", to, forwardedMessage);
channel.publish(MESSAGES_EXCHANGE_NAME, to, new Buffer(JSON.stringify(forwardedMessage)));
} catch (exception) {
if(DEBUG)
console.error("Garbled message from user %s.", name, exception);
}
});
});
channel.assertQueue(name, {
autoDelete: true
}).then(queue => {
channel.bindQueue(name, MESSAGES_EXCHANGE_NAME, name).then(() => {
channel.consume(name, message => {
try {
const decoded = JSON.parse(message.content.toString());
const { type } = decoded;
let forwardedMessage;
switch(type) {
case "MESSAGE_SENT":
const { message: { conversationId, from, text } } = decoded;
forwardedMessage = {
type: "MESSAGE_SENT",
message: {
conversationId, from, text
}
};
break;
case "CONVERSATION_CREATED":
const { conversation: { id, participants } } = decoded;
forwardedMessage = {
type: "CONVERSATION_CREATED",
conversation: {
id, participants
}
};
break;
}
if(DEBUG)
console.log("to socket", forwardedMessage);
connections[name].send(JSON.stringify(forwardedMessage));
} catch(exception) {
if(DEBUG)
console.error("Garbled message from queue.", exception);
}
channel.ack(message);
}).then(response => {
consumerTag = response.consumerTag;
});
});
socket.on("close", () => {
if(consumerTag)
channel.cancel(consumerTag);
delete connections[name];
});
});
});
});
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
var express = require('express');
var pg = require('pg');
var redis = require('redis');
var websocket = require('ws').Server;
var bodyParser = require('body-parser');
var app = express();
var pgClient = new pg.Client(process.env.DATABASE_URL || 'postgresql://mark@localhost/linkshortener');
var redisClient = redis.createClient();
var wss = new websocket({port: 3001});
var wsClients = {};
// Constants
var url_safe = ['2', 'f', 'D', '4', 'I', 'o', 'a', 'X', 'p', 'g', 'e', '9', 'i', '0', 'x', 'O', 'H', 'W', 's', 'h', 'Q', 'r', 'k', 'y', 'Z', 'c', '6', 'b', 'Y', 'S', 'J', 'M', 'E', 'G', 'l', '-', 'T', 'B', 'V', 'F', 'K', 'v', 'n', 'A', '_', 'U', 't', 'j', 'w', '1', 'd', 'N', 'm', 'u', 'C', 'R', '3', 'L', 'q', '8', 'z', 'P', '5', '7'];
var decode_array = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 35, -1, -1, 13, 49, 0, 56, 3, 62, 26, 63, 59, 11, -1, -1, -1, -1, -1, -1, -1, 43, 37, 54, 2, 32, 39, 33, 16, 4, 30, 40, 57, 31, 51, 15, 61, 20, 55, 29, 36, 45, 38, 17, 7, 28, 24, -1, -1, -1, -1, 44, -1, 6, 27, 25, 50, 10, 1, 9, 19, 12, 47, 22, 34, 52, 42, 5, 8, 58, 21, 18, 46, 53, 41, 48, 14, 23, 60];
pgClient.connect(function(err) {
if (err) {
return console.error('could not connect to database', err);
}
});
function encode_int(i) {
if (i === 0) {
return '';
//run: node test.js
var express = require("express"),
http = require("http"),
logger = require("../logger/logger.js"),
redis = require("redis"),
logger = require("../logger/logger.js"),
client = redis.createClient(),
crypto = require("crypto"),
rooms = require("../chatterapp/rooms.js"),
web = require("../chatterapp/websocket.js"),
WebSocketServer = require('ws').Server,
wss = new WebSocketServer({port: 7777});
var testApp = express();
testApp.set('port', process.env.PORT || 2222);
testApp.use(logger.logErrors);
testApp.set('development', function(){
testApp.use(express.errorHandler());
});
http.createServer(testApp).listen(testApp.get('port'), function(){
var port = testApp.get('port');
logger.logger.log("info", "Chatter server listening on port: " + port);
});
//begin our test suites
var WebSocketServer = require('ws').Server;
var VirtualMatrix = require('../VirtualMatrix.js');
var port = parseInt(process.argv[2]) || 8080;
var freq = parseFloat(process.argv[3]) || 5;
var dim = 8;
var movementDelta = 2;
var pressureDelta = 200;
var colDelay = 1/freq/dim;
var currentCol = 0;
var interval = false;
var matrix = new VirtualMatrix(dim, movementDelta, pressureDelta);
var wss = new WebSocketServer({'port': port});
function doCol () {
if (0 === wss.clients.length) {
clearInterval(interval);
interval = false;
return;
}
if (0 === currentCol) {
matrix.simulate();
}
message = JSON.stringify({c:currentCol,v:matrix.getCol(currentCol)});
wss.clients.forEach(function(client){
client.send(message);
});
currentCol++;
var server = require('http').createServer();
var WebSocketServer = require('ws').Server;
var wss = new WebSocketServer({ server: server });
var express = require('express');
var webpack = require('webpack');
var compression = require('compression');
var app = express();
var MemoryFileSystem = require("memory-fs");
var memoryFs = require('./memoryFs');
var middleware = require('./middleware');
var fs = require('fs');
var path = require('path');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var sessions = require('./sessions.js');
var middlewares = {};
var preLoadPackages = require('./preLoadPackages');
var utils = require('./utils');
var sandbox = require('./sandbox');
var database = require('./database');
var npm = require('./npm');
var bins = require('./bins');
var liveConnection = require('./live');
preLoadPackages([
// Core node
'process',
// Webpack
'webpack',
'node-pre-gyp',
#!/usr/bin/env node
const WebSocket = require('ws');
const redis = require('redis');
var validatePath = require('./validate').validatePath;
const wss = new WebSocket.Server({ port: process.env.WS_PORT || 43471 });
const REDIS_HOST = process.env.REDIS_HOST || '127.0.0.1';
const REDIS_PORT = process.env.REDIS_PORT || 6379;
console.log('Init Redis connection on %s:%s', REDIS_HOST, REDIS_PORT);
var redisClient = redis.createClient(process.env.REDIS_PORT || 6379, process.env.REDIS_HOST || '127.0.0.1');
var redisSubscriber = redisClient.duplicate();
redisClient.on('connect', function() {
console.log('Redis connected');
});
function broadcastPath(pathStr) {
var path = JSON.parse(pathStr);
wss.clients.forEach(function each(client) {
if (client.readyState === WebSocket.OPEN) {
if (client._socket.remoteAddress != path.ip ||
client._socket.remotePort != path.port) { // don't send message to its submitter
client.send('[' + pathStr + ']');
}
}
});
};
localPort: 7400,
remoteAddress: "127.0.0.1",
remotePort: 7500
});
udp.on("ready", function () {
var ipAddresses = getIPAddresses();
console.log("Listening for OSC over UDP.");
ipAddresses.forEach(function (address) {
console.log(" Host:", address + ", Port:", udp.options.localPort);
});
console.log("Broadcasting OSC over UDP to", udp.options.remoteAddress + ", Port:", udp.options.remotePort);
});
udp.open();
var wss = new WebSocket.Server({
port: 8081
});
wss.on("connection", function (socket) {
console.log("A Web Socket connection has been established!");
var socketPort = new osc.WebSocketPort({
socket: socket
});
var relay = new osc.Relay(udp, socketPort, {
raw: true
});
});
var WebSocketServer = require('ws').Server;
var wss = new WebSocketServer({port: 8270});
wss.on('connection', function(ws) {
console.log('connected!');
ws.on('message', function(message) {
console.log('received: %s', message);
});
ws.send('something');
});
const express = require('express');
const SocketServer = require('ws').Server;
const uuid = require('node-uuid');
const PORT = 4000;
const server = express()
.use(express.static('public'))
.listen(PORT, () => console.log(`Listening on ${ PORT }`));
const wss = new SocketServer({ server });
function broadcast(data) {
const stringifiedData = JSON.stringify(data);
wss.clients.forEach(function each(client) {
client.send(stringifiedData);
});
}
wss.on('connection', (socket) => {
console.log('A new client connected');
broadcast({type: "clientsOnline",
content: wss.clients.length});
socket.on('message', (incoming_msg) => {
const message = JSON.parse(incoming_msg);
switch (message.type) {
case 'chatMessage':
message.id= uuid.v4();
message.type= "outgoingMessage";
// HTTP server
http.createServer(app).listen(app.get('port'), function () {
console.log('HTTP server listening on port ' + app.get('port'));
});
/// Video streaming section
// Reference: https://github.com/phoboslab/jsmpeg/blob/master/stream-server.js
var STREAM_MAGIC_BYTES = 'jsmp'; // Must be 4 bytes
var width = 640;
var height = 480;
// WebSocket servers
var wsServerNormal = new (ws.Server)({ port: configServer.wsPortNormal });
var wsServerThermal = new (ws.Server)({ port: configServer.wsPortThermal });
console.log('WebSocket server listening on port ' + configServer.wsPortNormal + ' and ' + configServer.wsPortThermal);
wsServerNormal.on('connection', function(socket) {
// Send magic bytes and video size to the newly connected socket
// struct { char magic[4]; unsigned short width, height;}
var streamHeader = new Buffer(8);
streamHeader.write(STREAM_MAGIC_BYTES);
streamHeader.writeUInt16BE(width, 4);
streamHeader.writeUInt16BE(height, 6);
socket.send(streamHeader, { binary: true });
console.log('New WebSocket Connection (' + wsServerNormal.clients.length + ' total)');
var webServerPort = 8080;
var leapServerPort = 8081;
var playback = false;
console.log("Starting web server...");
var connect = require('connect');
connect.createServer(
connect.static(__dirname)
).listen(webServerPort);
console.log("Starting Leap Motion server...");
var WebSocketServer = require('ws').Server, wss = new WebSocketServer({port: leapServerPort});
wss.on('connection', function(ws) {
ws.on('message', function(message) {
if (message === "STOPJSON") {
playback = false;
} else {
fs = require('fs');
fs.readFile('leap_output/' + message, 'utf8', function(err, data) {
if (err) {
return console.log(err);
}
var dataPoints = data.split("|");
playback = true;
simulation = new DataSimulation(ws, dataPoints);
simulation.sendData();
});
}
});
var http = require("http");
var express = require("express");
var VehicleSubscriber = require('./src/Vehicle-Subscriber');
var AlertPublisher = require('./src/Alert-Publisher');
var app = express();
var port = process.env.PORT || 5000;
app.use('/static', express.static(__dirname + "/static"));
var server = http.createServer(app);
server.listen(port);
console.log("http server listening on %d", port);
var wss = new WebSocketServer({ server: server })
console.log("websocket server created");
var subscriberCache = {};
var subscriberId = 0;
var publisherCache = {};
var publisherId = 0;
app.get('/foobar', function(req, res){
console.log('>>>>> GET REQUEST');
res.json({
'msg': 'Whoop, there it is.'
});
});
var Datas = require('dataviz-tangible');
var WebSocket = require('ws');
var express = require('express'),
app = express();
app.use(express.static(__dirname + '/public'));
app.listen(8080);
var WebSocketServer = require('ws').Server
, wss = new WebSocketServer({port: 8000});
wss.on('connection', function(ws) {
ws.on('message', function(message) {
obj = JSON.parse(message);
console.log('received: %s', obj.value);
ws.send(message);
serialPort.write(obj.value +"\n");//Normalised to 0-255
});
ws.send('something');
});
var datas = new Datas({
forecast: 'myAPIKey',//Replace with user API key from https://developer.forecast.io/
});
// définir comment gérer la réponse du service météo
datas.on('weather', function(data) {
var unix_time=Date.now()/1000.0;
var interp = (unix_time -data.hourly.data[0].time)/( data.hourly.data[1].time - data.hourly.data[0].time)*(data.hourly.data[1].precipIntensity-data.hourly.data[0].precipIntensity) + data.hourly.data[0].precipIntensity
console.log("Send" + interp + "in./hr");
serialPort.write(interp/0.4*255 +"\n");//Normalised to 0-255
});
res.writeHead(404, {"Content-Type": "text/html"});
res.end("Not Found");
}
});
server.listen(8080);
server.on("listening", function() {
console.log("Server started");
open("http://localhost:8080/");
});
server.on("error", function(err) {
console.log("Failed to start server:", err);
process.exit(1);
});
// WebSocket adapter
var wss = new ws.Server({server: server});
wss.on("connection", function(socket) {
console.log("New WebSocket connection");
socket.on("close", function() {
console.log("WebSocket disconnected");
});
socket.on("message", function(data, flags) {
if (flags.binary) {
try {
// Decode the Response
var msg = Response.decode(data);
console.log("Received: "+msg);
} catch (err) {
console.log("Processing failed:", err);
}
} else {
var WebSocketServer = require('ws').Server,
wss = new WebSocketServer({port : 8181});
console.log("Starting server on port 8181 ...");
console.log("Awaiting connections ...");
var greetings = ["Hello", "Hi", "Greetings", "Aloha", "Wassup"];
var subjects = ["World", "You", "Everybody", "Everyone", "Y'all", "You Guys"];
var generateGreeting = function(){
var randomChoice = function(list){
return list[Math.floor(Math.random()*list.length)];
};
return randomChoice(greetings) + " " + randomChoice(subjects) + "!";
};
var randomMSDelay = function(min, max){
return Math.floor(Math.random()*(max - min + 1) + min);
};
wss.on('connection', function(ws){
console.log('Connection established with client');
var greetingUpdater;
var counter = 0;
var randomGreetingGenerator = function(){
var greeting = generateGreeting();
var delay = randomMSDelay(1000,3000);
greetingUpdater = setTimeout(function(){
randomGreetingGenerator();
}, delay);