serviceLoader.on('initialized', function(){
app.use(expressWinston.logger({winstonInstance: serviceLoader.get('Logs').access}));
app.use(expressWinston.errorLogger({winstonInstance: serviceLoader.get('Logs').error}));
app.listen(config.get('server.port'));
logger.log('info', "HTTP Server runing on port " + config.get('server.port'));
});
.then(function () {
app.use(mobile);
app.use(logCollector.errorLogger({
winstonInstance: logger
}));
return app;
});
exports.start = function(port, callback) {
var app = express();
app.use(express.limit('4mb'));
app.use(express.json());
app.use(express.urlencoded());
app.use(express.cookieParser());
app.use(express.cookieSession({
secret: config.get("server_sessionKey")
}));
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
app.use(connectFlash());
auth.addToExpress(port, app);
require("./posts.js")(app);
require("./downloadAllPosts.js")(app);
require("./feeds.js")(app);
require("./trimPosts.js")(app);
app.get("/", auth.requireLogin, handleHomepageRequest);
app.get("/status", handleStatusRequest);
app.get("/about", handleAboutRequest);
app.get("/client/main-built.js", function(req, res) {
var mainBuilt = path.resolve(__dirname + '../../../temp/main-built.js');
fs.exists(mainBuilt, function(exists) {
if (exists) {
res.sendfile(mainBuilt);
} else {
res.status(404).send("not found");
}
});
});
app.use("/client/runtime.js", function(req,res){
res.status(200).sendfile(path.resolve(__dirname, "../../node_modules/jade/runtime.js"));
});
app.use("/client", express.static(__dirname + './../client/'));
app.use("/client/views", express.static(__dirname + './../../temp/views'));
var transports = [];
transports.push(new winston.transports.Console({json: true}));
app.use(expressWinston.errorLogger({
transports: transports
}));
app.use(errorHandler);
server = http.createServer(app);
server.listen(port, callback);
};
exports.errorLogger = function(app) {
app.use(expressWinston.errorLogger({
// winstonInstance: winston,
transports: [
new winston.transports.SendGridLogger({
to: '*****@*****.**',
subject: 'Columby worker error report: Uncaught exception handler'
})
]
}));
};
function Ohm(config) {
Object.keys(config).map((key, index) => {
nconf.set(key, config[key]);
});
if (nconf.get('STATIC_PATH') === undefined) {
nconf.set('STATIC_PATH', PATH.join(__dirname, nconf.get('STATIC_DIR')));
}
winston.info('Server starting on port ' + config.port + ' in ' + app.settings.env + ' mode');
app.config = config;
configManager.handle(nconf, app);
if (config.SESSION_KEY) {
parseManager.handle(nconf, app);
sessionManager.handle(nconf, app, io);
}
if (config.GHOST_CONFIG_PATH) {
ghostManager.handle(nconf, app);
}
app.use(expressWinston.logger({
transports: [
new(winston.transports.File)({
filename: 'logs/ohm.debug.log',
level: 'debug',
}),
]
}));
if (config.SOCKETS) {
require(config.SOCKETS)(io, app);
}
require(config.ROUTES)(app);
app.use(expressWinston.errorLogger({
transports: [
new(winston.transports.File)({
filename: 'logs/ohm.error.log'
}),
]
}));
server.listen(config.port);
return server;
}
exports.error = (function () {
const transports = [
new (winston.transports.Console)({
colorize: true,
timestamp: true,
}),
];
addServerTransport(transports);
return expressWinston.errorLogger({
transports: transports,
baseMeta: {
server: {
name: pkg.name,
version: pkg.version,
}
}
});
})();
module.exports = function () {
var colorize = process.env.NODE_ENV !== 'production';
// Logger to capture all requests and output them to the console.
// [START requests]
var requestLogger = expressWinston.logger({
transports: [
new winston.transports.Console({
json: false,
colorize: colorize
})
],
expressFormat: true,
meta: false
});
// [END requests]
// Logger to capture any top-level errors and output json diagnostic info.
// [START errors]
var errorLogger = expressWinston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: colorize
})
]
});
// [END errors]
return {
requestLogger: requestLogger,
errorLogger: errorLogger,
error: winston.error,
warn: winston.warn,
info: winston.info,
log: winston.log,
verbose: winston.verbose,
debug: winston.debug,
silly: winston.silly
};
};
app.configure(function () {
// bodyParser should be above methodOverride
app.use(express.bodyParser());
app.use(express.methodOverride());
// cookieParser should be above session
app.use(express.cookieParser());
app.use(express.session({
secret: pkg.name,
store: new mongoStore({
url: mongoConfig.getDbUrl(),
collection : 'sessions'
})
}));
// Passport session
app.use(passport.initialize());
app.use(passport.session());
// routes should be at the last
app.use(app.router);
// express-winston errorLogger makes sense AFTER the router.
app.use(expressWinston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
})
]
}));
app.use(function (req, res, next) {
res.status(404).render('404', { url: req.originalUrl });
});
});
app.configure(function () {
app.disable('etag');
app.set('ipaddress', ipaddress)
app.set('port', port);
app.set('config', config);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
app.set('models', require('./models'));
app.set('checkIsMobile', isCallerMobile);
app.set('database', app.get('models').sequelize);
if(!process.env.SINGULAR) {
app.set('workerId', cluster.worker.id);
}
app.use(express.favicon());
app.use(express.compress());
app.use(express.bodyParser());
app.use(express.static(config.dataDir, 'data', { maxAge: '2h' }));
app.use(express.static(path.join(__dirname, 'public'), { maxAge: '2h' }));
app.use(express.json());
app.use(express.methodOverride());
app.use(express.cookieParser());
app.use(express.urlencoded());
app.use(express.cookieSession({ key: 'express.sid', secret: 'M9W2J1Yq6DbfM+iQZ5ydEMt88peKFz2zq5g6ajtygP4=', maxAge: new Date(Date.now() + 3600000), secure: true }));
app.use(passport.initialize());
app.use(passport.session());
app.use(expressWinston.logger({
transports: config.loggerTransports,
meta: false, // optional: control whether you want to log the meta data about the request (default to true)
msg: "HTTP {{req.method}} {{req.url}}"
}));
app.use(app.router);
app.use(expressWinston.errorLogger({
transports: config.loggerTransports
}));
});
extension.loadConfiguration(config, function (err) {
if (err) return callback(err)
// Set default to Infinity
http.globalAgent.maxSockets = config.maxSockets || Infinity
https.globalAgent.maxSockets = config.maxSockets || Infinity
var app = express()
app.use(bodyParser.json({limit: '10mb'}))
if (config.winstonInstance) logger = config.winstonInstance
var expressLogConfig = {
winstonInstance: logger,
msg: '{{res.statusCode}} HTTP {{req.method}} {{req.url}} {{res.responseTime}}ms',
meta: false
}
app.use(expressWinston.logger(expressLogConfig))
app.use(expressWinston.errorLogger(expressLogConfig))
routes(app)
port = config.port || 80
server = app.listen(port, function () {
logger.info('Express integrator-extension server listening on port: ' + port)
return callback()
})
server.on('error', function (err) {
logger.error('Express integrator-extension server error - ' + err.toString())
})
// Timeout should be greater than the server's/load balancer's idle timeout to avoid 504 errors.
server.timeout = config.timeout || 315000
})
json: false,
colorize: colorize,
}),
],
expressFormat: true,
meta: false,
});
// [END requests]
// Logger to capture any top-level errors and output json diagnostic info.
// [START errors]
const errorLogger = expressWinston.errorLogger({
transports: [
new StackdriverTransport(),
new winston.transports.Console({
json: true,
colorize: colorize,
}),
],
});
// [END errors]
module.exports = {
requestLogger: requestLogger,
errorLogger: errorLogger,
error: winston.error,
warn: winston.warn,
info: winston.info,
log: winston.log,
verbose: winston.verbose,
debug: winston.debug,
app.set("view engine", "jade");
app.use(express.urlencoded());
app.use(require("connect-multiparty")({ keepExtensions: true, uploadDir: config.tempDir || __dirname }))
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
app.use(express.cookieParser(config.cookieSecret || "changeme"));
app.use(express.session());
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
app.use(app.router);
app.use(expressWinston.errorLogger({
transports: [
new winston.transports.File({ filename: config.exceptionlogfile })
]
}));
app.use(express.static(path.join(__dirname, "static")));
// setting up protected static service
var templateStatic = express.static(path.join(__dirname, "template"));
var projectStatic = express.static(config.projectsDir || path.join(__dirname, "projects"));
app.get(/^\/api\/p\/([^\/]+)\/(.+)/, global.authTokenOrUser, global.authProject, function (req, res, next) {
if (req.params.length>=0 && req.params[0]) {
var projectName = req.params[0];
var reqPath = req.params[1];
var projectPath = path.join(Utils.getProjectDir(projectName), reqPath);
var templatePath = path.join(__dirname, "template", reqPath);
if (reqPath=="application.keystore" || reqPath=="storyquest.properties") {
res.status(404).send("Resource " + reqPath + " not found.");
cert: fs.readFileSync(certificateRealPath).toString(),
};
app.port = app.config.port || 443;
app.server = https.createServer(options, app);
app.server.listen(app.port, function() {
logger.info('HTTPS server listening on port ' + app.port);
require('./lib/sockets');
});
};
require('./routes');
// load after the routes
if (process.env.NODE_ENV === 'development') {
// only use in development
app.use(errorhandler());
}
// express-winston errorLogger makes sense AFTER the router.
app.use(expressWinston.errorLogger({
transports: myLogTransports,
}));
function handleError(err) {
logger.error('handleError : ', err, err.stack);
process.exit(1);
}
process.on('uncaughtException', handleError);
// All unhandled routes are served the static index.html file
app.get('*', (req, res) => {
// If in production or local mode, and the page is a static path, send the static version
if (
(ENV === 'production' || ENV === 'local') &&
staticPageCache[req.originalUrl]
) {
res.send(staticPageCache[req.originalUrl]);
} else {
res.send(publicIndexFile);
}
});
}
// Error logging
app.use(expressWinston.errorLogger({ transports: winstonTransports }));
// Pass the Express app to the user's custom error handler function.
const errorHandlerPath = './server/errorHandler.js';
if (utils.fileExists(errorHandlerPath)) {
const errorHandler = require(path.join(cwd, errorHandlerPath));
if (typeof errorHandler === 'function') {
app.use(errorHandler);
} else {
throw new Error('Custom error handler file must export a single function.');
}
}
// Start the Express server
const server = app.listen(EXPRESS_PORT, () => {
module.exports = function (app, passport) {
params.extend(app);
app.set('port', config.get('port'));
app.set('views', [config.get('root'), 'www', 'views'].join('/'));
app.set('view engine', 'ejs');
// HTML using ejs is used with server auth protected angularjs templates
// Eg. Only logged in uses can load the create template
app.engine('html', require('ejs').renderFile);
app.disable('x-powered-by');
// Enable response compression (utilize bandwidth)
app.use(express.compress({
filter: function (req, res) {
return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
},
// Levels are specified in a range of 0 to 9, where-as 0 is
// no compression and 9 is best compression, but slowest
level: 9
}));
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
app.use(express.cookieParser());
// Session storage
app.use(express.session({
key: config.get('cookieKey'),
secret: config.get('cookieSecret'),
cookie: {
domain: config.get('app').cookieDomain,
expires: new Date(config.get('cookieExpire'))
},
store: new RedisStore({
secret: config.get('redisSessionSecret'),
client: redisClient
})
}));
// connect-flash required by passportjs for flash messages
app.use(flash());
// use passport session
app.use(passport.initialize());
app.use(passport.session());
app.use(express.csrf());
// Angular’s $http library reads the token from the XSRF-TOKEN cookie.
// We therefore have to set this cookie and send it to the client.
// Setting a cookie in Express is done via the res.cookie('name', 'value') function.
// The name is obviously XSRF-TOKEN. The value is read from the user’s session.
// The key req.session._csrf is automatically generated by the csrf middleware.
app.use(function (req, res, next) {
res.cookie('XSRF-TOKEN', req.csrfToken());
next();
});
// Logging
// HTTP log
// express-winston logger BEFORE the router.
app.use(expressWinston.logger({
transports: [
new (winston.transports.File)({
filename: config.get('root') + '/log/' + env + '_access.log',
maxsize: config.get('logMaxFileSize'),
maxfiles: config.get('logMaxFiles')
})
]
}));
app.use(app.router);
// static files are handled by NGINX in production
app.use(express.static([config.get('root'), 'app'].join('/')));
// Error log
// express-winston errorLogger AFTER the router.
app.use(expressWinston.errorLogger({
transports: [
new (winston.transports.File)({
filename: config.get('root') + '/log/' + env + '_error.log',
maxsize: config.get('logMaxFileSize'),
maxfiles: config.get('logMaxFiles')
})
]
}));
// Server error handling
app.use(function (err, req, res, next) {
logger.error(err.stack);
// If 403 error send JSON response
if (err.status === +403) {
logger.error('403: ' + req.originalUrl);
res.jsonp(403, {error: 'Forbidden'});
}
else {
// 500 error repsonse
logger.error('500: ' + req.originalUrl);
// Error message to display
var errorMsg;
if ('production' === app.get('env')) {
errorMsg = 'We\'re very sorry, but something went wrong. We\'ve been notified about this issue and we\'ll follow up on this right away.';
}
else {
errorMsg = err.stack;
}
// If the request is from AngulaJS respond with JSON else full HTML page
if (req.header('X-XSRF-TOKEN')) {
res.send(500, { error: errorMsg });
}
else {
res.status(500).render('500.html', {
name: config.get('app').name,
error: errorMsg
});
}
// Fix JSHint's warning of next not being used by defining it
next = next;
return;
}
});
// Assume 404 since no middleware responded
app.use(function (req, res) {
logger.error('404: ' + req.originalUrl);
// AngularJS handle 404 page or 301 permanent redirect (better for SEO?)
// 404 response
// res.redirect('/#' + req.originalUrl);
// 301 response
res.writeHead(301, {'Location': '/#!' + req.originalUrl});
res.end();
});
};
'message': 'Ok',
'data': doc_id
};
res.send(success);
}
});
});
// this needs to go after any calls to verbs
app.use(express_winston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
}),
new winston.transports.File({
filename: config.logger.path,
json: true,
maxsize: 10485760,
maxFiles: 5
})
]
}));
if (config.app.listen_http) {
http.createServer(app).listen(config.app.port);
}
if (config.app.listen_https) {
https.createServer(config.ssl, app).listen(config.ssl.port);
}
var winston = require('winston');
var expressWinston = require('express-winston');
var transports = [new (winston.transports.Console)({json: true})];
module.exports = {
access: expressWinston.logger({transports: transports}),
error: expressWinston.errorLogger({transports: transports})
};
colorize: true
}),
new winston.transports.File({
filename: 'logs/success.log'
})
]
}));
// 路由
routes(app);
// 错误请求的日志
app.use(expressWinston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
}),
new winston.transports.File({
filename: 'logs/error.log'
})
]
}));
// error page
app.use(function (err, req, res, next) {
res.render('error', {
error: err
});
});
if (module.parent) {
module.exports = app;
var expressWinston = require('express-winston');
var winston = require('winston'); // for transports.Console
var mkdirp = require('mkdirp');
var path = require('path');
var logPath = 'log/ws.log';
mkdirp.sync(path.dirname(logPath));
var logger = {
consoleLogger: expressWinston.logger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
}),
new winston.transports.File({ filename: logPath })
]
}),
errorLogger: expressWinston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
}),
new winston.transports.File({ filename: logPath })
]
})
};
module.exports = logger;
// let date = new Date();
// let M = (date.getMonth() + 1) >= 10 ? date.getMonth() + 1 : `0${date.getMonth() + 1}`;
// let d = date.getDate() >= 10 ? date.getDate() : `0${date.getDate()}` ;
// overdueTask()
// .then(resolve => {
// console.log(`${date.getFullYear()}-${M}-${d} 00:00:00`);
// })
// }, 60 * 60 *24);
// 生成错误日志
app.use(expressWinston.errorLogger({
transports: [
// new (winston.transports.Console)({
// json: true,
// colorize: true
// }),
new winston.transports.File({
filename: 'logs/error.log'
})
]
}))
app.listen(config.port, () => {
console.log(`listen at http://localhost:${config.port}`);
});
const http = require('http').Server(express());
const io = require('socket.io')(http);
http.listen(config.ioPort, () => {
//
// config
// client
// views - directory where jade views are there, only required view is 'index'
// routes - react router routes
// publicPath
// resourcesPath
// api
// services - service instances, that also implement registry methods
//
export default function (app, config) {
const logger = buildLogger(config.logDirectory || process.cwd());
app.use(compression());
// log body too
ExpressWinston.requestWhitelist.push('params');
ExpressWinston.requestWhitelist.push('cookies');
ExpressWinston.requestWhitelist.push('body');
ExpressWinston.responseWhitelist.push('_headers');
app.use(ExpressWinston.logger({winstonInstance: logger, statusLevels: true}));
if (config.client) {
// view engine setup
const viewsDirectory = config.client.views || path.join(__dirname, 'views');
const layoutsDirectory = path.join(viewsDirectory, 'layouts');
const hbsEngine = expressHandleBars.create({
layoutsDir: layoutsDirectory,
defaultLayout: 'default'
});
app.set('views', viewsDirectory);
app.engine('handlebars', hbsEngine.engine);
app.set('view engine', 'handlebars');
if (config.client.publicPath) {
app.use(config.client.multiInstance ? '/:instanceName' : '/', express.static(config.client.publicPath, {index: false, maxAge: NinetyDays}));
}
if (config.client.resourcesPath) {
app.use(config.client.multiInstance ? '/:instanceName/resources' : '/resources', express.static(config.client.resourcesPath, {index: false, maxAge: NinetyDays}));
}
}
// For API and dynamic resources
app.use((req, res, next) => {
res.header('Access-Control-Allow-Origin', '*');
res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
res.header('Cache-Control', 'private, no-cache, no-store, must-revalidate');
res.header('Expires', '-1');
res.header('Pragma', 'no-cache');
next();
});
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(cookieParser());
//
// APIs
//
if (config.api) {
app.use(apiRequestHandler(config.api));
}
//
// CLIENT APP
//
if (config.client) {
// eslint-disable-next-line import/no-unresolved, import/no-extraneous-dependencies
const clientAppRequestHandler = require('reactjs-web-boilerplate/lib/server/ClientAppRequestHandler').default;
app.use(config.client.multiInstance ? '/:instanceName' : '/', clientAppRequestHandler(config.client.routes, config.client.multiInstance, config.client.properties, config.api));
}
// TODO: depending on the user agent either return REST response or page response here
// catch 404 and forward to error handler
app.use((req, res, next) => {
const err = new Error('404::Not Found');
err.status = 404;
next(err);
});
app.use(ExpressWinston.errorLogger({winstonInstance: logger}));
//
// ERROR HANDLERS
//
// TODO: depending on the user agent either return REST response or page response here
// development error handler - will print stacktrace
if (app.get('env') === 'development') {
app.use((err, req, res) => {
res.status(err.status || 500);
// res.render('error', {
// message: err.message,
// error: err
// });
res.send({message: err.message, status: err.status, error: err});
});
}
// TODO: depending on the user agent either return REST response or page response here
// production error handler- no stack traces leaked to user
app.use((err, req, res) => {
res.status(err.status || 500);
// res.render('error', {
// message: err.message,
// error: {}
// });
res.send({message: err.message, status: err.status});
});
}
res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
res.header('Access-Control-Allow-Headers', 'Content-Type,Content-Length,Cache-Control,Pragma,Origin,Connection,Host,Cookie,Accept');
res.header('Access-Control-Allow-Credentials', 'true');
res.header('Access-Control-Expose-Headers', 'Access-Control-Allow-Origin');
}
next();
};
app.use(allowCrossDomain);
app.use(expressWinston.errorLogger({
transports: [
new winston.transports.Console({
timestamp: true,
colorize: true
})
],
statusLevel: true
}));
function start(port) {
models.initData();
routes.setup(app, handlers);
app.listen(port || process.env.PORT || 3000);
return app;
}
exports.start = start;
exports.app = app;
var app = express();
app.use(cors());
app.use(compression());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
//app.use(bodyParser.json({limit: '50mb'}));
//app.use(bodyParser.urlencoded({limit: '50mb', extended: true}));
app.use(expressWinston.logger(config.logger.winston));
app.use('/', require('./controllers'));
//error handling
app.use(expressWinston.errorLogger(config.logger.winston));
app.use(function(err, req, res, next) {
if(typeof err == "string") err = {message: err};
logger.error(err);
if(err.stack) {
logger.error(err.stack);
err.stack = "hidden"; //for ui
}
res.status(err.status || 500);
res.json(err);
});
process.on('uncaughtException', function (err) {
logger.error((new Date).toUTCString() + ' uncaughtException:', err.message)
logger.error(err.stack)
});
app.use(bodyParser.json());
app.use(methodOverride());
app.use(session({ secret: 'keyboard cat', resave: false, saveUninitialized: false }));
// Initialize Passport! Also use passport.session() middleware, to support
// persistent login sessions (recommended).
app.use(passport.initialize());
app.use(passport.session());
app.use(expressWinston.logger({
winstonInstance: log,
level: 'info',
}));
// Routes
app.use(require('./routes/root'));
app.use('/auth', require('./routes/auth').router);
// app.use('/h/:hashid', require('./routes/hashid').router);
app.use('/:username', require('./routes/user').router);
app.use('/:username/course', require('./routes/course').createRouter);
app.use('/:username/:courseLabel', require('./routes/course').router);
app.use('/:username/:courseLabel/assignment', require('./routes/assignment').createRouter);
app.use('/:username/:courseLabel/:assignmentAbbr', require('./routes/assignment').router);
app.use(expressWinston.errorLogger({
winstonInstance: log,
level: 'error',
}));
app.listen(3000);
app.use(expressWinston.logger(loggingOptions.requestLogger));
// favicon server
app.use(favicon(settings.baseDirectory + '/' + settings.options["favicon"]));
// assets router for static modules content
app.use('/assets', require('./lib/asset-server'));
// API router for data providers
app.use('/api', require('./lib/api-router'));
// index router with EJS preprocessor in place
app.engine('.html', require('ejs').__express);
app.get('/', require('./lib/index-server'));
// static router for frontend files
app.use(express.static(settings.frontendDirectory));
// error logger middleware
app.use(expressWinston.errorLogger(loggingOptions.errorLogger));
// custom error handler
app.use(function(err, req, res, next){
if (err) {
res.writeHead(500, {'Content-Type' : 'text/html'});
res.end('<h2>500 : Internal Error</h2>');
logger.error(err.stack);
} else { next();
}});
// configure server port
app.listen(process.env.PORT || settings.options["port"]);
logger.debug("Server started!\n");
// Send the index.html for other files to support HTML5Mode
var configuration = {
application : {
title: settings.options["title"],
home: settings.options["home"],
pageNotFound : settings.options["page-not-found"],
modules: settings.getModulesSetup()
},
user: {}
};
res.render(settings.frontendDirectory + '/index.html', {
title: settings.options["title"],
configuration: JSON.stringify(configuration),
css: assetManager.cssPile.htmlTags(),
js: assetManager.jsPile.htmlTags()
});
});
app.use(express.static(settings.frontendDirectory));
app.use(expressWinston.errorLogger(loggingOptions.errorLogger)); // error logger middleware
app.use(function(err, req, res, next){ // custom error handlers should follow the error logger
if (err) {
res.writeHead(500, {'Content-Type' : 'text/html'});
res.end('<h2>500 : Internal Error</h2>\n<pre>'+ err.stack + '</pre>')
} else { next();
}});
app.listen(process.env.PORT || settings.options["port"]);
logger.debug("Server started!\n");
json: true,
colorize: true
})
],
// meta: true, // optional: control whether you want to log the meta data about the request (default to true)
// msg: "HTTP {{req.method}} {{req.url}}", // optional: customize the default logging message. E.g. "{{res.statusCode}} {{req.method}} {{res.responseTime}}ms {{req.url}}"
expressFormat: true, // Use the default Express/morgan request formatting, with the same colors. Enabling this will override any msg and colorStatus if true. Will only output colors on transports with colorize set to true
colorStatus: true, // Color the status code, using the Express/morgan color palette (default green, 3XX cyan, 4XX yellow, 5XX red). Will not be recognized if expressFormat is true
ignoreRoute: function (req, res) { return false; } // optional: allows to skip some log messages based on request and/or response
}));
// app.use('/api', user(express, require('./config/passport')(passport)));
// app.use('/api', chat(express));
// app.use(chatRoomRouter(express));
app.use(limaIndexRouter(express));
// logger for error (should be declared afoter souters middleware)
app.use(expressWinston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
})
]
}));
require('./config/socket')(socketioServer);
server.listen(port, function() {
console.log('Running on port ' + port);
});
var app = express();
app.use(expressWinston.logger({"transports" : [loggerTransport] }));
if (commander.multer) {
logger.info("USING multer");
app.use(multer({"dest" : "/tmp/"}));
} else {
logger.info("USING bodyParser");
app.use(express.bodyParser({"keepExtensions" : true, "uploadDir" : "/tmp"}));
}
app.use(express.methodOverride());
app.use(app.router);
app.use(expressWinston.errorLogger({"transports": [ loggerTransport ]}));
app.post('/(files/)?upload', function(req, res) {
logger.info("INSIDE UPLOAD FUNCTION");
if (req.files.Filedata){
fs.unlink(req.files.Filedata.path, function() {
logger.info("REMOVING FILE %s", req.files.Filedata.path);
res.send(200);
});
return;
}
res.send(200);
});
app.listen(8000);
return next(error);
} else if (!(err instanceof APIError)) {
const apiError = new APIError(err.message, err.status, err.isPublic);
return next(apiError);
}
return next(err);
});
// catch 404 and forward to error handler
app.use((req, res, next) => {
const err = new APIError('API not found', httpStatus.NOT_FOUND);
return next(err);
});
// log error in winston transports except when executing test suite
if (config.env !== 'test') {
app.use(expressWinston.errorLogger({
winstonInstance
}));
}
// error handler, send stacktrace only during development
app.use((err, req, res, next) => // eslint-disable-line no-unused-vars
res.status(err.status).json({
message: err.isPublic ? err.message : httpStatus[err.status],
stack: config.env === 'development' ? err.stack : {}
})
);
export default app;
app.configure(function() {
winston.setLevels(winston.config.syslog.levels);
app.set('port', process.env.PORT || 3000);
app.set('tempDir', "./temp");
app.use(express.logger('dev'));
app.use(express.compress());
app.use(express.methodOverride());
app.use(function(req, res, next) {
res.header('Access-Control-Allow-Origin', '*');
res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,HEAD,OPTIONS');
res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Olaround-Debug-Mode');
res.header('Access-Control-Expose-Headers', 'X-Olaround-Debug-Mode, X-Olaround-Request-Start-Timestamp, X-Olaround-Request-End-Timestamp, X-Olaround-Request-Time, X-Olaround-Request-Method, X-Olaround-Request-Result, X-Olaround-Request-Endpoint');
// intercept OPTIONS method
if ('OPTIONS' == req.method) {
res.send(200);
}
else {
next();
}
});
app.use(express.json());
app.use(express.urlencoded());
// Load the config
app.use(function(req, res, next) {
req.config = config;
next();
winston.warning("Current Count: %d", ++counter);
});
orm.settings.set('connection.reconnect', true);
orm.settings.set('connection.pool', true);
app.use(orm.express(process.env.MYSQL_CONN_STR, models));
// Overload the res.send() function to handle custom logic
app.use(function(req, res, next) {
console.log("In overload send");
res._baseSend = res.send;
var newSend = function(status, body) {
res.set({
'X-Olaround-Debug-Mode': 'Header',
'X-Olaround-Served-With': 'node.js/uploads'
});
if (typeof body == "undefined") {
res._baseSend(status);
} else {
res._baseSend(status, body);
}
}
res.send = newSend;
next();
});
uploadMiddleware = [
express.multipart({keepExtensions: true, uploadDir: app.get('tempDir')}),
function(req, res, next) {
if (typeof req.files.image == "undefined") {
winston.error("No file attached for Picture Upload");
console.log(util.inspect(req.files, {colors: true, depth: 5}));
ErrorHelper.sendError(req, res, 400);
return new Error(req.files);
} else {
next();
}
}
];
// express-winston logger makes sense BEFORE the router.
app.use(expressWinston.logger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
})
]
}));
app.use(app.router);
// express-winston errorLogger makes sense AFTER the router.
app.use(expressWinston.errorLogger({
transports: [
new winston.transports.Console({
json: true,
colorize: true
})
]
}));
});