var server = (function() {
var server = restify.createServer({
formatters : {
'application/json' : function(req, res, body) {
res.setHeader('Server', 'CouchDB/1.0.1 (Erlang OTP/R13B)');
res.setHeader('Cache-Control', 'must-revalidate');
// Check if the client *explicitly* accepts application/json. If not, send text/plain
var sendPlainText = (req.header('Accept') !== undefined && req.header('Accept').split(/, */).indexOf('application/json') === -1);
if(sendPlainText) {
res.setHeader('Content-Type', 'text/plain; charset=utf-8');
}
return JSON.stringify(body,function(key, val) {
if (typeof val === 'function') {
return val.toString();
}
return val;
});
}
}
});
server.use(restify.bodyParser({ mapParams: false }));
server.pre(restify.pre.sanitizePath());
server.use(restify.queryParser());
if (options.keepAlive === false) {
server.pre(function preventKeepAlive(req, res, next) {
res.setHeader('Connection', 'close');
next();
});
}
return server;
}());
initialise: function(callback) {
console.log('Starting http notifier...');
server = restify.createServer({
name: 'SENTINAL.Watcher',
formatters: {
'application/json': function formatJSON(req, res, body) {
if (body instanceof Error) {
// snoop for RestError or HttpError, but don't rely on
// instanceof
res.statusCode = body.statusCode || 500;
if (body.body) {
body = body.body;
} else {
body = {
message: body.message
};
}
} else if (Buffer.isBuffer(body)) {
body = body.toString('base64');
}
var data;
if (req.params && typeof req.params.pretty !== 'undefined' && req.params.pretty !== false) {
data = JSON.stringify(body, null, 4);
}
else {
data = JSON.stringify(body);
}
res.setHeader('Content-Length', Buffer.byteLength(data));
return (data);
}
}
});
server.pre(restify.pre.sanitizePath());
server.listen(config.port, function () {
console.log('%s listening at %s', server.name, server.url)
});
server
.use(restify.fullResponse())
.use(restify.bodyParser())
.use(restify.queryParser());
server.get(/^\/currentStatus\/(.*)/, function(req, res, next) {
res.send(getSpecificStatus(req.params[0].split('/'), currentStatus));
});
server.get('/currentStatus', function(req, res, next) {
res.send(currentStatus);
});
callback();
},
return new Promise(function (resolve, reject) {
// Creating a server.
var server = restify.createServer({
log: app.log
});
server.pre(restify.pre.sanitizePath());
// Request logger.
server.use(restify.requestLogger());
// Setting general headers.
server.use(function (req, res, next) {
res.setHeader('Server', app.config.http.serverIdentity + '/' + app.package.version);
next();
});
// CORS.
if (app.config.cors && app.config.cors.enabled) {
var corsConfig = {};
if (app.config.cors.origins) {
corsConfig.origins = app.config.cors.origins;
}
if (app.config.cors.allowCredentials) {
corsConfig.credentials = app.config.cors.allowCredentials;
}
app.log.debug(
'CORS is enabled: ' + JSON.stringify(corsConfig)
);
server.use(restify.CORS(corsConfig));
}
// Query parser.
server.use(restify.queryParser({
mapParams: false
}));
// Body parser.
server.use(restify.bodyParser({
mapParams: false
}));
// Cookies.
server.use(restifyCookies.parse);
server.on('uncaughtException', function (req, res, route, error) {
req.log.error('Exception', error);
res.send(error);
});
global.app.server = server;
resolve();
})
var server = (function() {
var server = restify.createServer({
formatters : {
'application/json' : function(req, res, body) {
res.setHeader('Server', 'CouchDB/1.0.1 (Erlang OTP/R13B)');
return JSON.stringify(body);
}
}
});
server.use(restify.bodyParser({ mapParams: false }));
server.pre(restify.pre.sanitizePath());
server.use(restify.queryParser());
return server;
}());
exports.setUp = function( callback ) {
var restify = require( 'restify' );
this.server = restify.createServer({
name: 'test',
version: '0.0.0'
});
this.server.listen( 8888 );
this.server.use( restify.acceptParser( this.server.acceptable ) );
this.server.use( restify.pre.sanitizePath() );
callback();
};
export default (server) => {
// Configure Middleware that runs before routing
server.pre(version()); // Add semver versioning
server.pre(restify.pre.sanitizePath()); // eg. /label///// --> /label
// Configure middleware that runs on all routes
server.use(restify.gzipResponse());
server.use(restify.bodyParser());
server.use(restify.queryParser());
// if (config.env === 'dev') {
// // Put environment specific middleware here
// }
};
function createServer () {
var server = restify.createServer()
server.name = 'standardizer'
server.use(restify.plugins.bodyParser({mapParams: true}))
server.pre(cors.preflight)
server.use(cors.actual)
server.pre(restify.pre.userAgentConnection())
server.get('/version', version)
server.post('/lint', lint)
server.post('/fix', fix)
server.get('/', sendIndex)
return server
}
db.connect(options.mongo, function(err) {
if (err) {
if (log) {
log.error('Unable to connect to database! Error:', err);
}
process.exit(1);
} else {
if (log) {
log.info('Database connection established to', db.url);
}
var server = restify.createServer({
name: options.name,
log: log
});
server.pre(restify.pre.sanitizePath());
server.use(restify.plugins.authorizationParser());
server.use(restify.plugins.bodyParser({mapParams: true}));
server.use(restify.plugins.gzipResponse());
var cors = corsMiddleware({
origins: ['*']
});
server.pre(cors.preflight);
server.use(cors.actual);
var client = require('./clients/')(log, new httpClient(options, errors), sharedCache, scrapers);
var handler = require('./handlers/')(client, responses);
server.on('uncaughtException', handler.exception);
server.on('NotFound', handler.notFound);
server.on('MethodNotAllowed', handler.methodNotAllowed);
if (options.log.verbose) {
server.on('after', handler.logRequest);
}
// Dispatch routes
var controller = require('./controllers/')(log, client, db, responses);
routes(server, handler, controller);
server.listen(options.port, function () {
if (!log) {
return;
}
log.info(options.name + ' started listening at ' + server.url);
});
}
});
export default options => {
let server = restify.createServer()
server.pre(restify.pre.userAgentConnection())
server.use(restify.gzipResponse())
server.use(restify.CORS({
credentials: true
}))
server.get(/.*/, restify.serveStatic({
directory: __dirname,
default: 'index.html'
}))
return server
}
function addMiddleware(app) {
'use strict';
app.pre(restify.pre.sanitizePath());
app.pre(function(req, res, next) {
// req.log.info({req: req}, 'REQUEST');
next();
});
app.use(restify.acceptParser(app.acceptable));
app.use(restify.dateParser());
app.use(restify.queryParser());
app.use(restify.jsonp());
app.use(restify.bodyParser());
app.use(restify.CORS());
}
(function () {
"use strict";
var restify = require('restify'),
bunyan = require('bunyan'),
api = require('./controller/api.js');
// Get the environment variables we need.
var host = process.env.VCAP_APP_HOST || 'localhost';
var port = process.env.VCAP_APP_PORT || 3005;
var logger = bunyan.createLogger({
name: 'Mobile Sumobot',
streams: [
{
level: process.env.LOG_LEVEL || 'info',
stream: process.stdout
},
{
level: 'error',
stream: process.stderr
}
]
});
var server = restify.createServer({
name: 'Mobile Sumobot',
version: '0.0.1',
log: logger
});
logger.info("Starting up " + server.name + " " + server.version);
// Cleans up sloppy paths
server.pre(restify.pre.sanitizePath());
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
// Service API
server.get('/operate/:cmd', api.command);
server.listen(port, host, function () {
console.log('%s listening at %s', server.name, server.url);
});
})();
var startServer = function (callBack) {
// this line is a restify docs-provided hack to support curl as a client
server.pre(restify.pre.userAgentConnection());
server.get('/watchfile/:name', watchFileResponse);
server.head('/watchfile/:name', watchFileResponse);
server.get('/now/:name', getFileResponse)
server.head('/now/:name', getFileResponse)
server.listen(8080, function() {
console.log('%s listening at %s', server.name, server.url);
console.log('Current working directory is %s', process.cwd());
if (typeof process.send == 'function'){process.send('started');};
if (typeof callBack == 'function'){callBack();};
});
//Set the keep-alive timeout for all connections
server.addListener("connection",function(stream) {
stream.setTimeout(HTTP_KEEP_ALIVE_TIMEOUT_MSEC);
});
}
server.pre(function(req, res, next) {
var token = req.header('X-Session-Token', '')
res.header('Application-Type', 'application/json')
res.header('Access-Control-Allow-Credentials', true);
res.header('Access-Control-Allow-Headers', 'Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, Api-Version, Response-Time, X-Session-Token');
res.header('Access-Control-Allow-Methods', ['OPTIONS','GET', 'POST'].join(', '));
res.header('Access-Control-Allow-Origin', '*');
restify.pre.sanitizePath()
session.init(token)
console.log(session.isAuthenticated ? 'Authenticated: ' + session.isAuthenticated : 'NOT Authenticated')
if(session.isAuthenticated)
session.refreshIfNeeded(res, token)
return next()
})
.factoryFunction(function(cfg) {
var restify = require('restify'),
server = restify.createServer({
name: 'node-books'
});
server.pre(restify.pre.userAgentConnection());
server.use(restify.acceptParser(server.acceptable));
server.use(restify.authorizationParser());
server.use(restify.dateParser());
server.use(restify.queryParser());
server.use(restify.jsonp());
server.use(restify.gzipResponse());
server.use(restify.bodyParser());
server.port = cfg.configuration.restify.port;
Object.keys(cfg.routes).forEach(function(k) {
console.log('Registering routes: %s', k);
cfg.routes[k].register(server);
});
return server;
});
var restify = require('restify');
var http = require('http');
var https = require('https');
// Manual set `maxSockets` to 10 for limit concurrents
http.globalAgent.maxSockets = 10;
https.globalAgent.maxSockets = 10;
var addr = process.env['HOBBY_ADDR'] || '0.0.0.0';
var port = process.env['HOBBY_PORT'] || 3000;
var server = restify.createServer({
name: 'hobby',
version: '0.0.3',
});
server.pre(restify.pre.sanitizePath());
server.use(restify.acceptParser(server.acceptable));
server.use(restify.bodyParser({ mapParams: false }));
server.use(restify.requestLogger());
// Service
require('./lib/tasks').bootstrap();
// Routes
require('./routes')(server);
server.listen(port, addr, function () {
console.log('%s listening at %s', server.name, server.url);
});
}
util.inherits(TaskNotFoundError, restify.RestError);
/**
* Our Server
*/
var server = restify.createServer({
name: "Windows Azure Active Directroy TODO Server",
version: "2.0.1"
});
// Ensure we don't drop data on uploads
server.pre(restify.pre.pause());
// Clean up sloppy paths like //todo//////1//
server.pre(restify.pre.sanitizePath());
// Handles annoying user agents (curl)
server.pre(restify.pre.userAgentConnection());
// Set a per request bunyan logger (with requestid filled in)
server.use(restify.requestLogger());
// Allow 5 requests/second by IP, and burst to 10
server.use(restify.throttle({
burst: 10,
rate: 5,
ip: true,
///--- API
/**
* Wrapper over restify's createServer to make testing and
* configuration handling easier.
*
* The returned server object will have a '.start()' method on it, which
* wraps up the port/host settings for you.
*
* @arg {object} options - options object.
* @arg {string} options.file - configuration file to read from.
* @arg {object} options.log - bunyan logger.
* @arg {function} callback - of the form f(err, server).
* @throws {TypeError} on bad input.
*/
function createServer(options, clearProxy) {
assert.object(options, 'options');
assert.object(options.log, 'options.log');
options.formatters = {
'application/json': formatJSON,
'text/plain': formatJSON,
'application/octet-stream': formatJSON,
'application/x-json-stream': formatJSON,
'*/*': formatJSON
};
options.noWriteContinue = true;
options.handleUpgrades = true;
var log = options.log.child({
component: 'HttpServer'
}, true);
var server = restify.createServer(options);
var _timeout = parseInt((process.env.SOCKET_TIMEOUT || 120), 10) * 1000;
server.server.setTimeout(_timeout, function onTimeout(socket) {
var l = (((socket._httpMessage || {}).req || {}).log || log);
var req = socket.parser && socket.parser.incoming;
var res = socket._httpMessage;
if (req && req.complete && res) {
l.warn('socket timeout: destroying connection');
options.dtrace_probes.socket_timeout.fire(function onFire() {
var dobj = req ? {
method: req.method,
url: req.url,
headers: req.headers,
id: req._id
} : {};
return ([dobj]);
});
socket.destroy();
}
});
server.pre(function stashPath(req, res, next) {
req._probes = options.dtrace_probes;
req.config = options;
req.pathPreSanitize = url.parse(req.url).pathname;
next();
});
server.pre(restify.pre.sanitizePath());
server.pre(function cleanupContentType(req, res, next) {
var ct = req.headers['content-type'];
/* JSSTYLED */
if (ct && !/.*\/.*/.test(ct))
req.headers['content-type'] = mime.lookup(ct);
next();
});
server.pre(function routeLiveJobs(req, res, next) {
var tmp = JOBS_ROOT_RE.exec(req.path());
if (tmp && tmp.length > 1 && JOBS_LIVE_RE.test(req.query()))
req._path = '/' + tmp[1] + '/jobs/live';
next();
});
// set up random stuff
other.mount(server);
server.use(common.earlySetupHandler(options));
server.use(restify.dateParser(options.maxRequestAge || 300));
server.use(restify.queryParser());
server.use(restify.authorizationParser());
server.use(auth.checkIfPresigned);
server.use(common.enforceSSLHandler(options));
server.use(function ensureDependencies(req, res, next) {
var ok = true;
if (!options.picker()) {
req.log.error('picker unavailable');
ok = false;
} else if (!options.moray()) {
req.log.error('index moray unavailable');
ok = false;
} else if (!options.mahi()) {
req.log.error('mahi unavailable');
ok = false;
} else if (!options.marlin()) {
req.log.error('marlin unavailable');
ok = !req.isMarlinRequest();
} else if (!options.medusa()) {
req.log.error('medusa unavailable');
ok = !req.isMedusaRequest();
}
if (!ok) {
next(new ServiceUnavailableError());
} else {
next();
}
});
server.use(auth.authenticationHandler({
log: log,
mahi: options.mahi,
keyapi: options.keyapi
}));
server.use(auth.gatherContext);
server.use(common.setupHandler(options));
// Compute jobs
server.post({
path: '/:account/jobs',
name: 'CreateJob'
}, jobs.createHandler());
server.get({
path: '/:account/jobs/live',
name: 'ListJobs'
}, jobs.listHandler());
server.get({
path: '/:account/jobs/:id/live/status',
name: 'GetJobStatus',
authAction: 'getjob'
}, jobs.getHandler());
server.post({
path: '/:account/jobs/:id/live/cancel',
name: 'PostJobCancel',
authAction: 'managejob'
}, jobs.cancelHandler());
server.get({
path: '/:account/jobs/:id/live/err',
name: 'GetJobErrors',
authAction: 'getjob'
}, jobs.getErrorsHandler());
server.get({
path: '/:account/jobs/:id/live/fail',
name: 'GetJobFailures',
authAction: 'getjob'
}, jobs.getFailuresHandler());
server.post({
path: '/:account/jobs/:id/live/in',
name: 'PostJobInput',
authAction: 'managejob'
}, jobs.addInputHandler());
server.get({
path: '/:account/jobs/:id/live/in',
name: 'GetJobInput',
authAction: 'getjob'
}, jobs.getInputHandler());
server.post({
path: '/:account/jobs/:id/live/in/end',
name: 'PostJobInputDone',
authAction: 'managejob'
}, jobs.endInputHandler());
server.get({
path: '/:account/jobs/:id/live/out',
name: 'GetJobOutput',
authAction: 'getjob'
}, jobs.getOutputHandler());
server.get({
path: '/:account/medusa/attach/:id/:type',
name: 'MedusaAttach',
authAction: 'mlogin'
}, medusa.getMedusaAttachHandler());
server.use(common.getMetadataHandler());
server.use(auth.storageContext);
server.use(auth.authorizationHandler());
// Tokens
server.post({
path: '/:account/tokens',
name: 'CreateToken'
}, auth.postAuthTokenHandler());
// Data plane
server.get({path: '/:account/jobs', name: 'ListJobs'},
common.getMetadataHandler(),
common.ensureEntryExistsHandler(),
common.assertMetadataHandler(),
dir.getDirectoryHandler());
// Root dir
server.get({
path: '/:account',
name: 'GetRootDir',
authAction: 'getdirectory'
}, dir.rootDirHandler());
server.head({
path: '/:account',
name: 'HeadRootDir',
authAction: 'getdirectory'
}, dir.rootDirHandler());
server.put({
path: '/:account',
name: 'PutRootDir',
authAction: 'putdirectory'
}, dir.rootDirHandler());
server.post({
path: '/:account',
name: 'PostRootDir'
}, dir.rootDirHandler());
server.del({
path: '/:account',
name: 'DeleteRootDir',
authAction: 'deletedirectory'
}, dir.rootDirHandler());
Object.keys(common.StoragePaths).forEach(function (k) {
var _p = common.StoragePaths[k].regex;
var _n = common.StoragePaths[k].name;
// Otherwise in audit/dtrace we'll see GetStorageStorage
if (_n === 'Storage')
_n = '';
server.put({
path: _p,
name: 'Put' + _n + 'Directory',
contentType: 'application/json; type=directory',
authAction: 'putdirectory'
}, dir.putDirectoryHandler());
server.put({
path: _p,
name: 'Put' + _n + 'Link',
contentType: 'application/json; type=link',
authAction: 'putlink'
}, link.putLinkHandler());
server.put({
path: _p,
name: 'Put' + _n + 'Object',
contentType: '*/*',
authAction: 'putobject'
}, obj.putObjectHandler());
server.opts({
path: _p,
name: 'Options' + _n + 'Storage'
}, // common.ensureEntryExistsHandler(),
// common.assertMetadataHandler(),
other.corsHandler());
server.get({
path: _p,
name: 'Get' + _n + 'Storage'
}, common.ensureEntryExistsHandler(),
common.assertMetadataHandler(),
dir.getDirectoryHandler(),
obj.getObjectHandler());
server.head({
path: _p,
name: 'Head' + _n + 'Storage'
}, common.ensureEntryExistsHandler(),
common.assertMetadataHandler(),
dir.getDirectoryHandler(),
obj.getObjectHandler());
server.del({
path: _p,
name: 'Delete' + _n + 'Storage'
}, common.ensureEntryExistsHandler(),
common.assertMetadataHandler(),
dir.deleteDirectoryHandler(),
obj.deleteObjectHandler());
});
var _audit = audit.auditLogger({
log: log
});
server.on('uncaughtException', function (req, res, route, err) {
if (!res._headerSent)
res.send(err);
_audit(req, res, route, err);
});
server.on('after', _audit);
return (server);
}
'use strict';
var restify = require('restify');
var sletatru = require('./interface');
var utils = require('./utils');
// HTTP Server
var server = restify.createServer({
name: 'SletatRuREST',
version: '0.1.1'
});
server.pre(restify.pre.sanitizePath()); // trailing slashes
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
server.get('/:requestId/', function (req, res, next) { // Django ResultsView
var requestId = Number(req.params['requestId']);
var start, end, page = Number(req.query.page);
var celeryClient = utils.getCeleryClient();
var redisClient = utils.getRedisClient();
if (isNaN(page) || page == 1) {
sletatru.checkStatus(requestId, function (requestId) {
sletatru.getResults(requestId, function (tours) {
if (tours['RowsCount'] == 0) {
res.send({
var restify = require('restify');
var server = restify.createServer({
name: 'CER Web Service',
versions: ['1.0.0']
});
server.use(restify.pre.userAgentConnection()); // work around for curl
server.use(restify.acceptParser(server.acceptable));
server.use(restify.queryParser());
server.use(restify.bodyParser());
// static files: /, /index.html, /images...
server.get(/^\/((.*)(\.)(.+))*$/, restify.serveStatic({ directory: 'public', default: "index.html" }));
// testing the service
server.get('/test', function (req, res, next) {
res.send("testing...");
next();
});
server.listen(5000, function () {
console.log('%s listening at %s', server.name, server.url);
});
server.listen(port, function(err){
should(err).be.not.ok;
var logger = index.createRestifyLogger(server,{logs:tmpdir});
should(logger).be.an.object;
should(logger.info).be.a.function;
_console.on('data',function(buf){
should(buf).be.equal('INFO | hello');
});
_console.start();
try {
logger.info('hello');
server.log.info('hello');
}
finally {
_console.stop();
}
server.pre(restify.pre.sanitizePath())
.pre(restify.pre.userAgentConnection())
.use(restify.fullResponse())
.use(restify.bodyParser())
.use(restify.gzipResponse())
.use(restify.queryParser());
server.get('/echo', function(req,resp,next){
resp.send({hello:'world'});
next();
});
var client = restify.createJsonClient({
url: 'http://localhost:'+port
});
client.get('/echo', function (err, req, res, obj) {
should(err).not.be.ok;
should(obj).be.an.object;
should(obj).eql({hello:'world'});
should(res.headers).be.an.object;
should(res.headers['request-id']).be.a.string;
var reqid = res.headers['request-id'];
var files = fs.readdirSync(tmpdir);
should(files).be.an.array;
should(files).have.length(2);
var fn = path.join(tmpdir, files.filter(function(fn){
return fn!=='requests.log';
})[0]);
var logfn = fn;
// validate that the request has the right info
var contents = JSON.parse(fs.readFileSync(fn).toString());
should(contents).be.an.object;
should(contents).have.property('name',files[0].replace(/\.log$/,''));
should(contents).have.property('req_id',reqid);
should(contents).have.property('req');
should(contents).have.property('res');
should(contents).have.property('start',true);
should(contents).have.property('ignore',true);
should(contents).have.property('msg','start');
should(contents).have.property('level',30);
// now validate that our request is logged that points to our
// request log
fn = path.join(tmpdir, 'requests.log');
contents = JSON.parse(fs.readFileSync(fn).toString());
should(contents).be.an.object;
should(contents).have.property('name',files[0].replace(/\.log$/,''));
should(contents).have.property('req_id',reqid);
should(contents).have.property('req');
should(contents).not.have.property('res');
should(contents).have.property('msg','');
should(contents).have.property('level',30);
should(contents).have.property('logname',logfn);
callback();
});
});
var createServer = module.exports.createServer = function(options) {
assert.object(options);
assert.object(options.log);
assert.string(options.dbconn);
// connect to db
mongoose.connect(options.dbconn);
// start up server
var server = restify.createServer({
log: options.log,
name: 'village-api',
version: '1.0.0'
});
server.pre(restify.pre.sanitizePath());
server.pre(restify.pre.userAgentConnection());
server.use(restify.requestLogger());
server.use(restify.acceptParser(server.acceptable));
server.use(restify.dateParser());
server.use(restify.authorizationParser());
server.use(restify.queryParser());
server.use(restify.gzipResponse());
server.use(restify.bodyParser());
// auth
// todo - grab creds first
// pass to authentication
server.use(auth.authenticate);
server.use(crossOrigin);
server.opts('.*', handleOptions);
// set up routes
initRoutes(server, [
{ url: '/families', model: models.Family },
{ url: '/students', model: models.Student },
{ url: '/config', model: models.Config }
], options);
// default / handler
server.get('/', function root(req, res, next) {
res.send(200, 'ok');
next();
});
// Setup an audit logger
if (!options.noAudit) {
server.on('after', restify.auditLogger({
body: true,
log: bunyan.createLogger({
level: 'info',
name: 'village-api-audit',
stream: process.stdout
})
}));
}
return (server);
};
function main()
{
mazLog = new mod_bunyan({
'name': mazServerName,
'level': 'debug'
});
if (process.argv.length < 3)
usage();
mod_panic.enablePanicOnCrash({
'skipDump': true,
'abortOnPanic': true
});
/*
* Set up connection to our parent, the global zone agent.
*/
mazUdsPath = process.argv[2];
mazLog.info('using client url "%s"', mazUdsPath);
mazClient = mod_restify.createJsonClient({
'socketPath': mazUdsPath,
'log': mazLog,
'retry': false
});
mazClient.agent = false;
mazClientRequests = {};
mazMantaClient = mod_manta.createClient({
'socketPath': mazUdsPath,
'log': mazLog,
'retry': false,
'sign': mod_mautil.mantaSignNull
});
/*
* Set up the process contract template.
*/
mod_contract.set_template(mazContractTemplate);
/*
* Construct default path.
*/
var base = mod_path.normalize(mod_path.join(__dirname, '../..'));
mazTaskPath = [
mod_path.join(base, 'ubin'),
'/opt/local/bin',
'/opt/local/sbin',
process.env['PATH']
].join(':');
/*
* Set up restify server for the in-zone Task Control API.
*/
mazServer = mod_restify.createServer({
'name': mazServerName,
'noWriteContinue': true,
'log': mazLog.child({
'component': 'LackeyHttpServer',
'serializers': mod_restify.bunyan.serializers
}),
'version': ['1.0.0']
});
mod_http.globalAgent.maxSockets = mazHttpSockets;
mazServerRequests = {};
mazServer.pre(mod_restify.pre.sanitizePath());
mazServer.use(mod_restify.requestLogger());
mazServer.use(function trackRequest(request, response, next) {
mazServerRequests[request['id']] = request;
next();
});
mazServer.use(mod_restify.queryParser());
mazServer.on('uncaughtException', mod_mautil.maRestifyPanic);
mazServer.on('after', mod_restify.auditLogger({ 'log': mazLog }));
mazServer.on('after', function (request, response) {
delete (mazServerRequests[request['id']]);
});
mazServer.on('error', function (err) {
mazLog.fatal(err, 'failed to start server: %s', err.mesage);
process.exit(1);
});
/*
* All incoming requests are just proxied directly to our parent agent.
*/
/* BEGIN JSSTYLED */
mazServer.get(/.*/, mazApiProxy);
mazServer.put(/.*/, mazApiProxy);
mazServer.post(/.*/, mazApiProxy);
mazServer.del(/.*/, mazApiProxy);
mazServer.head(/.*/, mazApiProxy);
/* END JSSTYLED */
/*
* Figure out whether we've executed the zone initialization script yet.
* There are three possibilities:
*
* - the "done" file exists, in which we don't need to do anything
*
* - the "running" file exists, in which case we crashed while the
* script was running, and the zone is in an undefined state
*
* - neither exists, in which case we just need to make sure to run
* the "init" script when we pick up our first task
*/
if (mod_fs.existsSync(mazInitStarted))
mazInitUndefined = true;
else if (mod_fs.existsSync(mazInitDone))
mazInitHasRun = true;
/*
* Create our output directory, start up the in-zone HTTP server, then
* ask our parent for work to do.
*/
mod_vasync.pipeline({
'funcs': [
function cleanupCores(_, callback) {
mazCleanupCores(callback);
},
function mkOutputDir(_, callback) {
mod_fs.mkdir(mazOutputDir, function (err) {
if (err && err['code'] == 'EEXIST')
err = null;
callback(err);
});
},
function mkCoreDir(_, callback) {
mod_fs.mkdir(mazCoreDir, function (err) {
if (err && err['code'] == 'EEXIST')
err = null;
callback(err);
});
},
function runCoreadm(_, callback) {
mod_child.execFile('coreadm', [ '-p',
mod_path.join(mazCoreDir, mazCorePattern),
process.pid ],
function (err, stdout, stderr) {
if (err)
err = new VError(err,
'coreadm failed: stderr = "%s"',
stderr);
callback(err);
});
},
function startListening(_, callback) {
mazServer.listen(mazPort, function () {
mazLog.info('server listening on port %d',
mazPort);
callback();
});
}
]
}, function (err) {
if (err) {
mazLog.fatal(err,
'initialization failed (dumping core)');
process.abort();
}
mazTaskFetch();
});
}
common.query(f, fields, sort, start, size, function (the_callback) {
callback(the_callback);
})
}
}
};
//Initialize express app
var app = restify.createServer({
formatters: {
'application/javascript': formatJSONP
}
});
app.pre(restify.pre.userAgentConnection());
app.pre(restify.pre.sanitizePath());
//redirect(app);
//Middlewares
app.use(jsonpParser);
app.use(function (req, res, next) {
res.header('Access-Control-Allow-Origin', '*');
next();
});
app.use(restify.queryParser());
app.use(restify.bodyParser())
//Include api handlers
require('./v3')(app, db, common);
/*
* hmmac
* https://github.com/cmawhorter/hmmac
*
* Copyright (c) 2014 Cory Mawhorter
* Licensed under the MIT license.
*/
var restify = require('restify');
var server = restify.createServer();
server.pre(restify.pre.pause());
// timeout requests
server.use(function(req, res, next) {
next();
res.timeoutFn = setTimeout(function() {
if (!res.finished) res.end();
}, 30000);
});
// we're done. clear timeout.
server.on('after', function(req, res, route, err) {
if (res.timeoutFn) clearTimeout(res.timeoutFn);
});
server.use(restify.acceptParser(server.acceptable));
server.use(restify.dateParser());
server.use(restify.jsonp());
server.use(restify.gzipResponse());
module.exports.init = function(){
var admin;
var app;
var api;
var paths;
//load and apply configuration
var _applyConfig = function(){
var configFilePath = path.join(process.cwd(),'files','config');
nconf.file('config', path.join(configFilePath, 'config.json'));
nconf.file('defaults', path.join(__dirname, 'defaults.json'));
admin = nconf.get('admin');
app = nconf.get('app');
api = nconf.get('api');
paths = nconf.get('paths');
if(!fs.existsSync(path.join(configFilePath,'config.json'))){
utils.mkdirRecursive(configFilePath);
nconf.remove('defaults');
nconf.set('admin', JSON.parse(JSON.stringify(admin)));
nconf.set('app', JSON.parse(JSON.stringify(app)));
nconf.set('api', JSON.parse(JSON.stringify(api)));
nconf.set('paths', JSON.parse(JSON.stringify(paths)));
nconf.save();
}
if(app.key) app.key = path.join(process.cwd(), app.key);
if(app.cert) app.cert = path.join(process.cwd(), app.cert);
if(app.ca) app.ca = path.join(process.cwd(), app.ca);
paths.dbPath = path.join(process.cwd(), paths.dbPath);
paths.backupPath = path.join(process.cwd(), paths.backupPath);
paths.tasksPath = path.join(process.cwd(), paths.tasksPath);
paths.templatesPath = path.join(process.cwd(), paths.templatesPath);
paths.staticsPath = path.join(process.cwd(), paths.staticsPath);
};
_applyConfig();
//configure and start HTTPS/SSL server
var _applyServer = function(){
var options = { name: 'subkit microservice', version: subkitPackage.version };
if(!process.env.NODE_ENV) process.env.NODE_ENV = 'development';
if(app.key && fs.existsSync(app.key)) options.key = fs.readFileSync(app.key);
if(app.cert && fs.existsSync(app.cert)) options.certificate = fs.readFileSync(app.cert);
if(app.ca && fs.existsSync(app.ca)) options.ca = fs.readFileSync(app.ca);
var srv = restify.createServer(options);
srv.listen(app.port, function(){
logger.log('Subkit micro-service (V'+subkitPackage.version+') listen.');
logger.log('ENVIRONMENT: '+process.env.NODE_ENV);
logger.log('SECURE: '+srv.secure);
logger.log('PORT: '+srv.address().port);
logger.log('PID: '+process.pid);
});
return srv;
};
var server = _applyServer();
server.formatters['text/html'] = require('restify-formatter-text');
server.acceptable.push('text/html');
//middleware
server.pre(restify.pre.sanitizePath());
server.pre(restify.pre.userAgentConnection());
server.use(restify.fullResponse());
server.use(restify.CORS({
origins: ['*'],
credentials: true,
headers: ['authorization','content-type','x-auth-token','x-subkit-event-persistent', 'x-subkit-event-metadata', 'x-subkit-event-webhook','x-subkit-event-filter','x-subkit-event-apikey']
}));
server.use(restify.authorizationParser());
server.use(restify.bodyParser({ mapParams: true }));
server.use(restify.queryParser());
server.use(restify.throttle({ burst: 100, rate: 900, ip: true }));
//handle CORS
server.opts(/\.*/, function (req, res, next) {
res.header('Access-Control-Allow-Origin', '*');
res.header('Access-Control-Allow-Methods','GET, POST, PUT, DELETE, HEAD, OPTION');
res.header('Access-Control-Allow-Headers', 'authorization, content-type, x-auth-token, x-subkit-event-persistent, x-subkit-event-metadata, x-subkit-event-webhook, x-subkit-event-filter, x-subkit-event-apikey');
res.send(200);
return next();
});
//modules
var storage = require('./lib/store.module.js').init(paths, logger);
var event = require('./lib/event.module.js').init({}, storage, logger);
var share = require('./lib/share.module.js').init({}, logger);
var file = require('./lib/file.module.js');
var es = require('./lib/eventsource.module.js').init(storage, event);
var template = require('./lib/template.module.js');
var task = require('./lib/task.module.js').init(paths, storage, event, es, template.init(paths, logger), file.init(paths, logger), logger);
var identity = require('./lib/identity.module.js');
//handle access
var usersIdent = identity.init(null, storage, logger);
server.use(function(req, res, next){
var apikey = req.headers['x-auth-token'] || req.params.apikey || req.params.api_key;
var token = null;
if(api.apiKey === apikey) {
logger.log('authorized', {apikey: apikey });
return next();
}
if((req.authorization)
&& (req.authorization.basic)
&& (req.username === admin.username)
&& (utils.validate(admin.password, req.authorization.basic.password))){
logger.log('authorized', { username: req.username || 'none'});
return next();
}
if(!apikey && req.username && req.authorization && req.authorization.basic && req.authorization.basic.password){
apikey = req.username;
token = req.authorization.basic.password;
}
usersIdent.validate(apikey,token,function(error, user){
//check share access
var cleanupUrl = req.url.indexOf('?') !== -1 ? req.url.substr(0, req.url.indexOf('?')) : req.url;
var urlParts = cleanupUrl.split('/');
var shareIdent = '';
for (var i = 1; i < urlParts.length; i++) {
shareIdent = shareIdent + '/' + urlParts[i];
var shareItem = share.list()[shareIdent];
if(shareItem){
var username = null;
if(user) username = user.id;
else username = req.username;
if(shareItem[req.method].indexOf(username) !== -1){
logger.log('authorized', {apikey: apikey || 'none', token: token || 'none', username: username || 'none'});
return next();
}
if(user && user.groups){
for (var p = 0; p < user.groups.length; p++) {
var group = user.groups[p];
if(shareItem[req.method].indexOf(group) !== -1){
logger.log('authorized', {apikey: apikey || 'none', token: token || 'none', username: username || 'none'});
return next();
}
}
}
}
}
logger.log('Unauthorized', {apikey: apikey || 'none', token: token || 'none'});
res.send(401, new Error('Unauthorized'));
});
});
//handle message streams
require('./routes/event.js').init(server, event, logger, nconf);
//starts the tasks scheduler
task.runScheduler(true);
//plugins
var pluginContext = {
plugins: subkitPackage.optionalDependencies,
server: server,
configuration: nconf,
util: utils,
storage: storage,
permission: share,
event: event,
eventSource: es,
file: file,
template: template,
task: task,
identity: identity,
logger: logger,
serve: restify.serveStatic
};
var plugin = require('./lib/plugin.module.js').init(pluginContext, logger);
plugin.loadAll();
//middleware
server.use(restify.acceptParser(server.acceptable));
server.use(restify.dateParser());
server.use(restify.gzipResponse());
//starts external API
require('./routes/manage.js').init(nconf, _applyConfig, server, _applyServer, storage, plugin, share, logger, subkitPackage.version);
require('./routes/store.js').init(server, storage);
require('./routes/task.js').init(server, task);
return {
getContext: function(){
return pluginContext;
}
};
};
Server.prototype.start = function(serverConf) {
checkConf();
var self = this;
var restify = require('restify');
// user can override the conf with param serverConf
var c = _.extend({}, require('./conf').get(), serverConf);
// create the restify server
var server = restify.createServer({
name: c['name'] || 'raskapp',
log: require('bunyan').createLogger(c['bunyan'])
});
this._server = server;
// wrap server functions to show 'register POST /asyncJob/query' like msg in log
wrapServerFunctions(server);
// disable curl default keep-alive
server.pre(restify.pre.userAgentConnection());
// allow cross domain access
if (this.options['allowCrossDomain']) {
server.pre(function(req, res, next) {
res.header('Access-Control-Allow-Origin', '*');
return next();
});
}
// enable auth check
if (this.options['enableAuthCheck']) {
var ac = require('./authCheck').init(server);
if (_.isFunction(this.options['enableAuthCheck'])) {
server.use(this.options['enableAuthCheck']);
} else {
server.use(ac.getDefaultChecker(server, c));
}
}
// auto parse query
if (this.options['allowParseQuery']) {
server.use(restify.queryParser());
}
// auto parse body
if (this.options['allowParseBody']) {
server.use(restify.bodyParser({ mapParams: false }));
}
// enable cookie
if (this.options['enableCookie']) {
server.use(require('./cookie').cookieParser());
}
// enable session
if (this.options['enableSession']) {
require('./session').init();
}
// enable preRouteHooks
if (this.preRouteHooks.length > 0) {
this.preRouteHooks.forEach(function(f) {
server.use(f);
});
}
// route map
if (this.rr) {
this.rr(server);
this.rr = null;
}
// enable async job support
if (this.options['enableAsyncJob']) {
require('./asyncJob').init().register(server);
}
// enable xact job support
if (this.options['enableXactJob']) {
require('./xactJob').init();
}
// enable ping server
if (this.options['enablePing']) {
require('./ping').register(server);
}
// gzip
if (this.options['enableGzip']) {
server.use(restify.gzipResponse());
}
// serve static
if (this.options['serveStatic']) {
var ss = require('./serveStatic');
if (_.isFunction(this.options['serveStatic'])) {
ss.register(server, this.options['serveStatic']);
} else {
ss.register(server);
}
}
// copy from restify source, for better uncaughtException reporting
server.on('uncaughtException', function (req, res, route, e) {
self.emit('serverInternalError', route, e);
log.error('uncaughtException:');
log.error(' route=', route);
log.error(' err=', e);
// try our best here, since the client connection may be lost
try {
res.send(200, { errno: 'InternalError', message: e.message });
} catch(e) {
// client connection is lost, nothing can do
log.error('client connection lost, report error back skipped.');
}
return true;
});
// now start listening
if (c['bind_sock']) {
server.listen(c['bind_sock'], function() {
log.info('%s listening at %s', server.name, c['bind_sock']);
});
} else {
// generate a port if specified random
if (c['bind_port'] === 'random') {
// random port range [10000, 60000)
this._bind_port = Math.floor((Math.random() * 60000) + 10000);
}
server.listen(this._bind_port || parseInt(c['bind_port']) || 12345, c['bind_host'] || '0.0.0.0', function() {
log.info('%s listening at %s', server.name, server.url);
});
}
// WebSocket
if (this.options['enableWebSocket']) {
this._wsServer = new (require('ws').Server)({ server: this._server });
if (this.wsrr) {
this.wsrr(this._wsServer);
this.wsrr = null;
}
}
this.emit('serverStarted');
// in test mode, we keep record of our last server
if (require('./test').testMode) {
require('./test').lastServer = this;
}
return this;
};
var setup_server = function (server) {
server.pre(restify.pre.userAgentConnection());
server.use(restify.bodyParser({mapParams: false}));
server.use(restify.queryParser());
server.use(restify.CORS());
server.use(restify.fullResponse());
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
server.get('/', function(req, res) {
console.log(req);
res.send('It works!');
});
server.get('/facebook', function(req, res) {
if (
req.params.hub.mode == 'subscribe' &&
req.params.hub.verify_token == 'token'
) {
res.setHeader('content-type', 'text/plain');
res.send(req.params.hub.challenge);
/*res.send(req.params.hub.challenge.toString());*/
} else {
res.send(400);
}
});
server.post('/facebook', function(req, res) {
console.log('Facebook request body:');
console.log(JSON.stringify(req.body));
// Process the Facebook updates here
//res.send(200);
fb.RealTimeUpdates(req.body);
res.end();
});
/* server.post('/webhook', function (req, res) {
var data = req.body;
// Make sure this is a page subscription
if (data.object === 'page') {
// Iterate over each entry - there may be multiple if batched
data.entry.forEach(function(entry) {
var pageID = entry.id;
var timeOfEvent = entry.time;
// Iterate over each messaging event
entry.messaging.forEach(function(event) {
if (event.message) {
receivedMessage(event);
} else {
console.log("Webhook received unknown event: ", event);
}
});
});
// Assume all went well.
//
// You must send back a 200, within 20 seconds, to let us know
// you've successfully received the callback. Otherwise, the request
// will time out and we will keep trying to resend.
res.sendStatus(200);
}
});
function receivedMessage(event) {
// Putting a stub for now, we'll expand it in the following steps
console.log("Message data: ", event.message);
}*/
server.post('/instagram', function(req, res) {
console.log('Instagram request body:');
console.log(req.body);
// Process the Instagram updates here
res.send(200);
});
};
server.on('MethodNotAllowed', function(req, res) {
if (req.method.toLowerCase() == "options") {
res.header('Access-Control-Allow-Headers', 'Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, Api-Version, Response-Time, X-Session-Token');
res.header('Access-Control-Allow-Credentials', true);
res.header('Access-Control-Allow-Headers', 'Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, Api-Version, Response-Time, X-Session-Token');
res.header('Access-Control-Allow-Methods', ['OPTIONS','GET', 'POST'].join(', '));
res.header('Access-Control-Allow-Origin', '*');
return res.send(204)
}else {
return res.send(405)
}
})
server.pre(restify.pre.userAgentConnection());
server.pre(function(req, res, next) {
var token = req.header('X-Session-Token', '')
res.header('Application-Type', 'application/json')
res.header('Access-Control-Allow-Credentials', true);
res.header('Access-Control-Allow-Headers', 'Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, Api-Version, Response-Time, X-Session-Token');
res.header('Access-Control-Allow-Methods', ['OPTIONS','GET', 'POST'].join(', '));
res.header('Access-Control-Allow-Origin', '*');
restify.pre.sanitizePath()
session.init(token)
console.log(session.isAuthenticated ? 'Authenticated: ' + session.isAuthenticated : 'NOT Authenticated')
///--- API
/**
* Returns a server with all routes defined on it
*/
function createServer(options) {
assert.object(options, 'options');
assert.string(options.directory, 'options.directory');
assert.object(options.log, 'options.log');
// Create a server with our logger and custom formatter
// Note that 'version' means all routes will default to
// 1.0.0
var server = restify.createServer({
formatters: {
'application/todo; q=0.9': formatTodo
},
log: options.log,
name: 'todoapp',
version: '1.0.0'
});
// Ensure we don't drop data on uploads
server.pre(restify.pre.pause());
// Clean up sloppy paths like //todo//////1//
server.pre(restify.pre.sanitizePath());
// Handles annoying user agents (curl)
server.pre(restify.pre.userAgentConnection());
// Set a per request bunyan logger (with requestid filled in)
server.use(restify.requestLogger());
// Allow 5 requests/second by IP, and burst to 10
server.use(restify.throttle({
burst: 10,
rate: 5,
ip: true,
}));
// Use the common stuff you probably want
server.use(restify.acceptParser(server.acceptable));
server.use(restify.dateParser());
server.use(restify.authorizationParser());
server.use(restify.queryParser());
server.use(restify.gzipResponse());
server.use(restify.bodyParser());
// Now our own handlers for authentication/authorization
// Here we only use basic auth, but really you should look
// at https://github.com/joyent/node-http-signature
server.use(function setup(req, res, next) {
req.dir = options.directory;
if (options.user && options.password) {
req.allow = {
user: options.user,
password: options.password
};
}
next();
});
server.use(authenticate);
/// Now the real handlers. Here we just CRUD on TODO blobs
server.use(loadTodos);
server.post('/todo', createTodo);
server.get('/todo', listTodos);
server.head('/todo', listTodos);
// everything else requires that the TODO exist
server.use(ensureTodo);
// Return a TODO by name
server.get('/todo/:name', getTodo);
server.head('/todo/:name', getTodo);
// Overwrite a complete TODO - here we require that the body
// be JSON - otherwise the caller will get a 415 if they try
// to send a different type
// With the body parser, req.body will be the fully JSON
// parsed document, so we just need to serialize and save
server.put({
path: '/todo/:name',
contentType: 'application/json'
}, putTodo);
// Delete a TODO by name
server.del('/todo/:name', deleteTodo);
// Destroy everything
server.del('/todo', deleteAll, function respond(req, res, next) {
res.send(204);
next();
});
// Register a default '/' handler
server.get('/', function root(req, res, next) {
var routes = [
'GET /',
'POST /todo',
'GET /todo',
'DELETE /todo',
'PUT /todo/:name',
'GET /todo/:name',
'DELETE /todo/:name'
];
res.send(200, routes);
next();
});
// Setup an audit logger
if (!options.noAudit) {
server.on('after', restify.auditLogger({
body: true,
log: bunyan.createLogger({
level: 'info',
name: 'todoapp-audit',
stream: process.stdout
})
}));
}
return (server);
}
exports.StartServer = function(startserver_callback, dbconnected_callback) {
var restify = require('restify'),
fs = require('fs'),
router = require('./routes/router'),
logger = require('./logger/logger'),
pinger = require('./utilities/pinger'),
hfConfig = require('./config/config.js');
logger.bunyanLogger().info("%s***** Starting hfapi web service *****", hfConfig.TAG);
if (_databaseName) hfConfig.setDatabaseName(_databaseName);
//
// HTTP server options
//
var http_options = {
name: "hfAPI HTTP",
log: hfConfig.useRestifyLogging ? logger.bunyanLogger() : null
}
//
// HTTPS server options
//
var https_options = hfConfig.usesHttps ? {
name: "hfAPI HTTPS",
key: fs.readFileSync('./certificates/ssl/self-signed/server.key'),
certificate: fs.readFileSync('./certificates/ssl/self-signed/server.crt'),
log: hfConfig.useRestifyLogging ? logger.bunyanLogger() : null
} : null;
// Instantiate the HTTP and HTTPS servers
var server = restify.createServer(http_options);
var https_server = hfConfig.usesHttps ? restify.createServer(https_options) : null;
// Error handlers
// BUGBUG - These should be updated to handle graceful shutdown of cluster
// per http://nodejs.org/api/domain.html.
server.on('uncaughtException', function(req, res, route, err) {
logger.bunyanLogger().error("%s*****Uncaught Exception*****: %s on route %s", hfConfig.TAG, err.message, route);
if (res._headerSent) {
return false;
}
res.send(new restify.InternalError("unexpected error"));
return true;
});
if (hfConfig.usesHttps) {
https_server.on('uncaughtException', function(req, res, route, err) {
logger.bunyanLogger().error("%s*****Uncaught Exception*****: %s on route %s", hfConfig.TAG, err.message, route);
if (res._headerSent) {
return false;
}
res.send(new restify.InternalError("unexpected error"));
return true;
});
}
//
// Pre-router callback.
//
function preRoutingHandler(req, res, next) {
return next();
}
server.use(restify.acceptParser(server.acceptable));
server.use(restify.authorizationParser());
server.use(restify.dateParser());
server.use(restify.queryParser());
server.use(restify.jsonp());
server.use(restify.gzipResponse());
server.use(restify.bodyParser());
// Check userAgent for curl. If it is, this sets the Connection header
// to "close" and removes the "Content-Length" header.
server.pre([restify.pre.userAgentConnection(), preRoutingHandler]);
if (hfConfig.usesHttps) {
https_server.use(restify.acceptParser(server.acceptable));
https_server.use(restify.authorizationParser());
https_server.use(restify.dateParser());
https_server.use(restify.queryParser());
https_server.use(restify.jsonp());
https_server.use(restify.gzipResponse());
https_server.use(restify.bodyParser());
https_server.pre([restify.pre.userAgentConnection(), preRoutingHandler]);
}
//
// Routes - see routes/router.js
//
for (var i = 0; i < router.routeMap.length; i++) {
var route = router.routeMap[i];
server[route.httpVerb](route.route, route.serverHandler);
if (hfConfig.usesHttps) {
https_server[route.httpVerb](route.route, route.serverHandler);
}
}
//
// Connect to the database
//
var isStartupConnectionAttempt = true;
function onDatabaseConnect(err) {
if (err && isStartupConnectionAttempt) {
// Re-attempt only if this is part of app startup. Otherwise, we rely on auto-reconnect in
// the mongodb native driver to try again.
logger.bunyanLogger().error('%sFailed to connect to MongoDB. Attempting to connect again. Err: %s', hfConfig.TAG, err.message);
setTimeout(connectWithRetry, 5000);
return;
}
else {
isStartupConnectionAttempt = false;
logger.bunyanLogger().info('%sMongoDB connection established', hfConfig.TAG);
if (dbconnected_callback) {
dbconnected_callback();
}
pinger.start();
}
}
function onDatabaseReconnect() {
logger.bunyanLogger().info('%sSuccessfully reconnected to MongoDB', hfConfig.TAG);
}
function onDatabaseDisconnect(err) {
if (isStartupConnectionAttempt) return;
logger.bunyanLogger().error('%sLost connection to MongoDB. Err: %s', hfConfig.TAG, err.message);
}
var connectWithRetry = function() {
logger.bunyanLogger().info('%sAttempting to connect to MongoDB. isStartupConnectionAttempt = %s', hfConfig.TAG, isStartupConnectionAttempt);
var connectionString = hfConfig.connectionString;
return hfConfig.dbUtils.connectToMongoDB(connectionString, hfConfig.databaseOptions, onDatabaseConnect, null, onDatabaseDisconnect, onDatabaseReconnect);
};
logger.bunyanLogger().info("%s*** Calling connectWithRetry", hfConfig.TAG);
connectWithRetry();
//
// Start the servers on the appropriate ports
//
server.listen(process.env.PORT || 1338 , function() {
logger.bunyanLogger().info('%s%s listening at %s in %s mode', hfConfig.TAG, server.name, server.url, hfConfig.environment);
logger.bunyanLogger().info("Using node.js %s", process.version);
if (hfConfig.usesHttps) {
https_server.listen(443, function() {
logger.bunyanLogger().info('%s%s listening at %s', hfConfig.TAG, https_server.name, https_server.url);
if (startserver_callback) {
startserver_callback();
}
});
}
else {
if (startserver_callback) {
startserver_callback();
}
}
});
};