(function () {
"use strict";
var stack = require('./lib/stack')
, gcf = require('express-chromeframe')
, addSendJson = require('./lib/jason-res-json')
, corsSession = require('./lib/connect-cors-session')
, nowww = require('nowww')
, queryparser = require('connect-queryparser')
, xcors = require('connect-xcors')
, cors
, session
, connect
;
connect = stack.create(
addSendJson()
);
cors = xcors();
session = corsSession();
connect.addMiddleware(
nowww()
, queryparser()
, cors
, session
, gcf()
);
// TODO push into middleware layer
cors.config.headers = cors.config.headers.concat(session.headers.slice());
module.exports = connect;
}());
function start(options, app) {
var corsOptions = {
origins: ["*"],
methods: ['HEAD', 'GET', 'POST'],
credentials: true,
headers: []
};
if (!options) { options = {}; }
if (!options.port) { options.port = conf.ports.proxy; }
if (!app) { app = server.start(options); }
if (!options.route) {
options.route = "";
} else if (!options.route.match(/^\//)) {
options.route = "/" + options.route;
}
app.use(function (req, res, next) {
var headers;
if (req.headers["access-control-request-headers"]) {
headers = req.headers["access-control-request-headers"].split(", ");
headers.forEach(function (header) {
if (!corsOptions.headers.some(function (h) {
return h === header;
})) {
corsOptions.headers.push(header);
}
});
}
next();
});
app.use(cors(corsOptions));
app.use(express.bodyParser());
app.all(options.route + "/xhr_proxy", xhrProxyHandler);
app.all(options.route + "/jsonp_xhr_proxy", jsonpXHRProxyHandler);
console.log("INFO:".green + " CORS XHR proxy service on: " +
("http://localhost:" + app._port + options.route + "/xhr_proxy").cyan);
console.log("INFO:".green + " JSONP XHR proxy service on: " +
("http://localhost:" + app._port + options.route + "/jsonp_xhr_proxy").cyan);
return app;
}
module.exports = exports = function(config) {
if (!config) config = {};
// Create a simple-stack-common app
var pack = stack(config);
pack
.useAfter("base", cors(config.cors || null))
.use(require("./lib/not-found")())
.use(require("./lib/error-handler")());
// Return the pack
return pack;
};
function startServer (onMonitorRequest) {
var Connect = require('connect');
var CORS = require('connect-xcors');
var sse = null;
function processServerRequest(req, res) {
function replyToSSEInit() {
if (req.url == '/events') {
res.writeHead(200, {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive'
});
res.write("data: ELM server ready\n\n");
sse = res;
console.log("Client connected\n");
} else {
res.writeHead(404);
res.end();
}
}
function processMonitorRequest() {
var command = req.url.substring(1);
onMonitorRequest(command, sse);
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end("Command queued\n");
}
// utils.debugHeaders(req);
if (req.headers.accept && req.headers.accept == 'text/event-stream')
replyToSSEInit();
else
processMonitorRequest();
};
var server = Connect.createServer(
CORS({}),
processServerRequest);
server.listen(9000);
}
, temp = require('temp')
, fs = require('fs')
, connectXCors = require('connect-xcors')
, sse = require('connect-sse')()
, Jobs = require('./jobs')
, settingsStore = require('./settings')
, extend = require('./extend')
, redis = require('redis')
, bodyParser = require('./bodyParser')()
, console = require('clim')()
var cors = connectXCors({
headers: [
'X-Requested-With',
'X-HTTP-Method-Override',
'Content-Type',
'Accept',
'Authorization',
]
})
var env = {
GENERATED_FILE_PREFIX: process.env.GENERATED_FILE_PREFIX || 'mediablast',
};
function errorMiddleware(err, req, res, next){
console.error(err.stack);
next(err);
}
function noCacheMiddleware(req, res, next){
/*
Reference: http://benramsey.com/blog/2008/05/206-partial-content-and-range-requests/
*/
var express = require('express'),
cors = require('connect-xcors'),
head = require('./head'),
get = require('./get')
;
var server = express();
server.
use(cors({
headers: ['Accept-Ranges', 'Content-length', 'Content-type', 'Content-Range', 'Date', 'Range']
})).
set('port', 8081).
set('data_dir', __dirname + '/data')
;
server.
head('/range/:oid', head(server.get('data_dir'))).
get('/range/:oid', get(server.get('data_dir')))
;
server.listen(server.get('port'));
console.log('Nodejs Example Http Range listen on ' + server.get('port'));
(function () {
"use strict";
var steve = require('./steve')
, connect = require('connect')
, app = connect.createServer()
/*
* CONFIG STUFF that should be moved out
*/
, xcorsOptions
, xcorsDefaultOptions = {
origins: ["http://apps.spotterrf.com", "http://hurpdurp.com"]
, methods: ['GET', 'POST']
, headers: ['Content-Type', 'Accept']
, credentials: false
}
, port = process.argv[2] || 7770
, publicDir = process.argv[3]
, wacServerUrl = "http://hurpdurp.com"
/*
* NORMAL STUFF
*/
, fs = require('fs')
, path = require('path')
, pkgConfigPath = path.join(__dirname, '..', 'package.json')
, curVer = JSON.parse(fs.readFileSync(pkgConfigPath)).version
, semver = require('semver')
, request = require('ahr2')
, xcors = require('connect-xcors')
, installer = require('./installer')
, pullRoute = require('./router')
, publicPath = path.join(__dirname, '..', 'webclient-deployed')
, releasesPath = path.join(__dirname, '..', 'webclient-deployed', 'releases')
, mountDir = path.join(__dirname, 'mounts')
, mounterFactory = require('connect-mounter')
//, DomStorage = require('dom-storage')
//, jsonStorage = require('json-storage').create(DomStorage.create(path.join(__dirname, 'settings.json')))
, mounter = mounterFactory.create(mountDir)
, failures = mounterFactory.fail
, installLock
;
// TODO allow 3rd party stores to be used via oauth or something
//xcorsOptions = jsonStorage.get('xcors');
if (!xcorsOptions) {
xcorsOptions = xcorsDefaultOptions;
}
/*
app.corsConfig.headers = xcorsOptions.headers;
app.corsConfig.origins = xcorsOptions.origins;
app.corsConfig.methods = xcorsOptions.methods;
app.corsConfig.credentials = xcorsOptions.credentials;
*/
if (failures) {
console.log('BAD APPS:', failures);
}
function update(cb) {
request.get(wacServerUrl + "/version").when(function(err, ahr, data) {
var newVer
, selfUpdate = true
, callback = null
, installLockTimeout
;
function removeInstallLock() {
installLock = false;
clearTimeout(installLockTimeout);
installLockTimeout = 0;
}
if(err || data.error === true) {
console.log('Could not contact WebAppsCenter update service. Going it alone...');
return;
}
if (cb) {
cb (err || data.error, curVer, newVer);
}
if (installLock) {
return;
}
if(semver.gt(data.result, curVer)) {
console.log("New version (" + data.result + ") detected... downloading and installing!");
newVer = data.result;
installLock = true;
installer(null, "client", newVer, selfUpdate, callback, wacServerUrl);
installLockTimeout = setTimeout(removeInstallLock, 15 * 60 * 1000);
}
});
}
if((parseFloat(port) !== parseInt(port, 10)) || !isNaN(port)) {
port = 7770;
}
if(typeof publicDir !== 'undefined' && fs.statSync(publicDir).isDirectory()) {
if (publicDir.substring(0, 1) === '/'
|| (/^win/.exec(process.platform) && /[A-Z]:/.test(publicDir.substring(0,2)))) {
publicPath = publicDir;
} else {
publicPath = __dirname + '/' + publicDir;
}
}
function sendUpdateInfo(req, res) {
function sendUpdateInfoHelper(err, curVer, newVer) {
if (err) {
res.error(err);
}
res.json({
current: curVer
, latest: newVer
});
}
update(sendUpdateInfoHelper);
}
function router(rest) {
rest.get('/update', sendUpdateInfo);
}
// check for updates every 3 hours
setInterval(update, 3 * 60 * 60 * 1000);
update();
app
.use(steve)
.use(mounter)
.use(xcors(xcorsOptions))
.use(connect.router(pullRoute))
//TODO remove this static / directory serving. Everything should be
// being pulled from the HTML5 webapp already.
.use(connect.static(publicPath))
.use(connect.static(releasesPath))
.use(connect.directory(publicPath))
;
module.exports = app;
}());
(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(res, req, 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 + '/../static'))
.use(connect.static(__dirname + '/../public'))
.use(connect.static(__dirname + '/../var/public'))
.use('/version', getVersion)
.use(connect.favicon())
;
module.exports = app;
}());