Beispiel #1
0
function start () {
  // Only one app per app in osx...
  const shouldQuit = app.makeSingleInstance(() => {
    if (mainWindow) {
      mainWindow.show(true)
      mainWindow.window.focus()
    }
  })

  if (shouldQuit) {
    console.log('Only one instance of keybase GUI allowed, bailing!')
    app.quit()
    return
  }

  // Check supported OS version
  if (os.platform() === 'darwin') {
    // Release numbers for OS versions can be looked up here: https://en.wikipedia.org/wiki/Darwin_%28operating_system%29#Release_history
    // 14.0.0 == 10.10.0
    // 15.0.0 == 10.11.0
    if (!semver.satisfies(os.release(), '>=14.0.0')) {
      dialog.showErrorBox('Keybase Error', 'This version of OS X isn\'t currently supported.')
      app.quit()
      return
    }
  }

  process.on('uncaughtException', e => {
    console.log('Uncaught exception on main thread:', e)
  })

  // MUST do this else we get limited by simultaneous hot reload event streams
  app.commandLine.appendSwitch('ignore-connections-limit', 'localhost')

  if (__DEV__) { // eslint-disable-line no-undef
    app.commandLine.appendSwitch('enable-logging')
    app.commandLine.appendSwitch('v', 3)
  }

  hello(process.pid, 'Main Thread', process.argv, __VERSION__) // eslint-disable-line no-undef

  consoleHelper()
  ipcLogs()
  devTools()
  menuBar()
  urlHelper()
  kbfsHelper()
  ListenLogUi()
  windowHelper(app)

  installer(err => {
    if (err) {
      console.log('Error: ', err)
    }
    splash()
  })

  app.once('ready', () => {
    mainWindow = MainWindow()
    storeHelper(mainWindow)
    if (!mainWindow.initiallyVisible) {
      hideDockIcon()
    }
  })

  // Called when the user clicks the dock icon
  app.on('activate', () => {
    mainWindow.show(true)
  })

  // Don't quit the app, instead try to close all windows
  app.on('close-windows', event => {
    const windows = BrowserWindow.getAllWindows()
    windows.forEach(w => {
      // We tell it to close, we can register handlers for the 'close' event if we want to
      // keep this window alive or hide it instead.
      w.close()
    })
  })

  app.on('before-quit', event => {
    const windows = BrowserWindow.getAllWindows()
    windows.forEach(w => {
      w.destroy()
    })
  })

  // quit through dock. only listen once
  app.once('before-quit', event => {
    console.log('Quit through before-quit')
    event.preventDefault()
    executeActionsForContext('beforeQuit')
  })
}
Beispiel #2
0
/**
* Outputs environment details at the top of the log file
* for each run of `titanium build`
* @param {Object} cli - The CLI instance
*
* See http://en.wikipedia.org/wiki/Darwin_%28operating_system%29#Release_history for
* os.release() to version mapping for OS X. (e.g. 14.0.0 is v10.10 Yosemite)
*/
function logBanner(cli) {
	var os = require('os');
	return new Date().toLocaleString() + '\n\n' +
		'Build Environment \n' +
		'   Host OS         = ' + (os.platform()==='darwin' ? "OS X" : os.platform()) + ' ' + os.release() + ', ' + os.arch() + '\n'  +
		'   Target platform = ' + ti.resolvePlatform(cli.argv.platform) + '\n'  +
		'   CLI version     = ' + cli.version + '\n'  +
		'   SDK version     = ' + cli.argv.sdk + '\n' +
		'   SDK path        = ' + cli.sdk.path + '\n' +
		'   Node version    = ' + process.version + '\n' +
		'   Command         = ' + cli.argv.$ + ' ' + cli.argv.$_.join(' ') + '\n' +
		'\n';
}
'use strict';

var os = require('os');
var url = require('url');

var request = require('request');

var ResourceError = require('../error/ResourceError');
var authc = require('../authc');
var packageJson = require('../../package.json');
var utils = require('../utils');

var USER_AGENT_VALUE = 'stormpath-sdk-node/' + packageJson.version + ' node/' + process.versions.node + ' ' + os.platform() + '/' + os.release();

/**
 *
 * @param {object} options
 * @constructor
 */
