/**
* Sets up a Koa app instance.
* @param {Object} app A Koa app instance as created by `new Koa()`
* @return {Object} A node `http` server instance
*/
function bootstrap(app, options) {
var config = defaults({}, options, DEFAULT_CONFIGURATION);
var log = logger.get(options);
log.info('Starting and configuring Koa server');
// Setup global error handler and logger
app.use(error(config.error));
app.on('error', (error) => {
log.error('Unexpected exception ', error);
});
// Configure and setup middlewares
app.use(bodyParser());
app.use(morgan(config.morgan.format, config.morgan.options));
app.use(responseTime());
app.use(helmet(config.helmet));
app.use(compress({
flush: zlib.Z_SYNC_FLUSH
}));
app.use(conditional());
app.use(etag());
app.use(adapt(cacheControl(config.cacheControl)));
app.use(cors(config.cors));
app.use(favicon(config.favicon));
app.use(jwt(config.jwt.options).unless(config.jwt.unless));
app.use(json());
return app;
}
export function init(options = {}) {
const passport = initPassport(options.PassportStrategy)
return app.use(generatePrometheusMiddleware(router, {
ignore: [/^\/repository/]
}))
.use(generateProblemMiddleware({
exposableErrorTypes: [
CHECK_ERROR_TYPE,
GITHUB_ERROR_TYPE,
REPO_ERROR_TYPE
]
}))
.use(morgan(morganFormat, {skip: morganSkip}))
.use(convert(session({store: store})))
.use(bodyParser())
.use(passport.initialize())
.use(passport.session())
.use(compress())
.use(router.routes())
.use(router.allowedMethods())
.use(conditional())
.use(etag())
.use(serve(
nconf.get('STATIC_DIR'), {
index: 'none',
maxage: 1.7 * 10 ** 8 // ~ 2 days
}))
.use(ensureModeMiddleware)
.use(renderStatic)
}
export default (app) => {
const accessLogStream = fs.createWriteStream(
__dirname + '/../../logs/access.log',
{ flags: 'a' }
);
app.on('error', function(err, ctx){
console.error('server error', err, ctx);
});
app.use(morgan('combined', { stream: accessLogStream }));
};
export function init(options = {}) {
const passport = initPassport(options.PassportStrategy)
return app.
use(morgan(morganFormat, {skip: morganSkip})).
use(convert(session({store: store}))).
use(bodyParser()).
use(passport.initialize()).
use(passport.session()).
use(router.routes()).
use(router.allowedMethods()).
use(convert(serve(nconf.get('STATIC_DIR'), {index: 'none'}))).
use(renderStatic)
}
export default function configKoa(app) {
app.use(compress()); //app.use로 라이브러리 사용함
app.use(parser({ //json보낼때 인식못하는 것들을 자동으로 json으로 파싱?해주는것
multipart: true
}));
app.use((ctx, next) => { //14-17은 앱에서 서버로 api콜(get or post)을 보냈어
//클라이언트 -> 서버 :리퀘스트 서버-> 클라이언트 : reponse
ctx.body = ctx.request.body;
return next();
});
app.on('error', err => console.error(err)); //에러 발생하면 콘솔로 찍어주ㅝ
// function (err){
// console.error(err)
// }
app.use(morgan(config.dev.logType)); //로그남기는 라이브러리리리
}
'use strict';
// const Promise = require('bluebird');
// const co = Promise.coroutine;
const Compress = require('koa-compress');
const Morgan = require('koa-morgan');
const Promise = require('bluebird');
const co = Promise.coroutine;
const init = require('./init')();
// middleware
const Koa = require('koa');
const api = new Koa();
const logger = Morgan('combined');
api.use(co(function *(ctx, next) {
var allowedOrigins = ['http://localhost:3000', 'http://localhost:3001'];
var origin = ctx.headers.origin;
if(allowedOrigins.indexOf(origin) > -1){
ctx.set('Access-Control-Allow-Origin', origin);
}
// ctx.set('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
ctx.set('Access-Control-Allow-Methods', 'GET, OPTIONS');
ctx.set('Access-Control-Allow-Credentials', true);
yield next();
}));
api.use(Compress({
const prefix = '/<%= project %>';
//------------------------------------------------------------------------------
// App Setup
//------------------------------------------------------------------------------
// Setup
const app = new Koa();
const router = new Router({ prefix });
// Routes
routes.root(router);
// Middleware
app.use(middleware.response());
app.use(morgan('dev'));
app.use(bodyparser());
app.use(router.routes());
app.use(router.allowedMethods());
// Not found handler
app.use(async ctx => {
ctx.failure({ status: 404 });
});
//------------------------------------------------------------------------------
// Public Interface
//------------------------------------------------------------------------------
/**
* Start server
/**
* Returns a Koa application you can launch or mix into an existing app.
*
* @param [options] {object} - options
* @param [options.static] {object} - koa-static config
* @param [options.static.root=.] {string} - root directory
* @param [options.static.options] {string} - [options](https://github.com/koajs/static#options)
* @param [options.serveIndex] {object} - koa-serve-index config
* @param [options.serveIndex.path=.] {string} - root directory
* @param [options.serveIndex.options] {string} - [options](https://github.com/expressjs/serve-index#options)
* @param [options.forbid] {string[]} - A list of forbidden routes, each route being an [express route-path](http://expressjs.com/guide/routing.html#route-paths).
* @param [options.spa] {string} - specify an SPA file to catch requests for everything but static assets.
* @param [options.log] {object} - [morgan](https://github.com/expressjs/morgan) config
* @param [options.log.format] {string} - [log format](https://github.com/expressjs/morgan#predefined-formats)
* @param [options.log.options] {object} - [options](https://github.com/expressjs/morgan#options)
* @param [options.compress] {boolean} - Serve gzip-compressed resources, where applicable
* @param [options.mime] {object} - A list of mime-type overrides, passed directly to [mime.define()](https://github.com/broofa/node-mime#mimedefine)
* @param [options.rewrite] {module:local-web-server~rewriteRule[]} - One or more rewrite rules
* @param [options.verbose] {boolean} - Print detailed output, useful for debugging
*
* @alias module:local-web-server
* @return {external:KoaApplication}
* @example
* const localWebServer = require('local-web-server')
* localWebServer().listen(8000)
*/
function localWebServer (options) {
options = Object.assign({
static: {},
serveIndex: {},
spa: null,
log: {},
compress: false,
mime: {},
forbid: [],
rewrite: [],
verbose: false,
mocks: []
}, options)
if (options.verbose) {
process.env.DEBUG = '*'
}
const log = options.log
log.options = log.options || {}
if (options.verbose && !log.format) {
log.format = 'none'
}
if (!options.static.root) options.static.root = process.cwd()
if (!options.serveIndex.path) options.serveIndex.path = process.cwd()
options.rewrite = arrayify(options.rewrite)
options.forbid = arrayify(options.forbid)
options.mocks = arrayify(options.mocks)
const debug = require('debug')('local-web-server')
const Koa = require('koa')
const convert = require('koa-convert')
const cors = require('kcors')
const _ = require('koa-route')
const json = require('koa-json')
const bodyParser = require('koa-bodyparser')
const mw = require('./middleware')
const app = new Koa()
const _use = app.use
app.use = x => _use.call(app, convert(x))
/* CORS: allow from any origin */
app.use(cors())
/* pretty print JSON */
app.use(json())
/* rewrite rules */
if (options.rewrite && options.rewrite.length) {
options.rewrite.forEach(route => {
if (route.to) {
if (url.parse(route.to).host) {
debug('proxy rewrite', `${route.from} -> ${route.to}`)
app.use(_.all(route.from, mw.proxyRequest(route, app)))
} else {
const rewrite = require('koa-rewrite')
const rmw = rewrite(route.from, route.to)
rmw._name = 'rewrite'
app.use(rmw)
}
}
})
}
/* must come after rewrite. See https://github.com/nodejitsu/node-http-proxy/issues/180. */
app.use(bodyParser())
/* path blacklist */
if (options.forbid.length) {
debug('forbid', options.forbid.join(', '))
app.use(mw.blacklist(options.forbid))
}
/* cache */
if (!options['no-cache']) {
const conditional = require('koa-conditional-get')
const etag = require('koa-etag')
app.use(conditional())
app.use(etag())
}
/* mime-type overrides */
if (options.mime) {
debug('mime override', JSON.stringify(options.mime))
app.use(mw.mime(options.mime))
}
/* compress response */
if (options.compress) {
const compress = require('koa-compress')
debug('compression', 'enabled')
app.use(compress())
}
/* Logging */
if (log.format !== 'none') {
const morgan = require('koa-morgan')
if (!log.format) {
const streamLogStats = require('stream-log-stats')
log.options.stream = streamLogStats({ refreshRate: 500 })
app.use(morgan('common', log.options))
} else if (log.format === 'logstalgia') {
morgan.token('date', logstalgiaDate)
app.use(morgan('combined', log.options))
} else {
app.use(morgan(log.format, log.options))
}
}
/* Mock Responses */
options.mocks.forEach(mock => {
if (mock.module) {
mock.responses = require(path.resolve(path.join(options.static.root, mock.module)))
}
if (mock.responses) {
app.use(mw.mockResponses(mock.route, mock.responses))
} else if (mock.response) {
mock.target = {
request: mock.request,
response: mock.response
}
app.use(mw.mockResponses(mock.route, mock.target))
}
})
/* serve static files */
if (options.static.root) {
const serve = require('koa-static')
app.use(serve(options.static.root, options.static.options))
}
/* serve directory index */
if (options.serveIndex.path) {
const serveIndex = require('koa-serve-index')
app.use(serveIndex(options.serveIndex.path, options.serveIndex.options))
}
/* for any URL not matched by static (e.g. `/search`), serve the SPA */
if (options.spa) {
const send = require('koa-send')
debug('SPA', options.spa)
app.use(_.all('*', function spa (ctx, route, next) {
const root = path.resolve(options.static.root) || process.cwd()
return send(ctx, options.spa, { root: root }).then(next)
}))
}
return app
}