it('should send "' + logLevels[i] + '" level', async () => {
const level = logLevels[i];
const server = Hapi.server({ port: 3000 });
registerWithBunny(server, options);
const rndMessage = randomString();
expect(server.logger()).to.not.be.undefined;
server.log([level], rndMessage);
const msg = catcher.pop();
expect(msg).to.be.not.undefined;
expect(msg).to.have.all.keys(['name', 'hostname', 'pid', 'level', 'msg', 'tags', 'time', 'v']);
expect(msg.msg).to.be.contain(rndMessage);
expect(msg.tags).to.be.contain(level);
});
it('does allow remote access when localOnly is false IPv6', async () => {
const barrier = new Barrier();
const server = Hapi.server();
const port = await internals.availablePort();
await server.register({ plugin: Reptile, options: { port, localOnly: false } });
const address = Net.Socket.prototype.address;
Net.Socket.prototype.address = function () {
Net.Socket.prototype.address = address;
return {
family: 'IPv6',
address: '3ffe:1900:4545:3:200:f8ff:fe21:67cf'
};
};
const sock = Net.connect(port);
let state = 0;
sock.on('readable', (size) => {
const buffer = sock.read();
if (!buffer) {
return;
}
const result = buffer.toString('ascii');
if (state === 0) {
expect(result.indexOf('>')).to.not.equal(-1);
sock.write('pack.hapi\n');
}
else if (state === 1) {
sock.write('.exit\n');
}
else if (state === 2) {
barrier.pass();
}
state++;
});
await barrier;
});
it('creates a REPL that a client can connect to over TCP IPv6', async () => {
const barrier = new Barrier();
const server = Hapi.server();
const port = await internals.availablePort();
await server.register({ plugin: Reptile, options: { port } });
const address = Net.Socket.prototype.address;
Net.Socket.prototype.address = function () {
Net.Socket.prototype.address = address;
return {
family: 'IPv6',
address: '::1'
};
};
const sock = Net.connect(port);
let state = 0;
sock.on('readable', () => {
const buffer = sock.read();
if (!buffer) {
return;
}
const result = buffer.toString('ascii');
if (state === 0) {
expect(result.indexOf('>')).to.not.equal(-1);
sock.write('pack.hapi\n');
}
else if (state === 1) {
sock.write('.exit\n');
}
else if (state === 2) {
barrier.pass();
}
state++;
});
return barrier;
});
;(async () => {
const server = HAPI.server({
host: "127.0.0.1",
port: 12345,
debug: { request: [ "error" ] }
})
await server.register(HAPIDucky)
/* provider */
server.route({
method: "POST",
path: "/foo",
config: {
payload: {
output: "data", parse: true, allow: "application/json"
},
plugins: {
ducky: "{ foo: string, bar?: boolean }"
}
},
handler: async (request, h) => {
return "OK"
}
})
await server.start()
/* consumer */
let response = await server.inject({
method: "POST",
url: "/foo",
payload: JSON.stringify({
foo: "foo",
bar: true
})
})
if (response.result === "OK")
console.log("-- internal request: /foo: OK")
else
console.log("-- internal request: /foo: ERROR: invalid response: ", response.result)
await server.stop({ timeout: 1000 })
process.exit(0)
})()
async function getServer() {
if (server) {
return server;
}
server = hapi.server({debug: false, host: "localhost", port: 0});
await server.register(require("vision")); // renders page templates (pug)
server.views({
engines: {pug: require("pug")},
relativeTo: path.join(__dirname, "../.."),
context: require("../../core/template-vars")({proSite: false})
});
const options = {
galleries: require("./galleries-test"),
baseDir: path.join(__dirname, "unit-test-galleries")
};
await server.register({plugin: require("./photos-plugin"), options});
await server.start();
return server;
}
it('closes all connections when the server is stopped', async () => {
const barrier = new Barrier();
const server = Hapi.server();
const port = await internals.availablePort();
await server.register({ plugin: Reptile, options: { port } });
const address = Net.Socket.prototype.address;
Net.Socket.prototype.address = function () {
Net.Socket.prototype.address = address;
return {
family: 'IPv4',
address: '127.0.0.1'
};
};
const sock = Net.connect(port);
let state = 0;
sock.once('close', () => {
barrier.pass();
});
sock.on('readable', () => {
const buffer = sock.read();
if (!buffer) {
return;
}
if (state === 0) {
server.stop();
}
state++;
});
return barrier;
});
const init = async () => {
const api = server({
port: 8000,
host: 'localhost',
routes: {
cors: {
origin: ['http://localhost:3000']
}
}
})
api.route({
method: 'GET',
path: '/hello',
handler: () => 'hello world'
})
await api.start()
console.log(`Server running at: ${api.info.uri}`)
}
it('calls through to handler on failed optional auth', async () => {
const server = Hapi.server();
await server.register(require('../'));
server.auth.strategy('default', 'hawk', { getCredentialsFunc });
server.route({
method: 'POST',
path: '/hawkOptional',
handler: function (request, h) {
return 'Success';
},
options: { auth: { mode: 'optional', strategy: 'default' } }
});
const request = { method: 'POST', url: 'http://example.com:8080/hawkOptional' };
const res = await server.inject(request);
expect(res.result).to.equal('Success');
});
it('returns an error on insufficient scope', async () => {
const server = Hapi.server();
await server.register(require('../'));
server.auth.strategy('default', 'hawk', { getCredentialsFunc });
server.route({
method: 'POST',
path: '/hawkScope',
handler: function (request, h) {
return 'Success';
},
options: { auth: { scope: 'x', strategy: 'default' } }
});
const request = { method: 'POST', url: 'http://example.com:8080/hawkScope', payload: '{}', headers: { authorization: hawkHeader('john', '/hawkScope').header } };
const res = await server.inject(request);
expect(res.statusCode).to.equal(403);
});
async function start() {
try {
const server = Hapi.server({
host: 'localhost',
port: Number(process.argv[2] || 8080)
})
server.route({
method:'POST',
path: '/upload',
config: {
handler: function(request, h) {
return new Promise((resolve,reject) => {
let fileContent = ''
request.payload.file.pipe(through((chunk,enc,callback) => {
fileContent += chunk.toString()
callback()
})).on('finish',() => {
return resolve(JSON.stringify({
description: request.payload.description,
file: {
data: fileContent,
filename: request.payload.file.hapi.filename,
headers: request.payload.file.hapi.headers
}
}))
})
})
},
payload: {
output: 'stream',
parse: true,
allow: 'multipart/form-data'
}
}
})
await server.start()
} catch (error) {
throw error
}
}
;(async () => {
const server = HAPI.server({
host: "127.0.0.1",
port: 12345,
debug: { request: [ "error" ] }
})
await server.register({
plugin: HAPIHeader,
options: {
"Server": "Example/1.2.3",
"X-Request-Id": (server, request, h) => request.info.id,
"X-External-IP": (server, request, h) => {
return Request.get("http://myexternalip.com/raw")
.then((value) => value.replace(/\r?\n/g, ""))
}
}
})
server.route({
method: "GET",
path: "/foo",
handler: async (request, h) => {
return "OK"
}
})
await server.start()
let response = await server.inject({
method: "GET",
url: "/foo"
})
if (response.result === "OK")
console.log("-- internal request: /foo: OK", response.headers)
else
console.log("-- internal request: /foo: ERROR: invalid response: ", response.result)
await server.stop({ timeout: 1000 })
process.exit(0)
})()
it('calls through to handler on successful auth', async () => {
const server = Hapi.server();
await server.register(require('../'));
server.auth.strategy('default', 'hawk', { getCredentialsFunc });
server.route({
method: 'POST',
path: '/hawk',
handler: function (request, h) {
return 'Success';
},
options: { auth: 'default' }
});
const request = { method: 'POST', url: 'http://example.com:8080/hawk', headers: { authorization: hawkHeader('john', '/hawk').header } };
const res = await server.inject(request);
expect(res.statusCode).to.equal(200);
expect(res.result).to.equal('Success');
});
it('does not include authorization header in response when the response is an error', async () => {
const server = Hapi.server();
await server.register(require('../'));
server.auth.strategy('default', 'hawk', { getCredentialsFunc });
server.route({
method: 'POST',
path: '/hawkError',
handler: function (request, h) {
return new Error();
},
options: { auth: 'default' }
});
const request = { method: 'POST', url: 'http://example.com:8080/hawkError', headers: { authorization: hawkHeader('john', '/hawkError').header } };
const res = await server.inject(request);
expect(res.statusCode).to.equal(500);
expect(res.headers.authorization).to.not.exist();
});
it('returns an error on bad scheme', async () => {
const server = Hapi.server();
await server.register(require('../'));
server.auth.strategy('default', 'hawk', { getCredentialsFunc });
server.route({
method: 'POST',
path: '/hawk',
handler: function (request, h) {
return 'Success';
},
options: { auth: 'default' }
});
const request = { method: 'POST', url: 'http://example.com:8080/hawk', headers: { authorization: 'junk something' } };
const res = await server.inject(request);
expect(res.result).to.exist();
expect(res.statusCode).to.equal(401);
});
function Server () {
const server = hapi.server({host: 'localhost'})
server.route({
method: 'GET',
path: '/',
handler () {
throw new Error('unexpected')
}
})
server.route({
method: 'GET',
path: '/boom',
handler () {
throw boom.forbidden()
}
})
server.initialize()
return server
}
async function start () {
const server = Hapi.server({ port: 3000 })
server.route({
method: 'GET',
path: '/',
handler: async function (request, h) {
return 'hello world'
}
})
await server.register({
plugin: require('..'),
options: {
mergeHapiLogData: false
}
})
server.events.on('response', () => {
server.log(['info'], { hello: 'world' })
})
await server.start()
}
'use strict'
const Hapi = require('hapi');
const H2o2 = require('h2o2');
const server = Hapi.server({
host:'localhost',
port: Number(process.argv[2] || 8080)
})
async function start(){
try {
await server.register({plugin:H2o2})
server.route({
method: 'GET',
path: '/proxy',
handler:{
proxy:{
host:'localhost',
port:65535
}
}
})
await server.start()
} catch (error) {
throw error
}
}
start()
'use strict'
const mongoose = require('mongoose')
const Hapi = require('hapi')
const server = Hapi.server({
port: process.env.PORT || 3000
})
const mongoHost = process.env.mongo_host || 'mongo'
const mongoPort = process.env.mongo_port || '27017'
const mongoCollection = process.env.mongo_collection || 'movieupc'
const mongoDbUrl = `mongodb://${mongoHost}:${mongoPort}/${mongoCollection}`
mongoose.connect(mongoDbUrl)
const schema = new mongoose.Schema({
DVD_Title: String,
Studio: String,
Released: String,
Status: String,
Sound: String,
Versions: String,
Price: String,
Rating: String,
Year: String,
Genre: String,
Aspect: String,
UPC: String,
DVD_ReleaseDate: String,
ID: String,
Timestamp: String
it('authenticates with mock', async (flags) => {
const mock = await Mock.v2(flags);
const server = Hapi.server({ host: 'localhost', port: 80 });
await server.register(Bell);
const custom = Bell.providers.bitbucket();
Hoek.merge(custom, mock.provider);
Mock.override('https://api.bitbucket.org/2.0/user', {
repositories: [{}],
uuid: '1E9C5160-E436-11E5-9897-4FCB70D5A8C7',
username: '******',
display_name: 'steve'
});
server.auth.strategy('custom', 'bell', {
password: '******',
isSecure: false,
clientId: 'bitbucket',
clientSecret: 'secret',
provider: custom
});
server.route({
method: '*',
path: '/login',
config: {
auth: 'custom',
handler: function (request, h) {
return request.auth.credentials;
}
}
});
const res1 = await server.inject('/login');
const cookie = res1.headers['set-cookie'][0].split(';')[0] + ';';
const res2 = await mock.server.inject(res1.headers.location);
const res3 = await server.inject({ url: res2.headers.location, headers: { cookie } });
expect(res3.result).to.equal({
provider: 'custom',
token: '456',
refreshToken: undefined,
expiresIn: 3600,
query: {},
profile: {
id: '1E9C5160-E436-11E5-9897-4FCB70D5A8C7',
username: '******',
displayName: 'steve',
raw: {
repositories: [{}],
uuid: '1E9C5160-E436-11E5-9897-4FCB70D5A8C7',
username: '******',
display_name: 'steve'
}
}
});
});
beforeEach(() => {
server = Hapi.server({ port: 0 })
})
* @fileOverview Hapi server main configuration file
*/
const Hapi = require('hapi')
const Boom = require('boom')
const auth = require('./auth')
const swagger = require('./swagger')
const jsdoc = require('./jsdoc')
const routes = require('../src/routes')
const server = Hapi.server({
port: process.env.PORT,
routes: {
validate: {
failAction: async (req, response, err) => {
throw Boom.badRequest(err.message)
},
},
},
})
auth.register(server)
if (process.env.SWAGGER === 'true') {
swagger.register(server)
}
if (process.env.JSDOC === 'true') {
jsdoc.register(server)
}
it('authenticates with mock (with custom fields)', async (flags) => {
const mock = await Mock.v2(flags);
const server = Hapi.server({ host: 'localhost', port: 80 });
await server.register(Bell);
const custom = Bell.providers.facebook({ fields: 'id,name,email,first_name,last_name,middle_name,picture' });
Hoek.merge(custom, mock.provider);
const profile = {
id: '1234567890',
username: '******',
name: 'steve',
first_name: 'steve',
last_name: 'smith',
email: '*****@*****.**',
picture: {
data: {
is_silhouette: false,
url: 'https://example.com/profile.png'
}
}
};
Mock.override('https://graph.facebook.com/v3.1/me', profile);
server.auth.strategy('custom', 'bell', {
password: '******',
isSecure: false,
clientId: 'facebook',
clientSecret: 'secret',
provider: custom
});
server.route({
method: '*',
path: '/login',
config: {
auth: 'custom',
handler: function (request, h) {
return request.auth.credentials;
}
}
});
const res1 = await server.inject('/login');
const cookie = res1.headers['set-cookie'][0].split(';')[0] + ';';
const res2 = await mock.server.inject(res1.headers.location);
const res3 = await server.inject({ url: res2.headers.location, headers: { cookie } });
expect(res3.result).to.equal({
provider: 'custom',
token: '456',
expiresIn: 3600,
refreshToken: undefined,
query: {},
profile: {
id: '1234567890',
username: '******',
displayName: 'steve',
name: {
first: 'steve',
last: 'smith',
middle: undefined
},
email: '*****@*****.**',
picture: {
data: {
is_silhouette: false,
url: 'https://example.com/profile.png'
}
},
raw: profile
}
});
});
it('performs a full authorization flow', async () => {
const encryptionPassword = '******';
const apps = {
social: {
id: 'social',
scope: ['a', 'b', 'c'],
key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
algorithm: 'sha256'
},
network: {
id: 'network',
scope: ['b', 'x'],
key: 'witf745itwn7ey4otnw7eyi4t7syeir7bytise7rbyi',
algorithm: 'sha256'
}
};
const grant = {
id: 'a1b2c3d4e5f6g7h8i9j0',
app: 'social',
user: '******',
exp: Oz.hawk.utils.now() + 60000
};
const options = {
oz: {
encryptionPassword,
loadAppFunc: (id) => apps[id],
loadGrantFunc: function (id) {
const ext = {
public: 'everybody knows',
private: 'the the dice are loaded'
};
return { grant, ext };
}
}
};
const server = Hapi.server();
await server.register(Scarecrow);
// Add strategy
server.auth.strategy('oz', 'oz', options);
server.auth.default('oz');
// Add a protected resource
server.route({
path: '/protected',
method: 'GET',
config: {
auth: {
entity: 'user'
},
handler: function (request) {
return request.auth.credentials.user + ' your in!';
}
}
});
// The app requests an app ticket using Hawk authentication
let req = {
method: 'POST',
url: 'http://example.com/oz/app',
headers: {
authorization: Oz.client.header('http://example.com/oz/app', 'POST', apps.social).header
}
};
const res1 = await server.inject(req);
expect(res1.statusCode).to.equal(200);
// The user is redirected to the server, logs in, and grant app access, resulting in an rsvp
const appTicket = res1.result;
const rsvp = await Oz.ticket.rsvp(apps.social, grant, encryptionPassword);
// After granting app access, the user returns to the app with the rsvp
// The app exchanges the rsvp for a ticket
req = {
method: 'POST',
url: 'http://example.com/oz/rsvp',
headers: {
authorization: Oz.client.header('http://example.com/oz/rsvp', 'POST', appTicket).header
},
payload: JSON.stringify({ rsvp })
};
const res2 = await server.inject(req);
const userTicket = res2.result;
// The app reissues the ticket
req = {
method: 'POST',
url: 'http://example.com/oz/reissue',
headers: {
authorization: Oz.client.header('http://example.com/oz/reissue', 'POST', userTicket).header
}
};
const res3 = await server.inject(req);
const newTicket = res3.result;
req = {
method: 'GET',
url: 'http://example.com/protected',
headers: {
authorization: Oz.client.header('http://example.com/protected', 'GET', newTicket).header
}
};
const res4 = await server.inject(req);
expect(res4.payload).to.equal('john your in!');
});
it('fails to authenticate a request with mismatching app id', async () => {
const encryptionPassword = '******';
const app = {
id: 'social',
scope: ['a', 'b', 'c'],
key: 'werxhqb98rpaxn39848xrunpaw3489ruxnpa98w4rxn',
algorithm: 'sha256'
};
const grant = {
id: 'a1b2c3d4e5f6g7h8i9j0',
app: 'social',
user: '******',
exp: Oz.hawk.utils.now() + 60000
};
const options = {
oz: {
encryptionPassword,
loadAppFunc: () => app,
loadGrantFunc: () => ({ grant })
}
};
const server = Hapi.server();
await server.register(Scarecrow);
// Add strategy
server.auth.strategy('oz', 'oz', options);
server.auth.default('oz');
// Add a protected resource
server.route({
path: '/protected',
method: 'GET',
config: {
auth: {
entity: 'user'
},
handler: function (request) {
return request.auth.credentials.user + ' your in!';
}
}
});
// The app requests an app ticket using Hawk authentication
let req = {
method: 'POST',
url: 'http://example.com/oz/app',
headers: {
authorization: Oz.client.header('http://example.com/oz/app', 'POST', app).header
}
};
const res1 = await server.inject(req);
// The user is redirected to the server, logs in, and grant app access, resulting in an rsvp
const appTicket = res1.result;
const rsvp = await Oz.ticket.rsvp(app, grant, encryptionPassword);
// After granting app access, the user returns to the app with the rsvp
// The app exchanges the rsvp for a ticket
req = {
method: 'POST',
url: 'http://example.com/oz/rsvp',
headers: {
authorization: Oz.client.header('http://example.com/oz/rsvp', 'POST', appTicket).header
},
payload: JSON.stringify({ rsvp })
};
const res2 = await server.inject(req);
const userTicket = res2.result;
userTicket.app = '567';
req = {
method: 'GET',
url: 'http://example.com/protected',
headers: {
authorization: Oz.client.header('http://example.com/protected', 'GET', userTicket).header
}
};
const res3 = await server.inject(req);
expect(res3.statusCode).to.equal(401);
expect(res3.result.message).to.equal('Mismatching application id');
});
const Hapi = require('hapi');
const server = Hapi.server({
host: 'localhost',
port: 3010
});
server.route({
method: 'GET',
path: '/hello',
handler: function(request, h) {
return 'Hello World';
}
});
//start server
async function start() {
try {
await server.start();
}
catch(err) {
console.log(err);
process.exit(1);
}
console.log('Server running at:', server.info.url);
}
start();
function createServer(host, port) {
const server = Hapi.server({ port: port, host: host });
return server;
}
'use strict';
var Hapi = require('hapi');
var server = Hapi.server({
port: 3000,
host: 'localhost'
});
server.route({
method: 'GET',
path: '/',
handler: (request, h) => {
return 'Hello world!';
}
});
var helloWorld = async () => {
await server.start();
console.log(`Listening at: ${server.info.uri}`);
};
process.on('unhandledRejection', (err) => {
console.log(err);
process.exit(1);
});
helloWorld();
import Hapi from 'hapi'
import path from 'path'
import fs from 'fs'
import { address } from 'ip'
const server = Hapi.server({
port: 4200,
host: process.argv[2] === 'dev' ? '127.0.0.1' : address()
});
export const start = async ({
}) => {
await server.register(require('inert'))
console.log('ADDRESS', address())
server.route({
method: 'GET',
path: '/{file*}',
handler: {
directory: {
path: request => {
console.log('App location:', request.headers.applocation)
console.log('file request:', request.params.file)
console.log('----->', fs.existsSync(request.params.file))
const { applocation: dir } = request.headers
console.log('dir', dir)
return request.params.file
},
listing: true
}
'use strict';
const Config = require('getconfig');
const Hapi = require('hapi');
const Pug = require('pug');
const Markdown = require('./lib/markdown');
const Path = require('path');
if (Config.server.cache) {
Config.server.cache.engine = require(Config.server.cache.engine);
}
const server = Hapi.server(Config.server);
Pug.filters.markdown = Markdown.parseSync;
const start = async function () {
server.ext({
type: 'onPreResponse',
method: function (request, h) {
if (!request.response.isBoom) {
return h.continue;
}
return h.view('error', request.response).code(request.response.output.statusCode);
} });
server.method(require('./lib/npm').methods);
server.method(require('./lib/github').methods);
server.method(require('./lib/markdown').methods);
server.method(require('./lib/community').methods);
it('should register successfully', async () => {
const server = Hapi.server({ port: 3000 });
await registerWithBunny(server, null);
expect(server.logger()).to.not.be.undefined;
});