function RequestExecutor(options) {

  options = options || {};

  this.baseUrl = options.baseUrl || 'https://api.stormpath.com/v1';

  this.requestAuthenticator = authc.getAuthenticator(options);

  options.headers = options.headers || {};
  options.json = true;

  this.options = options;
Beispiel #4
0
function supportsColor(stream) {
	if (hasFlag('no-color') ||
		hasFlag('no-colors') ||
		hasFlag('color=false')) {
		return 0;
	}

	if (hasFlag('color=16m') ||
		hasFlag('color=full') ||
		hasFlag('color=truecolor')) {
		return 3;
	}

	if (hasFlag('color=256')) {
		return 2;
	}

	if (hasFlag('color') ||
		hasFlag('colors') ||
		hasFlag('color=true') ||
		hasFlag('color=always')) {
		return 1;
	}

	if (stream && !stream.isTTY) {
		return 0;
	}

	if (process.platform === 'win32') {
		// Node.js 7.5.0 is the first version of Node.js to include a patch to
		// libuv that enables 256 color output on Windows. Anything earlier and it
		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
		// release that supports 256 colors. Windows 10 build 14931 is the first release
		// that supports 16m/TrueColor.
		const osRelease = os.release().split('.');
		if (
			Number(process.versions.node.split('.')[0]) >= 8 &&
			Number(osRelease[0]) >= 10 &&
			Number(osRelease[2]) >= 10586
		) {
			return Number(osRelease[2]) >= 14931 ? 3 : 2;
		}

		return 1;
	}

	if ('CI' in env) {
		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
			return 1;
		}

		return 0;
	}

	if ('TEAMCITY_VERSION' in env) {
		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
	}

	if ('TERM_PROGRAM' in env) {
		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);

		switch (env.TERM_PROGRAM) {
			case 'iTerm.app':
				return version >= 3 ? 3 : 2;
			case 'Hyper':
				return 3;
			case 'Apple_Terminal':
				return 2;
			// No default
		}
	}

	if (/-256(color)?$/i.test(env.TERM)) {
		return 2;
	}

	if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
		return 1;
	}

	if ('COLORTERM' in env) {
		return 1;
	}

	if (env.TERM === 'dumb') {
		return 0;
	}

	return 0;
}
  this.After(function(scenario) {
    sandbox.restore();

    scenario.attach('Operating System Platform: ' + os.platform(), 'text/plain');
    scenario.attach('Operating System Release Version ' + os.release(), 'text/plain');
  });
Beispiel #6
0
var os = require('os');

var obj = {};
obj.arch = os.arch();
obj.cpus = os.cpus();
obj.endianness = os.endianness();
obj.freemem = os.freemem();
obj.hostname = os.hostname();
obj.loadavg = os.loadavg();
obj.networkInterfaces = os.networkInterfaces();
obj.platform = os.platform();
obj.release = os.release();
obj.tmpdir = os.tmpdir();
obj.totalmem = os.totalmem();
obj.type = os.type();
obj.uptime = os.uptime();

console.log(obj);
Beispiel #7
0
    var version = process.versions.node.split('.');
    if (version[1] <= 8 && version[2] <= 5) badVersion = true;
  }

  return badVersion &&
         os.arch() === 'x64' &&
         os.type() === 'SunOS';
}

/**
 * Settings actually get scraped below.
 */

// in 64-bit SmartOS zones, node <= 0.8.5 pukes on os.cpus()
if (!badOS()) addSetting('Processors', os.cpus().length);

addSetting('OS',              os.type());
addSetting('OS version',      os.release());
addSetting('Node.js version', process.version);
addSetting('Architecture',    process.arch);

remapConfigSettings();
findPackages();

module.exports = {
  toJSON : function () { return settings; },
  setFramework : function (framework) { addSetting("Framework", framework); },
  setDispatcher : function (dispatcher) { addSetting("Dispatcher", dispatcher); },
  get : getSetting
};
Beispiel #8
0
//Returns the hostname of the operating system as a string.
console.log("os.hostname()",os.hostname());

//Returns an array containing the 1, 5, and 15 minute load averages.
console.log("os.loadavg()",os.loadavg());

//Returns an object containing only network interfaces that have been assigned a network address.
console.log("os.networkInterfaces()",os.networkInterfaces());

//Returns a string identifying the operating system platform as set during compile time of Node.js.
//'aix' 'darwin' 'freebsd' 'linux' 'openbsd' 'sunos' 'win32' 'android'
console.log("os.platform()",os.platform());

//Returns a string identifying the operating system release.
console.log("os.release()",os.release());

//Returns a string specifying the operating system's default directory for temporary files.
console.log("os.tmpdir()",os.tmpdir());

//Returns the total amount of system memory in bytes as an integer.
console.log("os.totalmem()",os.totalmem());

//Returns a string identifying the operating system 
//'Linux' on Linux, 'Darwin' on macOS and 'Windows_NT' on Windows.
console.log("os.type()",os.type());

//Returns the system uptime in number of seconds.
console.log("os.uptime()",os.uptime());

