app.get('/api/info/os', auth.dev, function (req, res) {
res.json({
type: os.type(),
platform: os.platform(),
arch: os.arch(),
release: os.release(),
uptime: os.uptime(),
loadavg: os.loadavg(),
totalmem: os.totalmem(),
freemem: os.freemem(),
cpus: os.cpus()
});
});
FileManager.downloadedBinaries = function (outputDir) {
var ostype = os.type();
var arch = os.arch();
var binaries = FileManager.setupBinaries();
var existingFiles = FileManager.getExistingFiles(outputDir);
var downloaded = {};
for (var bin in binaries) {
var binary = FileManager.downloadedVersions_(binaries[bin], ostype, arch, existingFiles);
if (binary != null) {
downloaded[binary.id()] = binary;
}
}
return downloaded;
};
socket.data(['rsvp', 'please-authenticate'], function() {
console.log('Authenticating...');
socket.send(['rsvp', 'login-as-client'], {
hostInfo : {
displayName: config.displayName,
comment: config.comment,
type: os.type(),
platform: os.platform(),
hostname: os.hostname(),
arch: os.arch(),
nics: os.networkInterfaces()
}
});
});
module.exports.getSystemInfo = function (callback) {
var sysInfo = {
arch: os.arch(),
cpus: os.cpus(),
freemem: os.freemem(),
loadavg: os.loadavg(),
platform: os.platform(),
release: os.release(),
totalmem: os.totalmem(),
type: os.type(),
uptime: os.uptime()
}
callback(sysInfo)
}
function getIEDriverUrl(version) {
// Example output: http://selenium-release.storage.googleapis.com/2.41/IEDriverServer_x64_2.41.0.zip
// Example output: http://selenium-release.storage.googleapis.com/2.41/IEDriverServer_Win32_2.41.0.zip
// versioning: major.minor.build.revision. e.g. v2.41.0.2
var tpl = 'http://selenium-release.storage.googleapis.com/{version}/IEDriverServer_{platform}_{patch}.zip';
var platform = os.arch() === 'x64' ? 'x64' : 'Win32';
var patch = version;
version = version.split('.').slice(0,2).join('.');
return utils.format(tpl, {
version: version,
patch: patch,
platform: platform
});
}
function badOS() {
var badVersion = false
if (!process.versions) {
badVersion = true
} else {
var version = process.versions.node.split('.')
if (version[1] <= 8 && version[2] <= 5) badVersion = true
}
return badVersion &&
os.arch() === 'x64' &&
os.type() === 'SunOS'
}
.then(paths => {
let tasks = []
if (shouldBuildAll) {
platforms.forEach(plat => {
archs.forEach(arch => {
tasks.push(pack(plat, arch))
})
})
} else {
tasks.push(pack(os.platform(), os.arch()))
}
return Promise.all(tasks)
}).then(list => {
Acon.sysinfo = function(socket,type){
if(infoi>10){infoi=0;}
//if(infoi==5){Acon.plist(function(data){Agl.plist = data;});}
if(!type) type=1;
if(!Agl.client[socket.id] || Agl.client[socket.id].login==false){return;}
var obj = Acon.osinfo();
//if(Agl.plist){obj.plist = Agl.plist;delete Agl.plist;}
if(type==2){
obj.info = {hostname:os.hostname(),type:os.type(),release:os.release(),arch:os.arch(),platform:os.platform()}
}
socket.emit('sysinfo',obj);
infoi++;
setTimeout(function() {Acon.sysinfo(socket);}, 1000);
}
getUrl: function (urlOrOptions, callback) {
var future = new Future;
// can't just use Future.wrap, because we want to return "body", not
// "response".
urlOrOptions = _.clone(urlOrOptions); // we are going to change it
var appVersion;
try {
appVersion = files.getToolsVersion();
} catch(e) {
appVersion = 'checkout';
}
// meteorReleaseContext - an option with information about app directory
// release versions, etc, is used to get exact Meteor version used.
if (urlOrOptions.hasOwnProperty('meteorReleaseContext')) {
// Get meteor app release version: if specified in command line args, take
// releaseVersion, if not specified, try global meteor version
var meteorReleaseContext = urlOrOptions.meteorReleaseContext;
appVersion = meteorReleaseContext.releaseVersion;
if (appVersion === 'none')
appVersion = meteorReleaseContext.appReleaseVersion;
if (appVersion === 'none')
appVersion = 'checkout';
delete urlOrOptions.meteorReleaseContext;
}
// Get some kind of User Agent: environment information.
var ua = util.format('Meteor/%s OS/%s (%s; %s; %s;)',
appVersion, os.platform(), os.type(), os.release(), os.arch());
var headers = {'User-Agent': ua };
if (_.isObject(urlOrOptions))
urlOrOptions.headers = _.extend(headers, urlOrOptions.headers);
else
urlOrOptions = { url: urlOrOptions, headers: headers };
httpHelpers.request(urlOrOptions, function (error, response, body) {
if (error)
future.throw(new files.OfflineError(error));
else if (response.statusCode >= 400 && response.statusCode < 600)
future.throw(response);
else
future.return(body);
});
return future.wait();
}
})(function () {
var os = require("os");
var details = {
workerId: _workerId,
environment: __appEnv,
processName: process.title,
versions: process.versions,
architecture: process.arch,
platform: process.platform,
environmentVariables: process.env,
pid: process.pid,
features: process.features,
debugPort: process.debugPort,
listeningPort: _app.get('port'),
nodeFilePath: process.execPath,
processConfig: process.config,
hostname: os.hostname(),
uptime: os.uptime(),
ram: {
free: os.freemem(),
total: os.totalmem()
},
cpus: os.cpus(),
osType: {
name: os.type(),
release: os.release(),
arch: os.arch()
},
networkInterfaces: os.networkInterfaces(),
tempDir: os.tmpDir(),
updated: new Date().getTime()
};
details = JSON.parse(JSON.stringify(details)); //sanitize
ClusterWorker.update({workerId: _workerId}, {$set: details}, {upsert: true}, function (err) {
if (err) log.error(err);
});
try {
ClusterWorker.find({updated: {$lt: (new Date().getTime() - (1000 * 40))}}, function (err, objList) {
objList.forEach(function (obj) {
ClusterWorker.remove({_id: obj._id}, function (err) {
if (err) log.error(err);
else globalEvent.emit("OnClusterWorkerFoundInactive", obj);
});
});
});
} catch (c) {
log.error(c);
}
}), 1000 * 30);
var Process = function() {
var mx = ManagementFactory.getRuntimeMXBean();
var rt = Runtime.getRuntime();
this.platform = os.type();
this.arch = os.arch();
this.pid = System.getProperty("sprintstack.pid");
this.nextTick = function(callback) {
return new future(callback);
}
this.uptime = function() {
return mx.getUptime();
}
this.getgid = function() {
return System.getProperty("sprintstack.gid");
}
this.getuid = function() {
return System.getProperty("sprintstack.uid");
}
this.memoryUsage = function() {
var heap = rt.totalMemory();
var used = heap - rt.freeMemory();
return {
heapTotal: heap,
heapUsed: used
};
}
this.exit = function() {
var code = 0;
if (arguments.length > 0) code = arguments[0];
java.lang.System.exit(code);
};
this.cwd = function() {
return System.getProperty("sprintstack.dir");
}
this.env = {}
};
var buildInfo; // loaded lazily
/**
* GET /$v/version
*
* Example response from a Go docker server:
* {'ApiVersion':'1.12',"Arch":"amd64","GitCommit":"990021a",
* 'GoVersion':'go1.2.1',"KernelVersion":"3.13.0-36-generic",
* 'Os':'linux',"Version":"1.0.1"}
*/
function version(req, res, next) {
var dockerArch = dockerArchFromArch[os.arch()];
if (!dockerArch) {
return next(new errors.DockerError('unknown arch:' + os.arch()));
}
var dockerOs = dockerOsFromPlatform[os.platform()];
if (!dockerOs) {
return next(new errors.DockerError(
'unknown platform:' + os.platform()));
}
buildInfo = require(path.resolve(__dirname, '../../etc/build.json'));
var v = {
'ApiVersion': common.SERVER_VERSION.toString(),
'Arch': dockerArch,
'GitCommit': buildInfo.commit,
'GoVersion': 'node' + process.version.slice(1),
// XXX shell out to `uname` for this? Then *cache* that.
// 'KernelVersion': '3.13.0-36-generic',
'Os': dockerOs,
'Version': req.app.version
};
res.send(v);
next();
}
(function() {
const os = require('os');
console.log('arch: ' + os.arch());
console.log('free: ' + os.freemem());
console.log('total: ' + os.totalmem());
console.log( 'platform: ' + os.platform() );
console.log( 'release: ' + os.release() );
console.log( 'os type: ' + os.type() );
console.log( 'uptime: ' + os.uptime() );
console.log('os.cpus()');
//dump(os.cpus());
console.log(os.cpus());
})();
core.app.get('/config', function(request, response) {
response.json(
{
'current_time': (new Date().toLocaleString()),
'NODE_ENV': process.env.NODE_ENV,
'OS': {
'hostname':os.hostname(),
'arch':os.arch(),
'type':os.type(),
'platform':os.platform(),
'release':os.release(),
'NodeJS version':process.version
}
});
});
SystemInfo.prototype.getGeneral = function() {
return {
"hostname": os.hostname(),
"type": os.type(),
"platform": os.platform(),
"arch": os.arch(),
"release": os.release(),
"uptime": os.uptime(),
//"loadavg": os.loadavg(),
//"totalmem": os.totalmem(),
//"freemem": os.freemem(),
//"cpus": os.cpus(),
//"netwok": os.networkInterfaces(),
};
};
exports.sendStats = function(cmd) {
debug('sendStats: %s', cmd);
try {
var sessionId = util.guid();
var timestamp = new Date().getTime();
var data = {
appId: 'lu348f5799fc5u3eujpzn23acmxy761kq6soyovjc3k6kwrs',
device: {
sdk_version: pkg.version,
os_version: (os.platform() + ' ' + os.arch() + ' ' + os.release()),
device_id: getDeviceId(),
app_version: pkg.version,
device_model: os.platform(),
os: 'ios'
},
events: {
event: [{
du: 1,
name: cmd,
ts: timestamp
}],
launch: {
date: timestamp,
sessionId: sessionId
},
terminate: {
activities: [],
duration: 1,
sessionId: sessionId
}
}
};
util.request('stats/collect', {
method: 'POST',
appId: 'lu348f5799fc5u3eujpzn23acmxy761kq6soyovjc3k6kwrs',
appKey: 'nrit4mhmqzm1euc3n3k9fv3w0wo72v1bdic6tfrl2usxix3e',
data: data,
apiServer: util.API_HOST.cn
}, function(err) {
if (err) {
debug(err.stack);
}
});
} catch (err) {
debug(err.stack);
//ignore
}
};
var getDefaultConfig = function() {
// Grab version things
var packageJson = require(path.join(env.srcRoot, 'package.json'));
// Check whether we are in NW or not
var isNw = _.has(process.versions, 'node-webkit');
var config = {
appConfigFilename: APP_CONFIG_FILENAME,
appsRoot: path.join(env.home, 'Lando'),
appRegistry: path.join(env.userConfRoot, 'appRegistry.json'),
cache: true,
composeBin: env.composeBin,
composeVersion: '3.2',
configFilename: CONFIG_FILENAME,
containerGlobalEnv: {},
dockerBin: env.dockerBin,
dockerBinDir: env.dockerBinDir,
engineId: user.getEngineUserId(),
engineGid: user.getEngineUserGid(),
env: env.env,
home: env.home,
isNW: isNw,
logLevel: 'debug',
logLevelConsole: 'info',
loadPassphraseProtectedKeys: false,
node: process.version,
os: {
type: os.type(),
platform: os.platform(),
release: os.release(),
arch: os.arch()
},
stats: {
report: true,
url: 'http://metrics.devwithlando.io'
},
srcRoot: env.srcRoot,
sysConfRoot: env.sysConfRoot,
userConfRoot: env.userConfRoot,
version: packageJson.version
};
// Return default config
return config;
};
var getUserAgent = function () {
var version;
if (release.current)
version = release.current.isCheckout() ? 'checkout' : release.current.name;
else
// This happens when we haven't finished starting up yet (say, the
// user passed --release 1.2.3 and we have to download 1.2.3
// before we can get going), or if we are using an installed copy
// of Meteor to 'meteor update'ing a project that was created by a
// checkout and doesn't have a version yet.
version = files.inCheckout() ? 'checkout' : files.getToolsVersion();
return util.format('Meteor/%s OS/%s (%s; %s; %s;)', version,
os.platform(), os.type(), os.release(), os.arch());
};
function trackingEvent(name, properties, additionalData) {
if (commander.mixpanelToken) {
properties = merge(properties, { 'Server OS': os.platform(), 'Server Arch': os.arch() });
if (commander.mixpanelData)
properties = merge(properties, JSON.parse(new Buffer(commander.mixpanelData, 'base64').toString()));
if (additionalData)
properties = merge(properties, JSON.parse(new Buffer(additionalData, 'base64').toString()));
getDistinctId(function(distinctId) {
properties['distinct_id'] = distinctId;
mixpanel.init(commander.mixpanelToken).track(name, properties);
});
}
}
var makeUserAgentStr = function () {
var systemInfo = os.type() + " Version" + os.release() + ": " + os.arch();
var versionKeys = Object.keys(process.versions);
var nodeInfo = '';
versionKeys.forEach(function (key) {
if (key === 'node') {
nodeInfo += "NodeJS/" + process.versions[key] + ' (BccsSDK v' + pkg.version + ')';
}else{
nodeInfo += key + "/" + process.versions[key] + " ";
}
});
return 'BCCS_SDK/3.0 (' + systemInfo + ') ' + nodeInfo;
};
/**
* @param {string} projectRoot
* @param {!BrowserFetcher.Options=} options
*/
constructor(projectRoot, options = {}) {
this._downloadsFolder = options.path || path.join(projectRoot, '.local-chromium');
this._downloadHost = options.host || DEFAULT_DOWNLOAD_HOST;
this._platform = options.platform || '';
if (!this._platform) {
const platform = os.platform();
if (platform === 'darwin')
this._platform = 'mac';
else if (platform === 'linux')
this._platform = 'linux';
else if (platform === 'win32')
this._platform = os.arch() === 'x64' ? 'win64' : 'win32';
assert(this._platform, 'Unsupported platform: ' + os.platform());
}
assert(supportedPlatforms.includes(this._platform), 'Unsupported platform: ' + this._platform);
}
function sendResetMessage()
{
var info =
{
arch: OS.arch(),
platform: OS.platform(),
osrelease: OS.release(),
ostype: OS.type()
}
var uuid = SETTINGS.getEvoGUID()
LOGGER.log('[file-server.js] ------ Sending factory reset')
mDeviceInfo = info
sendMessageToServer(mSocket, 'workbench.factory-reset', { sessionID: mSessionID, uuid: uuid, info: info })
mHeartbeatTimer = setInterval(heartbeat, mHeartbeatInterval)
heartbeat()
}
exec('sw_vers', function(err, stdout, stderr) {
var items = { };
stdout.trim().split('\n').forEach(function(line) {
var parts = line.split(':').map(function(s) {
return s.trim();
});
items[parts[0]] = parts[1];
});
result.distro = {
key: 'OS',
value: distro + ' ' +
items['ProductVersion'] + ' ' +
items['BuildVersion'] + ' ' + os.arch()
};
done();
});
function sendConnectMessage()
{
var info =
{
arch: OS.arch(),
platform: OS.platform(),
osrelease: OS.release(),
ostype: OS.type()
}
var uuid = SETTINGS.getEvoGUID()
LOGGER.log('[file-server.js] sendConnectMessage called. ------ uuid = '+uuid)
mDeviceInfo = info
sendMessageToServer(mSocket, 'workbench.connected', { sessionID: mSessionID, uuid: uuid, info: info })
mHeartbeatTimer = setInterval(heartbeat, mHeartbeatInterval)
heartbeat()
}
fs.readFile("/etc/hostname", "utf8", (err, data) => {
let val = "";
val += "Hostname: " + data +"\n";
val += "Platform: " + os.platform()+"\n";
val += "Arch: " + os.arch() + "\n";
val += "CPU count: " + os.cpus().length+ "\n";
val += "Uptime: " + os.uptime()+ "\n";
if (content && content.length && content.indexOf("verbose") > -1) {
val += util.inspect(os.cpus()) + "\n";
val += util.inspect(os.networkInterfaces())+ "\n";
}
callback(null, val);
});
initLogs: function(appVersion) {
var ifaces = os.networkInterfaces();
var memories = os.totalmem() / 1024 / 1024 / 1024;
var freeMemories = os.freemem() / 1024 / 1024 / 1024;
this.info("Launching Application: " + AppName());
this.info("Network Interfaces", ifaces);
this.info("Operating System", {
'Release': os.release(),
'Type': os.type(),
'Arch': os.arch(),
'LoadAvg': os.loadavg(),
'Total Memory': memories + 'GB',
'Free Memory': freeMemories + 'GB',
'CPUs': os.cpus().length
});
}
getMashineInfo = function () {
return {
hostname:os.hostname(),
osType:os.type(),
osPlatform:os.platform(),
osArch:os.arch(),
osVer:os.release(),
uptime:os.uptime(),
load:os.loadavg(),
totalmem:os.totalmem(),
freemem:os.freemem(),
cpus:os.cpus(),
nics:os.networkInterfaces(),
lastTimeStamp: new Date().getTime()
};
};
Agent.prototype.getSystemInfo = function (callback) {
var system = {};
system.platform = os.platform();
system.hostname = os.hostname();
// cpu architecture
system.arch = os.arch();
system.release = os.release();
// uptime in seconds
system.uptime = os.uptime();
system.totalmem = os.totalmem() / 1048576; // convert to MB
system.freemem = os.freemem() / 1048576; // convert to MB
// os.cpus() // probably overkill to no the specifics of the cpus
system.device = config.device || system.hostname;
callback(null, system);
}
worker.addFunction("statOS", function(job) {
var retval = {
name: os.type(),
platform: os.platform(),
arch: os.arch(),
release: os.release(),
uptime: os.uptime(),
load: os.loadavg(),
totalMemory: os.totalmem(),
freeMemory: os.freemem(),
cpus: os.cpus(),
networkInterfaces: os.networkInterfaces(),
}
job.workComplete(JSON.stringify({result: retval}));
});
server.get('/healthcheck', function(req, res, next) {
res.send({
alive:true,
hostname:os.hostname(),
type:os.type(),
platform:os.platform(),
arch:os.arch(),
release:os.release(),
uptime:os.uptime(),
load:os.loadavg(),
totalMemory:os.totalmem(),
freeMemory:os.freemem(),
cpus:os.cpus()
});
return next();
});