async function getOutputDevelopment({ directory, env = {} }) {
try {
const { stdout, stderr } = await execa(
'./node_modules/.bin/react-scripts',
['start', '--smoke-test'],
{
cwd: directory,
env: Object.assign(
{},
{
BROWSER: 'none',
PORT: await getPort(),
CI: 'false',
FORCE_COLOR: '0',
},
env
),
}
);
return { stdout: stripAnsi(stdout), stderr: stripAnsi(stderr) };
} catch (err) {
return {
stdout: '',
stderr: stripAnsi(
err.message
.split(os.EOL)
.slice(2)
.join(os.EOL)
),
};
}
}
return () => {
return getPort()
.then((port) => {
const server = plugins.liveServer('server', {
env: {
PORT: port,
NODE_ENV: 'production',
},
}, false);
return server.start()
.then(() => {}, () => {}, () => {
if (!isRunning) {
isRunning = true;
return backstop('reference', {
config: require('../tests/backstop/backstop.config.js')({
port: port
})
})
.then(() => {
server.stop();
}).catch(() => {
server.stop();
process.exit(1);
});
}
});
});
};
var localfile = function(ctx, next) {
if (ctx.mode !== 'launch') return next();
if (!contains(ctx.options.playlist, isFile)) return next();
getPort(function(err, port) {
var route = router();
var list = ctx.options.playlist.slice(0);
ctx.options.playlist = list.map(function(item, idx) {
if (!isFile(item)) return item;
return {
path: 'http://' + internalIp() + ':' + port + '/' + idx,
type: 'video/mp4',
media: {
metadata: {
title: path.basename(item.path)
}
}
};
});
route.all('/{idx}', function(req, res) {
serveMp4(req, res, list[req.params.idx].path);
});
http.createServer(route).listen(port);
next();
});
};
async startServer(): Promise<void> {
// Find a port at runtime. Default to 4000 if it is available
this.port =
typeof process.env.SUBTITLES_PORT === 'number'
? parseInt(process.env.SUBTITLES_PORT, 10)
: await getPort({ port: 4000 });
// Start the static file server for the subtitle files
const server = express();
// Enable CORS
// https://github.com/thibauts/node-castv2-client/wiki/How-to-use-subtitles-with-the-DefaultMediaReceiver-app#subtitles
server.use((req, res, next) => {
if (req.headers.origin) {
res.headers['Access-Control-Allow-Origin'] = req.headers.origin;
}
next();
});
server.use(express.static(this.basePath));
this.server = server.listen(this.port);
console.info(
`Subtitle server serving on http://localhost:${this.port}, serving ${
this.basePath
}`
);
}
ncp('./app', './test/app', function (err) {
if (err) return done(err);
getPort(function (err, availablePort) {
if (err) return done(err);
port = availablePort;
done();
})
});
return queue.add(async () => {
const ports = []
for (let i = 0; i < numPorts; i++) {
const port = await getPort()
ports.push(port)
}
return { ports }
})
beforeAll(async () => {
const scriptPath = join(appDir, 'server.js')
context.appPort = appPort = await getPort()
const env = clone(process.env)
env.PORT = `${appPort}`
server = await initNextServerScript(scriptPath, /Ready on/, env)
})
/**
* Start the engine. Will prepare everything before you will start your run:
* * Start XVFB (if it is configured)
* * Set connectivity
* * Start the extension server
*/
async start() {
this.options.devToolsPort = await getPort({
port: getPort.makeRange(9222, 9350),
host: '127.0.0.1'
});
return Promise.all([
this.myXVFB.start(),
addConnectivity(this.options),
this.myExtensionServer.start()
]);
}
before(async () => {
const args = {
level: "debug",
config: "test/data/config.json",
port: await getPort()
};
await main.start(args);
cachePath = await utils.createTmpDir();
await fs.ensureDir(cachePath);
});
test.cb('start markserv via "readme" command', t => {
t.plan(3)
const expected = String(
fs.readFileSync(
path.join(__dirname, 'markserv-cli.expected.html')
)
)
getPort().then(port => {
const cliOpts = {
input: [],
flags: {
port,
livereloadport: false,
address: 'localhost',
silent: true,
browser: false
}
}
const done = () => {
t.end()
}
readme.run(cliOpts).then(service => {
const closeServer = () => {
service.httpServer.close(done)
}
const opts = {
url: service.launchUrl,
timeout: 1000 * 2
}
request(opts, (err, res, body) => {
if (err) {
t.fail(err)
closeServer()
}
t.true(body.includes(expected))
t.is(res.statusCode, 200)
t.pass()
closeServer()
})
}).catch(err => {
t.fail(err)
t.end()
})
})
})
(async () => {
let randomUnusedPortToListenToTCPPeerConnections = await getPort();
basketutil.log('type: ' + peerType + ', masterPeerId: ' + masterPeerId.toString('hex') + ', channel: ' + channelName + ', port: ' + randomUnusedPortToListenToTCPPeerConnections);
swarm.listen(randomUnusedPortToListenToTCPPeerConnections);
swarm.join(channel);
swarm.on('connection', (conn, info) => {
let seq = counterforConnections,
checkMasterPeerId = info.id.toString('hex');
basketutil.log(`Master Connected #${seq} to peer: ${checkMasterPeerId}`);
// Keep peer alive
if (info.initiator) {
try {
conn.setKeepAlive(true, 600);
} catch (exception) {
basketutil.log('exception', exception);
}
}
conn.on('data', data => {
basketutil.log('From: ' + checkMasterPeerId);
let mPeerId = masterPeerId.toString('hex');
if (checkMasterPeerId == mPeerId) {
basketutil.log('ignore messages sent by myself');
}
basketutil.log('From: ' + checkMasterPeerId);
basketutil.log('Received message' + Buffer.from(data, 'hex'));
let message = JSON.parse(data);
roomsCallbackFromP2P(checkMasterPeerId, message.type, message.data);
});
conn.on('close', () => {
basketutil.log(`Master Connection ${seq} closed, peer id: ${checkMasterPeerId}`);
// If last connection delete
if (peers[checkMasterPeerId].seq === seq) {
delete peers[checkMasterPeerId]
}
});
// Save connection
if (!peers[checkMasterPeerId]) {
peers[checkMasterPeerId] = {}
}
peers[checkMasterPeerId].conn = conn;
peers[checkMasterPeerId].seq = seq;
counterforConnections++
})
})();
function Browser(cb) {
var that = this;
getPort().then(function(port) {
that._upnpSSDP = new SSDP(port);
that._devices = [];
_classCallCheck(that, Browser);
cb();
});
}
module.exports = function startServer(path) {
var app = connect();
app.use(middleware.regProjectFinder(path));
app.use(middleware.underscore);
app.use(middleware.mwl);
app.use(middleware.static);
app.use(middleware.fallback);
return port().then(function gotPort(num) {
return {
server: app.listen(num),
port: num,
};
});
};
async function isSuccessfulDevelopment({ directory }) {
const { stdout, stderr } = await execa(
'./node_modules/.bin/react-scripts',
['start', '--smoke-test'],
{
cwd: directory,
env: { BROWSER: 'none', PORT: await getPort() },
}
);
if (!/Compiled successfully/.test(stdout)) {
throw new Error(`stdout: ${stdout}${os.EOL + os.EOL}stderr: ${stderr}`);
}
}
before(function*() {
let tmpobj = tmp.dirSync();
let args = {
level: false,
config: "test/data/config.json",
repositoriesPath: tmpobj.name,
port: yield getPort()
};
yield fs.ensureDirAsync(args.repositoriesPath + "/repo1");
yield main.start(args, "A.B.C");
});
var executeRemoteChildProcess = function (runOpts, options) {
if(!options) options = {};
if(!options.cwd) options.cwd = process.cwd();
var child = new FakeChild(options.stdio);
var client = new RcpClient();
var needServer = !runOpts.address;
getPort().then(port => {
runOpts.address = runOpts.address || {
hostname: '127.0.0.1',
port: port
};
var maxTimeoutLen = options.bridgeTimeout || 1000 * 60 * 3;
if (needServer) {
var serverOptions = {
maxTimeoutLen: maxTimeoutLen,
autoClose: true
}
invokeElevatedCmd(runOpts.address, serverOptions);
}
var mustFinish = false;
var maxTimeout = setTimeout(function () {
mustFinish = true;
}, maxTimeoutLen);
var openAndConnectChild = function () {
client.open(runOpts.address, function (err) {
if (err) {
if (!mustFinish && err.code && err.code==='ECONNREFUSED') {
return setTimeout(openAndConnectChild, 100);
}
clearTimeout(maxTimeout);
child.emit('error', err);
return child.emit('close', -2) //unsure which code is correct
}
clearTimeout(maxTimeout);
delete options.bridgeTimeout;
client.runRemote(child, runOpts, options)
})
}
openAndConnectChild();
});
return child;
}
/**
* Start server for penthouse
*
* @param opts
* @returns {Promise}
*/
function startServer(opts) {
var cb = serveStatic(opts.base);
return getPort().then(function (port) {
var server = http.createServer(function (req, res) {
var done = finalhandler(req, res);
cb(req, res, done);
}).listen(port);
return {
instance: server,
port: port
};
});
}
return function () {
return getPort().then(function (port) {
var server = http.createServer(fn);
server.host = host;
server.port = port;
server.url = 'http://' + host + ':' + port;
server.protocol = 'http';
server.listen(port);
server.close = pify(server.close);
return server;
});
};
test.skip("works with yarn install", async () => {
const cwd = await initFixture("BootstrapCommand/integration-lifecycle");
const port = await getPort(42042);
const mutex = ["--mutex", `network:${port}`];
// NOTE: yarn doesn't support linking binaries from transitive dependencies,
// so it's important to test _both_ lifecycle variants.
// TODO: ...eventually :P
// FIXME: yarn doesn't understand file:// URLs... /sigh
await execa("yarn", ["install", "--no-lockfile", ...mutex], { cwd });
const { stdout, stderr } = await execa("yarn", ["test", "--silent", ...mutex], { cwd });
expect(stdout).toMatchSnapshot("yarn postinstall: stdout");
expect(stderr).toMatchSnapshot("yarn postinstall: stderr");
});
return function (req, res, next) {
if (!client) return respondError(res, "Client not started")
var torrentId = req.body.torrent;
var torrent = client.get(torrentId);
if (!torrent) return respondError(res, "Torrent not found")
var okId = torrent.infoHash;
if (torrentServers[okId])
return res.status(200).json({body: torrentServers[okId].href})
getPort().then(function (port) {
var server = torrent.createServer()
server.listen(port)
torrentServers[okId] = {
href: 'http://localhost:' + port + '/',
server: server
}
return res.status(200).json({body: torrentServers[okId].href})
});
}
srtToVtt(ctx.options.subtitles, function(err, data) {
if (err) return next();
getPort(function(err, port) {
if (err) return next();
var addr = 'http://' + internalIp() + ':' + port;
http.createServer(function(req, res) {
res.writeHead(200, {
'Access-Control-Allow-Origin': '*',
'Content-Length': data.length,
'Content-type': 'text/vtt;charset=utf-8'
});
res.end(data);
}).listen(port);
ctx.options.subtitles = addr;
attachSubtitles(ctx);
next();
});
});
module.exports = opts => {
opts = opts || {};
return getPort().then(port => {
const s = http.createServer((req, res) => {
setTimeout(() => {
s.emit(req.url, req, res);
}, (opts.delay || 0) * 1000);
});
s.port = port;
s.url = `http://localhost:${port}`;
s.close = pify(s.close);
s.on('/', (req, res) => {
res.writeHead(200, {'Content-Type': 'text/html'});
res.end('<html style="background-color: black;"></html>');
});
s.on('/cookies', (req, res) => {
const color = cookie.parse(req.headers.cookie).color || 'white';
const style = [
`background-color: ${color}; position: absolute;`,
'top: 0; right: 0; bottom: 0; left: 0;'
].join(' ');
res.writeHead(200, {'Content-Type': 'text/html'});
res.end(`<body><div style="${style}"></div></body>`);
});
s.on('/redirect', (req, res) => {
res.writeHead(302, {location: `http://localhost:${port}/`});
res.end();
});
s.listen(port);
return s;
});
};
async function serve(bundler, port, useHTTPS = false) {
let handler = middleware(bundler);
let server;
if (!useHTTPS) {
server = http.createServer(handler);
} else if (typeof useHTTPS === 'boolean') {
server = https.createServer(generateCertificate(bundler.options), handler);
} else {
server = https.createServer(await getCertificate(useHTTPS), handler);
}
let freePort = await getPort({port});
server.listen(freePort);
return new Promise((resolve, reject) => {
server.on('error', err => {
logger.error(new Error(serverErrors(err, server.address().port)));
reject(err);
});
server.once('listening', () => {
let addon =
server.address().port !== port
? `- ${logger.chalk.yellow(
`configured port ${port} could not be used.`
)}`
: '';
logger.persistent(
`Server running at ${logger.chalk.cyan(
`${useHTTPS ? 'https' : 'http'}://localhost:${server.address().port}`
)} ${addon}`
);
resolve(server);
});
});
}
async function restart() {
const { pidList, port: oldPort } = getEggRunningInfo();
// reload nginx only
if (process.env.ONLY_NGINX) {
return nginxReload(oldPort);
}
// restart server
const port = await getPort();
const { stdout } = shell.exec('npm start', {
env: {
...process.env,
NODE_ENV: 'production',
EGG_SERVER_ENV: 'prod',
PORT: port,
},
});
const appUrl = `http://127.0.0.1:${port}`;
if (!stdout.includes(`started on ${appUrl}`)) {
throw new Error('app start not success');
}
// check server status
const resp = await urllib.curl(appUrl);
assert(resp.status === 200, 'app start not success');
console.info('app started success in ' + appUrl);
// update nginx config
nginxReload(port);
// kill egg server pid
pidList.forEach(pid => {
shell.exec('kill -9 ' + pid);
console.info('kill process ' + pid);
});
}
function run (cmd, opts = {}) {
const startServer = (port) => {
process.env.PORT = port
const serverAddress = `http://localhost:${port}`
add(serverAddress, opts)
console.log(serverAddress)
exitHook(() => rm(opts))
const [command, ...args] = getCmd(cmd)
cp.spawnSync(command, args, {
stdio: 'inherit'
})
}
if (opts.port) {
startServer(opts.port)
} else {
getPort(startServer)
}
}
tmp.tmpName(function _tempNameGenerated(err, path) {
if (err) throw err;
fileToQuit = path;
getPort().then(port => {
address = {
hostname: '127.0.0.1',
port: port,
port: port
}
var serverOptions = {
maxTimeoutLen: 1000 * 60 * 3,
autoClose: false,
fileToQuit: fileToQuit,
tokenToQuit: tokenToQuit
}
invokeElevatedCmd(address, serverOptions);
pendings.splice(0, pendings.length).forEach(function(fn){
fn();
})
}).catch(function (err) {
console.log(err);
});
});
function buildArgs(cb) {
var argv = minimist(process.argv.slice(2));
var port = argv.port || argv.p || 0;
var silent = Boolean(argv.silent || argv.s);
var folders = [];
if (argv.h || argv.help) { return displayUsage(); }
argv.folder = argv.folder || argv.f;
if (!argv.folder) {
console.error('----------------------');
console.error('Error: folder missing!');
console.error('----------------------\n');
return displayUsage();
}
folders = Array.isArray(argv.folder) ? argv.folder : [argv.folder];
folders.map(function(folder) {
return path.resolve(__dirname + '/..', folder);
});
cb = dezalgo(cb);
if (port === 0) {
getPort(errTo(cb, function(foundPort) {
cb(null, folders, foundPort, silent);
}));
} else {
port = parseInt(port, 10);
cb(null, folders, port, silent);
}
}
before(async () => {
port = await getPort();
await server.run(port);
});
.then(() => {
return getPort()
})
}
_read() {
socket.on('stdin', (input) => {
console.log('stdin', input);
this.push(input);
this.push(null);
});
}
}
let projPath = path.join(config.YG_BASE_PATH, puuid);
console.log(projPath);
let outerPort;
if (util.PORT_POOL[puuid]) {
outerPort = await getPort({
port: ~~util.PORT_POOL[puuid]
});
} else {
outerPort = await getPort();
}
util.PORT_POOL[puuid] = outerPort;
socket.emit("receive", {
outerPort: outerPort
});
let evn = [`PATH=/root/.nvm/versions/node/v${nodeVersion}/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`];
/**
* 注射器，多种构建平台猜测配置文件
*/