return new Promise(function (resolve, reject) {
return Glue.compose(manifest, options, function (err, server) {
exports.ready(err, server, resolve, reject);
});
});
internals.startThemeEditor = function(options, callback) {
var themeEditorHost = 'http://localhost:' + options.stencilEditorPort;
var stencilEditorConfig = {
connections: [{
host: 'localhost',
port: options.stencilEditorPort
}],
plugins: {
'./plugins/StencilEditor': {
variationIndex: options.variationIndex,
stencilServerPort: options.dotStencilFile.stencilServerPort,
stencilEditorPort: options.stencilEditorPort,
themeEditorHost: themeEditorHost,
themeServer: options.themeServer
}
}
};
Glue.compose(stencilEditorConfig, {relativeTo: __dirname}, function (err, server) {
if (err) {
return callback(err);
}
server.start(function () {
console.log('Theme Editor:', themeEditorHost.cyan);
return callback();
});
});
};
exports.init = (manifest, options, next) => {
Glue.compose(manifest, options, (err, server) => {
if (err) {
return next(err);
}
server.on('request-error', (request, err) => {
const logData = {
event: 'onRequestError',
reqId: request.id,
ip: request.headers['x-forwarded-for'] || request.info.remoteAddress,
userAgent: request.headers['user-agent'],
reqPath: request.path,
error: err
};
logger('log', logData);
});
server.ext('onPreHandler', (request, reply) => {
const logData = {
event: 'onPreHandler',
reqId: request.id,
ip: request.headers['x-forwarded-for'] || request.info.remoteAddress,
userAgent: request.headers['user-agent'],
reqPath: request.path,
reqData: { query: request.query, params: request.params, payload: request.payload }
};
logger('log', logData);
return reply.continue();
});
server.on('response', (request) => {
try {
const responseData = JSON.stringify(Util.inspect(request.response.source));
const logData = {
event: 'onResponse',
reqId: request.id,
ip: request.headers['x-forwarded-for'] || request.info.remoteAddress,
userAgent: request.headers['user-agent'],
reqPath: request.path,
resData: responseData
};
logger('log', logData);
}
catch (e) {
logger('error', 'Server on response cannot parse output');
}
});
server.start((err) => {
return next(err, server);
});
});
};
exports.init = (manifest, options, next) => {
Glue.compose(manifest, options, (err, server) => {
if (err) {
return next(err);
}
const web = server.select('web');
const webTls = server.select('web-tls');
// TLS everything
web.ext('onRequest', (request, reply) => {
return reply.redirect(webTls.info.uri + request.url.path).permanent();
});
// Start the server
server.start((err) => {
return next(err, server);
});
});
};
module.exports = async () => {
try {
const server = await Glue.compose(
manifest,
options
);
return server;
} catch (error) {
// eslint-disable-next-line no-console
return console.warn(error);
}
};
exports.init = (manifest,options, next) => {
Glue.compose(manifest,options, (err,server) => {
if(err) {
return next(err)
}
server.start((err) => {
return next(err, server)
})
})
}
exports.init = (manifest, options, next) => {
Glue.compose(manifest, options, (err, server) => {
Hoek.assert(!err, err);
server.start((err) => {
// console.log(`✅ Hapi Days!`);
return next(err, server);
});
});
};
exports.init = function (manifest, composeOptions, next) {
Glue.compose(manifest, composeOptions, function (err, server){
if (err) {
return next(err);
}
server.start(function (err) {
return next(err, server);
});
});
};
const start = async () => {
try {
console.log("Composing server...")
server = await Glue.compose(
manifest,
{ relativeTo: Path.join(__dirname, "modules") }
)
console.log("Starting server...")
await server.start()
console.log(`Server running at: ${server.info.uri}`)
} catch (err) {
console.error(err)
process.exit(1)
}
}
module.exports = (callback) => {
Glue.compose(manifest, options, (err, server) => {
server.start(function (err) {
// API running on port 3000
if (err) throw err;
console.log('Server running at:', server.info.uri);
});
if (callback) {
callback(server);
}
});
};
internals.prepareServer = function (options, callback) {
const manifest = {
registrations: [
{ plugin: { register: '../', options: options } },
{ plugin: { register:'./plugins/blah.js', options: null } },
{ plugin: { register: './plugins/main.js', options: null } }
]
};
Glue.compose(manifest, { relativeTo: __dirname }, (err, server) => {
expect(err).to.not.exist();
return callback(err, server);
});
};
return new Promise((resolve, reject) => {
let options = {
relativeTo: __dirname
};
/**
* Load all plugins declared in manifest and start web-server with specified settings.
*/
Glue.compose(manifest, options,
(err, server) => {
if (err) {
throw err;
}
resolve(server);
});
});
return new Promise(function(resolve, reject) {
console.log("Starting server");
if (cachedServer) {
return resolve(cachedServer);
}
Glue.compose(AppConfig.manifest, glueOptions, function(err, serverInstance) {
if (err){ console.log("Glue Error!", err); return reject(err); }
cachedServer = serverInstance;
serverInstance.start(function(err, startedServer) {
if (err){
return reject(err);
} else {
console.log("Server started!");
}
resolve(cachedServer);
});
});
});
internals.loadPacks(manifest, function (err, options) {
if (err) {
console.error(err);
process.exit(1);
}
Glue.compose(manifest, options, function (err, server) {
Hoek.assert(!err, 'Failed loading plugins: ' + (err && err.message));
server.start(function (err) {
Hoek.assert(!err, 'Failed starting server: ' + (err && err.message));
// Use kill -s QUIT {pid} to kill the servers gracefully
process.once('SIGQUIT', function () {
server.stop(function () {
process.exit(0);
});
});
// Use kill -s SIGUSR2 {pid} to restart the servers
process.on('SIGUSR2', function () {
console.log('Stopping...');
server.stop(function () {
console.log('Starting...');
internals.start();
});
});
});
});
});
module.exports = () => {
let manifest = {
connections: [
config.server
],
registrations: [{
plugin: {
register: './db',
options: config
}
}]
};
Glue.compose(manifest, options, (err, server) => {
if (err) {
throw err;
}
server.start(() => {
console.log(`Server listning: ${server.info.uri}`);
});
});
};
module.exports = function(options, callback) {
var config = manifest.get('/'),
parsedSecureUrl = Url.parse(options.dotStencilFile.storeUrl), //The url to a secure page (prompted as login page)
parsedNormalUrl = Url.parse(options.dotStencilFile.normalStoreUrl); //The host url of the homepage;
callback = Hoek.nextTick(callback);
config.connections[0].port = options.dotStencilFile.port;
config.plugins['./plugins/router/router.module'].storeUrl = parsedSecureUrl.protocol + '//' + parsedSecureUrl.host;
config.plugins['./plugins/router/router.module'].normalStoreUrl = parsedNormalUrl.protocol + '//' + parsedNormalUrl.host;
config.plugins['./plugins/router/router.module'].apiKey = options.dotStencilFile.apiKey;
config.plugins['./plugins/router/router.module'].port = options.dotStencilFile.port;
config.plugins['./plugins/router/router.module'].staplerUrl = options.dotStencilFile.staplerUrl;
config.plugins['./plugins/renderer/renderer.module'].useCache = options.useCache;
config.plugins['./plugins/renderer/renderer.module'].username = options.dotStencilFile.username;
config.plugins['./plugins/renderer/renderer.module'].token = options.dotStencilFile.token;
config.plugins['./plugins/renderer/renderer.module'].customLayouts = options.dotStencilFile.customLayouts;
Glue.compose(config, {relativeTo: __dirname}, function (err, server) {
if (err) {
return callback(err);
}
server.start(function () {
console.log(logo);
if (options.stencilEditorEnabled) {
options.themeServer = server;
return internals.startThemeEditor(options, callback);
} else {
return callback(null, server);
}
});
});
};
exports.init = (manifest, options, next) => {
Glue.compose(manifest, options, (err, server) => {
Hoek.assert(!err, err);
//== Add `onRequest` handling
server.ext({
type: 'onRequest',
method: (request, reply) => {
// const scoot = request.plugins.scooter.toJSON();
// const useragent = {
// browser: `${scoot.family} v${scoot.major}.${scoot.minor}.${scoot.patch}`,
// device: scoot.device.family,
// os: `${scoot.os.family} v${scoot.os.major}.${scoot.os.minor}.${scoot.os.patch}`,
// source: request.headers['user-agent']
// };
const { remoteAddress, referrer } = request.info;
server.app.logData = {
remoteAddress, referrer,
host: os.hostname()
};
server.app.timer = new Hoek.Timer();
return reply.continue();
}
});
//== Kickstart my heart
server.start((_err) => {
next(_err, server);
});
});
};
'use strict';
var Glue = require('glue');
var manifest = require('./manifest');
var path = require('path');
var plugins = path.join(__dirname, './');
function onError(err) {
console.log(err);
}
function onSuccess() {
console.log('Listening on port:8080');
}
Glue.compose(manifest, { relativeTo: plugins }, function(err, server) {
if (err) {
console.log(err);
}
server.start(function(err) {
if (err) {
onError(err);
}
else {
onSuccess();
}
});
});
import 'isomorphic-fetch';
import Boom from 'boom';
import Config from 'config';
import Glue from 'glue';
import Hoek from 'hoek';
import Jwt from 'jsonwebtoken';
import Renderer from './controllers/renderer';
import Twitter from './controllers/twitter';
import settings from './settings';
export default Glue.compose(settings).then((server) => {
// Configure scheme that will require the user to login with twitter when
// JWT token is not valid.
server.auth.scheme('login', () => ({
authenticate: (request, reply) => {
server.auth.test('jwt', request, (error, credentials) => {
if (error) {
reply.redirect('/auth/twitter');
} else {
reply.continue({ credentials });
}
});
},
}));
server.auth.strategy('login', 'login', true);
// Configure JWT session cookie
server.state(Config.get('jwt.cookie'), {
ttl: Config.get('jwt.ttl'),
var Glue = require('glue'),
manifest = require('./manifest');
Glue.compose(manifest.get('/'), {relativeTo: __dirname}, function (err, server) {
server.start(function () {
server.log('info', 'Server running at: ' + server.connections[0].info.uri);
});
});
},
options: {
select: 'chalice-api'
}
}
]
};
module.exports = manifest;
// If this is being required, return the manifest. Otherwise, start the server.
if (!module.parent) {
Glue.compose(manifest, { relativeTo: Path.join(__dirname, 'node_modules') }, (err, server) => {
if (err) {
throw err;
}
server.start((err) => {
if (err) {
throw (err);
}
console.log('Chalice API Started on ' + Config.server.chaliceApi.uri);
});
});
}
Glue.compose(manifest, { relativeTo: process.cwd() }, (err, server) => {
server.start(() => { });
lab.describe("Routes", () => {
lab.it('Known route should return http status 200', done => {
server.inject('/api/v1', response => {
Code.expect(response.statusCode).to.equal(200);
done();
});
});
lab.it('Restricted route should return http status 401 for anonymous user', done => {
server.inject('/api/v1/restricted', response => {
Code.expect(response.statusCode).to.equal(401);
done();
});
});
lab.it('Restricted route should return http status 200 for authenticated user', done => {
var options = {
method : 'GET',
url : '/api/v1/restricted',
headers : {
'Authorization' : 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6MSwibmFtZSI6IkFudGhvbnkgVmFsaWQgVXNlciIsImlhdCI6MTQyNTQ3MzUzNX0.KA68l60mjiC8EXaC2odnjFwdIDxE__iDu5RwLdN1F2A',
'Content-Type' : 'application/json; charset=utf-8'
}
};
server.inject(options, response => {
Code.expect(response.statusCode).to.equal(200);
done();
});
});
lab.it('Unknown route should return http status 404', done => {
server.inject('/api/v1/unkownroute', response => {
Code.expect(response.statusCode).to.equal(404);
done();
});
});
});
});
const getserver = function () {
return Glue.compose(manifest, servOptions);
};
'use strict';
const Glue = require('glue');
const options = {
relativeTo: __dirname
};
Glue.compose(require('./plugins.js'), options, (err, server) => {
if (err) {
throw err;
}
server.start((err) => {
if (err) {
throw err;
}
console.log(`Server running at: ${server.info.uri}`);
});
module.exports = server;
});
}
}],
registrations : [{
plugin : { register : 'inert' }
}, {
plugin : { register : 'vision' }
}, {
plugin : {
register : 'hapi-router',
options : {
cwd : __dirname,
routes : 'routes/**/*.route.js'
}
}
}]
};
glue.compose(manifest, { relativeTo: __dirname }, function(error, server) {
if (error) throw error;
server.views({
engines : { ejs: require('ejs') },
relativeTo : __dirname,
path : 'views'
});
server.start(function() {
console.info('Server running at %s', server.info.uri);
});
});
compose: function (endCompose) {
Glue.compose(manifest, options, function (err, _server) {
server = _server;
endCompose();
});
},
var Glue = require('glue');
var Manifest = require('./manifest');
var options = {
relativeTo: __dirname
};
Glue.compose(Manifest.get('/'), options, function (err, server) {
if (err) {
throw err;
}
server.start(function () {
console.log('Started the plot device.');
});
});
* specifying the Hapi server options, connections and plugins
*/
Glue.compose(manifest, options, function (err, server) {
server.start(function(err) {
// throw error if the server doesnt start correctly.
if(err){ throw err }
// Server started great, log connection information
else {
server.route({
method: 'OPTIONS',
path: '/{p*}',
config: {
handler: function(request, reply){
reply(true)
.header('access-control-allow-headers', 'accept, authorization, content-type')
.header('access-control-allow-origin', 'http://192.241.169.148:3000')
.header('access-control-allow-methods', 'GET, PUT, POST, DELETE, OPTIONS');
}
}
});
console.log("CoffeeHouse Radio Started!");
console.log("Connections:");
console.log(" >>> Webapp: " + server.connections[0].info.address + ":" + server.connections[0].info.port);
console.log(" >>> API: " + server.connections[1].info.address + ":" + server.connections[1].info.port);
}
});
});
import Glue from 'glue';
import manifest from './manifest';
export default Glue.compose(manifest, {relativeTo: __dirname})
.then(server => server.start().then(() => {
server.log(['startup'], `Server started at http://${server.info.address}:${server.info.port}`);
return server;
}));
Glue.compose(config, { relativeTo: Path.join(process.cwd(), 'server') }, (err, server) => {
if (err) throw err;
server.views({
engines: {
jsx: HapiReactViews
},
compileOptions: {
layoutPath: Path.join(process.cwd(), 'universal', 'containers'),
layout: 'layout'
},
isCached: false,
path: Path.join(process.cwd(), 'universal')
});
// store initial state in hapi request object
server.ext('onRequest', function (request, reply) {
request.app.state = {
meta: {}
};
reply.continue();
});
// static file root
server.route({
method: 'GET',
path: '/files/{files*}',
handler: {
directory: {
path: 'server/files'
}
}
});
server.start(() => console.info(server.plugins.blipp.text()));
});