236 lines
6 KiB
JavaScript
236 lines
6 KiB
JavaScript
"use strict";
|
|
|
|
var messages = require("./../messages");
|
|
var snippetUtils = require("./../snippet").utils;
|
|
var utils = require("./utils.js");
|
|
var mainUtils = require("./../utils");
|
|
var connect = require("connect");
|
|
var _ = require("lodash");
|
|
var http = require("http");
|
|
var https = require("https");
|
|
var foxy = require("foxy");
|
|
var fs = require("fs");
|
|
|
|
/**
|
|
*
|
|
*/
|
|
module.exports.plugin = function (bs, scripts) {
|
|
|
|
var options = bs.options;
|
|
var debug = bs.debug;
|
|
var proxy = options.proxy || false;
|
|
var server = options.server || false;
|
|
|
|
var snippet = (!server && !proxy);
|
|
var baseDir = mainUtils.getBaseDir(server.baseDir || "./");
|
|
var type = "snippet";
|
|
var events = bs.events;
|
|
|
|
if (options.server) {
|
|
options.server.middleware = bs.pluginManager.hook("server:middleware", server.middleware || null);
|
|
}
|
|
|
|
var bsServer = exports.createServer(options, scripts, bs);
|
|
|
|
if (server || snippet) {
|
|
debug("Static Server running ({magenta:%s}) ...", options.https ? "https" : "http");
|
|
type = server ? "server" : "snippet";
|
|
}
|
|
|
|
if (proxy) {
|
|
debug("Proxy running, proxing: {magenta:%s}", options.proxy.target);
|
|
type = "proxy";
|
|
}
|
|
|
|
if (bsServer) {
|
|
bs.server = bsServer.listen(options.port);
|
|
}
|
|
|
|
debug("Running mode: %s", type.toUpperCase());
|
|
|
|
if (type && (server || proxy)) {
|
|
if (options.tunnel && options.online) {
|
|
try {
|
|
var tunnel = bs.pluginManager.get("tunnel:runner");
|
|
if (tunnel) {
|
|
bs.pluginManager.get("tunnel")(bs, tunnel(), finished);
|
|
}
|
|
} catch (e) {
|
|
console.log("ERRRRRRRRRRRRR: " + e);
|
|
}
|
|
} else {
|
|
finished(options.urls.local);
|
|
}
|
|
} else {
|
|
finished("n/a");
|
|
}
|
|
|
|
function finished (url, tunnel) {
|
|
|
|
if (tunnel) {
|
|
bs.options.urls.tunnel = url;
|
|
}
|
|
|
|
events.emit("service:running", {
|
|
type: type,
|
|
options: bs.options,
|
|
baseDir: baseDir || null,
|
|
port: options.port,
|
|
url: url,
|
|
tunnel: tunnel ? url : false
|
|
});
|
|
}
|
|
|
|
return bsServer;
|
|
};
|
|
|
|
/**
|
|
* Launch the server for serving the client JS plus static files
|
|
* @param {Object} options
|
|
* @param {String} scripts
|
|
* @param {BrowserSync} bs
|
|
* @returns {{staticServer: (http.Server), proxyServer: (http.Server)}}
|
|
*/
|
|
module.exports.createServer = function (options, scripts, bs) {
|
|
|
|
var proxy = options.proxy || false;
|
|
var server = options.server || false;
|
|
|
|
options.snippet = messages.scriptTags(options.port, options);
|
|
options.scriptPaths = messages.clientScript(options, true);
|
|
|
|
if (!proxy && !server) {
|
|
return createSnippetServer(options, scripts, bs);
|
|
}
|
|
|
|
if (options.proxy) {
|
|
return exports.createProxy(options, scripts, bs);
|
|
}
|
|
|
|
if (options.server) {
|
|
return createServer(options, scripts, bs);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @param options
|
|
* @param scripts
|
|
* @param context
|
|
* @returns {*}
|
|
*/
|
|
function createServer (options, scripts, context) {
|
|
|
|
var server = options.server;
|
|
var middleware = server.middleware;
|
|
var secure = (options.https !== undefined && options.https !== false);
|
|
|
|
var secureKey, secureCert;
|
|
|
|
var index, app;
|
|
|
|
index = server.index || "index.html";
|
|
|
|
app = context.app = connect();
|
|
context.connect = connect;
|
|
|
|
utils.addMiddleware(app, middleware);
|
|
|
|
app.use(function (req, res, next) {
|
|
snippetUtils.isOldIe(req);
|
|
return next();
|
|
})
|
|
.use(options.scriptPaths.versioned, scripts)
|
|
.use(options.scriptPaths.path, scripts);
|
|
|
|
if (server.directory) {
|
|
utils.addDirectory(app, server.baseDir);
|
|
}
|
|
|
|
app.use(snippetUtils.getSnippetMiddleware(options.snippet, options.snippetOptions));
|
|
|
|
utils.addBaseDir(app, server.baseDir, index);
|
|
|
|
if (server.routes) {
|
|
utils.addRoutes(app, server.routes);
|
|
}
|
|
|
|
if (secure) {
|
|
secureKey = fs.readFileSync(secure.key || __dirname + "/certs/server.key");
|
|
secureCert = fs.readFileSync(secure.cert || __dirname + "/certs/server.crt");
|
|
return https.createServer({key: secureKey, cert: secureCert}, app);
|
|
} else {
|
|
return http.createServer(app);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param options
|
|
* @param scripts
|
|
* @param context
|
|
* @returns {*}
|
|
*/
|
|
function createSnippetServer (options, scripts, context) {
|
|
|
|
var app = context.app = connect();
|
|
context.connect = connect;
|
|
|
|
app.use(options.scriptPaths.versioned, scripts)
|
|
.use(options.scriptPaths.path, scripts);
|
|
|
|
return http.createServer(app);
|
|
}
|
|
|
|
/**
|
|
* @param options
|
|
* @param scripts
|
|
* @returns {*}
|
|
* @param {BrowserSync} bs
|
|
*/
|
|
module.exports.createProxy = function (options, scripts, bs) {
|
|
|
|
exports.checkProxyTarget(options.proxy, function (err) {
|
|
if (err) {
|
|
bs.events.emit("config:warn", {msg: err});
|
|
}
|
|
});
|
|
|
|
return foxy(options.proxy.target, {
|
|
rules: snippetUtils.getRegex(options.snippet, options.snippetOptions),
|
|
ignorePaths: options.snippetOptions.ignorePaths,
|
|
middleware: snippetUtils.getProxyMiddleware(scripts, options.scriptPaths.versioned),
|
|
errHandler: function () {}
|
|
}
|
|
);
|
|
};
|
|
|
|
/**
|
|
* @param {Object} proxy
|
|
* @param {Function} cb
|
|
*/
|
|
module.exports.checkProxyTarget = function (proxy, cb) {
|
|
|
|
var chunks = [];
|
|
var errored = false;
|
|
|
|
function logError() {
|
|
if (!errored) {
|
|
cb("Proxy address not reachable - is your server running?");
|
|
errored = true;
|
|
}
|
|
}
|
|
|
|
require("http").get(proxy.target, function (res) {
|
|
res.on("data", function (data) {
|
|
chunks.push(data);
|
|
});
|
|
}).on("error", function (err) {
|
|
if (_.contains(["ENOTFOUND", "ECONNREFUSED"], err.code)) {
|
|
logError();
|
|
}
|
|
}).on("close", function () {
|
|
if (!chunks.length) {
|
|
logError();
|
|
}
|
|
});
|
|
};
|