├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── binary-ready.sh
├── binding.gyp
├── compiled
    ├── linux
    │   ├── ia32
    │   │   └── 0.10
    │   │   │   └── sysinfo.node
    │   └── x64
    │   │   └── 0.10
    │   │       └── sysinfo.node
    └── sunos
    │   ├── ia32
    │       └── 0.10
    │       │   └── sysinfo.node
    │   └── x64
    │       └── 0.10
    │           └── sysinfo.node
├── examples
    └── test.js
├── lib
    ├── providers
    │   ├── index.js
    │   ├── linux.js
    │   ├── other.js
    │   ├── ps.js
    │   └── sunos.js
    └── usage.js
├── package.json
├── src
    ├── binding.cpp
    ├── binding.h
    ├── solaris.cpp
    └── solaris.h
├── sysinfo.js
└── test
    ├── mocha.opts
    └── usage.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | build


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "0.10"
4 |   - "0.12"
5 |   - "iojs-v1.1.0"
6 |   - "iojs-v1.2.0"
7 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | (The MIT License)
 2 | 
 3 | Copyright (c) 2011-2014 Arunoda Susiripala <arunoda.susiripala@gmail.com>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining
 6 | a copy of this software and associated documentation files (the
 7 | 'Software'), to deal in the Software without restriction, including
 8 | without limitation the rights to use, copy, modify, merge, publish,
 9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | > **Depricate Notice:**
 2 | >
 3 | > This project works. But there's a much better project with a similar API.<br/>
 4 | > It even does not need a binary addon (So, it's easy to use). <br/>
 5 | > See pidusage: https://github.com/soyuka/pidusage
 6 | 
 7 | # node-usage [![Build Status](https://travis-ci.org/arunoda/node-usage.png?branch=master)](https://travis-ci.org/arunoda/node-usage)
 8 | 
 9 | ### process usage lookup with nodejs
10 | 
11 | * Simple interface to lookup cpu and memory usage of any accessible process on the system.
12 | * Works on OSX, Linux, SmartOS and Solaris
13 | * Tested on Heroku, Nodejitsu and Modulus
14 | 
15 | ## Example
16 | 
17 | ### Code
18 | ~~~js
19 | var usage = require('usage');
20 | 
21 | var pid = process.pid // you can use any valid PID instead
22 | usage.lookup(pid, function(err, result) {
23 | 
24 | });
25 | ~~~
26 | 
27 | ### Result Object
28 | ~~~js
29 | {
30 | 	memory: 100065280, // in no of bytes
31 | 	memoryInfo: {
32 | 		rss: 15966208, // resident size memory in bytes
33 | 		vsize: 3127906304 // virtual memory size in bytes
34 | 	},
35 | 	cpu: 10.6 // in percentage
36 | }
37 | ~~~
38 | 
39 | ## Average CPU usage vs Current CPU usage
40 | >This is only applicable for Linux
41 | 
42 | By default CPU Percentage provided is an average from the starting time of the process. It does not correctly reflect the current CPU usage. (this is also a problem with linux `ps` utility)
43 | 
44 | But If you call `usage.lookup()` continuously for a given pid, you can turn on **keepHistory** flag and you'll get the CPU usage since last time you track the usage. This reflects the current CPU usage.
45 | 
46 | see following example to enable keepHistory flag
47 | 
48 | ~~~js
49 | var pid = process.pid;
50 | var options = { keepHistory: true }
51 | usage.lookup(pid, options, function(err, result) {
52 | 
53 | });
54 | ~~~
55 | 
56 | you can clear history cache too
57 | ~~~js
58 | usage.clearHistory(pid); //clear history for the given pid
59 | usage.clearHistory(); //clean history for all pids
60 | ~~~
61 | 


--------------------------------------------------------------------------------
/binary-ready.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | git rm binding.gyp
4 | git commit -m "bindings removed"
5 | 


--------------------------------------------------------------------------------
/binding.gyp:
--------------------------------------------------------------------------------
 1 | {
 2 | 	'targets': [
 3 | 		{
 4 | 			'target_name': 'sysinfo',
 5 | 			'conditions': [
 6 | 				['OS=="solaris"', {
 7 | 					'sources': [
 8 | 						'src/solaris.cpp'
 9 | 					]
10 | 				}]
11 | 			],
12 | 			"include_dirs": [
13 | 				"<!(node -e \"require('nan')\")"
14 | 			],
15 | 			'sources': [
16 | 				'src/binding.cpp',
17 | 			],
18 | 			'linkflags': [
19 | 				'-Lbuild/cd Release/obj.target/sysinfo/src/'
20 | 			],
21 | 			'defines': [
22 | 				'OS="<(OS)"',
23 | 				'is_<(OS)'
24 | 			],
25 | 		}
26 | 	]
27 | }
28 | 


--------------------------------------------------------------------------------
/compiled/linux/ia32/0.10/sysinfo.node:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arunoda/node-usage/6e0f896c9bcbfed3cb6a0784ad4f5c244ae85d0c/compiled/linux/ia32/0.10/sysinfo.node


--------------------------------------------------------------------------------
/compiled/linux/x64/0.10/sysinfo.node:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arunoda/node-usage/6e0f896c9bcbfed3cb6a0784ad4f5c244ae85d0c/compiled/linux/x64/0.10/sysinfo.node


--------------------------------------------------------------------------------
/compiled/sunos/ia32/0.10/sysinfo.node:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arunoda/node-usage/6e0f896c9bcbfed3cb6a0784ad4f5c244ae85d0c/compiled/sunos/ia32/0.10/sysinfo.node


--------------------------------------------------------------------------------
/compiled/sunos/x64/0.10/sysinfo.node:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/arunoda/node-usage/6e0f896c9bcbfed3cb6a0784ad4f5c244ae85d0c/compiled/sunos/x64/0.10/sysinfo.node


--------------------------------------------------------------------------------
/examples/test.js:
--------------------------------------------------------------------------------
 1 | var usage = require('../');
 2 | var pid = (process.argv[2])? parseInt(process.argv[2]): process.pid;
 3 | 
 4 | setInterval(function() {
 5 | 
 6 | 	var options =  { keepHistory: true };
 7 | 	usage.lookup(pid, options, function(err, stat) {
 8 | 
 9 | 		console.log(err, stat);
10 | 	});
11 | }, 2000);


--------------------------------------------------------------------------------
/lib/providers/index.js:
--------------------------------------------------------------------------------
 1 | var providers = {
 2 |   'linux': ['linux', 'ps'],
 3 |   'sunos': ['sunos', 'ps'],
 4 |   'darwin': ['ps'],
 5 |   'freebsd': ['ps'],
 6 |   'win': ['other']
 7 | };
 8 | 
 9 | var format = require('util').format;
10 | 
11 | module.exports = function() {
12 |   var platform = (process.platform == "solaris")? "sunos": process.platform;
13 |   var potentialProviders = providers[platform];
14 | 
15 |   if(!potentialProviders) {
16 |     return require('./other')();
17 |   } else {
18 |     for(var lc=0; lc<potentialProviders.length; lc++) {
19 |       var providerName = potentialProviders[lc];
20 |       try {
21 |         var provider = require("./" + providerName);
22 |         return provider();
23 |       } catch (ex) {
24 |         var message = "usage: failed loading provider `%s`";
25 |         console.warn(format(message, providerName));
26 |       }
27 |     }
28 | 
29 |     console.warn("usage: no potential provider found!")
30 |     return require('./other')();
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/lib/providers/linux.js:
--------------------------------------------------------------------------------
  1 | var fs = require('fs');
  2 | 
  3 | module.exports = function linuxProvider() {
  4 |   var sysinfo = require('../../sysinfo.js')();
  5 |   var historyCpuUsage = {};
  6 | 
  7 |   return {
  8 |     lookup: lookup,
  9 |     clearHistory: clearHistory
 10 |   };
 11 | 
 12 |   function lookup(pid, options, callback) {
 13 |     if(typeof options == 'function') {
 14 |         callback = options;
 15 |         options = {};
 16 |     }
 17 |     options = options || {};
 18 | 
 19 |     var uptime;
 20 |     getUptime(function(err, value) {
 21 |       if(err) {
 22 |         callback(err);
 23 |       } else {
 24 |         uptime = value;
 25 |         getProcStat(pid, calculateUsage);
 26 |       }
 27 |     });
 28 | 
 29 |     function calculateUsage(err, stat) {
 30 |       if(err) {
 31 |         callback(err);
 32 |       } else {
 33 |         var usageData = {};
 34 | 
 35 |         if(historyCpuUsage[pid] && options.keepHistory) {
 36 |           var cpuUsage = calculateCpuUsageFromHistory(sysinfo, uptime, stat, historyCpuUsage[pid]);
 37 |         } else {
 38 |           var cpuUsage = calculateCpuUsage(sysinfo, uptime, stat);
 39 |         }
 40 | 
 41 |         // memeory info
 42 |         usageData.memory = calculateMemoryUsage(sysinfo, stat);
 43 |         usageData.memoryInfo = {
 44 |           rss: calculateMemoryUsage(sysinfo, stat),
 45 |           vsize: calculateVirtualMemoryUsage(sysinfo, stat)
 46 |         };
 47 | 
 48 |         // cpu info
 49 |         usageData.cpu = cpuUsage.pcpu;
 50 |         usageData.cpuInfo = {
 51 |           pcpu: cpuUsage.pcpu,
 52 |           pcpuUser: cpuUsage.pcpuUser,
 53 |           pcpuSystem: cpuUsage.pcpuSystem,
 54 |           cpuTime: cpuUsage.cpuTime
 55 |         };
 56 | 
 57 |         if(options.keepHistory) {
 58 |           //save totalTime in history
 59 |           historyCpuUsage[pid] = {
 60 |             timestamp: Date.now(),
 61 |             stat: stat,
 62 |             uptime: uptime
 63 |           };
 64 |         }
 65 | 
 66 |         callback(null, usageData);
 67 |       }
 68 |     }
 69 |   };
 70 | 
 71 |   function clearHistory (pid) {
 72 |     if(pid) {
 73 |       if(historyCpuUsage[pid]) {
 74 |         historyCpuUsage[pid] = null;
 75 |       }
 76 |     } else {
 77 |       historyCpuUsage = {};
 78 |     }
 79 |   }
 80 | };
 81 | 
 82 | function calculateCpuUsage(sysinfo, uptime, stat) {
 83 |   var userTime = stat.utime / sysinfo.HERTZ;
 84 |   var systemTime = stat.stime / sysinfo.HERTZ;
 85 |   var totalTime = (stat.stime + stat.utime) / sysinfo.HERTZ;
 86 |   var processUptime = uptime - stat.startTime / sysinfo.HERTZ;
 87 |   return {
 88 |     pcpu: (totalTime / processUptime) * 100,
 89 |     pcpuUser: (userTime / processUptime) * 100,
 90 |     pcpuSystem: (systemTime / processUptime) * 100
 91 |   };
 92 | }
 93 | 
 94 | function calculateCpuUsageFromHistory(sysinfo, uptime, stat, lastUsage) {
 95 |   var userTime = stat.utime / sysinfo.HERTZ;
 96 |   var systemTime = stat.stime / sysinfo.HERTZ;
 97 |   var totalTime = userTime + systemTime;
 98 | 
 99 |   var lastUserTime = lastUsage.stat.utime / sysinfo.HERTZ;
100 |   var lastSystemTime = lastUsage.stat.stime / sysinfo.HERTZ;
101 |   var lastTotalTime = lastUserTime + lastSystemTime;
102 | 
103 |   var diffTotal = totalTime - lastTotalTime;
104 |   var diffUser = userTime - lastUserTime;
105 |   var diffSystem = systemTime - lastSystemTime;
106 |   var timeSpent = uptime - lastUsage.uptime;
107 | 
108 |   return {
109 |     pcpu: (diffTotal / timeSpent) * 100,
110 |     pcpuUser: (diffUser / timeSpent) * 100,
111 |     pcpuSystem: (diffSystem / timeSpent) * 100,
112 |     cpuTime: diffTotal
113 |   };
114 | }
115 | 
116 | function calculateMemoryUsage(sysinfo, stat) {
117 |   return stat.rss * sysinfo.PAGE_SIZE;
118 | }
119 | 
120 | function calculateVirtualMemoryUsage(sysinfo, stat) {
121 |   return stat.vsize * sysinfo.PAGE_SIZE;
122 | }
123 | 
124 | function getUptime(callback) {
125 |   fs.readFile('/proc/uptime', 'utf8', function(err, data) {
126 |     if(err) {
127 |       callback(err);
128 |     } else {
129 |       var matched = data.match(/^(.*) /);
130 |       if(matched) {
131 |         var uptime = parseFloat(matched[1]);
132 |         callback(null, uptime);
133 |       } else {
134 |         callback(new Error('Invalid formatted uptime file'));
135 |       }
136 |     }
137 |   });
138 | }
139 | 
140 | var STAT_INDEXES = {
141 |   STIME: 11,
142 |   UTIME: 12,
143 |   START_TIME: 19,
144 |   RSS: 21,
145 |   VSIZE: 20
146 | };
147 | 
148 | function getProcStat(pid, callback) {
149 |   var fileName = '/proc/' + pid + '/stat';
150 |   fs.readFile(fileName, 'utf8', function(err, data) {
151 |     if(err) {
152 |       callback(err);
153 |     } else {
154 |       data = data.substr(data.lastIndexOf(')') + 2);
155 |       var parts = data.split(' ');
156 |       var statObject = {
157 |         stime: parseFloat(parts[STAT_INDEXES.STIME]),
158 |         utime: parseFloat(parts[STAT_INDEXES.UTIME]),
159 |         startTime: parseFloat(parts[STAT_INDEXES.START_TIME]),
160 |         rss: parseFloat(parts[STAT_INDEXES.RSS]),
161 |         vsize: parseFloat(parts[STAT_INDEXES.VSIZE])
162 |       };
163 |       callback(null, statObject);
164 |     }
165 |   });
166 | }
167 | 


--------------------------------------------------------------------------------
/lib/providers/other.js:
--------------------------------------------------------------------------------
 1 | module.exports = function(sysinfo) {
 2 |   return {
 3 |     lookup: lookup
 4 |   };
 5 | 
 6 |   function lookup(pid, options, callback) {
 7 |     if(typeof options == 'function') {
 8 |       callback = options;
 9 |       options = {};
10 |     }
11 |     options = options || {};
12 | 
13 |     var helpUrl = "https://github.com/arunoda/node-usage/issues";
14 |     var message = 'Unsupported OS. Please submit an issue: ';
15 |     callback(new Error(message + helpUrl));
16 |   }
17 | };
18 | 


--------------------------------------------------------------------------------
/lib/providers/ps.js:
--------------------------------------------------------------------------------
 1 | var exec = require('child_process').exec;
 2 | 
 3 | module.exports = function() {
 4 |   return {
 5 |     lookup: lookup
 6 |   };
 7 | 
 8 |   function lookup(pid, options, callback) {
 9 |     if(typeof options == 'function') {
10 |       callback = options;
11 |       options = {};
12 |     }
13 |     options = options || {};
14 | 
15 |     exec('ps -o "rss,vsize,pcpu" -p ' + pid, function(err, stdout, stderr) {
16 |       if (err || stderr) return callback(err || stderr);
17 | 
18 |       try {
19 |         callback(null, parsePS(pid, stdout));
20 |       } catch(ex) {
21 |         callback(ex);
22 |       }
23 |     });
24 |   }
25 | };
26 | 
27 | function parsePS(pid, output) {
28 |   var lines = output.trim().split('\n');
29 |   if (lines.length !== 2) {
30 |     throw new Error('INVALID_PID');
31 |   }
32 | 
33 |   var matcher = /[ ]*([0-9]*)[ ]*([0-9]*)[ ]*([0-9\.]*)/;
34 |   var result = lines[1].match(matcher);
35 | 
36 |   if(result) {
37 |     return {
38 |       memory: parseInt(result[1]) * 1024,
39 |       memoryInfo: {
40 |         rss: parseFloat(result[1]) * 1024,
41 |         vsize: parseFloat(result[2]) * 1024
42 |       },
43 |       cpu: parseFloat(result[3])
44 |     };
45 |   } else {
46 |     throw new Error('PS_PARSE_ERROR');
47 |   }
48 | }
49 | 


--------------------------------------------------------------------------------
/lib/providers/sunos.js:
--------------------------------------------------------------------------------
 1 | module.exports = function() {
 2 |   var sysinfo = require('../../sysinfo.js')();
 3 |   return {
 4 |     lookup: lookup
 5 |   };
 6 | 
 7 |   function lookup(pid, options, callback) {
 8 |     if(typeof options == 'function') {
 9 |       callback = options;
10 |       options = {};
11 |     }
12 |     options = options || {};
13 | 
14 |     sysinfo.getUsage(pid, callback);
15 |   };
16 | };
17 | 


--------------------------------------------------------------------------------
/lib/usage.js:
--------------------------------------------------------------------------------
1 | module.exports = require('./providers')();
2 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "usage",
 3 |   "version": "0.7.1",
 4 |   "description": "simple way to lookup linux process usage",
 5 |   "keywords": [
 6 |     "usage",
 7 |     "ps",
 8 |     "cpu",
 9 |     "ram",
10 |     "memory"
11 |   ],
12 |   "author": "Arunoda Susiripala <arunoda.susiripala@gmail.com>",
13 |   "repository": {
14 |     "type": "git",
15 |     "url": "git://github.com/arunoda/node-usage.git"
16 |   },
17 |   "main": "./lib/usage.js",
18 |   "scripts": {
19 |     "test": "./node_modules/.bin/mocha"
20 |   },
21 |   "engines": {
22 |     "node": ">= 0.10.x"
23 |   },
24 |   "dependencies": {
25 |     "bindings": "1.x.x",
26 |     "nan": "^2.0.9"
27 |   },
28 |   "devDependencies": {
29 |     "mocha": "1.x.x"
30 |   }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/binding.cpp:
--------------------------------------------------------------------------------
 1 | #include "binding.h"
 2 | #include "nan.h"
 3 | using namespace v8;
 4 | 
 5 | void RegisterModule(Local<Object> exports) {
 6 | 
 7 | #ifdef is_linux
 8 |   exports->Set(Nan::New<String>("HERTZ").ToLocalChecked(), Nan::New<Number>(sysconf(_SC_CLK_TCK)));
 9 |   exports->Set(Nan::New<String>("PAGE_SIZE").ToLocalChecked(), Nan::New<Number>(sysconf(_SC_PAGESIZE)));
10 | #endif
11 | 
12 | #ifdef is_solaris
13 |   exports->Set(Nan::New<String>("getUsage").ToLocalChecked(),
14 |     FunctionTemplate::New(GetUsage)->GetFunction());
15 | #endif
16 |   exports->Set(Nan::New<String>("OS").ToLocalChecked(), Nan::New<String>(OS).ToLocalChecked());
17 | }
18 | 
19 | NODE_MODULE(sysinfo, RegisterModule);
20 | 


--------------------------------------------------------------------------------
/src/binding.h:
--------------------------------------------------------------------------------
 1 | #include <node.h>
 2 | 
 3 | #ifdef is_linux
 4 | #include <unistd.h>
 5 | #endif
 6 | 
 7 | #ifdef is_solaris
 8 | #include "solaris.h"
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/src/solaris.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include "solaris.h"
  3 | 
  4 | /*
  5 |   Getting CPU Usage from the /proc
  6 | */
  7 | static int read_buffer(char *buffer, int buffer_size, char* file_path) {
  8 |   FILE *fp = fopen(file_path, "r");
  9 |   if(fp != NULL) {
 10 |     size_t read_len = fread(buffer, sizeof(char), buffer_size, fp);
 11 |     if(read_len == 0) {
 12 |       return 0;
 13 |     }
 14 | 
 15 |     fclose(fp);
 16 |     return 1;
 17 |   } else {
 18 |     return 0;
 19 |   }
 20 | }
 21 | 
 22 | static char* get_proc_file(char* type, char* pid) {
 23 |   size_t type_len = strlen(type);
 24 |   size_t pid_len = strlen(pid);
 25 |   size_t proc_len = strlen("/proc/");
 26 |   size_t spaces = 2;
 27 |   size_t slashes = 1;
 28 | 
 29 |   size_t total = proc_len + pid_len + type_len + spaces + slashes + 1;
 30 |   char* final = (char*)malloc(total);
 31 | 
 32 |   sprintf(final, "/proc/%s/%s", pid, type);
 33 |   return final;
 34 | }
 35 | 
 36 | static float get_pct(ushort_t pct) {
 37 |   uint_t value = pct; /* need 32 bits to compute with */
 38 |   value = ((value * 1000) + 0x7000) >> 15;    /* [0 .. 1000] */
 39 | 
 40 |   float f_value = (float)value;
 41 |   return f_value/10;
 42 | }
 43 | 
 44 | int get_usage(int pid, ps_usage_t* ps_usage) {
 45 |   char str_pid[10];
 46 |   sprintf(str_pid, "%d", pid);
 47 | 
 48 |   char* psinfo_proc_file = get_proc_file("psinfo", str_pid);
 49 |   psinfo_t psinfo;
 50 |   int success_psinfo = read_buffer((char*)&psinfo, sizeof(psinfo), psinfo_proc_file);
 51 |   free(psinfo_proc_file);
 52 | 
 53 |   if(success_psinfo) {
 54 |     ps_usage->cpu = get_pct(psinfo.pr_pctcpu);
 55 |     ps_usage->memory = psinfo.pr_rssize * 1024;
 56 |     return 1;
 57 |   } else {
 58 |     return 0;
 59 |   }
 60 | }
 61 | 
 62 | /*
 63 |     V8 Integration
 64 | */
 65 | 
 66 | void AsyncGetUsage(uv_work_t* req) {
 67 |   UsageData* usageData = static_cast<UsageData*>(req->data);
 68 |   ps_usage_t ps_usage;
 69 |   int pid_exists = get_usage(usageData->pid, &ps_usage);
 70 | 
 71 |   if(pid_exists) {
 72 |     usageData->ps_usage = ps_usage;
 73 |   } else {
 74 |     usageData->failed = true;
 75 |   }
 76 | }
 77 | 
 78 | void AsyncAfterGetUsage(uv_work_t* req) {
 79 |   UsageData* usageData = static_cast<UsageData*>(req->data);
 80 | 
 81 |   if(usageData->failed) {
 82 |     const unsigned argc = 1;
 83 |     Local<Value> argv[argc] = {
 84 |       Exception::Error(String::New("INVALID_PID"))
 85 |     };
 86 |     usageData->callback->Call(Context::GetCurrent()->Global(), argc, argv);
 87 |   } else {
 88 |     Local<Object> usage = Object::New();
 89 |     usage->Set(String::NewSymbol("cpu"), Number::New(usageData->ps_usage.cpu));
 90 |     usage->Set(String::NewSymbol("memory"), Number::New(usageData->ps_usage.memory));
 91 | 
 92 |     const unsigned argc = 2;
 93 |     Local<Value> argv[argc] = { Local<Value>::New(Null()), usage };
 94 |     usageData->callback->Call(Context::GetCurrent()->Global(), argc, argv);
 95 |   }
 96 | 
 97 |   delete usageData;
 98 |   delete req;
 99 | }
100 | 
101 | Handle<Value> GetUsage(const Arguments& args) {
102 |   HandleScope scope;
103 | 
104 |   int pid = (int)(Local<Number>::Cast(args[0])->Value());
105 |   Local<Function> callback = Local<Function>::Cast(args[1]);
106 | 
107 |   UsageData* usageData = new UsageData();
108 |   usageData->pid = pid;
109 |   usageData->callback = Persistent<Function>::New(callback);
110 |   usageData->failed = false;
111 | 
112 |   uv_work_t* req = new uv_work_t();
113 |   req->data = usageData;
114 | 
115 |   uv_queue_work(uv_default_loop(), req, AsyncGetUsage, (uv_after_work_cb)AsyncAfterGetUsage);
116 | 
117 |   return scope.Close(Undefined());
118 | }
119 | 


--------------------------------------------------------------------------------
/src/solaris.h:
--------------------------------------------------------------------------------
 1 | #ifndef SOLARIS_H
 2 | #define SOLARIS_H
 3 | 
 4 | #include <stdlib.h>
 5 | #include <procfs.h>
 6 | #include <string.h>
 7 | #include <node.h>
 8 | #include <uv.h>
 9 | 
10 | typedef struct ps_usage {
11 |   float cpu;
12 |   long memory;
13 | } ps_usage_t;
14 | 
15 | using namespace v8;
16 | struct UsageData {
17 |   int pid;
18 |   Persistent<Function> callback;
19 |   ps_usage_t ps_usage;
20 |   bool failed;
21 | };
22 | 
23 | extern int get_usage(int pid, ps_usage_t* ps_usage);
24 | extern Handle<Value> GetUsage(const Arguments& args);
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/sysinfo.js:
--------------------------------------------------------------------------------
 1 | var format = require('util').format;
 2 | 
 3 | module.exports = function() {
 4 |   try {
 5 |     return require('bindings')('sysinfo');
 6 |   } catch(ex) {
 7 |     // let's try to find a pre-compiled binary
 8 | 
 9 |     var availableVersionPaths = [
10 |       // currently 0.10.x is enough (currently look for Meteor)
11 |       [/v0\.10\..*/, '0.10']
12 |     ];
13 | 
14 |     var platform = (process.platform == "solaris")? "sunos": process.platform;
15 |     var arch = process.arch;
16 |     var version = process.version;
17 |     var versionPath;
18 | 
19 |     for(var lc=0; lc<availableVersionPaths.length; lc++) {
20 |       var pathMatcher = availableVersionPaths[lc][0];
21 |       if(pathMatcher.test(version)) {
22 |         versionPath = availableVersionPaths[lc][1];
23 |         break;
24 |       }
25 |     }
26 | 
27 |     var path = format('./compiled/%s/%s/%s/sysinfo.node',
28 |       platform, arch, versionPath);
29 | 
30 |     try {
31 |       return require(path);
32 |     } catch(ex) {
33 |       console.warn(
34 |         'usage: cannot find pre-compiled binary for: %s/%s/%s',
35 |         platform, arch, version
36 |       );
37 |       throw ex;
38 |     }
39 |   }
40 | };
41 | 


--------------------------------------------------------------------------------
/test/mocha.opts:
--------------------------------------------------------------------------------
1 | -R spec
2 | -u tdd
3 | 


--------------------------------------------------------------------------------
/test/usage.js:
--------------------------------------------------------------------------------
 1 | var usage   = require('../');
 2 | var assert  = require('assert');
 3 | 
 4 | suite('Usage', function() {
 5 |   test('invalid pid', function(done) {
 6 |     usage.lookup(1232323, function(err, result) {
 7 |       assert.ok(err.message);
 8 |       done();
 9 |     });
10 |   });
11 | 
12 |   test('valid pid', function(done) {
13 |     usage.lookup(process.pid, function(err, result) {
14 |       assert.ifError(err);
15 |       assert.ok(result.cpu >= 0);      
16 |       assert.ok(result.memory > 0);
17 |       assert.ok(result.memoryInfo.rss >= 0);
18 |       assert.ok(result.memoryInfo.vsize >= 0);
19 |       done();
20 |     });
21 |   });
22 | 
23 |   if(process.platform == 'linux') {
24 |     test('valid pid - with keepHistory', function(done) {
25 |       var options = { keepHistory: true };
26 |       usage.lookup(process.pid, options, function(err, result) {
27 |         assert.ifError(err);
28 |         assert.ok(result.cpu >= 0);
29 |         assert.ok(result.cpuInfo.pcpu >= 0);
30 |         assert.ok(result.cpuInfo.pcpuUser >= 0);
31 |         assert.ok(result.cpuInfo.pcpuSystem >= 0);
32 |         
33 |         assert.ok(result.memory > 0);
34 |         assert.ok(result.memoryInfo.rss > 0);
35 |         assert.ok(result.memoryInfo.vsize > 0);
36 |         
37 |         for(var lc=0; lc<999999; lc++) {
38 |           Math.random();
39 |         }
40 | 
41 |         setTimeout(function() {
42 |           usage.lookup(process.pid, options, checkCpuTime);
43 |         }, 200);
44 |       });
45 | 
46 |       function checkCpuTime (err, result) {
47 |         assert.ifError(err);
48 |         assert.ok(result.cpu >= 0);
49 |         assert.ok(result.cpuInfo.pcpu >= 0);
50 |         assert.ok(result.cpuInfo.cpuTime >= 0);
51 |         assert.ok(result.cpuInfo.pcpuUser >= 0);
52 |         assert.ok(result.cpuInfo.pcpuSystem >= 0);
53 |         
54 |         assert.ok(result.memory > 0);
55 |         assert.ok(result.memoryInfo.rss > 0);
56 |         assert.ok(result.memoryInfo.vsize > 0);
57 |         usage.clearHistory();
58 |         
59 |         usage.lookup(process.pid, options, checkCpuTime);
60 |         done();
61 |       }
62 |     });
63 |   }
64 | });
65 | 


--------------------------------------------------------------------------------