server: (function () {
if (options.get('scheme') === 'https') {
const pfxPath = options.getIn(['https', 'pfx']);
if (pfxPath) {
return https.createServer(getPFX(pfxPath), app);
}
return https.createServer(getKeyAndCert(options), app);
}
return http.createServer(app);
})(),
_startAuthenticationServer():Promise {
var result = deferred();
var port = config.controlChannelPort + 1;
var serverOptions = {
key: keys.privateKey,
cert: keys.certificate
};
https.createServer(serverOptions, (req, res) => {
var path = this._pathForRequest(req);
console.log("Path:", path);
if (path.indexOf('authenticate') === 0) {
return this._authenticate(req, res);
}
}).listen(port, function(err) {
if (err) {
result.reject('Unable to start control channel server: ' + err);
} else {
console.log('Listening for authentication requests on port', port);
result.resolve();
}
});
return result.promise;
}
export function start(
port,
networkInterface,
ssl,
_listener,
onConnection?
): void {
listener = _listener;
if (ssl) {
const options = {
key: fs.readFileSync(ssl.key),
cert: fs.readFileSync(ssl.cert),
ca: null
};
try {
// Use intermediate certificates if available
options.ca = fs
.readFileSync(ssl.ca)
.toString()
.match(/-+BEGIN CERTIFICATE-+[0-9a-zA-Z+\-/=\s]+?-+END CERTIFICATE-+/g);
} catch (error) {
// No intermediate certificate
}
server = https.createServer(options, listener);
if (onConnection != null) server.on("secureConnection", onConnection);
} else {
server = http.createServer(listener);
if (onConnection != null) server.on("connection", onConnection);
}
server.listen(port, networkInterface);
}
function startServer(webServerConfig: IWebServerConfig, app: core.Express, done:(secure: boolean, host:string, port:number) => void, errorCallback?:(err:any) => void ) : void {
let server: net.Server = null;
let wsConfig: IHTTPServerConfig = null;
if (webServerConfig.https) {
wsConfig = webServerConfig.https;
let httpsConfig = webServerConfig.https;
let sslConfig = httpsConfig.ssl;
let private_key_file = sslConfig.private_key_file;
let certificate_file = sslConfig.certificate_file;
let ca_files = sslConfig.ca_files;
let privateKey = fs.readFileSync(private_key_file, 'utf8');
let certificate = fs.readFileSync(certificate_file, 'utf8');
let credentials:https.ServerOptions = {key: privateKey, cert: certificate};
if (ca_files && ca_files.length > 0) {
let ca:string[] = [];
for (let i in ca_files)
ca.push(fs.readFileSync(ca_files[i], 'utf8'));
credentials.ca = ca;
}
server = https.createServer(credentials, app);
} else {
wsConfig = webServerConfig.http;
server = http.createServer(app);
}
let port = (wsConfig.port ? wsConfig.port : (webServerConfig.https ? 443 : 80));
let host = (wsConfig.host ? wsConfig.host : "0.0.0.0");
server.on('error', (err:any) => {
if (typeof errorCallback === 'function') errorCallback(err);
});
server.listen(port, host, () => {
let host = server.address().address;
let port = server.address().port;
if (typeof done === 'function') done((webServerConfig.https ? true : false), host, port);
});
}
export async function createHttpServer(devServerConfig: d.DevServerConfig, fs: d.FileSystem, destroys: d.DevServerDestroy[]) {
// figure out the port to be listening on
// by figuring out the first one available
devServerConfig.port = await findClosestOpenPort(devServerConfig.address, devServerConfig.port);
// create our request handler
const reqHandler = createRequestHandler(devServerConfig, fs);
let server: http.Server;
if (devServerConfig.protocol === 'https') {
// https server
server = https.createServer(await getSSL(), reqHandler) as any;
} else {
// http server
server = http.createServer(reqHandler);
}
destroys.push(() => {
// close down the serve on destroy
server.close();
server = null;
});
return server;
}
_startControlChannelServer():Promise {
var result = deferred();
var port = config.controlChannelPort;
var serverOptions = {
key: keys.privateKey,
cert: keys.certificate,
ca: [keys.certificate],
requestCert: true,
rejectUnauthorized: true
};
https.createServer(serverOptions, (req, res) => {
var path = this._pathForRequest(req);
console.log(req.connection.getPeerCertificate());
console.log(req.secure);
console.log(req.client.authorized);
}).listen(port, function(err) {
if (err) {
result.reject('Unable to start control channel server: ' + err);
} else {
console.log('Listening for control channel traffic on port', port);
result.resolve();
}
});
return result.promise;
}
function createSimpleServer({ port = 8000 }) {
const server = createServer({ key: privateKey, cert: certificate });
server.addListener('request', request);
server.listen(port);
console.log(`Listen port ${port}, for simple server`);
console.log(`https://${ip}:${port}`);
}
async run(inputs: CommandLineInputs, options: CommandLineOptions) {
const [ url ] = inputs;
const { host, port, ssl } = options;
const protocol = ssl ? 'https' : 'http';
const projectType = options['project-type'];
const name = options['app-name'];
const version = options['app-version'];
const app = express();
app.use('/', express.static(WWW_DIRECTORY));
app.get('/api/app', (req, res) => {
res.json({ url, name, version, projectType });
});
const server = ssl ? https.createServer(await this.collectSecureContextOptions(options), app) : http.createServer(app);
server.listen({ port, host });
const labUrl = `${protocol}://${host}:${port}`;
server.on('listening', () => {
process.stdout.write(
'Ionic Lab running!\n' +
`Lab: ${chalk.bold(labUrl)}\n` +
`App: ${chalk.bold(url)}\n`
);
});
}
before((done) => {
const options = {
key: fs.readFileSync(path.join(certPath, 'server.key')),
cert: fs.readFileSync(path.join(certPath, 'server.pem')),
ca: [
fs.readFileSync(path.join(certPath, 'rootCA.pem')),
fs.readFileSync(path.join(certPath, 'intermediateCA.pem'))
],
requestCert: true,
rejectUnauthorized: false
}
server = https.createServer(options, (req, res) => {
if ((req as any).client.authorized) {
res.writeHead(200)
res.end('<title>authorized</title>')
} else {
res.writeHead(401)
res.end('<title>denied</title>')
}
})
server.listen(0, '127.0.0.1', () => {
const port = (server.address() as net.AddressInfo).port
secureUrl = `https://127.0.0.1:${port}`
done()
})
})
return co(function *createHttpsServer() {
const privateKeyPromise = fs.readFileAsync(keypath, 'utf8');
const certificatePromise = fs.readFileAsync(crtpath, 'utf8');
const [key, cert] = yield Promise.all([privateKeyPromise, certificatePromise]);
return https.createServer({ secureOptions: SSL_OP_NO_TLSv1, key, cert }, app);
}).call(this);