//Returns information about the currently effective user 
Beispiel #9
0
function errorHandler (er) {
  log.disableProgress()
  if (!npm.config || !npm.config.loaded) {
    // logging won't work unless we pretend that it's ready
    er = er || new Error('Exit prior to config file resolving.')
    console.error(er.stack || er.message)
  }

  if (cbCalled) {
    er = er || new Error('Callback called more than once.')
  }

  cbCalled = true
  if (!er) return exit(0)
  if (typeof er === 'string') {
    log.error('', er)
    return exit(1, true)
  } else if (!(er instanceof Error)) {
    log.error('weird error', er)
    return exit(1, true)
  }

  var m = er.code || er.message.match(/^(?:Error: )?(E[A-Z]+)/)
  if (m && !er.code) {
    er.code = m
  }

  ;[
    'type',
    'fstream_path',
    'fstream_unc_path',
    'fstream_type',
    'fstream_class',
    'fstream_finish_call',
    'fstream_linkpath',
    'stack',
    'fstream_stack',
    'statusCode',
    'pkgid'
  ].forEach(function (k) {
    var v = er[k]
    if (!v) return
    if (k === 'fstream_stack') v = v.join('\n')
    log.verbose(k, v)
  })

  log.verbose('cwd', process.cwd())

  var os = require('os')
  log.verbose('', os.type() + ' ' + os.release())
  log.verbose('argv', process.argv.map(JSON.stringify).join(' '))
  log.verbose('node', process.version)
  log.verbose('npm ', 'v' + npm.version)

  ;[
    'file',
    'path',
    'code',
    'errno',
    'syscall'
  ].forEach(function (k) {
    var v = er[k]
    if (v) log.error(k, v)
  })

  var msg = errorMessage(er)
  msg.summary.concat(msg.detail).forEach(function (errline) {
    log.error.apply(log, errline)
  })
  if (npm.config.get('json')) {
    var error = {
      error: {
        code: er.code,
        summary: messageText(msg.summary),
        detail: messageText(msg.detail)
      }
    }
    console.log(JSON.stringify(error, null, 2))
  }

  exit(typeof er.errno === 'number' ? er.errno : 1)
}
  track(name, data) {
    if (!name) {
      return;
    }

    const payload = data || {};

    if (localStorage.getItem('metrics.enabled') !== 'true') {
      return;
    }

    let id = localStorage.getItem('metrics.id');
    if (!id) {
      id = uuid.v4();
      localStorage.setItem('metrics.id', id);
    }

    const osName = os.platform();
    const osVersion = util.isWindows() ? os.release() : osxRelease(os.release()).version;

    mixpanel.track(name, assign({
      distinct_id: id,
      version: util.packagejson().version,
      'Operating System': osName,
      'Operating System Version': osVersion,
      'Operating System Architecture': os.arch()
    }, payload));
  },

};
Beispiel #11
0
var os = require('os');
console.log('TempDir:\t ' + os.tmpdir() );
console.log('endianness: \t' + os.endianness);
console.log('hostname: \t'+ os.hostname());
console.log('type: \t\t'+ os.type());
console.log('platform: \t' + os.platform());
console.log('arch: \t\t'+ os.arch());
console.log('release: \t'+ os.release());
console.log('uptime: \t'+ os.uptime());
console.log('loadavg: \t'+ os.loadavg());
console.log('totalmem: \t' + os.totalmem());
console.log('freemem: \t'+ os.freemem());
console.log('EOL: \t'+ os.EOL);
console.log('Cpus: \t\t:' + JSON.stringify(os.cpus()));
console.log("networkInterfaces: " + JSON.stringify(os.networkInterfaces()));
Beispiel #12
0
 }).then(() => {
   if (log.isEnabledFor(log.VERBOSE)) {
     Promise.longStackTraces();
   }
   log.info('Versions OS: %s sitespeed.io: %s browsertime: %s coach: %s', os.platform() + ' ' + os.release(), packageInfo.version, packageInfo.dependencies.browsertime, packageInfo.dependencies.webcoach);
 }).then((pluginNames) => {
Beispiel #13
0
export function getOsVersion(): string {
  return os.release();
}
Beispiel #14
0
if (STUDENT_IDS.length) {
    log("Will test only for student ids " + STUDENT_IDS);
}

log("******************* Starting homework #" + HOMEWORK_NUMBER + " *******************");

var SOLUTIONS_FOLDER = './data/' + HOMEWORK_NUMBER;

var walk    = require('walk');
//****************************************************************************************************************

//this will be used to invoke a compiler
//if you don't have clang++, you wil have to modify that
var COMPILER_START_COMMAND = 'clang++ -Xclang -std=c++14 -O3 -stdlib=libc++ -I/Developer/git/GPAPI/GPAPI/HPC2015/ -fno-vectorize  -lstdc++ -lpthread -march=native';

var USE_SANDBOXING = (os.platform()=="darwin") && parseFloat(os.release()) >= 15;

checkUserDirExists("./data");
checkUserDirExists(SOLUTIONS_FOLDER);

if (USE_SANDBOXING) {
    log("Sandboxing is supported and will be used");
} else {
    log("WARNING! Sandboxing is not supported and will be disabled");
}

//the folder that holds the homeworks for all students
//it should be located in the folder from which this file is started
//if it not exists there, it will be created. In this folder the script will create a folder for each student id.
//In each student id folders, there will be a file named 'sandbox', that has the sandbox configuration for that folder and a folder for each homework.
//In each homework folder, there will be a HOMEWORK_EXECUTABLE_NAME.cpp file (containing the source), HOMEWORK_EXECUTABLE_NAME.bin (containing the executable) and results.txt (containing part of the log that this scripts prints).
.on('request', function (request, response){

	// Ability to chain calls
	var writeHead = response.writeHead;
	response.writeHead = function (){
		writeHead.apply(this, arguments);
		return this;
	};

	var request_url = url.parse(request.url, true/*???*/);
	switch(request_url.pathname){
		case '/':
		response
		.writeHead(200, {'Content-type': 'text/html'})
		.end(["<html><head><title>Hello, world!</title></head>",
			"<body><h1>Hello, world!</h1>",
			"<p><a href='/osinfo'>OS Info</a></p>",
			"</body></html>"].join('\n'));
		break;
		case '/osinfo':
		response
		.writeHead(200, {'Content-type':'text/html'})
		.end(["<html><head>",
			"<title>Operating System Info</title></head>",
			"<body><h1>Operating System Info</h1>",
			"<table>",
			"<tr><th>TMP Dir</th><td>{tmpdir}</td></tr>",
			"<tr><th>Host Name</th><td>{hostname}</td></tr>",
			"<tr><th>OS Type</th>",
			"<td>{type} {osplat} {osarch} {osrelease}</td></tr>",
			"<tr><th>Uptime</th>",
			"    <td>{uptime} {loadavg}</td></tr>",
			"<tr><th>Memory</th>",
			"    <td>total: {totalmem} free:{freemem}</td></tr>",
			"<tr><th>CPU's</th>",
			"    <td><pre>{cpudata}</pre></td></tr>",
			"<tr><th>Network</th>",
			"    <td><pre>{netdata}</pre></td></tr>",
			"</table>",
			"</body></html>"]
			.join('\n')
			.replace("{tmpdir}", os.tmpDir())
			.replace("{hostname}", os.hostname())
			.replace("{type}", os.type())
			.replace("{osplat}", os.platform())
			.replace("{osarch}", os.arch())
			.replace("{osrelease}", os.release())
			.replace("{uptime}", os.uptime())
			.replace("{loadavg}", util.inspect(os.loadavg()))
			.replace("{totalmem}", os.totalmem())
			.replace("{freemem}", os.freemem())
			.replace("{cpudata}", util.inspect(os.cpus()))
			.replace("{netdata}", util.inspect(os.networkInterfaces()))
		//
		);
		//
		break;
		default:
			// error
			console.log("HOLA");
			response
			.writeHead(404, {'Content-type': 'text/plain'})
			.end("bad URL "+request.url);
		//
		break;
	}

})
Beispiel #16
0
 function walkThroughSchedule() {
     
     var schedule = JSON.parse(localStorage.schedule || '{}');
     
     var today = new Date();
     var nowTime = Date.now();
     
     // once every day send analytics daily hit
     var todayDate = today.getFullYear() + '-' + (today.getMonth() + 1) + '-' + today.getDate();
     if (todayDate !== schedule.lastAnalyticsDailyHit) {
         analytics.dailyHit();
         schedule.lastAnalyticsDailyHit = todayDate;
     }
     
     // once every month send reaport about basic usage informations
     if (!schedule.nextAnalyticsMonthlyReaport) {
         // first reaport in 7 days
         schedule.nextAnalyticsMonthlyReaport = nowTime + daysToMs(7);
     } else if (schedule.nextAnalyticsMonthlyReaport <= nowTime) {
         analytics.monthlyReaport({
             feedsCount: feedsService.feeds.length,
             categoriesCount: feedsService.categoriesNames.length,
             tagsCount: articlesService.allTags.length,
             articlesDbSize: articlesService.dbSize,
             platform: config.targetPlatform + '|' + os.platform() + '|' + os.type() + '|' + os.release(),
             windowSize: win.width + 'x' + win.height
         });
         schedule.nextAnalyticsMonthlyReaport = nowTime + daysToMs(30);
     }
     
     // check for new version every 7 days
     if (!schedule.nextCheckForUpdates || schedule.nextCheckForUpdates <= nowTime) {
         schedule.nextCheckForUpdates = nowTime + daysToMs(7);
         checkForUpdates();
     }
     
     // update all feeds' favicons every 7 days
     if (!schedule.nextFaviconUpdate || schedule.nextFaviconUpdate <= nowTime) {
         faviconsService.updateMany(feedsService.feeds);
         schedule.nextFaviconUpdate = nowTime + daysToMs(7);
     }
     
     // perform database compaction every 7 days
     if (!schedule.nextDatabaseCompaction || schedule.nextDatabaseCompaction <= nowTime) {
         // assume month is 31 days
         var olderThan = nowTime - (config.keepArticlesForMonths * 31 * 24 * 60 * 60 * 1000);
         articlesService.removeOlderThan(olderThan, config.keepTaggedArticlesForever)
         .then(function (numRemoved) {
             // done
         });
         schedule.nextDatabaseCompaction = nowTime + daysToMs(3);
     }
     
     // save changed schedule after every run
     localStorage.schedule = JSON.stringify(schedule);
 }
Beispiel #17
0
function Node ()
{
	this.info = {
		name: INSTANCE_NAME || (process.env.EC2_INSTANCE_ID || os.hostname()),
		contact: (process.env.CONTACT_DETAILS || ""),
		coinbase: null,
		node: null,
		net: null,
		protocol: null,
		api: null,
		port: (process.env.LISTENING_PORT || 30303),
		os: os.platform(),
		os_v: os.release(),
		client: pjson.version,
		canUpdateHistory: true,
	};

	this.id = _.camelCase(this.info.name);

	this.stats = {
		active: false,
		mining: false,
		hashrate: 0,
		peers: 0,
		pending: 0,
		gasPrice: 0,
		block: {
			number: 0,
			hash: '?',
			difficulty: 0,
			totalDifficulty: 0,
			transactions: [],
			uncles: []
		},
		syncing: false,
		uptime: 0
	};

	this._lastBlock = 0;
	this._lastStats = JSON.stringify(this.stats);
	this._lastFetch = 0;
	this._lastPending = 0;

	this._tries = 0;
	this._down = 0;
	this._lastSent = 0;
	this._latency = 0;

	this._web3 = false;
	this._socket = false;

	this._latestQueue = null;
	this.pendingFilter = false;
	this.chainFilter = false;
	this.updateInterval = false;
	this.pingInterval = false;
	this.connectionInterval = false;

	this._lastBlockSentAt = 0;
	this._lastChainLog = 0;
	this._lastPendingLog = 0;
	this._chainDebouncer = 0;
	this._chan_min_time = 50;
	this._max_chain_debouncer = 20;
	this._chain_debouncer_cnt = 0;
	this._connection_attempts = 0;
	this._timeOffset = null;

	this.startWeb3Connection();

	return this;
}
Beispiel #18
0
	db.query('select version() as v', function(err, rows) {
		res.json({status: 1, info: {serverIP: serverIP, serverVersion: os.release(), 
				clientIP: clientIP, clientVersion: req.headers['user-agent'], dbVersion: rows[0]['v']} });
	});
Beispiel #19
0
function buildActionSoapRequest(service, actionName, argObj){
	/*
	sample request:

	POST path control URL HTTP/1.0
	HOST: hostname:portNumber
	CONTENT-LENGTH: bytes in body
	CONTENT-TYPE: text/xml; charset="utf-8"
	USER-AGENT: OS/version UPnP/1.1 product/version
	SOAPACTION: "urn:schemas-upnp-org:service:serviceType:v#actionName"
	<?xml version="1.0"?>
	<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
		<s:Body>
			<u:actionName xmlns:u="urn:schemas-upnp-org:service:serviceType:v">
				<argumentName>in arg value</argumentName>
			<!-- other in args and their values go here, if any -->
			</u:actionName>
		</s:Body>
	</s:Envelope>
	*/
	var d = Q.defer();


	// Create a new xml parser with an array of xml elements to look for
	//var parser = new xml2object([ 'Envelope' ], undefined, {xmlns:true});
	var parser = new xml2object([ 'Body' ], undefined, {xmlns:true});

	// Bind to the object event to work with the objects found in the XML file
	parser.on('object', function(name, obj) {
		// looking for only 1 object (Body) for both success and error messages
		if(obj.Fault){
			d.reject(new UPnPError(obj.Fault.detail.UPnPError));
		}else{
			//TODO handle state vars updating?
			d.resolve(obj);
		}
	});

	// Bind to the file end event to tell when the file is done being streamed
	parser.on('end', function() {
		console.log('Finished parsing xml!');
	});


	console.log('creating http request');
	// handle bad URLs
	try{
		var req = http.request(
			{
				method: 'POST',
				/*
				hostname: '127.0.0.1',
				//path: '/test/echo.php',
				//path: '/test/upnpServiceActionResponse.php',
				path: '/test/upnpServiceActionResponse_error.php',
				/*/
				path: service.controlUrl,
				//*/
				headers: {
					'CONTENT-TYPE': 'text/xml; charset="utf-8"',
					'SOAPACTION' : '"urn:schemas-upnp-org:service:'+service.type+'#'+actionName+'"',
					'USER-AGENT': os.platform()+'/'+os.release() + ' UPnP/1.1 ' + pkgJson.name+'/'+pkgJson.version //TODO get version from package.json file
				}
			},
			function(response){
				console.log('got serviceUrl response', response.statusCode);
				//TODO parse XML fun!
				response.pipe(parser.saxStream);
			}
		);

		req.on('error', function(err){
			console.error('error in http request');
			d.reject(err);
		});

		console.log('writing out to request');
		//TODO each req.write is a chunk, while efficient if streaming data, if we have it all here it's likely just harder on the endpoint

		req.write('<?xml version="1.0"?>');
		req.write('<Envelope xmlns="http://schemas.xmlsoap.org/soap/envelope/" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">');
		req.write(	'<Body>');

		req.write(		'<'+actionName+' xmlns="urn:schemas-upnp-org:service:'+service.type+'">');

		Object.keys(argObj).forEach(function(argName){
			req.write(		'<'+argName+'>'+argObj[argName]+'</'+argName+'>');
		});

		req.write(		'</'+actionName+'>');

		req.write(	'</Body>');
		req.write('</Envelope>');

		req.end(); // we don't need to keep the stream open longer than the parser needs
	}catch(e){
		console.error('couldnt make request', e);
		//callback.call(self, e);
		returnPromise.reject(e);
	}

	return d.promise;
}
Beispiel #20
0
    /**
     * Returns all browser names found on the current system.
     *
     * @param {!Object} browsers The object with all browsers fro the browsers directory.
     * @returns {Array}
     */
    function getInstalledBrowsers (browsers) {
        var i, length,
            browserNames = Object.keys(browsers),
            result = [];

        // iterate over all browsers in the browsers folder
        for (i = 0, length = browserNames.length; i < length; i++) {
            var browser = browsers[browserNames[i]],
                browserPaths = browser.DEFAULT_CMD[process.platform] || [],
                y, paths = browserPaths.length;

            // iterate over all browser paths
            for (y = 0; y < paths; y++) {
                try {
                    var browserLocated = fs.existsSync(browserPaths[y]) || process.env[browser.ENV_CMD] || which.sync(browserPaths[y]);

                    // don't use Edge on operating systems other than Windows 10
                    // (the launcher would be found, but would fail to run)
                    var useBrowser = browser.name !== 'Edge' || process.platform === 'win32' && /^1\d/.test(os.release());

                    if (browserLocated && useBrowser) {
                        // add browser when found in file system or when env variable is set
                        result.push(browser.name);

                        // set env variable on win32 when it does not exist yet
                        if (process.platform === 'win32' && !process.env[browser.ENV_CMD]) {
                            process.env[browser.ENV_CMD] = browserPaths[y];
                        }

                        break;
                    }
                } catch (e) {
                    // which.sync() failed to find the browser.
                }
            }
        }

        return result;
    }
Beispiel #21
0
var isGalileo = (function() {
  var release = os.release();
  return release.includes("yocto") ||
    release.includes("edison");
})();
Beispiel #22
0
function errorHandler (er) {
  var printStack = false
  // console.error("errorHandler", er)
  if (!npm.config.loaded) {
    // logging won't work unless we pretend that it's ready
    er = er || new Error("Exit prior to config file resolving.")
    console.error(er.stack || er.message)
  }

  if (cbCalled) {
    er = er || new Error("Callback called more than once.")
  }

  cbCalled = true
  if (!er) return exit(0)
  if (typeof er === "string") {
    log.error("", er)
    return exit(1, true)
  } else if (!(er instanceof Error)) {
    log.error("weird error", er)
    return exit(1, true)
  }

  var m = er.code || er.message.match(/^(?:Error: )?(E[A-Z]+)/)
  if (m && !er.code) er.code = m

  switch (er.code) {
  case "ECONNREFUSED":
    log.error("", er)
    log.error("", ["\nIf you are behind a proxy, please make sure that the"
              ,"'proxy' config is set properly.  See: 'npm help config'"
              ].join("\n"))
    printStack = true
    break

  case "EACCES":
  case "EPERM":
    log.error("", er)
    log.error("", ["\nPlease try running this command again as root/Administrator."
              ].join("\n"))
    printStack = true
    break

  case "ELIFECYCLE":
    er.code = "ELIFECYCLE"
    log.error("", er.message)
    log.error("", ["","Failed at the "+er.pkgid+" "+er.stage+" script."
              ,"This is most likely a problem with the "+er.pkgname+" package,"
              ,"not with npm itself."
              ,"Tell the author that this fails on your system:"
              ,"    "+er.script
              ,"You can get their info via:"
              ,"    npm owner ls "+er.pkgname
              ,"There is likely additional logging output above."
              ].join("\n"))
    break

  case "EJSONPARSE":
    er.code = "EJSONPARSE"
    log.error("", er.message)
    log.error("", "File: "+er.file)
    log.error("", ["Failed to parse package.json data."
              ,"package.json must be actual JSON, not just JavaScript."
              ,"","This is not a bug in npm."
              ,"Tell the package author to fix their package.json file."
              ].join("\n"), "JSON.parse")
    break

  case "E404":
    er.code = "E404"
    if (er.pkgid && er.pkgid !== "-") {
      var msg = ["'"+er.pkgid+"' is not in the npm registry."
                ,"You should bug the author to publish it"]
      if (er.pkgid.match(/^node[\.\-]|[\.\-]js$/)) {
        var s = er.pkgid.replace(/^node[\.\-]|[\.\-]js$/g, "")
        if (s !== er.pkgid) {
          s = s.replace(/[^a-z0-9]/g, ' ')
          msg.push("\nMaybe try 'npm search " + s + "'")
        }
      }
      msg.push("\nNote that you can also install from a"
              ,"tarball, folder, or http url, or git url.")
      log.error("404", msg.join("\n"))
    }
    break

  case "EPUBLISHCONFLICT":
    er.code = "EPUBLISHCONFLICT"
    log.error("publish fail", ["Cannot publish over existing version."
              ,"Bump the 'version' field, set the --force flag, or"
              ,"    npm unpublish '"+er.pkgid+"'"
              ,"and try again"
              ].join("\n"))
    break

  case "EISGIT":
    er.code = "EISGIT"
    log.error("git", [er.message
              ,"    "+er.path
              ,"Refusing to remove it. Update manually,"
              ,"or move it out of the way first."
              ].join("\n"))
    break

  case "ECYCLE":
    er.code = "ECYCLE"
    log.error("cycle", [er.message
              ,"While installing: "+er.pkgid
              ,"Found a pathological dependency case that npm cannot solve."
              ,"Please report this to the package author."
              ].join("\n"))
    break

  case "EBADPLATFORM":
    er.code = "EBADPLATFORM"
    log.error("notsup", [er.message
              ,"Not compatible with your operating system or architecture: "+er.pkgid
              ,"Valid OS:    "+er.os.join(",")
              ,"Valid Arch:  "+er.cpu.join(",")
              ,"Actual OS:   "+process.platform
              ,"Actual Arch: "+process.arch
              ].join("\n"))
    break

  case "EEXIST":
    log.error([er.message
              ,"File exists: "+er.path
              ,"Move it away, and try again."].join("\n"))
    break

  case "ENEEDAUTH":
    log.error("need auth", [er.message
              ,"You need to authorize this machine using `npm adduser`"
              ].join("\n"))
    break

  case "ENOTSUP":
    if (er.required) {
      log.error("notsup", [er.message
                ,"Not compatible with your version of node/npm: "+er.pkgid
                ,"Required: "+JSON.stringify(er.required)
                ,"Actual:   "
                +JSON.stringify({npm:npm.version
                                ,node:npm.config.get("node-version")})
                ].join("\n"))
      break
    } // else passthrough

  default:
    log.error("", er.stack || er.message || er)
    log.error("", ["If you need help, you may report this log at:"
                  ,"    <http://github.com/isaacs/npm/issues>"
                  ,"or email it to:"
                  ,"    <npm-@googlegroups.com>"
                  ].join("\n"))
    printStack = false
    break
  }

  var os = require("os")
  // just a line break
  console.error("")
  log.error("System", os.type() + " " + os.release())
  log.error("command", process.argv
            .map(JSON.stringify).join(" "))
  log.error("cwd", process.cwd())
  log.error("node -v", process.version)
  log.error("npm -v", npm.version)

  ; [ "file"
    , "path"
    , "type"
    , "syscall"
    , "fstream_path"
    , "fstream_unc_path"
    , "fstream_type"
    , "fstream_class"
    , "fstream_finish_call"
    , "fstream_linkpath"
    , "code"
    , "errno"
    , "stack"
    , "fstream_stack"
    ].forEach(function (k) {
      var v = er[k]
      if (k === "stack") {
        if (!printStack) return
        if (!v) v = er.message
      }
      if (!v) return
      if (k === "fstream_stack") v = v.join("\n")
      log.error(k, v)
    })

  exit(typeof er.errno === "number" ? er.errno : 1)
}
Beispiel #23
0
"use babel";

const path = require('path');
const os = require('os');
const electron = require('electron');

function requireAtomCoreModule(name) {
  return require(path.join(atom.packages.resourcePath, 'src', name));
}
const Pane = requireAtomCoreModule('pane');
const PaneAxis = requireAtomCoreModule('pane-axis');
const TextEditorComponent = requireAtomCoreModule('text-editor-component');

if (os.platform() == 'win32' && os.release().startsWith('10.')) {
  // currently `transparent` isnt supported on win10 
  document.body.style.backgroundColor = "#000";
}

let cursorBlinkInterval = 1000;
function setCursorBlinkInterval(editor) {
  let editorView = atom.views.getView(editor);
  if(!editorView.component){
    return;
  }
  let editorComponent = editorView.component;
  editorComponent.stopCursorBlinking(true);
  editorComponent.props.cursorBlinkPeriod = cursorBlinkInterval;
  editorComponent.startCursorBlinking();
}
atom.workspace.observeTextEditors(setCursorBlinkInterval);
Beispiel #24
0
if( typeof __isNewInstall != 'undefined' && __isNewInstall == true )  {
  userTracking.event('App Install', getOperatingSystem().capitalize(), Settings.get('version')).send();
}
else if( typeof __isUpgradeInstall != 'undefined' && __isUpgradeInstall == true )  {
  userTracking.event('App Upgrade', getOperatingSystem().capitalize(), Settings.get('version')).send();
}


// Todo: Remove Upgrade in the next version to prevent double counting of device stats (we'd send stats once per version)
if( (typeof __isNewInstall != 'undefined' && __isNewInstall == true) || 
    (typeof __isUpgradeInstall != 'undefined' && __isUpgradeInstall == true) )  {
    
  // General Device Stats
  userTracking.event('Device Stats', 'Version', Settings.get('version') + (isDebug ? '-debug' : '') ).send();
  userTracking.event('Device Stats', 'Type', getOperatingSystem().capitalize()).send();
  userTracking.event('Device Stats', 'Operating System', os.type() +' '+ os.release()).send();
  userTracking.event('Device Stats', 'CPU', os.cpus()[0].model +' @ '+ (os.cpus()[0].speed/1000).toFixed(1) +'GHz' +' x '+ os.cpus().length ).send();
  userTracking.event('Device Stats', 'RAM', Math.round(os.totalmem() / 1024 / 1024 / 1024)+'GB' ).send();
  userTracking.event('Device Stats', 'Uptime', Math.round(os.uptime() / 60 / 60)+'hs' ).send();

  // Screen resolution, depth and pixel ratio (retina displays)
  if( typeof screen.width == 'number' && typeof screen.height == 'number' ) {
    var resolution = (screen.width).toString() +'x'+ (screen.height.toString());
    if( typeof screen.pixelDepth == 'number' ) {
      resolution += '@'+ (screen.pixelDepth).toString();
    }
    if( typeof window.devicePixelRatio == 'number' ) {
      resolution += '#'+ (window.devicePixelRatio).toString();
    }
    userTracking.event('Device Stats', 'Resolution', resolution).send();
  }
Beispiel #25
0
console.log('hostname = %s', hostname);
assert.ok(hostname.length > 0);

var uptime = os.uptime();
console.log('uptime = %d', uptime);
assert.ok(uptime > 0);

var cpus = os.cpus();
console.log('cpus = ', cpus);
assert.ok(cpus.length > 0);

var type = os.type();
console.log('type = ', type);
assert.ok(type.length > 0);

var release = os.release();
console.log('release = ', release);
assert.ok(release.length > 0);

var platform = os.platform();
console.log('platform = ', platform);
assert.ok(platform.length > 0);

var arch = os.arch();
console.log('arch = ', arch);
assert.ok(arch.length > 0);

if (process.platform != 'sunos') {
  // not implemeneted yet
  assert.ok(os.loadavg().length > 0);
  assert.ok(os.freemem() > 0);
Beispiel #26
0
 set:function(e) { 
   var os = require('os');
   var version = parseInt(os.release().substring(0,os.release().indexOf('.')));
   if(version < 14) return;
   this.native('setTitleVisibility', e ? $.NSWindowTitleVisible : $.NSWindowTitleHidden ); 
 }
  log('sentry disabled (dev mode)');
} else if (!trackAnalytics) {
  log('sentry disabled (analytics disabled)');
} else {
  log('setting up sentry');

  client = require(process.type + '/services/sentry').getClient();

  client.setUserContext({
    uid: getUserId()
  });

  client.setExtraContext({
    portable: global.manifest.portable,
    buildNum: global.manifest.buildNum,
    os_release: os.release(),
    versions: {
      electron: global.manifest.electronVersion,
      app: global.manifest.version
    },
    prefs: prefs.getAll()
  });

  client.setTagsContext({
    process_type: 'renderer',
    distrib: global.manifest.distrib,
    os_platform: os.platform()
  });
}

export default client;
exports.index = function(){
	var config = cfg.get();
	
	console.log("Your System is:",os.type(),os.platform(),os.release(),os.arch());
	/*
	if( 'darwin' == os.platform() ){
		console.log("Using OSX");
		if( 'x64' == os.arch() ){
			console.log("64Bit Arch");
			Ffmpeg.setFfmpegPath(__dirname + '/ffmpeg/ffmpeg-osx64/ffmpeg');
			Ffmpeg.setFfprobePath(__dirname + '/ffmpeg/ffmpeg-osx64/ffprobe');
			Ffmpeg.setFlvtoolPath('/usr/bin/flvtool2');
		}

	}else if( 'windows' == os.platform() ){
		if( 'x64' == os.arch() ){
			console.log("64Bit Arch");
			Ffmpeg.setFfmpegPath('./ffmpeg/ffmpeg-win64/bin/ffmpeg.exe');
			Ffmpeg.setFfprobePath('./ffmpeg/ffmpeg-win64/bin/ffprobe.exe');
			Ffmpeg.setFlvtoolPath('./ffmpeg/ffmpeg-win64/bin/flvtool2.exe');
		}
	}
	*/
	
	
	/*
	 * For debug and testing
	Ffmpeg.getAvailableFormats(function(err, formats) {
	  console.log('Available formats:');
	  console.dir(formats);
	});
	
	Ffmpeg.getAvailableCodecs(function(err, codecs) {
	  console.log('Available codecs:');
	  console.dir(codecs);
	});
	
	Ffmpeg().getAvailableEncoders(function(err, encoders) {
	  console.log('Available encoders:');
	  console.dir(encoders);
	});
	
	Ffmpeg.getAvailableFilters(function(err, filters) {
	  console.log("Available filters:");
	  console.dir(filters);
	});
	*/
	
	if(dd.type(config.media,'object') && dd.type(config.media.paths,'array')){
		console.log("Search our defined paths");
		config.media.paths.forEach( function(_path){
			console.log("Path:",_path);
			fs.exists(_path,function(exists){
				if(exists){
					pathRead(_path);
				}else{
					console.log("Path does not exists! '"+_path+"'");
				}
				//should we add fs watchers to these dirs?
			});
		} );
	}else{
		console.log("No paths defined",dd.type(config.media));
		process.exit(1);
	}
};
Beispiel #29
0
var os = require('os');

var message ='Here is some info about your system';

var sysarray = new Array('Type: '+os.type(),
						 'Node Version: '+process.version,
						 'Platform: '+os.platform(),
						 'Hostname: '+os.hostname(),
						 'Total Memory: '+os.totalmem(),
						 'Free Memory: '+os.freemem(),
						 'Uptime: '+os.uptime(),
						 'Cpus: '+os.cpus(),
						 'Process.arch: '+os.arch(),
						 'HomDir: '+os.homedir(),
						 'Loadavg: '+os.loadavg(),
						 'Network: '+os.networkInterfaces(),
						 'Relesae: '+os.release(),
						 'Type: '+os.type(),
						 'Uptime: '+os.uptime(),
						 'Endianness of the CPU: '+os.endianness()
						);
console.log(message);

var arraylen = sysarray.length;

i = 0;

while(i < arraylen){
	console.log(sysarray[i]);
	i++;
}
Beispiel #30
0
function setMeta() {
    var id = 'system.host.' + firstIp;
    var obj = {
        _id: id,
        type: 'host',
        common: {},
        native: {
            process: {
                title:      process.title,
                pid:        process.pid,
                versions:   process.versions,
                env:        process.env
            },
            os: {
                hostname:   os.hostname(),
                type:       os.type(),
                platform:   os.platform(),
                arch:       os.arch(),
                release:    os.release(),
                uptime:     os.uptime(),
                endianness: os.endianness(),
                tmpdir:     os.tmpdir()
            },
            hardware: {
                cpus:       os.cpus(),
                totalmem:   Math.floor(os.totalmem() / 1024 / 1024),
                networkInterfaces: os.networkInterfaces()
            }
        }
    };
    objects.setObject(id, obj);
    var idMem = id + ".mem";
    var obj = {
        _id: idMem,
        type: 'state',
        parent: id,
        common: {
            type: 'number',
            name: 'Memory usage',
            unit: '%',
            min: 0,
            max: 100
        },
        native: {}
    };
    objects.setObject(idMem, obj);
    var idLoad = id + ".load";
    var obj = {
        _id: idLoad,
        type: 'state',
        parent: id,
        common: {
            unit: '',
            type: 'number',
            name: 'Load Average 1min'
        },
        native: {}
    };
    objects.setObject(idLoad, obj);
    var idAlive = id + ".alive";
    var obj = {
        _id: idAlive,
        type: 'state',
        parent: id,
        common: {
            name: 'Host alive',
            type: 'boolean'
        },
        native: {}
    };
    objects.setObject(idAlive, obj);
}