(() => {
const tunnelingAgent = tunnel.httpOverHttps({
maxSockets: poolSize, // Defaults to http.Agent.defaultMaxSockets
proxy: { // Proxy settings
host: proxyHost, // Defaults to 'localhost'
port: proxyPort, // Defaults to 443
localAddress, // Local interface if necessary
// Basic authorization for proxy server if necessary
proxyAuth: 'user:password',
// Header fields for proxy server if necessary
headers: {
'User-Agent': 'Node'
},
// CA for proxy server if necessary
ca: [ fs.readFileSync('origin-server-ca.pem')],
// Server name for verification if necessary
servername: 'example.com',
// Client certification for proxy server if necessary
key: fs.readFileSync('origin-server-key.pem'),
cert: fs.readFileSync('origin-server-cert.pem'),
}
});
const req = http.request({
host: 'example.com',
port: 80,
agent: tunnelingAgent
});
})();
(() => {
const tunnelingAgent = tunnel.httpOverHttp({
maxSockets: poolSize, // Defaults to http.Agent.defaultMaxSockets
proxy: { // Proxy settings
host: proxyHost, // Defaults to 'localhost'
port: proxyPort, // Defaults to 80
localAddress, // Local interface if necessary
// Basic authorization for proxy server if necessary
proxyAuth: 'user:password',
// Header fields for proxy server if necessary
headers: {
'User-Agent': 'Node'
}
}
});
const req = http.request({
host: 'example.com',
port: 80,
agent: tunnelingAgent
});
})();
await new Promise((resolve) => {
const reqData = "name is sparky";
const req = request(
{
socketPath: runtime.metadata.socketPath,
path: "/",
method: "post",
headers: {
"Content-Type": "gibber/ish",
"Content-Length": reqData.length,
},
},
(res) => {
let data = "";
res.on("data", (chunk) => (data += chunk));
res.on("end", () => {
expect(JSON.parse(data).type).to.deep.equal("Buffer");
expect(JSON.parse(data).data.length).to.deep.equal(14);
resolve();
});
}
);
req.write(reqData);
req.end();
});
process.on("exit", () => {
http.request({
port: 3001,
path: "/" + name,
method: "DELETE"
}).end();
});
ngZome.run(() => {
nodeReq = http.request(reqInfo, (res: http.IncomingMessage) => {
let body = '';
res.on('data', (chunk) => body += chunk);
let status = res.statusCode;
let headers = new Headers(res.headers);
let url = res.url;
res.on('end', () => {
let responseOptions = new ResponseOptions({body, status, headers, url});
let response = new Response(responseOptions);
if (utils.isSuccess(status)) {
ngZome.run(() => {
responseObserver.next(response);
});
ngZome.run(() => {
responseObserver.complete();
});
return;
}
ngZome.run(() => {
responseObserver.error(response);
});
});
});
})
function checkWebsiteIsRunning() {
//The url we want is: 'www.random.org/integers/?num=1&min=1&max=10&col=1&base=10&format=plain&rnd=new'
const options: http.RequestOptions = {
host: 'localhost',
port: 4200,
path: '/'
};
const callback = function (response: http.IncomingMessage) {
let content = '';
//another chunk of data has been recieved, so append it to `str`
response.on('data', function (chunk) {
content += chunk;
});
//the whole response has been recieved, so we just print it out here
response.on('end', function () {
if (content.indexOf('<title>Croquet Australia Admin Website</title>') < 0) {
console.log('Website content does not include expected title');
console.log(content);
throw new Error('Website is not running');
}
console.log('Website is running');
});
}
http.request(options, callback).end();
}
public static sender(payload: string, config) {
var headers = {
'Content-Type': 'application/json',
'Content-Length': payload.length,
};
var endpointUrl = config.endpointUrl();
if (endpointUrl && endpointUrl.indexOf("//") === 0) {
// add http protocol if the config did not specify https
endpointUrl = "http:" + endpointUrl;
}
var options = {
host: url.parse(endpointUrl).hostname,
path: url.parse(endpointUrl).pathname,
method: 'POST',
headers: headers
};
var req = http.request(options, (res) => {
res.setEncoding('utf-8');
//returns empty if the data is accepted
var responseString = '';
res.on('data', (data) => {
responseString += data;
});
res.on('end', () => {
});
});
req.write(payload);
req.end();
}
/**
* Get the NPM repository's package.json for a package. This is p
* @param {string} packageName The package name to fetch.
* @param {LoggerApi} logger A logger instance to log debug information.
* @returns {Observable<JsonObject>} An observable that will put the pacakge.json content.
* @private
*/
function _getNpmPackageJson(
packageName: string,
logger: logging.LoggerApi,
): Observable<JsonObject> {
const url = `http://registry.npmjs.org/${packageName.replace(/\//g, '%2F')}`;
logger.debug(`Getting package.json from ${JSON.stringify(packageName)}...`);
let maybeRequest = npmPackageJsonCache.get(url);
if (!maybeRequest) {
const subject = new ReplaySubject<JsonObject>(1);
const request = http.request(url, response => {
let data = '';
response.on('data', chunk => data += chunk);
response.on('end', () => {
try {
const json = JSON.parse(data);
subject.next(json as JsonObject);
subject.complete();
} catch (err) {
subject.error(err);
}
});
response.on('error', err => subject.error(err));
});
request.end();
maybeRequest = subject.asObservable();
npmPackageJsonCache.set(url, maybeRequest);
}
return maybeRequest;
}
return new Promise<string>((resolve, reject) => {
let unexpectedEnd = () => {
reject({code: 'UNKNOWN', message: 'Request ended unexpectedly'});
};
let req = http.request(
{port: parseInt(port), method: method, path: path, headers: headers}, (res) => {
req.removeListener('end', unexpectedEnd);
if (res.statusCode !== 200) {
reject({code: res.statusCode, message: res.statusMessage});
} else {
let buffer: (string|Buffer)[] = [];
res.on('data', buffer.push.bind(buffer));
res.on('end', () => {
resolve(buffer.join('').replace(/\0/g, ''));
});
}
});
if (timeout) {
req.setTimeout(timeout, () => {
reject({code: 'TIMEOUT', message: 'Request timed out'});
});
}
req.on('error', reject);
req.on('end', unexpectedEnd);
if (hasContent) {
req.write(data as string);
}
req.end();
});
worker.request = new Promise<PhantomResult>((resolve, reject) => {
const hmac = crypto.createHmac("sha256", worker.key)
.update([worker.counter, 'POST', '/', `localhost:${worker.port}`, 'application/json', payload].join('\n'))
.digest('hex');
http.request({
port: worker.port,
method: 'POST',
auth: worker.counter + ':' + hmac,
headers: {
'Content-Type': 'application/json',
'Content-Length': payload.length,
},
}, (response) => {
let result = '';
response.on('error', (error) => {
reject(error);
});
response.on('data', (data) => {
result += data;
});
response.on('end', () => {
resolve([response, result]);
});
})
.on('error', (error) => {
reject(error);
})
.end(payload);
});
