var connect = require('connect');
var serveStatic = require('serve-static');
var port = 9001;
console.log('Setting up server on http://localhost:' + port + '/');
connect().use(serveStatic(__dirname)).listen(port);
var MessageServer = function(container) {
var serverPort = 0;
this.container = container;
this.app = connect();
this.app.use(bodyParser.urlencoded({ extended: true }));
this.app.use(bodyParser.json({ limit : 10240000 }));
this.server = null;
var self = this;
var log = this.container.log;
this.start = function(port) {
serverPort = port;
self.server = http.createServer(self.app);
log.info('server.listen : ' + port);
self.server.listen(port);
};
this.stop = function(callback) {
if(self.server) {
log.info('server.stop : ' + serverPort);
self.server.close(function() {
log.info('server.stoped : ' + serverPort);
callback();
});
} else {
callback(null);
}
};
this.on = function(name, callback) {
function parseResponse(req, res, next) {
req.data = {};
if(req.body)
req.data = req.body;
if(req.params)
req.data = req.params;
res.send = function(jsonDataOrCode, jsonData) {
if(jsonData === undefined)
res.end(JSON.stringify(jsonDataOrCode));
else {
res.writeHead(jsonDataOrCode, { 'Content-Type': 'application/json' });
res.end(JSON.stringify(jsonData));
}
};
res.error = function(errOrCode, err) {
if(err === undefined) {
var code = 500;
if(errOrCode && errOrCode.responseCode)
code = errOrCode.responseCode;
res.writeHead(code, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({code : code, message : errOrCode.message}));
} else {
res.writeHead(errOrCode, { 'Content-Type': 'application/json' });
res.end(JSON.stringify({code : errOrCode, message : err.message}));
}
};
res.writeHead(200, { 'Content-Type': 'application/json' });
try {
callback(req, res);
} catch(e) {
self.container.log.error('uncaughtException', e.stack);
res.error(500, e);
}
next();
}
self.app.use('/' + name, parseResponse);
};
};
var connect = require("connect");
var http = require("http");
var app = connect();
function profile(request, response) {
console.log("User requested profile")
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
app.use("/profile", profile);
http.createServer(app); //listen(???)
console.log("Server is running...");
var connect = require('connect');
var serveStatic = require('serve-static');
var port = process.env.PORT || 8080
var publicDir = __dirname + '/../../public'
connect().use("/", serveStatic(publicDir)).listen(port, function(){
console.log('Server running on %s...', port);
});
/*jshint asi:true, nodejs:true, laxbreak:true*/
var connect = require('connect')
module.exports = connect(
connect.logger(':remote-addr :method :url - :referrer')
,
// connect.router(function(app){
// app.get('/user/:id', function(req, res, next){
// // populates req.params.id
// });
// app.put('/user/:id', function(req, res, next){
// // populates req.params.id
// });
// })
// ,
connect.static(__dirname + '/public')
,
connect.directory(__dirname + '/public')
)
gulp.task('server', function(next) {
var connect = require('connect'),
server = connect();
server.use(connect.static(dest)).listen(process.env.PORT || 8080, next);
});
module.exports = (function () {
'use strict';
var connect = require('connect')
, valid = require('./valid')
, extract = require('./extract');
var app = connect()
.use(connect.logger('dev'))
.use('/snapshot/campaign', connect.static('./snapshot/campaign'))
.use('/snapshot/campaign', require('./unkonw')())
.use('/snapshot/template', connect.static('./snapshot/template'))
.use(connect.query())
.use(connect.bodyParser())
.use('/campaign/snapshot', require('./snapshot'))
.use('/urls', function (req, res, next) {
if (req.method !== 'POST') return next();
var listId = req.body.listId
, campaignId = req.body.campaignId
, urls = req.body.urls;
if (listId && campaignId && urls) {
valid(listId, campaignId, urls, function (results) {
var data = {
code: 0,
urls: results
};
res.writeHead(200, {
'Content-Type': 'application/json; charset=UTF-8',
'Access-Control-Allow-Origin': '*'
});
res.statusCode = 200;
return res.end(JSON.stringify(data));
});
} else {
next();
}
})
.use('/getExtract', function (req, res, next) {
if (req.query.url) {
var url = req.query.url;
extract.getExtract(url, function (err, data) {
if (err) {
data = {
code: 1
};
}
res.writeHead(200, {
'Content-Type': 'application/json; charset=UTF-8',
'Access-Control-Allow-Origin': '*'
});
res.statusCode = 200;
return res.end(JSON.stringify(data));
});
} else {
next();
}
})
.use('/extract', function (req, res, next) {
if (req.query.url) {
extract.one(req.query.url, function (data) {
res.writeHead(200, {
'Content-Type': 'application/json; charset=UTF-8',
'Access-Control-Allow-Origin': '*'
});
res.statusCode = 200;
return res.end(JSON.stringify(data));
});
} else {
next();
}
})
.use('/check', function (req, res, next) {
if (req.query.url) {
valid.uv(req.query.url, function (err, v) {
if (err) console.log(err);
res.writeHead(200, {
'Content-Type': 'application/json; charset=UTF-8',
'Access-Control-Allow-Origin': '*'
});
res.statusCode = 200;
console.log('v === ' + v);
return res.end(JSON.stringify({
status: v ? 1 : 0
}));
})
} else {
next();
}
})
.use('/saveUrl', require('./saveUrl'))
.listen(80);
})();
}, function (reg) {
_self.registry = reg;
_self.log = core.getLogger(_self.serviceName, _self.registry.serviceConfig.logger);
if (fetchedHostIp) {
if (!fetchedHostIp.result) {
_self.log.warn("Unable to find the service host ip. The service will NOT be registered for awareness.");
_self.log.info("IPs found: ", fetchedHostIp.ips);
if (serviceIpNotDetected) {
_self.log.warn("The default service IP has been used [" + _self.serviceIp + "]");
}
}
else {
_self.log.info("The IP registered for service [" + _self.serviceName + "] awareness : ", fetchedHostIp.ip);
}
}
var app = connect();
app.use(favicon_mw());
app.use(soajs_mw({
"serviceName": _self.serviceName,
"log": _self.log
}));
app.use(cors_mw());
app.use(response_mw({"controllerResponse": true}));
app.use(awareness_mw({
"awareness": _self.awareness,
"serviceName": _self.serviceName,
"log": _self.log,
"serviceIp": _self.serviceIp
}));
app.use(controller_mw());
app.use(function (req, res, next) {
setImmediate(function () {
req.soajs.controller.gotoservice(req, res, null);
});
req.on("error", function (error) {
req.soajs.log.error("Error @ controller:", error);
if (req.soajs.controller.redirectedRequest) {
req.soajs.controller.redirectedRequest.abort();
}
});
req.on("close", function () {
if (req.soajs.controller.redirectedRequest) {
req.soajs.log.info("Request aborted:", req.url);
req.soajs.controller.redirectedRequest.abort();
}
});
});
_self.server = http.createServer(app);
_self.serverMaintenance = http.createServer(function (req, res) {
if (req.url === '/favicon.ico') {
res.writeHead(200, {'Content-Type': 'image/x-icon'});
return res.end();
}
var parsedUrl = url.parse(req.url, true);
var response;
var maintenanceResponse = function (req, route) {
var response = {
'result': false,
'ts': Date.now(),
'service': {
'service': _self.serviceName.toUpperCase(),
'type': 'rest',
'route': route || parsedUrl.pathname
}
};
return response;
};
if (parsedUrl.pathname === '/reloadRegistry') {
core.registry.reload({
"serviceName": _self.serviceName,
"serviceVersion": null,
"apiList": null,
"awareness": _self.awareness,
"serviceIp": _self.serviceIp
}, function (err, reg) {
res.writeHead(200, {'Content-Type': 'application/json'});
response = maintenanceResponse(req);
if (err) {
_self.log.warn("Failed to load registry. reusing from previous load. Reason: " + err.message);
} else {
response['result'] = true;
response['data'] = reg;
}
return res.end(JSON.stringify(response));
});
}
else if (parsedUrl.pathname === '/awarenessStat') {
res.writeHead(200, {'Content-Type': 'application/json'});
var tmp = core.registry.get();
response = maintenanceResponse(req);
if (tmp && (tmp.services || tmp.daemons)) {
response['result'] = true;
response['data'] = {"services" : tmp.services, "daemons" : tmp.daemons};
}
return res.end(JSON.stringify(response));
}
else if (parsedUrl.pathname === '/register') {
/**
* if service
* name
* group
* port
* ip
* extKeyRequired
* if host
* name
* ip
*/
res.writeHead(200, {'Content-Type': 'application/json'});
response = maintenanceResponse(req);
var regOptions = {
"name": parsedUrl.query.name,
"group": parsedUrl.query.group,
"port": parseInt(parsedUrl.query.port),
"ip": parsedUrl.query.ip,
"type": parsedUrl.query.type,
"version": parseInt(parsedUrl.query.version)
};
if (regOptions.type === "service") {
regOptions["extKeyRequired"] = (parsedUrl.query.extKeyRequired === "true" ? true : false);
regOptions["requestTimeout"] = parseInt(parsedUrl.query.requestTimeout);
regOptions["requestTimeoutRenewal"] = parseInt(parsedUrl.query.requestTimeoutRenewal);
}
core.registry.register(
regOptions,
function (err, data) {
if (!err) {
response['result'] = true;
response['data'] = data;
}
else {
_self.log.warn("Failed to register service for [" + parsedUrl.query.name + "] " + err.message);
}
return res.end(JSON.stringify(response));
});
}
else {
var heartbeat = function (res) {
res.writeHead(200, {'Content-Type': 'application/json'});
response = maintenanceResponse(req);
response['result'] = true;
res.end(JSON.stringify(response));
};
if (req.url === '/heartbeat') {
return heartbeat(res);
}
return heartbeat(res);
}
});
callback();
});
nmcln.once('ready', function(){
if (Debug) console.log('name-client ready on vURL:'+nmcln.vurl);
// 3.
// setup noVNC proxy
for (var idx = 0; idx < vncs.length; idx ++) {
var vncstrs = vncs[idx].split(':');
var vnchost = vncstrs[0];
var vncport = vncstrs[1] || 5900; // default VNC port
// assume vncserver listen on 5900 above
vncport = (vncport < 5900) ? 5900 + vncport : vncport;
// create ws server to proxy VNC/RFB data
var wspath = '/'+vnchost+'-'+vncport;
var vncwss = new WebSocketServer({httpp: true, server: nmcln.bsrv.srv, path: wspath});
vncwss.on('connection', noVNC.tcpProxy({host: vnchost, port: vncport}));
self.proxyURL[vncs[idx]] = nmcln.vurl + wspath;
// 3.1
// report peer-service
// like {vurl:x,cate:x,name:x,desc:x,tags:x,acls:x,accounting:x,meta:x}
nmcln.reportService({
vurl: self.proxyURL[vncs[idx]],
cate: 'peer-vnc',
name: 'vnc'+idx,
meta: {
vnchost: vnchost === 'localhost' ? OS.hostname() : vnchost,
vncport: vncport
}
});
// 3.2
// update peer-service: connection loss, etc
// TBD...
}
// 4.
// create http App
var appHttp = Connect();
// 4.1
// add third-party connect middle-ware
// TBD...
// 4.2
// add noVNC web service in App
appHttp.use(noVNC.webServer);
// 5.
// hook http App on name-client
nmcln.bsrv.srv.on('request', appHttp);
// 5.1
// handle http CONNECT request in case come from forward proxy
// notes: the idea is see https request/websocket proxy as reverse proxy to destination http website,
// so, create connection to peer-vnc httpps server self.
nmcln.bsrv.srv.on('connect', function(req, socket, head){
var roptions = {
port: nmcln.port,
host: nmcln.ipaddr,
localAddress: {
addr: nmcln.ipaddr
}
};
if (Debug) console.log('http tunnel proxy, connect to self %s:%d', nmcln.ipaddr, nmcln.port);
var srvSocket = UDT.connect(roptions, function() {
if (Debug) console.log('http tunnel proxy, got connected!');
///srvSocket.write(head);
socket.pipe(srvSocket);
socket.write('HTTP/1.1 200 Connection Established\r\n' +
'Proxy-agent: Node-Proxy\r\n' +
'\r\n');
srvSocket.pipe(socket);
});
srvSocket.on('error', function(e) {
console.log("http tunnel proxy, socket error: " + e);
socket.end();
});
});
// 6.
// pass proxy URLs back
fn(null, self.proxyURL);
});
(function () {
"use strict";
require('http-json')(require('http'));
var connect = require('connect')
, fs = require('fs')
, path = require('path')
, cookielessSession = require('connect-cookieless-session')
, pathname = require('connect-pathname')
, gcf = require('express-chromeframe')
, nowww = require('nowww')
, xcors = require('connect-xcors')
, cors = xcors()
, session = cookielessSession()
, app = connect()
, version = JSON.parse(
fs.readFileSync(
path.join(__dirname, '..', 'package.json')
, 'utf8'
)
).version
, semver
;
function parseSemver(version) {
// semver, major, minor, patch
// https://github.com/mojombo/semver/issues/32
// https://github.com/isaacs/node-semver/issues/10
// optional v
var m = /^\s*(v)?([0-9]+)(\.([0-9]+))(\.([0-9]+))(([\-+])([a-zA-Z0-9\.]+))?\s*$/.exec(version) || []
, ver = {
semver: m[0] || version
, major: m[2]
, minor: m[4]
, patch: m[6]
, revision: m[7]
}
;
if (!/^v/.test(ver.semver)) {
ver.semver = 'v' + ver.semver;
}
if ('+' === m[8]) {
ver.build = m[9];
}
if ('-' === m[8]) {
ver.release = m[9];
}
return ver;
}
function getVersion(req, res, next) {
res.json(semver);
}
semver = parseSemver(version);
connect.router = require('connect_router');
connect.corsPolicy = cors.config;
cors.config.headers = cors.config.headers.concat(session.headers.slice());
app
.use(nowww())
.use(gcf())
.use(pathname())
.use(connect.query())
.use(connect.json())
.use(connect.urlencoded())
.use(cors)
.use(session)
.use(connect.static(__dirname + '/../public'))
.use(connect.static(__dirname + '/../var/public'))
.use('/version', getVersion)
.use(connect.favicon())
;
module.exports = app;
}());
var connect = require('connect');
connect(
connect['static'](__dirname+'/', { maxAge: 0 })
).listen(8080);
console.log('Server running...');
gulp.task('serve', () => {
connect().use(serveStatic('build')).listen(10000);
});
module.exports = function(options) {
var defaults = {
/**
*
* BASIC DEFAULTS
*
**/
host: 'localhost',
port: 8000,
fallback: false,
https: false,
open: false,
/**
*
* MIDDLEWARE DEFAULTS
*
* NOTE:
* All middleware should defaults should have the 'enable'
* property if you want to support shorthand syntax like:
*
* webserver({
* livereload: true
* });
*
*/
// Middleware: Livereload
livereload: {
enable: false,
port: 35729,
filter: function (filename) {
if (filename.match(/node_modules/)) {
return false;
} else { return true; }
}
},
// Middleware: Directory listing
// For possible options, see:
// https://github.com/expressjs/serve-index
directoryListing: {
enable: false,
path: './',
options: undefined
},
// Middleware: Proxy
// For possible options, see:
// https://github.com/andrewrk/connect-proxy
proxies: []
};
// Deep extend user provided options over the all of the defaults
// Allow shorthand syntax, using the enable property as a flag
var config = enableMiddlewareShorthand(defaults, options, [
'directoryListing',
'livereload'
]);
if (typeof config.open === 'string' && config.open.length > 0) {
// ensure leading slash
config.open = (config.open.indexOf('/') !== 0 ? '/' : '') + config.open;
}
var app = connect();
var openInBrowser = function() {
if (config.open === false) return;
open('http' + (config.https ? 's' : '') + '://' + config.host + ':' + config.port + (typeof config.open === 'string' ? config.open : ''));
};
var lrServer;
if (config.livereload.enable) {
app.use(connectLivereload({
port: config.livereload.port
}));
if (config.https) {
if (config.https.pfx) {
lrServer = tinyLr({
pfx: fs.readFileSync(config.https.pfx),
passphrase: config.https.passphrase
});
}
else {
lrServer = tinyLr({
key: fs.readFileSync(config.https.key || __dirname + '/../ssl/dev-key.pem'),
cert: fs.readFileSync(config.https.cert || __dirname + '/../ssl/dev-cert.pem')
});
}
} else {
lrServer = tinyLr();
}
lrServer.listen(config.livereload.port, config.host);
}
if (config.directoryListing.enable) {
app.use(serveIndex(path.resolve(config.directoryListing.path), config.directoryListing.options));
}
// Proxy requests
for (var i = 0, len = config.proxies.length; i < len; i++) {
var proxyoptions = url.parse(config.proxies[i].target);
if (config.proxies[i].hasOwnProperty('options')) {
extend(proxyoptions, config.proxies[i].options);
}
app.use(config.proxies[i].source, proxy(proxyoptions));
}
var files = [];
// Create server
var stream = through.obj(function(file, enc, callback) {
app.use(serveStatic(file.path));
if (config.livereload.enable) {
var watchOptions = {
ignoreDotFiles: true,
filter: config.livereload.filter
};
watch.watchTree(file.path, watchOptions, function (filename) {
lrServer.changed({
body: {
files: filename
}
});
});
}
this.push(file);
callback();
})
.on('data', function(f){files.push(f);})
.on('end', function(){
if (config.fallback) {
files.forEach(function(file){
var fallbackFile = file.path + '/' + config.fallback;
if (fs.existsSync(fallbackFile)) {
app.use(function(req, res) {
res.setHeader('Content-Type', 'text/html; charset=UTF-8');
fs.createReadStream(fallbackFile).pipe(res);
});
}
});
}
});
var webserver;
if (config.https) {
var opts;
if (config.https.pfx) {
opts = {
pfx: fs.readFileSync(config.https.pfx),
passphrase: config.https.passphrase
};
} else {
opts = {
key: fs.readFileSync(config.https.key || __dirname + '/../ssl/dev-key.pem'),
cert: fs.readFileSync(config.https.cert || __dirname + '/../ssl/dev-cert.pem')
};
}
webserver = https.createServer(opts, app).listen(config.port, config.host, openInBrowser);
} else {
webserver = http.createServer(app).listen(config.port, config.host, openInBrowser);
}
gutil.log('Webserver started at', gutil.colors.cyan('http' + (config.https ? 's' : '') + '://' + config.host + ':' + config.port));
stream.on('kill', function() {
webserver.close();
if (config.livereload.enable) {
lrServer.close();
}
});
return stream;
};
gulp.task('serve', function(){
var app = connect();
app.use(morgan('dev'));
app.use(serveStatic(config.root));
http.createServer(app).listen(config.port);
});
currentVersion = "1.2.2";
// Path where attachments are stored
contentPath = "/shared";
// Rules to grant special badges and achievements
badges;
// Mount the static directory to be cached
var mount = st({path: __dirname + '/public/', index: true, index: 'index.html'});
/*****************************
* APPLICATION SERVER
******************************/
var handlers = new Store(),
transport = new Transport(handlers),
app = http.createServer(connect()
.use(connect.logger())
.use(connect.compress())
.use(connect.responseTime())
.use(connect.bodyParser({ uploadDir:contentPath+'/public/upload', keepExtensions: true }))
.use('/upload', srvUtils.uploadFunc)
.use('/downloads', srvUtils.downloadFunc)
.use(function(req, res, next) {
var ori = req.headers.origin || "http://app.ideafy.com";
res.setHeader("Access-Control-Allow-Origin", ori);
res.setHeader("Access-Control-Allow-Headers", "X-Requested-With");
res.setHeader("Access-Control-Allow-Methods", 'GET,PUT,POST,DELETE,OPTIONS');
res.setHeader("Ideady Server", "node.js/" + process.versions.node);
res.setHeader("X-Powered-By", "OlivesJS + Connect + Socket.io");
if ('OPTIONS' == req.method) {
res.send(200);
module.exports = function( options ) {
var seneca = this
var plugin = 'admin'
var defaultoptions = {
web:true,
prefix:'/admin',
user:{nick:'admin'},
units:['admin-summary','admin-plugins','admin-logging','admin-action'],
unitspecs:{
'admin-summary': {title:'Status Summary', ng:{module:'senecaAdminSummaryModule', directive:'seneca-admin-summary'}},
'admin-plugins': {title:'Action Patterns', ng:{module:'senecaAdminPluginsModule', directive:'seneca-admin-plugins'}},
'admin-logging': {title:'Streaming Log', ng:{module:'senecaAdminLoggingModule', directive:'seneca-admin-logging'}},
'admin-action': {title:'Action Executor', ng:{module:'senecaAdminActionModule', directive:'seneca-admin-action'}},
},
unitcontent:{
'admin-summary': [{type:'js',file:__dirname+'/web/admin-summary.js'}],
'admin-plugins': [{type:'js',file:__dirname+'/web/admin-plugins.js'}],
'admin-logging': [{type:'js',file:__dirname+'/web/admin-logging.js'}],
'admin-action': [{type:'js',file:__dirname+'/web/admin-action.js'}],
},
mimetype:{
js:'text/javascript',
css:'text/css'
},
local:false
}
// TODO: is this needed?
seneca.depends(plugin,[
'data-editor'
])
// TODO: hack! deepextend needs to be fixed
var http_server = options.server
delete options.server
options = seneca.util.deepextend(defaultoptions,options)
options.server = http_server
if( !options.local ) {
seneca.depends(plugin,[
'user'
])
}
var content = {}
seneca.add({role:plugin,cmd:'stats'},cmd_stats)
seneca.add({role:plugin,cmd:'webstats'},cmd_webstats)
function cmd_stats(args,done) {
seneca.act('role:seneca,stats:true',{summary:args.summary},done)
}
function cmd_webstats(args,done) {
seneca.act('role:web,stats:true',done)
}
seneca.add({init:plugin}, function( args, done ){
var seneca = this
if( seneca.hasplugin('user') ) setup_users();
else return loadcontent();
function setup_users() {
var userent = seneca.make$( 'sys/user' )
var useract = seneca.pin( { role:'user', cmd:'*' } )
var users = _.isArray(options.user) ? options.user : [options.user]
async.mapSeries(users, function(userdata,next) {
userdata.admin = true
userent.load$({nick:userdata.nick}, function(err,user){
if( err ) return done(err);
if( user ) {
if( user.admin ) return next();
user.admin = true
return user.save$(next)
}
userdata.password = _.isString(options.user.password) ? options.user.password : makepass()
useract.register( userdata, function(err,out){
if( err ) return done(err);
seneca.log.info('admin','user',out.user.nick,userdata.password)
return next();
})
})
}, function(err){
if( err ) return done(err);
return loadcontent();
})
}
function loadcontent() {
seneca.act({role:'util',note:true,cmd:'list',key:'admin/units',default$:{}}, function(err,out){
if(err) return done(err);
if( out ) {
_.each( out, function(unitdef) {
if( unitdef.unit && unitdef.spec && unitdef.content ) {
options.units.push(unitdef.unit)
options.unitspecs[unitdef.unit] = unitdef.spec
options.unitcontent[unitdef.unit] = unitdef.content
}
})
seneca.act({
role:'web',
plugin:plugin,
config:{
prefix:options.prefix,
units:options.units,
unitspecs:options.unitspecs
}})
}
async.mapSeries(options.units,function(name,next){
var items = options.unitcontent[name]
async.mapSeries(items||[],function(item,next){
var text = content[item.type] || ''
fs.readFile(item.file,function(err,data){
if(err) return next(err);
text += '\n;\n' + data
content[item.type] = text
return next()
})
}, next)
}, done)
})
}
})
// FIX: serious hack here to disable old loghandlers
var activelogs = {}
var loghandlers = {}
function loghandler(client) {
var code = activelogs['admin-log-'+client.id] = nid()
var logh = function(){
if( code == activelogs['admin-log-'+client.id] ) {
var msg = JSON.stringify(Array.prototype.slice.call(arguments))
client.write(msg)
}
}
logh.code = 'admin-log-'+client.id+'-'+code
return logh
}
if( options.web ) {
if( options.server ) {
var clients = {}
var socket = sockjs.createServer();
socket.on('connection', function(client) {
clients[client.id] = client
client.on('close', function(){
delete clients[client.id]
})
client.on('data', function(data){
var msg = JSON.parse(data)
function hello() {
client.token = msg.token
client.write(JSON.stringify({hello:true}))
}
if( msg.hello ) {
if( !options.local ) {
seneca.make$('sys/login').load$(msg.token,function(err,out){
if( out ) return hello()
client.write(JSON.stringify({goodbye:true}))
})
}
else return hello();
}
else if(msg.update && (options.local || client.token==msg.token) ) {
if( msg.oldroute ) {
seneca.logroute(msg.oldroute)
}
if( msg.newroute ) {
var logh = loghandler(client)
seneca.logroute(msg.newroute,logh)
}
}
else {
client.write(JSON.stringify({ok:true}))
}
})
})
socket.installHandlers(
options.server,
{
prefix:options.prefix+'/socket',
log:function(severity,line){
seneca.log.debug(severity,line)
}
}
)
}
var app = connect()
app.use(serve_static(__dirname+'/web'))
seneca.act({
role:'web',
plugin:plugin,
config:{
prefix:options.prefix,
units:options.units,
unitspecs:options.unitspecs
},
use:{
startware:function(req,res,next){
if( 0 != req.url.indexOf(options.prefix) ) return next();
if( options.prefix === req.url && '/' !== req.url[req.url.length-1] ) {
res.writeHead(301,{Location:req.url+'/'})
return res.end();
}
var isadminuser = req.seneca && req.seneca.user && req.seneca.user.admin
if( !isadminuser ) {
isadminuser = options.local && (
'127.0.0.1' === req.connection.remoteAddress ||
'::1' === req.connection.remoteAddress )
if( !isadminuser ) {
res.writeHead(401)
return res.end();
}
}
if( 0 == req.url.indexOf(options.prefix+'/act') ) {
req.seneca.act( req.body, function( err, out ){
if( err ) return next(err);
var outjson = _.isUndefined(out) ? '{}' : JSON.stringify(out)
res.writeHead(200,{
'Content-Type': 'application/json',
'Cache-Control': 'private, max-age=0, no-cache, no-store',
'Content-Length': buffer.Buffer.byteLength(outjson)
})
res.end( outjson )
})
}
else if( 0 == req.url.indexOf(options.prefix+'/content/') ) {
var type = req.url.substring( (options.prefix+'/content/').length )
var text = content[type] || ''
res.writeHead(200,{
'Content-Type': (options.mimetype[type]||'text/plain'),
'Cache-Control': 'private, max-age=0, no-cache, no-store',
'Content-Length': buffer.Buffer.byteLength(text)
})
res.end( text )
}
else return next();
},
pin:{role:plugin,cmd:'*'},
prefix:'/admin',
map:{
stats:true,
webstats:true
},
endware:function(req,res,next){
if( 0 != req.url.indexOf(options.prefix) ) return next();
if( 0 == req.url.indexOf(options.prefix+'/socket') ) return next();
req.url = req.url.replace(/^\/admin/,"")
return app( req, res );
}
}
})
}
return plugin;
}
}, {
browserName: 'chrome',
'tunnel-identifier': process.env.TRAVIS_JOB_NUMBER
}];
else if(!process.env.TRAVIS_JOB_NUMBER) // local tests
seleniumCaps = [{
browserName: 'internet explorer'
}, {
browserName: 'firefox'
}, {
browserName: 'chrome'
}];
// Server for selenium
const connect = require('connect');
const server = connect();
server.use(require('serve-static')(process.cwd()));
server.listen(9435);
let nodeTests = []
let webTests = []
// Find tests
glob('lib/**/*.spec.js')
.then((tests) => {
nodeTests = tests.filter(test => !test.endsWith('.web.spec.js'))
webTests = tests.filter(test => !test.endsWith('.node.spec.js'))
return createWebTestScript()
})
.then(() => {
// Run web tests in each browser
if(webTests.length > 0){
var connect = require('connect');
var http = require('http');
var injector = require('connect-injector');
var rewrite = injector(function(req, res) {
return true;
}, function(data, req, res, callback) {
callback(null, 'rewrite');
}
);
var app = connect().use(rewrite).use(function(req, res) {
res.end('test');
});
var port = 9001;
var server = http.createServer(app).listen(port, function() {
console.log('Listening on port ' + port);
});
var connect = require('connect');
var server = connect()
.use(connect.static(__dirname))
.use(connect.directory(__dirname))
.listen(8080);
var connect = require('connect');
var serveStatic = require('serve-static');
connect().use(serveStatic(__dirname)).listen(1337);
console.log('服务器已开启, http://localhost:1337');
// Room statistics
RocketChat.metrics.totalRooms.set(statistics.totalRooms, date);
RocketChat.metrics.totalChannels.set(statistics.totalChannels, date);
RocketChat.metrics.totalPrivateGroups.set(statistics.totalPrivateGroups, date);
RocketChat.metrics.totalDirect.set(statistics.totalDirect, date);
RocketChat.metrics.totalLivechat.set(statistics.totalLivechat, date);
// Message statistics
RocketChat.metrics.totalMessages.set(statistics.totalMessages, date);
RocketChat.metrics.totalChannelMessages.set(statistics.totalChannelMessages, date);
RocketChat.metrics.totalPrivateGroupMessages.set(statistics.totalPrivateGroupMessages, date);
RocketChat.metrics.totalDirectMessages.set(statistics.totalDirectMessages, date);
RocketChat.metrics.totalLivechatMessages.set(statistics.totalLivechatMessages, date);
};
const app = connect();
// const compression = require('compression');
// app.use(compression());
app.use('/metrics', (req, res) => {
res.setHeader('Content-Type', 'text/plain');
res.end(RocketChat.promclient.register.metrics());
});
const server = http.createServer(app);
let timer;
const updatePrometheusConfig = () => {
const port = RocketChat.settings.get('Prometheus_Port');
const enabled = RocketChat.settings.get('Prometheus_Enabled');
var io = require('socket.io'),
connect = require('connect');
var messagelog = [];
var storeMessages = function (name, data) {
messagelog.push({name: name, data: data});
if (messagelog.length > 20) messagelog.shift();
}
var app = connect().use(connect.static('public')).listen(8888);
var chat_room = io.listen(app);
var connectCounter = 0;
chat_room.sockets.on('connection', function(socket) {
connectCounter++;
console.log(connectCounter);
chat_room.sockets.emit('changeCount', {message: connectCounter});
messagelog.forEach(function(message) {
socket.emit('chat', {message: message.name + ": " + message.data});
});
messagelog.forEach(function(message) {
socket.emit('names', {message: message.name});
});
socket.emit('entrance', {message: "welcome to the chat"});
var dirWebRoot = 'public';
var port = Number(process.env.PORT || 5000);
var connect = require('connect');
connect().use(connect.static(dirWebRoot)).listen(port);
console.log('Static web server runnin on port: ' + port);
/**
* Created by luke.grymek on 8/12/2016.
*/
var echo = {
handle: function (req, res, next) {
req.pipe(res);
}
};
var connect = require('connect');
connect()
.use(echo)
.listen(3000);
var connect = require('connect'),
serveStatic = require('serve-static');
connect().use(serveStatic(__dirname)).listen(8080,
function(){console.log('Server running on 8080...');
});
// Dependency modules
var D2DServer = require('D2D');
var connect = require('connect');
var http = require('http');
var serveStatic = require('serve-static');
// Create static server
var app = connect().use(serveStatic(__dirname + '/public'));
var server = http.createServer(app);
// Start XD-MVC server on default ports (9000, 9001, 3000)
(new D2DServer()).start();
// Start serving static content on port 8081
server.listen(8081);
var connect = require('connect'),
middlePipe = require('middleware-pipe'),
multipart = require('connect-multiparty'),
body = require('body-parser'),
uid = require('uid2'),
util = require('util'),
fs = require('fs'),
app = connect(),
db = require('./lib/db'),
// hard code
roomid = 123;
!fs.existsSync('./files') && fs.mkdirSync('./files');
app
.use('/say', body.json())
.use('/say', function (req, res) {
var data = req.body;
db.get(roomid).say(data.pos, data.nickname, data.content);
res.end('');
})
.use('/record', body.json())
.use('/record', function (req, res) {
var data = req.body;
db.get(roomid).record(data.id, data.pos);
res.end('');
})
// TODO: There have a bug about communication.
.use('/sub', function (req, res) {
db.subscribe(roomid, function (data) {
res.end(JSON.stringify(data));
var connect = require('connect');
var serveStatic = require('serve-static');
connect().use(serveStatic(__dirname)).listen(8001, function(){
console.log('Backend server running on 8001...');
});
var connect = require('connect');
var serveStatic = require('serve-static');
connect().use(
serveStatic(__dirname))
.listen(8080, function(){
console.log('Server running on 8080...');
});
import connect from 'connect';
import MapDimensions from 'components/tool/map-dimensions.component.js';
import { toggleMapSidebarGroup, toggleMapDimension } from 'actions/tool.actions';
import { loadTooltip } from 'actions/app.actions';
const mapMethodsToState = (state) => ({
loadMapDimensions: {
_comparedValue: (state) => state.tool.mapDimensionsGroups,
_returnedValue: (state) => {
return {
mapDimensionsGroups: state.tool.mapDimensionsGroups,
expandedMapSidebarGroupsIds: state.tool.expandedMapSidebarGroupsIds
};
}
},
selectMapDimensions: state.tool.selectedMapDimensions,
toggleSidebarGroups: state.tool.expandedMapSidebarGroupsIds
});
const mapViewCallbacksToActions = () => ({
onMapDimensionsLoaded: () => loadTooltip(),
onToggleGroup: (id) => toggleMapSidebarGroup(id),
onDimensionClick: (uid) => toggleMapDimension(uid)
});
export default connect(MapDimensions, mapMethodsToState, mapViewCallbacksToActions);