├── .gitignore ├── .gitmodules ├── .travis.yml ├── binding.gyp ├── index.js ├── license.md ├── package.json ├── readme.md ├── samples ├── cpu_list.js ├── cpu_usage.ls └── perf.coffee ├── src ├── node_sigar.cc ├── node_sigar.h ├── node_sigar_format.cc ├── node_sigar_utils.cc └── v8u.hpp ├── test ├── cpu.coffee ├── file_system.coffee ├── misc.coffee ├── network.coffee ├── process.coffee ├── system.coffee └── todo.coffee └── wscript /.gitignore: -------------------------------------------------------------------------------- 1 | build 2 | node_modules 3 | wscript-binary-dylib 4 | wscript-compile-src 5 | .* 6 | # Fix npm publish which otherwise include build hidden directories 7 | **/.* 8 | !.travis.yml 9 | !.gitignore 10 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "deps/sigar"] 2 | path = deps/sigar 3 | url = https://github.com/hyperic/sigar.git 4 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | 2 | language: node_js 3 | node_js: 4 | - 0.6 5 | - 0.7 6 | before_install: 7 | - "sudo apt-get install libtool pkg-config" 8 | - "git submodule update --init --recursive" 9 | -------------------------------------------------------------------------------- /binding.gyp: -------------------------------------------------------------------------------- 1 | { 2 | 'targets': [ 3 | { 4 | 'target_name': 'sigar', 5 | 'sources': [ 'src/node_sigar.cc' ], 6 | 'cflags!': [ '-fno-exceptions' ], 7 | 'cflags_cc!': [ '-fno-exceptions' ], 8 | "libraries": [ 9 | "<(module_root_dir)/build/sigar/src/.libs/libsigar.a" 10 | ], 11 | "include_dirs": [ 12 | 'deps/sigar/include' 13 | ], 14 | 'conditions': [ 15 | ['OS=="mac"', { 16 | 'xcode_settings': { 17 | 'GCC_ENABLE_CPP_EXCEPTIONS': 'YES' 18 | } 19 | }] 20 | ] 21 | } 22 | ] 23 | } 24 | -------------------------------------------------------------------------------- /index.js: -------------------------------------------------------------------------------- 1 | 2 | var sigar = new require('./build/Release/sigar'); 3 | 4 | module.exports = function(){ 5 | return new sigar.NodeSigar; 6 | } 7 | for(var k in sigar){ 8 | if(k !== 'NodeSigar'){ 9 | module.exports[k] = sigar[k]; 10 | } 11 | } -------------------------------------------------------------------------------- /license.md: -------------------------------------------------------------------------------- 1 | Software License Agreement (BSD License) 2 | ======================================== 3 | Copyright (c) 2012, SARL Adaltas. 4 | 5 | All rights reserved. 6 | 7 | Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 8 | 9 | - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 10 | 11 | - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 12 | 13 | - Neither the name of SARL Adaltas nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of the SARL Adaltas. 14 | 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 16 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "sigar", 3 | "description": "Sigar binding for Node.js", 4 | "keywords": ["cluster", "system", "cpu", "os", "network"], 5 | "version": "0.0.2", 6 | "homepage": "http://www.adaltas.com/projects/node-sigar", 7 | "author": "David Worms ", 8 | "repository": { 9 | "type": "git", 10 | "url": "https://github.com/wdavidw/node-sigar.git" 11 | }, 12 | "bugs": { 13 | "email": "open@adaltas.com", 14 | "url": "https://github.com/wdavidw/node-sigar.git" 15 | }, 16 | "dependencies": {}, 17 | "devDependencies": { 18 | "coffee-script": "latest", 19 | "printf": "latest", 20 | "mocha": "latest", 21 | "should": "latest" 22 | }, 23 | "contributors": [ 24 | { "name": "Kenneth Bentley", "email": "funisher@gmail.com" }, 25 | { "name": "David Worms", "email": "david@adaltas.com" } 26 | ], 27 | "main": "index", 28 | "gypfile": true, 29 | "engines": { "node": ">= 0.6.0" }, 30 | "scripts": { 31 | "cmakenotworking": "mkdir -p build/sigar && cp -rp deps/sigar/* build/sigar/ && cd build/sigar && cmake -D CMAKE_BUILD_TYPE=Release -D BUILD_SHARED_LIBS=false . && cmake --build . && node-gyp configure && node-gyp build", 32 | "preinstall": "mkdir -p build/sigar && cp -rp deps/sigar/* build/sigar/ && cd build/sigar && ./autogen.sh && ./configure --prefix=`pwd`/build/sigar --with-pic && make && make install && cd ../.. && node-gyp configure && node-gyp build", 33 | "test": "mocha" 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | [![Build Status](https://secure.travis-ci.org/wdavidw/node-sigar.png)](http://travis-ci.org/wdavidw/node-sigar) 2 | 3 | Node Sigar binding 4 | ================== 5 | 6 | A complete binding to the [SIGAR](http://support.hyperic.com/display/SIGAR/Home) library. 7 | 8 | Documentation is available on the [project website](http://www.adaltas.com/projects/node-sigar). 9 | 10 | Note, documentation include important installation instruction for some platforms. 11 | 12 | SIGAR is a cross platform interface for gathering system information. From the project website, such information include: 13 | 14 | * System memory, swap, cpu, load average, uptime, logins 15 | * Per-process memory, cpu, credential info, state, arguments, environment, open files 16 | * File system detection and metrics 17 | * Network interface detection, configuration info and metrics 18 | * TCP and UDP connection tables 19 | * Network route table 20 | 21 | ``` 22 | var sigar = require('sigar'); 23 | console.log(sigar.version()); // returns the version 24 | 25 | // invoke the library 26 | var Sigar = sigar.init(); 27 | console.log(sigar.cpu()); // {} 28 | 29 | ``` 30 | 31 | API 32 | === 33 | 34 | Sigar.mem(); 35 | ``` 36 | > { 37 | ram: Number 38 | total: Number 39 | used: Number 40 | free: Number 41 | actual_used: Number 42 | actual_free: Number 43 | used_percent: Number 44 | free_percent: Number 45 | } 46 | ``` 47 | Sigar.swap(); 48 | ``` 49 | { 50 | total: Number 51 | used: Number 52 | free: Number 53 | page_in: Number 54 | page_out: Number 55 | } 56 | ``` 57 | Sigar.uptime(); 58 | ``` 59 | > 52883 // seconds 60 | ``` 61 | Sigar.loadavg(); 62 | ``` 63 | [0.11, 0.13, 0.09] 64 | ``` 65 | Sigar.resourceLimit(); 66 | Sigar.whoList(); 67 | Sigar.sysInfo(); 68 | Sigar.fqdn(); 69 | // CPU 70 | Sigar.cpu(); 71 | Sigar.cpuList(); 72 | Sigar.cpuInfoList(); 73 | // Process 74 | Sigar.procList(); 75 | Sigar.procStat(); 76 | Sigar.procMem(); 77 | Sigar.procCred(); 78 | Sigar.procTime(); 79 | Sigar.procCpu(); 80 | Sigar.procState(); 81 | Sigar.procArgs(); 82 | Sigar.procEnv(); 83 | Sigar.procFd(); 84 | Sigar.procExe(); 85 | Sigar.procModules(); 86 | Sigar.procPort(); 87 | Sigar.threadCpu(); 88 | // Disk 89 | Sigar.fileSystemList(); 90 | Sigar.fileSystemUsage(); 91 | Sigar.fileSystemPing(); 92 | // Network 93 | Sigar.netInfo(); 94 | Sigar.netRouteList(); 95 | Sigar.netInterfaceList(); 96 | Sigar.netInterfaceConfig(); 97 | Sigar.netInterfaceConfigPrimary(); 98 | Sigar.netInterfaceStat(); 99 | Sigar.netConnectionList(); 100 | Sigar.netListenAddress(); 101 | Sigar.netStat(); 102 | Sigar.netStatPort(); 103 | Sigar.tcp(); 104 | Sigar.nfsClientV2(); 105 | Sigar.nfsServerV2(); 106 | Sigar.arpList(); 107 | // Misc 108 | Sigar.rpcPing(); 109 | 110 | 111 | 112 | TODO 113 | ==== 114 | 115 | * compile the entire library with gyp 116 | * fix up the tests (and improve on them) 117 | * utilize / reimplement / remove `sigar_format.c` functions 118 | * convert functions without args to be getters 119 | * provide async funcs for long-running actions 120 | * old / broken code still exists for converting network addresses (see `node_sigar_utils.cc::node_sigar_str2net_address()`) 121 | 122 | 123 | LICENSE 124 | ======= 125 | 126 | Node Sigar is licensed under the BSD license. 127 | -------------------------------------------------------------------------------- /samples/cpu_list.js: -------------------------------------------------------------------------------- 1 | var sigar = require('sigar'); 2 | 3 | var cpus = sigar().cpuList() 4 | for(var i = 0; i < cpus.length; i++){ 5 | console.log(cpus[i]); 6 | } 7 | -------------------------------------------------------------------------------- /samples/cpu_usage.ls: -------------------------------------------------------------------------------- 1 | 2 | Sigar = require '../build/Release/sigar' .init! 3 | printf = require 'printf' 4 | 5 | # replication of `sigar_cpu_perc_calculate` 6 | # please refer to `sigar_format.c` for more info 7 | 8 | prev = Sigar.cpu! 9 | setInterval -> 10 | curr = Sigar.cpu! 11 | diff_user = curr.user - prev.user 12 | diff_sys = curr.sys - prev.sys 13 | diff_nice = curr.nice - prev.nice 14 | diff_idle = curr.idle - prev.idle 15 | diff_wait = curr.wait - prev.wait 16 | diff_irq = curr.irq - prev.irq 17 | diff_soft_irq = curr.soft_irq - prev.soft_irq 18 | diff_stolen = curr.stolen - prev.stolen 19 | 20 | diff_user = if diff_user < 0 then 0 else diff_user 21 | diff_sys = if diff_sys < 0 then 0 else diff_sys 22 | diff_nice = if diff_nice < 0 then 0 else diff_nice 23 | diff_idle = if diff_idle < 0 then 0 else diff_idle 24 | diff_wait = if diff_wait < 0 then 0 else diff_wait 25 | diff_irq = if diff_irq < 0 then 0 else diff_irq 26 | diff_soft_irq = if diff_soft_irq < 0 then 0 else diff_soft_irq 27 | diff_stolen = if diff_stolen < 0 then 0 else diff_stolen 28 | 29 | diff_total = 30 | diff_user + diff_sys + diff_nice + diff_idle + 31 | diff_wait + diff_irq + diff_soft_irq + 32 | diff_stolen 33 | 34 | perc = { 35 | user: diff_user / diff_total 36 | sys: diff_sys / diff_total 37 | nice: diff_nice / diff_total 38 | idle: diff_idle / diff_total 39 | wait: diff_wait / diff_total 40 | irq: diff_irq / diff_total 41 | soft_irq: diff_soft_irq / diff_total 42 | stolen: diff_stolen / diff_total 43 | } 44 | perc.combined = perc.user + perc.sys + perc.nice + perc.wait 45 | console.log printf "user: %0.2f sys: %0.2f nice: %0.2f idle: %0.2f", perc.user, perc.sys, perc.nice, perc.idle 46 | prev := curr 47 | , 1000 48 | -------------------------------------------------------------------------------- /samples/perf.coffee: -------------------------------------------------------------------------------- 1 | 2 | sigar = require '..' 3 | 4 | l = 1*1000*1000 5 | 6 | ### 7 | i = 0 8 | time = (new Date).getTime() 9 | while i++ < l 10 | sigar() 11 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 12 | ### 13 | 14 | i = 0 15 | s = sigar() 16 | time = (new Date).getTime() 17 | while i++ < l 18 | s.swap() 19 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 20 | 21 | i = 0 22 | s = sigar() 23 | time = (new Date).getTime() 24 | while i++ < l 25 | s.cpu() 26 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 27 | 28 | i = 0 29 | s = sigar() 30 | time = (new Date).getTime() 31 | while i++ < l 32 | s.cpuList() 33 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 34 | 35 | i = 0 36 | s = sigar() 37 | time = (new Date).getTime() 38 | while i++ < l 39 | s.cpuInfoList() 40 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 41 | 42 | i = 0 43 | s = sigar() 44 | time = (new Date).getTime() 45 | while i++ < l 46 | s.loadavg() 47 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 48 | 49 | i = 0 50 | s = sigar() 51 | time = (new Date).getTime() 52 | while i++ < l 53 | s.resourceLimit() 54 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 55 | 56 | i = 0 57 | s = sigar() 58 | time = (new Date).getTime() 59 | while i++ < l 60 | s.procList() 61 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 62 | 63 | i = 0 64 | s = sigar() 65 | time = (new Date).getTime() 66 | while i++ < l 67 | s.procStat() 68 | console.log Math.round(l / (Date.now() - time) * 1000), ' per seconds' 69 | -------------------------------------------------------------------------------- /src/node_sigar.cc: -------------------------------------------------------------------------------- 1 | 2 | #include "node_sigar.h" 3 | #include "v8u.hpp" 4 | 5 | using namespace node; 6 | using namespace v8; 7 | NodeSigar::NodeSigar(sigar_t* ptr): sigar(ptr) {} 8 | NodeSigar::~NodeSigar() { 9 | sigar_close(sigar); 10 | } 11 | 12 | V8_ESCTOR(NodeSigar) { V8_CTOR_NO_JS } 13 | 14 | NODE_ETYPE(NodeSigar, "NodeSigar") { 15 | //Local func = templ->GetFunction(); 16 | target->Set(v8u::Symbol("init"), v8u::Func(Init)->GetFunction()); 17 | target->Set(v8u::Symbol("version"), v8u::Func(SigarVersionGet)->GetFunction()); 18 | target->Set(v8u::Symbol("password"), v8u::Func(SigarPasswordGet)->GetFunction()); 19 | target->Set(v8u::Symbol("formatSize"), v8u::Func(SigarFormatSize)->GetFunction()); 20 | 21 | // Testing, see './test/TodoTest.coffee' 22 | target->Set(v8u::Symbol("testNetAdress"), v8u::Func(SigarTestNetAdress)->GetFunction()); 23 | 24 | // System 25 | NODE_SET_PROTOTYPE_METHOD(templ, "mem", GetMem); 26 | NODE_SET_PROTOTYPE_METHOD(templ, "swap", GetSwap); 27 | NODE_SET_PROTOTYPE_METHOD(templ, "uptime", SigarUptimeGet); 28 | NODE_SET_PROTOTYPE_METHOD(templ, "loadavg", SigarLoadavgGet); 29 | NODE_SET_PROTOTYPE_METHOD(templ, "resourceLimit", SigarResourceLimitGet); 30 | NODE_SET_PROTOTYPE_METHOD(templ, "whoList", SigarWhoListGet); 31 | NODE_SET_PROTOTYPE_METHOD(templ, "sysInfo", SigarSysInfoGet); 32 | NODE_SET_PROTOTYPE_METHOD(templ, "fqdn", SigarFqdnGet); 33 | // CPU 34 | NODE_SET_PROTOTYPE_METHOD(templ, "cpu", SigarCpuGet); 35 | NODE_SET_PROTOTYPE_METHOD(templ, "cpuList", SigarCpuListGet); 36 | NODE_SET_PROTOTYPE_METHOD(templ, "cpuInfoList", SigarCpuInfoListGet); 37 | // Process 38 | NODE_SET_PROTOTYPE_METHOD(templ, "procList", SigarProcListGet); 39 | NODE_SET_PROTOTYPE_METHOD(templ, "procStat", SigarProcStatGet); 40 | NODE_SET_PROTOTYPE_METHOD(templ, "procMem", SigarProcMemGet); 41 | NODE_SET_PROTOTYPE_METHOD(templ, "procCred", SigarProcCredGet); 42 | NODE_SET_PROTOTYPE_METHOD(templ, "procTime", SigarProcTimeGet); 43 | NODE_SET_PROTOTYPE_METHOD(templ, "procCpu", SigarProcCpuGet); 44 | NODE_SET_PROTOTYPE_METHOD(templ, "procState", SigarProcStateGet); 45 | NODE_SET_PROTOTYPE_METHOD(templ, "procArgs", SigarProcArgsGet); 46 | NODE_SET_PROTOTYPE_METHOD(templ, "procEnv", SigarProcEnvGet); 47 | NODE_SET_PROTOTYPE_METHOD(templ, "procFd", SigarProcFdGet); 48 | NODE_SET_PROTOTYPE_METHOD(templ, "procExe", SigarProcExeGet); 49 | NODE_SET_PROTOTYPE_METHOD(templ, "procModules", SigarProcModulesGet); 50 | NODE_SET_PROTOTYPE_METHOD(templ, "procPort", SigarProcPortGet); 51 | NODE_SET_PROTOTYPE_METHOD(templ, "threadCpu", SigarThreadCpuGet); 52 | // Disk 53 | NODE_SET_PROTOTYPE_METHOD(templ, "fileSystemList", SigarFileSystemListGet); 54 | NODE_SET_PROTOTYPE_METHOD(templ, "fileSystemUsage", SigarFileSystemUsageGet); 55 | NODE_SET_PROTOTYPE_METHOD(templ, "fileSystemPing", SigarFileSystemPingGet); 56 | // Network 57 | NODE_SET_PROTOTYPE_METHOD(templ, "netInfo", SigarNetInfoGet); 58 | NODE_SET_PROTOTYPE_METHOD(templ, "netRouteList", SigarNetRouteListGet); 59 | NODE_SET_PROTOTYPE_METHOD(templ, "netInterfaceList", SigarNetInterfaceListGet); 60 | NODE_SET_PROTOTYPE_METHOD(templ, "netInterfaceConfig", SigarNetInterfaceConfigGet); 61 | NODE_SET_PROTOTYPE_METHOD(templ, "netInterfaceConfigPrimary", SigarNetInterfaceConfigPrimaryGet); 62 | NODE_SET_PROTOTYPE_METHOD(templ, "netInterfaceStat", SigarNetInterfaceStatGet); 63 | NODE_SET_PROTOTYPE_METHOD(templ, "netConnectionList", SigarNetConnectionListGet); 64 | NODE_SET_PROTOTYPE_METHOD(templ, "netListenAddress", SigarNetListenAddressGet); 65 | NODE_SET_PROTOTYPE_METHOD(templ, "netStat", SigarNetStatGet); 66 | NODE_SET_PROTOTYPE_METHOD(templ, "netStatPort", SigarNetStatPortGet); 67 | NODE_SET_PROTOTYPE_METHOD(templ, "tcp", SigarTcpGet); 68 | NODE_SET_PROTOTYPE_METHOD(templ, "nfsClientV2", SigarNfsClientV2Get); 69 | NODE_SET_PROTOTYPE_METHOD(templ, "nfsServerV2", SigarNfsServerV2Get); 70 | NODE_SET_PROTOTYPE_METHOD(templ, "arpList", SigarArpListGet); 71 | // Misc 72 | NODE_SET_PROTOTYPE_METHOD(templ, "rpcPing", SigarRpcPing); 73 | //target->Set(v8u::Symbol("NodeSigar"), s_ct->GetFunction()); 74 | 75 | } NODE_TYPE_END() 76 | V8_POST_TYPE(NodeSigar); 77 | 78 | V8_SCB(NodeSigar::Init) { 79 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 80 | 81 | sigar_t* out; 82 | int status = sigar_open(&out); 83 | 84 | if(status == SIGAR_OK) return (new NodeSigar(out))->Wrapped(); 85 | V8_STHROW(v8u::Err("unknown error initializing")); 86 | } 87 | 88 | V8_SCB(NodeSigar::SigarVersionGet) { 89 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 90 | //V8_M_UNWRAP(NodeSigar, args.This()); 91 | 92 | sigar_version_t *version = sigar_version_get(); 93 | Handle h_version = Object::New(); 94 | h_version->Set(v8u::Symbol("build_date"), String::New(version->build_date)); 95 | h_version->Set(v8u::Symbol("scm_revision"), String::New(version->scm_revision)); 96 | h_version->Set(v8u::Symbol("version"), String::New(version->version)); 97 | h_version->Set(v8u::Symbol("archname"), String::New(version->archname)); 98 | h_version->Set(v8u::Symbol("archlib"), String::New(version->archlib)); 99 | h_version->Set(v8u::Symbol("binname"), String::New(version->binname)); 100 | h_version->Set(v8u::Symbol("description"), String::New(version->description)); 101 | h_version->Set(v8u::Symbol("major"), Number::New(version->major)); 102 | h_version->Set(v8u::Symbol("minor"), Number::New(version->minor)); 103 | h_version->Set(v8u::Symbol("maint"), Number::New(version->maint)); 104 | h_version->Set(v8u::Symbol("build"), Number::New(version->build)); 105 | return h_version; 106 | } 107 | 108 | V8_SCB(NodeSigar::SigarTestNetAdress) { 109 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 110 | //V8_M_UNWRAP(NodeSigar, args.This()); 111 | 112 | Handle h_source = args[0]->ToString(); 113 | sigar_net_address_t address; 114 | int status = node_sigar_str2net_address(h_source, &address); 115 | if(status != SIGAR_OK) { 116 | char msg[200]; 117 | sprintf(msg, "node_sigar_str2net_address error"); 118 | V8_STHROW(v8u::TypeErr(msg)); 119 | }; 120 | Handle h_result = node_sigar_net_address_to_string(&address); 121 | return h_result; 122 | } 123 | 124 | V8_SCB(NodeSigar::SigarPasswordGet) { 125 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 126 | //V8_M_UNWRAP(NodeSigar, args.This()); 127 | 128 | String::Utf8Value prompt(args[0]->ToString()); 129 | char* password = sigar_password_get(*prompt); 130 | return String::New(password); 131 | } 132 | 133 | V8_SCB(NodeSigar::SigarFormatSize) { 134 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 135 | //V8_M_UNWRAP(NodeSigar, args.This()); 136 | 137 | sigar_uint64_t size = args[0]->IntegerValue(); 138 | // char *buffer; 139 | char buffer[56]; 140 | char *result = sigar_format_size(size, buffer); 141 | return String::New(result); 142 | } 143 | 144 | V8_CB(NodeSigar::GetMem) { 145 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 146 | V8_M_UNWRAP(NodeSigar, args.This()); 147 | 148 | sigar_mem_t mem; 149 | int status = sigar_mem_get(inst->sigar, &mem); 150 | if(status != SIGAR_OK) { 151 | char msg[200]; 152 | sprintf(msg, "sigar_mem_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 153 | V8_STHROW(v8u::TypeErr(msg)); 154 | } 155 | Handle h_mem = Object::New(); 156 | h_mem->Set(v8u::Symbol("ram"), Number::New(mem.ram)); 157 | h_mem->Set(v8u::Symbol("total"), Number::New(mem.total)); 158 | h_mem->Set(v8u::Symbol("used"), Number::New(mem.used)); 159 | h_mem->Set(v8u::Symbol("free"), Number::New(mem.free)); 160 | h_mem->Set(v8u::Symbol("actual_used"), Number::New(mem.actual_used)); 161 | h_mem->Set(v8u::Symbol("actual_free"), Number::New(mem.actual_free)); 162 | h_mem->Set(v8u::Symbol("used_percent"), Number::New(mem.used_percent)); 163 | h_mem->Set(v8u::Symbol("free_percent"), Number::New(mem.free_percent)); 164 | 165 | return scope.Close(h_mem); 166 | } V8_CB_END(); 167 | 168 | V8_CB(NodeSigar::GetSwap) { 169 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 170 | V8_M_UNWRAP(NodeSigar, args.This()); 171 | 172 | sigar_swap_t swap; 173 | int status = sigar_swap_get(inst->sigar, &swap); 174 | if(status != SIGAR_OK) { 175 | char msg[200]; 176 | sprintf(msg, "sigar_swap_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 177 | V8_STHROW(v8u::TypeErr(msg)); 178 | } 179 | Handle h_swap = Object::New(); 180 | h_swap->Set(v8u::Symbol("total"), Number::New(swap.total)); 181 | h_swap->Set(v8u::Symbol("used"), Number::New(swap.used)); 182 | h_swap->Set(v8u::Symbol("free"), Number::New(swap.free)); 183 | h_swap->Set(v8u::Symbol("page_in"), Number::New(swap.page_in)); 184 | h_swap->Set(v8u::Symbol("page_out"), Number::New(swap.page_out)); 185 | return scope.Close(h_swap); 186 | } V8_CB_END(); 187 | 188 | V8_CB(NodeSigar::SigarUptimeGet) { 189 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 190 | V8_M_UNWRAP(NodeSigar, args.This()); 191 | 192 | sigar_uptime_t uptime; 193 | int status = sigar_uptime_get(inst->sigar, &uptime); 194 | if(status != SIGAR_OK) { 195 | char msg[200]; 196 | sprintf(msg, "sigar_uptime_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 197 | V8_STHROW(v8u::TypeErr(msg)); 198 | } 199 | return scope.Close(Number::New(uptime.uptime)); 200 | } V8_CB_END(); 201 | 202 | V8_CB(NodeSigar::SigarLoadavgGet) { 203 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 204 | V8_M_UNWRAP(NodeSigar, args.This()); 205 | 206 | sigar_loadavg_t loadavg; 207 | int status = sigar_loadavg_get(inst->sigar, &loadavg); 208 | if(status != SIGAR_OK) { 209 | char msg[200]; 210 | sprintf(msg, "sigar_uptime_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 211 | V8_STHROW(v8u::TypeErr(msg)); 212 | } 213 | Handle h_loadavgs = Array::New(3); 214 | h_loadavgs->Set(0, Number::New(loadavg.loadavg[0])); 215 | h_loadavgs->Set(1, Number::New(loadavg.loadavg[1])); 216 | h_loadavgs->Set(2, Number::New(loadavg.loadavg[2])); 217 | return scope.Close(h_loadavgs); 218 | } V8_CB_END(); 219 | 220 | V8_CB(NodeSigar::SigarResourceLimitGet) { 221 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 222 | V8_M_UNWRAP(NodeSigar, args.This()); 223 | 224 | sigar_resource_limit_t resourcelimit; 225 | int status = sigar_resource_limit_get(inst->sigar, &resourcelimit); 226 | if(status != SIGAR_OK) { 227 | char msg[200]; 228 | sprintf(msg, "sigar_cpu_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 229 | V8_STHROW(v8u::TypeErr(msg)); 230 | } 231 | Handle h_resourcelimit= Object::New(); 232 | h_resourcelimit->Set(v8u::Symbol("cpu_cur"), Number::New(resourcelimit.cpu_cur)); 233 | h_resourcelimit->Set(v8u::Symbol("cpu_max"), Number::New(resourcelimit.cpu_max)); 234 | h_resourcelimit->Set(v8u::Symbol("file_size_cur"), Number::New(resourcelimit.file_size_cur)); 235 | h_resourcelimit->Set(v8u::Symbol("file_size_max"), Number::New(resourcelimit.file_size_max)); 236 | h_resourcelimit->Set(v8u::Symbol("pipe_size_cur"), Number::New(resourcelimit.pipe_size_cur)); 237 | h_resourcelimit->Set(v8u::Symbol("pipe_size_max"), Number::New(resourcelimit.pipe_size_max)); 238 | h_resourcelimit->Set(v8u::Symbol("data_cur"), Number::New(resourcelimit.data_cur)); 239 | h_resourcelimit->Set(v8u::Symbol("data_max"), Number::New(resourcelimit.data_max)); 240 | h_resourcelimit->Set(v8u::Symbol("stack_cur"), Number::New(resourcelimit.stack_cur)); 241 | h_resourcelimit->Set(v8u::Symbol("stack_max"), Number::New(resourcelimit.stack_max)); 242 | h_resourcelimit->Set(v8u::Symbol("core_cur"), Number::New(resourcelimit.core_cur)); 243 | h_resourcelimit->Set(v8u::Symbol("core_max"), Number::New(resourcelimit.core_max)); 244 | h_resourcelimit->Set(v8u::Symbol("memory_cur"), Number::New(resourcelimit.memory_cur)); 245 | h_resourcelimit->Set(v8u::Symbol("memory_max"), Number::New(resourcelimit.memory_max)); 246 | h_resourcelimit->Set(v8u::Symbol("processes_cur"), Number::New(resourcelimit.processes_cur)); 247 | h_resourcelimit->Set(v8u::Symbol("processes_max"), Number::New(resourcelimit.processes_max)); 248 | h_resourcelimit->Set(v8u::Symbol("open_files_cur"), Number::New(resourcelimit.open_files_cur)); 249 | h_resourcelimit->Set(v8u::Symbol("open_files_max"), Number::New(resourcelimit.open_files_max)); 250 | h_resourcelimit->Set(v8u::Symbol("virtual_memory_cur"), Number::New(resourcelimit.virtual_memory_cur)); 251 | h_resourcelimit->Set(v8u::Symbol("virtual_memory_max"), Number::New(resourcelimit.virtual_memory_max)); 252 | return scope.Close(h_resourcelimit); 253 | } V8_CB_END(); 254 | 255 | V8_CB(NodeSigar::SigarWhoListGet) { 256 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 257 | V8_M_UNWRAP(NodeSigar, args.This()); 258 | 259 | sigar_who_list_t wholist; 260 | int status = sigar_who_list_get(inst->sigar, &wholist); 261 | if(status != SIGAR_OK) { 262 | char msg[200]; 263 | sprintf(msg, "sigar_who_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 264 | V8_STHROW(v8u::TypeErr(msg)); 265 | } 266 | Handle h_wholist = Array::New(wholist.number); 267 | unsigned i; 268 | for (i=0; i h_who = Object::New(); 271 | h_who->Set(v8u::Symbol("user"), String::New(who.user)); 272 | h_who->Set(v8u::Symbol("device"), String::New(who.device)); 273 | h_who->Set(v8u::Symbol("host"), String::New(who.host)); 274 | h_who->Set(v8u::Symbol("time"), Number::New(who.time)); 275 | h_wholist->Set(i, h_who); 276 | } 277 | sigar_who_list_destroy(inst->sigar, &wholist); 278 | return scope.Close(h_wholist); 279 | } V8_CB_END(); 280 | 281 | V8_CB(NodeSigar::SigarSysInfoGet) { 282 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 283 | V8_M_UNWRAP(NodeSigar, args.This()); 284 | 285 | sigar_sys_info_t sysinfo; 286 | int status = sigar_sys_info_get(inst->sigar, &sysinfo); 287 | if(status != SIGAR_OK) { 288 | char msg[200]; 289 | sprintf(msg, "sigar_who_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 290 | V8_STHROW(v8u::TypeErr(msg)); 291 | } 292 | Handle h_sysinfo = Object::New(); 293 | h_sysinfo->Set(v8u::Symbol("name"), String::New(sysinfo.name)); 294 | h_sysinfo->Set(v8u::Symbol("version"), String::New(sysinfo.version)); 295 | h_sysinfo->Set(v8u::Symbol("arch"), String::New(sysinfo.arch)); 296 | h_sysinfo->Set(v8u::Symbol("machine"), String::New(sysinfo.machine)); 297 | h_sysinfo->Set(v8u::Symbol("description"), String::New(sysinfo.description)); 298 | h_sysinfo->Set(v8u::Symbol("patch_level"), String::New(sysinfo.patch_level)); 299 | h_sysinfo->Set(v8u::Symbol("vendor"), String::New(sysinfo.vendor)); 300 | h_sysinfo->Set(v8u::Symbol("vendor_version"), String::New(sysinfo.vendor_version)); 301 | h_sysinfo->Set(v8u::Symbol("vendor_name"), String::New(sysinfo.vendor_name)); 302 | h_sysinfo->Set(v8u::Symbol("vendor_code_name"), String::New(sysinfo.vendor_code_name)); 303 | return scope.Close(h_sysinfo); 304 | } V8_CB_END(); 305 | 306 | V8_CB(NodeSigar::SigarFqdnGet) { 307 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 308 | V8_M_UNWRAP(NodeSigar, args.This()); 309 | 310 | char fqdn[SIGAR_FQDN_LEN]; 311 | int status = sigar_fqdn_get(inst->sigar, fqdn, sizeof(fqdn)); 312 | if(status != SIGAR_OK) { 313 | char msg[200]; 314 | sprintf(msg, "sigar_fqdn_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 315 | V8_STHROW(v8u::TypeErr(msg)); 316 | } 317 | return scope.Close(String::New(fqdn)); 318 | } V8_CB_END(); 319 | 320 | V8_CB(NodeSigar::SigarCpuGet) { 321 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 322 | V8_M_UNWRAP(NodeSigar, args.This()); 323 | 324 | sigar_cpu_t cpu; 325 | int status = sigar_cpu_get(inst->sigar, &cpu); 326 | if(status != SIGAR_OK) { 327 | char msg[200]; 328 | sprintf(msg, "sigar_cpu_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 329 | V8_STHROW(v8u::TypeErr(msg)); 330 | } 331 | Handle h_cpu = Object::New(); 332 | h_cpu->Set(v8u::Symbol("user"), Number::New(cpu.user)); 333 | h_cpu->Set(v8u::Symbol("sys"), Number::New(cpu.sys)); 334 | h_cpu->Set(v8u::Symbol("nice"), Number::New(cpu.nice)); 335 | h_cpu->Set(v8u::Symbol("idle"), Number::New(cpu.idle)); 336 | h_cpu->Set(v8u::Symbol("wait"), Number::New(cpu.wait)); 337 | h_cpu->Set(v8u::Symbol("irq"), Number::New(cpu.irq)); 338 | h_cpu->Set(v8u::Symbol("soft_irq"), Number::New(cpu.soft_irq)); 339 | h_cpu->Set(v8u::Symbol("stolen"), Number::New(cpu.stolen)); 340 | h_cpu->Set(v8u::Symbol("total"), Number::New(cpu.total)); 341 | return scope.Close(h_cpu); 342 | } V8_CB_END(); 343 | 344 | V8_CB(NodeSigar::SigarCpuListGet) { 345 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 346 | V8_M_UNWRAP(NodeSigar, args.This()); 347 | 348 | sigar_cpu_list_t cpulist; 349 | int status = sigar_cpu_list_get(inst->sigar, &cpulist); 350 | if(status != SIGAR_OK) { 351 | char msg[200]; 352 | sprintf(msg, "sigar_cpu_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 353 | V8_STHROW(v8u::TypeErr(msg)); 354 | } 355 | Handle h_cpus = Array::New(cpulist.number); 356 | unsigned i; 357 | for (i=0; i h_cpu = Object::New(); 360 | h_cpu->Set(v8u::Symbol("user"), Number::New(cpu.user)); 361 | h_cpu->Set(v8u::Symbol("sys"), Number::New(cpu.sys)); 362 | h_cpu->Set(v8u::Symbol("nice"), Number::New(cpu.nice)); 363 | h_cpu->Set(v8u::Symbol("idle"), Number::New(cpu.idle)); 364 | h_cpu->Set(v8u::Symbol("wait"), Number::New(cpu.wait)); 365 | h_cpu->Set(v8u::Symbol("irq"), Number::New(cpu.irq)); 366 | h_cpu->Set(v8u::Symbol("soft_irq"), Number::New(cpu.soft_irq)); 367 | h_cpu->Set(v8u::Symbol("stolen"), Number::New(cpu.stolen)); 368 | h_cpu->Set(v8u::Symbol("total"), Number::New(cpu.total)); 369 | h_cpus->Set(i, h_cpu); 370 | } 371 | sigar_cpu_list_destroy(inst->sigar, &cpulist); 372 | return scope.Close(h_cpus); 373 | } V8_CB_END(); 374 | 375 | V8_CB(NodeSigar::SigarCpuInfoListGet) { 376 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 377 | V8_M_UNWRAP(NodeSigar, args.This()); 378 | 379 | sigar_cpu_info_list_t cpuinfo; 380 | int status = sigar_cpu_info_list_get(inst->sigar, &cpuinfo); 381 | if(status != SIGAR_OK) { 382 | char msg[200]; 383 | sprintf(msg, "sigar_cpu_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 384 | V8_STHROW(v8u::TypeErr(msg)); 385 | } 386 | Handle h_cpus = Array::New(cpuinfo.number); 387 | unsigned i; 388 | for (i=0; i h_cpu = Object::New(); 391 | h_cpu->Set(v8u::Symbol("vendor"), String::New(cpu.vendor)); 392 | h_cpu->Set(v8u::Symbol("model"), String::New(cpu.model)); 393 | h_cpu->Set(v8u::Symbol("mhz"), Number::New(cpu.mhz)); 394 | h_cpu->Set(v8u::Symbol("mhz_max"), Number::New(cpu.mhz_max)); 395 | h_cpu->Set(v8u::Symbol("mhz_min"), Number::New(cpu.mhz_min)); 396 | h_cpu->Set(v8u::Symbol("cache_size"), Number::New(cpu.cache_size)); 397 | h_cpu->Set(v8u::Symbol("total_sockets"), Number::New(cpu.total_sockets)); 398 | h_cpu->Set(v8u::Symbol("total_cores"), Number::New(cpu.total_cores)); 399 | h_cpu->Set(v8u::Symbol("cores_per_socket"), Number::New(cpu.cores_per_socket)); 400 | h_cpus->Set(i, h_cpu); 401 | } 402 | sigar_cpu_info_list_destroy(inst->sigar, &cpuinfo); 403 | return scope.Close(h_cpus); 404 | } V8_CB_END(); 405 | 406 | V8_CB(NodeSigar::SigarProcListGet) { 407 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 408 | V8_M_UNWRAP(NodeSigar, args.This()); 409 | 410 | sigar_proc_list_t proclist; 411 | int status = sigar_proc_list_get(inst->sigar, &proclist); 412 | if(status != SIGAR_OK) { 413 | char msg[200]; 414 | sprintf(msg, "sigar_proc_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 415 | V8_STHROW(v8u::TypeErr(msg)); 416 | } 417 | Handle h_proclist = Array::New(proclist.number); 418 | unsigned i; 419 | for (i=0; iSet(i, Number::New(pid)); 422 | } 423 | sigar_proc_list_destroy(inst->sigar, &proclist); 424 | return scope.Close(h_proclist); 425 | } V8_CB_END(); 426 | 427 | V8_CB(NodeSigar::SigarProcStatGet) { 428 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 429 | V8_M_UNWRAP(NodeSigar, args.This()); 430 | 431 | sigar_proc_stat_t procstat; 432 | int status = sigar_proc_stat_get(inst->sigar, &procstat); 433 | if(status != SIGAR_OK) { 434 | char msg[200]; 435 | sprintf(msg, "sigar_proc_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 436 | V8_STHROW(v8u::TypeErr(msg)); 437 | } 438 | Handle h_procstat = Object::New(); 439 | h_procstat->Set(v8u::Symbol("total"), Number::New(procstat.total)); 440 | h_procstat->Set(v8u::Symbol("sleeping"), Number::New(procstat.sleeping)); 441 | h_procstat->Set(v8u::Symbol("running"), Number::New(procstat.running)); 442 | h_procstat->Set(v8u::Symbol("zombie"), Number::New(procstat.zombie)); 443 | h_procstat->Set(v8u::Symbol("stopped"), Number::New(procstat.stopped)); 444 | h_procstat->Set(v8u::Symbol("idle"), Number::New(procstat.idle)); 445 | h_procstat->Set(v8u::Symbol("threads"), Number::New(procstat.threads)); 446 | return scope.Close(h_procstat); 447 | } V8_CB_END(); 448 | 449 | V8_CB(NodeSigar::SigarProcMemGet) { 450 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 451 | V8_M_UNWRAP(NodeSigar, args.This()); 452 | 453 | sigar_proc_mem_t procmem; 454 | int status = sigar_proc_mem_get(inst->sigar, args[0]->IntegerValue(), &procmem); 455 | if(status != SIGAR_OK) { 456 | char msg[200]; 457 | sprintf(msg, "sigar_proc_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 458 | V8_STHROW(v8u::TypeErr(msg)); 459 | } 460 | Handle h_procmem = Object::New(); 461 | h_procmem->Set(v8u::Symbol("size"), Number::New(procmem.size)); 462 | h_procmem->Set(v8u::Symbol("resident"), Number::New(procmem.resident)); 463 | h_procmem->Set(v8u::Symbol("share"), Number::New(procmem.share)); 464 | h_procmem->Set(v8u::Symbol("minor_faults"), Number::New(procmem.minor_faults)); 465 | h_procmem->Set(v8u::Symbol("major_faults"), Number::New(procmem.major_faults)); 466 | h_procmem->Set(v8u::Symbol("page_faults"), Number::New(procmem.page_faults)); 467 | return scope.Close(h_procmem); 468 | } V8_CB_END(); 469 | 470 | V8_CB(NodeSigar::SigarProcCredGet) { 471 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 472 | V8_M_UNWRAP(NodeSigar, args.This()); 473 | 474 | sigar_proc_cred_t proccred; 475 | int status = sigar_proc_cred_get(inst->sigar, args[0]->IntegerValue(), &proccred); 476 | if(status != SIGAR_OK) { 477 | char msg[200]; 478 | sprintf(msg, "sigar_proc_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 479 | V8_STHROW(v8u::TypeErr(msg)); 480 | } 481 | Handle h_proccred = Object::New(); 482 | h_proccred->Set(v8u::Symbol("uid"), Number::New(proccred.uid)); 483 | h_proccred->Set(v8u::Symbol("gid"), Number::New(proccred.gid)); 484 | h_proccred->Set(v8u::Symbol("euid"), Number::New(proccred.euid)); 485 | h_proccred->Set(v8u::Symbol("egid"), Number::New(proccred.egid)); 486 | return scope.Close(h_proccred); 487 | } V8_CB_END(); 488 | 489 | V8_CB(NodeSigar::SigarProcTimeGet) { 490 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 491 | V8_M_UNWRAP(NodeSigar, args.This()); 492 | 493 | sigar_proc_time_t proctime; 494 | int status = sigar_proc_time_get(inst->sigar, args[0]->IntegerValue(), &proctime); 495 | if(status != SIGAR_OK) { 496 | char msg[200]; 497 | sprintf(msg, "sigar_proc_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 498 | V8_STHROW(v8u::TypeErr(msg)); 499 | } 500 | Handle h_proctime = Object::New(); 501 | h_proctime->Set(v8u::Symbol("start_time"), Number::New(proctime.start_time)); 502 | h_proctime->Set(v8u::Symbol("user"), Number::New(proctime.user)); 503 | h_proctime->Set(v8u::Symbol("sys"), Number::New(proctime.sys)); 504 | h_proctime->Set(v8u::Symbol("total"), Number::New(proctime.total)); 505 | return scope.Close(h_proctime); 506 | } V8_CB_END(); 507 | 508 | V8_CB(NodeSigar::SigarProcCpuGet) { 509 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 510 | V8_M_UNWRAP(NodeSigar, args.This()); 511 | 512 | sigar_proc_cpu_t proccpu; 513 | int status = sigar_proc_cpu_get(inst->sigar, args[0]->IntegerValue(), &proccpu); 514 | if(status != SIGAR_OK) { 515 | char msg[200]; 516 | sprintf(msg, "sigar_proc_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 517 | V8_STHROW(v8u::TypeErr(msg)); 518 | } 519 | Handle h_proccpu = Object::New(); 520 | h_proccpu->Set(v8u::Symbol("start_time"), Number::New(proccpu.start_time)); 521 | h_proccpu->Set(v8u::Symbol("user"), Number::New(proccpu.user)); 522 | h_proccpu->Set(v8u::Symbol("sys"), Number::New(proccpu.sys)); 523 | h_proccpu->Set(v8u::Symbol("total"), Number::New(proccpu.total)); 524 | h_proccpu->Set(v8u::Symbol("last_time"), Number::New(proccpu.last_time)); 525 | h_proccpu->Set(v8u::Symbol("percent"), Number::New(proccpu.percent)); 526 | return scope.Close(h_proccpu); 527 | } V8_CB_END(); 528 | 529 | V8_CB(NodeSigar::SigarProcStateGet) { 530 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 531 | V8_M_UNWRAP(NodeSigar, args.This()); 532 | 533 | sigar_proc_state_t procstate; 534 | int status = sigar_proc_state_get(inst->sigar, args[0]->IntegerValue(), &procstate); 535 | if(status != SIGAR_OK) { 536 | char msg[200]; 537 | sprintf(msg, "sigar_proc_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 538 | V8_STHROW(v8u::TypeErr(msg)); 539 | }; 540 | // TODO: state is probably not handled correctly, 541 | // eg, moving the next 2 lines after h_procstate creation will add extra characters 542 | char state[0]; 543 | state[0] = procstate.state; 544 | Handle h_procstate = Object::New(); 545 | h_procstate->Set(v8u::Symbol("name"), String::New(procstate.name)); 546 | h_procstate->Set(v8u::Symbol("state"), String::New(state)); 547 | h_procstate->Set(v8u::Symbol("ppid"), Number::New(procstate.ppid)); 548 | h_procstate->Set(v8u::Symbol("tty"), Number::New(procstate.tty)); 549 | h_procstate->Set(v8u::Symbol("priority"), Number::New(procstate.priority)); 550 | h_procstate->Set(v8u::Symbol("nice"), Number::New(procstate.nice)); 551 | h_procstate->Set(v8u::Symbol("processor"), Number::New(procstate.processor)); 552 | h_procstate->Set(v8u::Symbol("threads"), Number::New(procstate.threads)); 553 | return scope.Close(h_procstate); 554 | } V8_CB_END(); 555 | 556 | V8_CB(NodeSigar::SigarProcArgsGet) { 557 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 558 | V8_M_UNWRAP(NodeSigar, args.This()); 559 | 560 | sigar_proc_args_t procargs; 561 | int status = sigar_proc_args_get(inst->sigar, args[0]->IntegerValue(), &procargs); 562 | if(status != SIGAR_OK) { 563 | char msg[200]; 564 | sprintf(msg, "sigar_proc_args_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 565 | V8_STHROW(v8u::TypeErr(msg)); 566 | } 567 | Handle h_procargs = Array::New(procargs.number); 568 | unsigned i; 569 | for (i=0; iSet(i, String::New(arg)); 572 | } 573 | sigar_proc_args_destroy(inst->sigar, &procargs); 574 | return scope.Close(h_procargs); 575 | } V8_CB_END(); 576 | 577 | static int SigarProcEnvGet_getter(void *data, 578 | const char *key, int klen, 579 | char *val, int vlen) 580 | { 581 | Handle d = *((Handle*)data); 582 | d->Set(String::New(key, klen), String::New(val, vlen)); 583 | return SIGAR_OK; 584 | } 585 | 586 | V8_CB(NodeSigar::SigarProcEnvGet) { 587 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 588 | V8_M_UNWRAP(NodeSigar, args.This()); 589 | 590 | sigar_proc_env_t procenv; 591 | procenv.type = procenv.SIGAR_PROC_ENV_ALL; 592 | procenv.env_getter = SigarProcEnvGet_getter; 593 | Handle data = Object::New(); 594 | procenv.data = &data; 595 | int status = sigar_proc_env_get(inst->sigar, args[0]->IntegerValue(), &procenv); 596 | if(status != SIGAR_OK) { 597 | char msg[200]; 598 | sprintf(msg, "sigar_proc_env_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 599 | V8_STHROW(v8u::TypeErr(msg)); 600 | } 601 | return scope.Close(data); 602 | } V8_CB_END(); 603 | 604 | V8_CB(NodeSigar::SigarProcFdGet) { 605 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 606 | V8_M_UNWRAP(NodeSigar, args.This()); 607 | 608 | sigar_proc_fd_t procfd; 609 | int status = sigar_proc_fd_get(inst->sigar, args[0]->IntegerValue(), &procfd); 610 | if(status != SIGAR_OK) { 611 | char msg[200]; 612 | sprintf(msg, "sigar_proc_fd_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 613 | V8_STHROW(v8u::TypeErr(msg)); 614 | } 615 | // Note, return an object because only total but a comment 616 | // suggest they might add other properties 617 | Handle h_procfd = Object::New(); 618 | h_procfd->Set(v8u::Symbol("total"), Number::New(procfd.total)); 619 | return scope.Close(h_procfd); 620 | } V8_CB_END(); 621 | 622 | V8_CB(NodeSigar::SigarProcExeGet) { 623 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 624 | V8_M_UNWRAP(NodeSigar, args.This()); 625 | 626 | sigar_proc_exe_t procexe; 627 | int status = sigar_proc_exe_get(inst->sigar, args[0]->IntegerValue(), &procexe); 628 | if(status != SIGAR_OK) { 629 | char msg[200]; 630 | sprintf(msg, "sigar_proc_exe_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 631 | V8_STHROW(v8u::TypeErr(msg)); 632 | }; 633 | Handle h_procexe = Object::New(); 634 | h_procexe->Set(v8u::Symbol("name"), String::New(procexe.name)); 635 | h_procexe->Set(v8u::Symbol("cwd"), String::New(procexe.cwd)); 636 | h_procexe->Set(v8u::Symbol("root"), String::New(procexe.root)); 637 | return scope.Close(h_procexe); 638 | } V8_CB_END(); 639 | 640 | static int SigarProcModulesGet_getter(void *data, 641 | char *key, int klen) 642 | { 643 | Handle d = *((Handle*)data); 644 | // Not sure if index arg is meant to work 645 | d->Set(d->Length(), String::New(key, klen)); 646 | return SIGAR_OK; 647 | } 648 | 649 | V8_CB(NodeSigar::SigarProcModulesGet) { 650 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 651 | V8_M_UNWRAP(NodeSigar, args.This()); 652 | 653 | sigar_proc_modules_t procmodule; 654 | procmodule.module_getter = SigarProcModulesGet_getter; 655 | Handle data = Array::New(); 656 | procmodule.data = &data; 657 | int status = sigar_proc_modules_get(inst->sigar, args[0]->IntegerValue(), &procmodule); 658 | if(status != SIGAR_OK) { 659 | char msg[200]; 660 | sprintf(msg, "sigar_proc_module_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 661 | V8_STHROW(v8u::TypeErr(msg)); 662 | } 663 | return scope.Close(data); 664 | } V8_CB_END(); 665 | 666 | V8_CB(NodeSigar::SigarProcPortGet) { 667 | if(args.Length() != 2) V8_STHROW(v8u::TypeErr("Invalid argument")); 668 | V8_M_UNWRAP(NodeSigar, args.This()); 669 | 670 | int protocol = args[0]->Int32Value(); 671 | //int protocol = SIGAR_NETCONN_TCP; 672 | //int protocol = SIGAR_NETCONN_UDP; 673 | //int protocol = SIGAR_NETCONN_RAW; 674 | //int protocol = SIGAR_NETCONN_UNIX; 675 | unsigned long port = args[1]->Int32Value(); 676 | sigar_pid_t pid; 677 | int status = sigar_proc_port_get(inst->sigar, protocol, port, &pid); 678 | if(status != SIGAR_OK) { 679 | char msg[200]; 680 | sprintf(msg, "sigar_proc_port_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 681 | V8_STHROW(v8u::TypeErr(msg)); 682 | } 683 | return scope.Close(Number::New(pid)); 684 | } V8_CB_END(); 685 | 686 | V8_CB(NodeSigar::SigarThreadCpuGet) { 687 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 688 | V8_M_UNWRAP(NodeSigar, args.This()); 689 | 690 | sigar_thread_cpu_t threadcpu; 691 | int status = sigar_thread_cpu_get(inst->sigar, args[0]->IntegerValue(), &threadcpu); 692 | if(status != SIGAR_OK) { 693 | char msg[200]; 694 | sprintf(msg, "sigar_thread_cpu_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 695 | V8_STHROW(v8u::TypeErr(msg)); 696 | }; 697 | Handle h_threadcpu = Object::New(); 698 | h_threadcpu->Set(v8u::Symbol("user"), Number::New(threadcpu.user)); 699 | h_threadcpu->Set(v8u::Symbol("sys"), Number::New(threadcpu.sys)); 700 | h_threadcpu->Set(v8u::Symbol("total"), Number::New(threadcpu.total)); 701 | return scope.Close(h_threadcpu); 702 | } V8_CB_END(); 703 | 704 | V8_CB(NodeSigar::SigarFileSystemListGet) { 705 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 706 | V8_M_UNWRAP(NodeSigar, args.This()); 707 | 708 | sigar_file_system_list_t filesystemlist; 709 | int status = sigar_file_system_list_get(inst->sigar, &filesystemlist); 710 | if(status != SIGAR_OK) { 711 | char msg[200]; 712 | sprintf(msg, "sigar_file_system_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 713 | V8_STHROW(v8u::TypeErr(msg)); 714 | } 715 | Handle h_filesystemlist = Array::New(filesystemlist.number); 716 | unsigned i; 717 | for (i=0; i h_filesystem = Object::New(); 720 | h_filesystem->Set(v8u::Symbol("dir_name"), String::New(filesystem.dir_name)); 721 | h_filesystem->Set(v8u::Symbol("dev_name"), String::New(filesystem.dev_name)); 722 | h_filesystem->Set(v8u::Symbol("type_name"), String::New(filesystem.type_name)); 723 | h_filesystem->Set(v8u::Symbol("sys_type_name"), String::New(filesystem.sys_type_name)); 724 | h_filesystem->Set(v8u::Symbol("options"), String::New(filesystem.options)); 725 | h_filesystem->Set(v8u::Symbol("type"), Number::New(filesystem.type)); 726 | h_filesystem->Set(v8u::Symbol("flags"), Number::New(filesystem.flags)); 727 | h_filesystemlist->Set(i, h_filesystem); 728 | } 729 | sigar_file_system_list_destroy(inst->sigar, &filesystemlist); 730 | return scope.Close(h_filesystemlist); 731 | } V8_CB_END(); 732 | 733 | V8_CB(NodeSigar::SigarFileSystemUsageGet) { 734 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 735 | V8_M_UNWRAP(NodeSigar, args.This()); 736 | 737 | sigar_file_system_usage_t filesystemusage; 738 | String::Utf8Value dirname(args[0]->ToString()); 739 | int status = sigar_file_system_usage_get(inst->sigar, *dirname, &filesystemusage); 740 | if(status != SIGAR_OK) { 741 | char msg[200]; 742 | sprintf(msg, "sigar_file_system_usage_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 743 | V8_STHROW(v8u::TypeErr(msg)); 744 | }; 745 | Handle h_filesystemusage = Object::New(); 746 | Handle h_diskusage= Object::New(); 747 | sigar_disk_usage_t diskusage = filesystemusage.disk; 748 | h_diskusage->Set(v8u::Symbol("reads"), Number::New(diskusage.reads)); 749 | h_diskusage->Set(v8u::Symbol("writes"), Number::New(diskusage.writes)); 750 | h_diskusage->Set(v8u::Symbol("write_bytes"), Number::New(diskusage.write_bytes)); 751 | h_diskusage->Set(v8u::Symbol("read_bytes"), Number::New(diskusage.read_bytes)); 752 | h_diskusage->Set(v8u::Symbol("rtime"), Number::New(diskusage.rtime)); 753 | h_diskusage->Set(v8u::Symbol("wtime"), Number::New(diskusage.wtime)); 754 | h_diskusage->Set(v8u::Symbol("qtime"), Number::New(diskusage.qtime)); 755 | h_diskusage->Set(v8u::Symbol("time"), Number::New(diskusage.time)); 756 | h_diskusage->Set(v8u::Symbol("snaptime"), Number::New(diskusage.snaptime)); 757 | h_diskusage->Set(v8u::Symbol("service_time"), Number::New(diskusage.service_time)); 758 | h_diskusage->Set(v8u::Symbol("queue"), Number::New(diskusage.queue)); 759 | h_filesystemusage->Set(v8u::Symbol("disk"), h_diskusage); 760 | h_filesystemusage->Set(v8u::Symbol("use_percent"), Number::New(filesystemusage.use_percent)); 761 | h_filesystemusage->Set(v8u::Symbol("total"), Number::New(filesystemusage.total)); 762 | h_filesystemusage->Set(v8u::Symbol("free"), Number::New(filesystemusage.free)); 763 | h_filesystemusage->Set(v8u::Symbol("used"), Number::New(filesystemusage.used)); 764 | h_filesystemusage->Set(v8u::Symbol("avail"), Number::New(filesystemusage.avail)); 765 | h_filesystemusage->Set(v8u::Symbol("files"), Number::New(filesystemusage.files)); 766 | h_filesystemusage->Set(v8u::Symbol("free_files"), Number::New(filesystemusage.free_files)); 767 | return scope.Close(h_filesystemusage); 768 | } V8_CB_END(); 769 | 770 | V8_CB(NodeSigar::SigarFileSystemPingGet) { 771 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 772 | V8_M_UNWRAP(NodeSigar, args.This()); 773 | 774 | sigar_file_system_t filesystem; 775 | int status = sigar_file_system_ping(inst->sigar, &filesystem); 776 | if(status != SIGAR_OK) { 777 | char msg[200]; 778 | sprintf(msg, "sigar_file_system_ping error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 779 | V8_STHROW(v8u::TypeErr(msg)); 780 | }; 781 | Handle h_filesystem = Object::New(); 782 | //printf("TEST %s | %u \n", filesystem.dir_name, filesystem.dev_name); 783 | h_filesystem->Set(v8u::Symbol("dir_name"), String::New(filesystem.dir_name)); 784 | h_filesystem->Set(v8u::Symbol("dev_name"), String::New(filesystem.dev_name)); 785 | h_filesystem->Set(v8u::Symbol("type_name"), String::New(filesystem.type_name)); 786 | h_filesystem->Set(v8u::Symbol("sys_type_name"), String::New(filesystem.sys_type_name)); 787 | h_filesystem->Set(v8u::Symbol("options"), String::New(filesystem.options)); 788 | h_filesystem->Set(v8u::Symbol("type"), Number::New(filesystem.type)); 789 | h_filesystem->Set(v8u::Symbol("flags"), Number::New(filesystem.flags)); 790 | return scope.Close(h_filesystem); 791 | } V8_CB_END(); 792 | 793 | V8_CB(NodeSigar::SigarNetInfoGet) { 794 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 795 | V8_M_UNWRAP(NodeSigar, args.This()); 796 | 797 | sigar_net_info_t netinfo; 798 | int status = sigar_net_info_get(inst->sigar, &netinfo); 799 | if(status != SIGAR_OK) { 800 | char msg[200]; 801 | sprintf(msg, "sigar_file_system_ping error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 802 | V8_STHROW(v8u::TypeErr(msg)); 803 | }; 804 | Handle h_netinfo = Object::New(); 805 | h_netinfo->Set(v8u::Symbol("default_gateway"), String::New(netinfo.default_gateway)); 806 | h_netinfo->Set(v8u::Symbol("default_gateway_interface"), String::New(netinfo.default_gateway_interface)); 807 | h_netinfo->Set(v8u::Symbol("host_name"), String::New(netinfo.host_name)); 808 | h_netinfo->Set(v8u::Symbol("domain_name"), String::New(netinfo.domain_name)); 809 | h_netinfo->Set(v8u::Symbol("primary_dns"), String::New(netinfo.primary_dns)); 810 | h_netinfo->Set(v8u::Symbol("secondary_dns"), String::New(netinfo.secondary_dns)); 811 | return scope.Close(h_netinfo); 812 | } V8_CB_END(); 813 | 814 | V8_CB(NodeSigar::SigarNetRouteListGet) { 815 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 816 | V8_M_UNWRAP(NodeSigar, args.This()); 817 | 818 | sigar_net_route_list_t netroutelist; 819 | int status = sigar_net_route_list_get(inst->sigar, &netroutelist); 820 | if(status != SIGAR_OK) { 821 | char msg[200]; 822 | sprintf(msg, "sigar_net_route_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 823 | V8_STHROW(v8u::TypeErr(msg)); 824 | } 825 | Handle h_netroutelist = Array::New(netroutelist.number); 826 | unsigned i; 827 | for (i=0; i h_netroute = Object::New(); 830 | 831 | h_netroute->Set(v8u::Symbol("destination"), node_sigar_net_address_to_string(&netroute.destination)); 832 | h_netroute->Set(v8u::Symbol("gateway"), node_sigar_net_address_to_string(&netroute.gateway)); 833 | h_netroute->Set(v8u::Symbol("mask"), node_sigar_net_address_to_string(&netroute.mask)); 834 | 835 | h_netroute->Set(v8u::Symbol("flags"), Number::New(netroute.flags)); 836 | h_netroute->Set(v8u::Symbol("refcnt"), Number::New(netroute.refcnt)); 837 | h_netroute->Set(v8u::Symbol("use"), Number::New(netroute.use)); 838 | h_netroute->Set(v8u::Symbol("metric"), Number::New(netroute.metric)); 839 | h_netroute->Set(v8u::Symbol("mtu"), Number::New(netroute.mtu)); 840 | h_netroute->Set(v8u::Symbol("window"), Number::New(netroute.window)); 841 | h_netroute->Set(v8u::Symbol("irtt"), Number::New(netroute.irtt)); 842 | h_netroute->Set(v8u::Symbol("ifname"), String::New(netroute.ifname)); 843 | h_netroutelist->Set(i, h_netroute); 844 | } 845 | sigar_net_route_list_destroy(inst->sigar, &netroutelist); 846 | return scope.Close(h_netroutelist); 847 | } V8_CB_END(); 848 | 849 | V8_CB(NodeSigar::SigarNetInterfaceListGet) { 850 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 851 | V8_M_UNWRAP(NodeSigar, args.This()); 852 | 853 | sigar_net_interface_list_t netinterfacelist; 854 | int status = sigar_net_interface_list_get(inst->sigar, &netinterfacelist); 855 | if(status != SIGAR_OK) { 856 | char msg[200]; 857 | sprintf(msg, "sigar_net_route_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 858 | V8_STHROW(v8u::TypeErr(msg)); 859 | } 860 | Handle h_netinterfacelist = Array::New(netinterfacelist.number); 861 | unsigned i; 862 | for (i=0; i h_name= String::New(name); 865 | h_netinterfacelist->Set(i, h_name); 866 | } 867 | sigar_net_interface_list_destroy(inst->sigar, &netinterfacelist); 868 | return scope.Close(h_netinterfacelist); 869 | } V8_CB_END(); 870 | 871 | V8_CB(NodeSigar::SigarNetInterfaceConfigGet) { 872 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 873 | V8_M_UNWRAP(NodeSigar, args.This()); 874 | 875 | sigar_net_interface_config_t netinterface; 876 | String::Utf8Value name(args[0]->ToString()); 877 | int status = sigar_net_interface_config_get(inst->sigar, *name, &netinterface); 878 | if(status != SIGAR_OK) { 879 | char msg[200]; 880 | sprintf(msg, "sigar_net_interface_config_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 881 | V8_STHROW(v8u::TypeErr(msg)); 882 | }; 883 | Handle h_netinterface = Object::New(); 884 | h_netinterface->Set(v8u::Symbol("name"), String::New(netinterface.name)); 885 | h_netinterface->Set(v8u::Symbol("type"), String::New(netinterface.type)); 886 | h_netinterface->Set(v8u::Symbol("description"), String::New(netinterface.description)); 887 | h_netinterface->Set(v8u::Symbol("hwaddr"), node_sigar_net_address_to_string(&netinterface.hwaddr)); 888 | h_netinterface->Set(v8u::Symbol("address"), node_sigar_net_address_to_string(&netinterface.address)); 889 | h_netinterface->Set(v8u::Symbol("destination"), node_sigar_net_address_to_string(&netinterface.destination)); 890 | h_netinterface->Set(v8u::Symbol("broadcast"), node_sigar_net_address_to_string(&netinterface.broadcast)); 891 | h_netinterface->Set(v8u::Symbol("netmask"), node_sigar_net_address_to_string(&netinterface.netmask)); 892 | h_netinterface->Set(v8u::Symbol("address6"), node_sigar_net_address_to_string(&netinterface.address6)); 893 | h_netinterface->Set(v8u::Symbol("prefix6_length"), Number::New(netinterface.prefix6_length)); 894 | h_netinterface->Set(v8u::Symbol("scope6"), Number::New(netinterface.scope6)); 895 | h_netinterface->Set(v8u::Symbol("flags"), Number::New(netinterface.flags)); 896 | h_netinterface->Set(v8u::Symbol("mtu"), Number::New(netinterface.mtu)); 897 | h_netinterface->Set(v8u::Symbol("metric"), Number::New(netinterface.metric)); 898 | h_netinterface->Set(v8u::Symbol("tx_queue_len"), Number::New(netinterface.tx_queue_len)); 899 | return scope.Close(h_netinterface); 900 | } V8_CB_END(); 901 | 902 | V8_CB(NodeSigar::SigarNetInterfaceConfigPrimaryGet) { 903 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 904 | V8_M_UNWRAP(NodeSigar, args.This()); 905 | 906 | sigar_net_interface_config_t netinterface; 907 | int status = sigar_net_interface_config_primary_get(inst->sigar, &netinterface); 908 | if(status != SIGAR_OK) { 909 | char msg[200]; 910 | sprintf(msg, "sigar_net_interface_config_primary_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 911 | V8_STHROW(v8u::TypeErr(msg)); 912 | }; 913 | Handle h_netinterface = Object::New(); 914 | h_netinterface->Set(v8u::Symbol("name"), String::New(netinterface.name)); 915 | h_netinterface->Set(v8u::Symbol("type"), String::New(netinterface.type)); 916 | h_netinterface->Set(v8u::Symbol("description"), String::New(netinterface.description)); 917 | h_netinterface->Set(v8u::Symbol("hwaddr"), node_sigar_net_address_to_string(&netinterface.hwaddr)); 918 | h_netinterface->Set(v8u::Symbol("address"), node_sigar_net_address_to_string(&netinterface.address)); 919 | h_netinterface->Set(v8u::Symbol("destination"), node_sigar_net_address_to_string(&netinterface.destination)); 920 | h_netinterface->Set(v8u::Symbol("broadcast"), node_sigar_net_address_to_string(&netinterface.broadcast)); 921 | h_netinterface->Set(v8u::Symbol("netmask"), node_sigar_net_address_to_string(&netinterface.netmask)); 922 | h_netinterface->Set(v8u::Symbol("address6"), node_sigar_net_address_to_string(&netinterface.address6)); 923 | h_netinterface->Set(v8u::Symbol("prefix6_length"), Number::New(netinterface.prefix6_length)); 924 | h_netinterface->Set(v8u::Symbol("scope6"), Number::New(netinterface.scope6)); 925 | h_netinterface->Set(v8u::Symbol("flags"), Number::New(netinterface.flags)); 926 | h_netinterface->Set(v8u::Symbol("mtu"), Number::New(netinterface.mtu)); 927 | h_netinterface->Set(v8u::Symbol("metric"), Number::New(netinterface.metric)); 928 | h_netinterface->Set(v8u::Symbol("tx_queue_len"), Number::New(netinterface.tx_queue_len)); 929 | return scope.Close(h_netinterface); 930 | } V8_CB_END(); 931 | 932 | V8_CB(NodeSigar::SigarNetInterfaceStatGet) { 933 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 934 | V8_M_UNWRAP(NodeSigar, args.This()); 935 | 936 | sigar_net_interface_stat_t netinterface; 937 | String::Utf8Value name(args[0]->ToString()); 938 | int status = sigar_net_interface_stat_get(inst->sigar, *name, &netinterface); 939 | if(status != SIGAR_OK) { 940 | char msg[200]; 941 | sprintf(msg, "sigar_net_interface_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 942 | V8_STHROW(v8u::TypeErr(msg)); 943 | }; 944 | Handle h_netinterface = Object::New(); 945 | h_netinterface->Set(v8u::Symbol("rx_packets"), Number::New(netinterface.rx_packets)); 946 | h_netinterface->Set(v8u::Symbol("rx_bytes"), Number::New(netinterface.rx_bytes)); 947 | h_netinterface->Set(v8u::Symbol("rx_errors"), Number::New(netinterface.rx_errors)); 948 | h_netinterface->Set(v8u::Symbol("rx_dropped"), Number::New(netinterface.rx_dropped)); 949 | h_netinterface->Set(v8u::Symbol("rx_overruns"), Number::New(netinterface.rx_overruns)); 950 | h_netinterface->Set(v8u::Symbol("rx_frame"), Number::New(netinterface.rx_frame)); 951 | h_netinterface->Set(v8u::Symbol("tx_packets"), Number::New(netinterface.tx_packets)); 952 | h_netinterface->Set(v8u::Symbol("tx_bytes"), Number::New(netinterface.tx_bytes)); 953 | h_netinterface->Set(v8u::Symbol("tx_errors"), Number::New(netinterface.tx_errors)); 954 | h_netinterface->Set(v8u::Symbol("tx_dropped"), Number::New(netinterface.tx_dropped)); 955 | h_netinterface->Set(v8u::Symbol("tx_overruns"), Number::New(netinterface.tx_overruns)); 956 | h_netinterface->Set(v8u::Symbol("tx_collisions"), Number::New(netinterface.tx_collisions)); 957 | h_netinterface->Set(v8u::Symbol("tx_carrier"), Number::New(netinterface.tx_carrier)); 958 | h_netinterface->Set(v8u::Symbol("speed"), Number::New(netinterface.speed)); 959 | return scope.Close(h_netinterface); 960 | } V8_CB_END(); 961 | 962 | V8_CB(NodeSigar::SigarNetConnectionListGet) { 963 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 964 | V8_M_UNWRAP(NodeSigar, args.This()); 965 | 966 | sigar_net_connection_list_t netconnectionlist; 967 | int flags = args[0]->Int32Value(); 968 | int status = sigar_net_connection_list_get(inst->sigar, &netconnectionlist, flags); 969 | if(status != SIGAR_OK) { 970 | char msg[200]; 971 | sprintf(msg, "sigar_net_connection_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 972 | V8_STHROW(v8u::TypeErr(msg)); 973 | } 974 | Handle h_netconnectionlist = Array::New(netconnectionlist.number); 975 | unsigned i; 976 | for (i=0; i h_netconnection = Object::New(); 979 | h_netconnection->Set(v8u::Symbol("local_port"), Number::New(netconnection.local_port)); 980 | h_netconnection->Set(v8u::Symbol("local_address"), node_sigar_net_address_to_string(&netconnection.local_address)); 981 | h_netconnection->Set(v8u::Symbol("remote_port"), Number::New(netconnection.remote_port)); 982 | h_netconnection->Set(v8u::Symbol("remote_address"), node_sigar_net_address_to_string(&netconnection.remote_address)); 983 | h_netconnection->Set(v8u::Symbol("uid"), Number::New(netconnection.uid)); 984 | h_netconnection->Set(v8u::Symbol("inode"), Number::New(netconnection.inode)); 985 | h_netconnection->Set(v8u::Symbol("type"), Number::New(netconnection.type)); 986 | h_netconnection->Set(v8u::Symbol("state"), Number::New(netconnection.state)); 987 | h_netconnection->Set(v8u::Symbol("send_queue"), Number::New(netconnection.send_queue)); 988 | h_netconnection->Set(v8u::Symbol("receive_queue"), Number::New(netconnection.receive_queue)); 989 | h_netconnectionlist->Set(i, h_netconnection); 990 | } 991 | sigar_net_connection_list_destroy(inst->sigar, &netconnectionlist); 992 | return scope.Close(h_netconnectionlist); 993 | } V8_CB_END(); 994 | 995 | V8_CB(NodeSigar::SigarNetListenAddressGet) { 996 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 997 | V8_M_UNWRAP(NodeSigar, args.This()); 998 | 999 | sigar_net_address_t netaddress; 1000 | int port = args[0]->Int32Value(); 1001 | int status = sigar_net_listen_address_get(inst->sigar, port, &netaddress); 1002 | if(status != SIGAR_OK) { 1003 | char msg[200]; 1004 | sprintf(msg, "sigar_net_listen_address_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1005 | V8_STHROW(v8u::TypeErr(msg)); 1006 | } 1007 | Handle h_netaddress = node_sigar_net_address_to_string(&netaddress); 1008 | return scope.Close(h_netaddress); 1009 | } V8_CB_END(); 1010 | 1011 | V8_CB(NodeSigar::SigarNetStatGet) { 1012 | if(args.Length() != 1) V8_STHROW(v8u::TypeErr("Invalid argument")); 1013 | V8_M_UNWRAP(NodeSigar, args.This()); 1014 | 1015 | sigar_net_stat_t netstat; 1016 | int flags = args[0]->Int32Value(); 1017 | int status = sigar_net_stat_get(inst->sigar, &netstat, flags); 1018 | if(status != SIGAR_OK) { 1019 | char msg[200]; 1020 | sprintf(msg, "sigar_net_interface_stat_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1021 | V8_STHROW(v8u::TypeErr(msg)); 1022 | }; 1023 | Handle h_netstat = Object::New(); 1024 | Handle h_states = Array::New(); 1025 | unsigned i; 1026 | for (i=0; iSet(i, Number::New(netstat.tcp_states[i])); 1028 | } 1029 | h_netstat->Set(v8u::Symbol("tcp_states"), h_states); 1030 | h_netstat->Set(v8u::Symbol("tcp_inbound_total"), Number::New(netstat.tcp_inbound_total)); 1031 | h_netstat->Set(v8u::Symbol("tcp_outbound_total"), Number::New(netstat.tcp_outbound_total)); 1032 | h_netstat->Set(v8u::Symbol("all_inbound_total"), Number::New(netstat.all_inbound_total)); 1033 | h_netstat->Set(v8u::Symbol("all_outbound_total"), Number::New(netstat.all_outbound_total)); 1034 | return scope.Close(h_netstat); 1035 | } V8_CB_END(); 1036 | 1037 | V8_CB(NodeSigar::SigarNetStatPortGet) { 1038 | if(args.Length() != 3) V8_STHROW(v8u::TypeErr("Invalid argument")); 1039 | V8_M_UNWRAP(NodeSigar, args.This()); 1040 | 1041 | sigar_net_stat_t netstatport; 1042 | int flags = args[0]->Int32Value(); 1043 | 1044 | sigar_net_address_t address; 1045 | node_sigar_str2net_address(args[1]->ToString(), &address); 1046 | unsigned long port = args[2]->Int32Value(); 1047 | int status = sigar_net_stat_port_get(inst->sigar, &netstatport, flags, &address, port); 1048 | if(status != SIGAR_OK) { 1049 | char msg[200]; 1050 | sprintf(msg, "sigar_net_stat_port_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1051 | V8_STHROW(v8u::TypeErr(msg)); 1052 | }; 1053 | Handle h_netstatport = Object::New(); 1054 | Handle h_states = Array::New(); 1055 | unsigned i; 1056 | for (i=0; iSet(i, Number::New(netstatport.tcp_states[i])); 1058 | } 1059 | h_netstatport->Set(v8u::Symbol("tcp_states"), h_states); 1060 | h_netstatport->Set(v8u::Symbol("tcp_inbound_total"), Number::New(netstatport.tcp_inbound_total)); 1061 | h_netstatport->Set(v8u::Symbol("tcp_outbound_total"), Number::New(netstatport.tcp_outbound_total)); 1062 | h_netstatport->Set(v8u::Symbol("all_inbound_total"), Number::New(netstatport.all_inbound_total)); 1063 | h_netstatport->Set(v8u::Symbol("all_outbound_total"), Number::New(netstatport.all_outbound_total)); 1064 | return scope.Close(h_netstatport); 1065 | } V8_CB_END(); 1066 | // Testing, see './test/TodoTest.coffee' V8_CB_END(); 1067 | 1068 | V8_CB(NodeSigar::SigarTcpGet) { 1069 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 1070 | V8_M_UNWRAP(NodeSigar, args.This()); 1071 | 1072 | sigar_tcp_t tcp; 1073 | int status = sigar_tcp_get(inst->sigar, &tcp); 1074 | if(status != SIGAR_OK) { 1075 | char msg[200]; 1076 | sprintf(msg, "sigar_tcp_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1077 | V8_STHROW(v8u::TypeErr(msg)); 1078 | }; 1079 | Handle h_tcp = Object::New(); 1080 | h_tcp->Set(v8u::Symbol("active_opens"), Number::New(tcp.active_opens)); 1081 | h_tcp->Set(v8u::Symbol("passive_opens"), Number::New(tcp.passive_opens)); 1082 | h_tcp->Set(v8u::Symbol("attempt_fails"), Number::New(tcp.attempt_fails)); 1083 | h_tcp->Set(v8u::Symbol("estab_resets"), Number::New(tcp.estab_resets)); 1084 | h_tcp->Set(v8u::Symbol("curr_estab"), Number::New(tcp.curr_estab)); 1085 | h_tcp->Set(v8u::Symbol("in_segs"), Number::New(tcp.in_segs)); 1086 | h_tcp->Set(v8u::Symbol("out_segs"), Number::New(tcp.out_segs)); 1087 | h_tcp->Set(v8u::Symbol("retrans_segs"), Number::New(tcp.retrans_segs)); 1088 | h_tcp->Set(v8u::Symbol("in_errs"), Number::New(tcp.in_errs)); 1089 | h_tcp->Set(v8u::Symbol("out_rsts"), Number::New(tcp.out_rsts)); 1090 | return scope.Close(h_tcp); 1091 | } V8_CB_END(); 1092 | 1093 | V8_CB(NodeSigar::SigarNfsClientV2Get) { 1094 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 1095 | V8_M_UNWRAP(NodeSigar, args.This()); 1096 | 1097 | sigar_nfs_client_v2_t nfsclientv2; 1098 | int status = sigar_nfs_client_v2_get(inst->sigar, &nfsclientv2); 1099 | if(status != SIGAR_OK) { 1100 | char msg[200]; 1101 | sprintf(msg, "sigar_nfs_client_v2_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1102 | V8_STHROW(v8u::TypeErr(msg)); 1103 | }; 1104 | Handle h_nfsclientv2 = Object::New(); 1105 | h_nfsclientv2->Set(v8u::Symbol("null"), Number::New(nfsclientv2.null)); 1106 | h_nfsclientv2->Set(v8u::Symbol("getattr"), Number::New(nfsclientv2.getattr)); 1107 | h_nfsclientv2->Set(v8u::Symbol("setattr"), Number::New(nfsclientv2.setattr)); 1108 | h_nfsclientv2->Set(v8u::Symbol("root"), Number::New(nfsclientv2.root)); 1109 | h_nfsclientv2->Set(v8u::Symbol("lookup"), Number::New(nfsclientv2.lookup)); 1110 | h_nfsclientv2->Set(v8u::Symbol("readlink"), Number::New(nfsclientv2.readlink)); 1111 | h_nfsclientv2->Set(v8u::Symbol("read"), Number::New(nfsclientv2.read)); 1112 | h_nfsclientv2->Set(v8u::Symbol("writecache"), Number::New(nfsclientv2.writecache)); 1113 | h_nfsclientv2->Set(v8u::Symbol("write"), Number::New(nfsclientv2.write)); 1114 | h_nfsclientv2->Set(v8u::Symbol("create"), Number::New(nfsclientv2.create)); 1115 | h_nfsclientv2->Set(v8u::Symbol("remove"), Number::New(nfsclientv2.remove)); 1116 | h_nfsclientv2->Set(v8u::Symbol("rename"), Number::New(nfsclientv2.rename)); 1117 | h_nfsclientv2->Set(v8u::Symbol("link"), Number::New(nfsclientv2.link)); 1118 | h_nfsclientv2->Set(v8u::Symbol("symlink"), Number::New(nfsclientv2.symlink)); 1119 | h_nfsclientv2->Set(v8u::Symbol("mkdir"), Number::New(nfsclientv2.mkdir)); 1120 | h_nfsclientv2->Set(v8u::Symbol("rmdir"), Number::New(nfsclientv2.rmdir)); 1121 | h_nfsclientv2->Set(v8u::Symbol("readdir"), Number::New(nfsclientv2.readdir)); 1122 | h_nfsclientv2->Set(v8u::Symbol("fsstat"), Number::New(nfsclientv2.fsstat)); 1123 | return scope.Close(h_nfsclientv2); 1124 | } V8_CB_END(); 1125 | 1126 | V8_CB(NodeSigar::SigarNfsServerV2Get) { 1127 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 1128 | V8_M_UNWRAP(NodeSigar, args.This()); 1129 | 1130 | sigar_nfs_server_v2_t nfsserverv2; 1131 | int status = sigar_nfs_server_v2_get(inst->sigar, &nfsserverv2); 1132 | if(status != SIGAR_OK) { 1133 | char msg[200]; 1134 | sprintf(msg, "sigar_nfs_server_v2_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1135 | V8_STHROW(v8u::TypeErr(msg)); 1136 | }; 1137 | Handle h_nfsserverv2 = Object::New(); 1138 | h_nfsserverv2->Set(v8u::Symbol("null"), Number::New(nfsserverv2.null)); 1139 | h_nfsserverv2->Set(v8u::Symbol("getattr"), Number::New(nfsserverv2.getattr)); 1140 | h_nfsserverv2->Set(v8u::Symbol("setattr"), Number::New(nfsserverv2.setattr)); 1141 | h_nfsserverv2->Set(v8u::Symbol("root"), Number::New(nfsserverv2.root)); 1142 | h_nfsserverv2->Set(v8u::Symbol("lookup"), Number::New(nfsserverv2.lookup)); 1143 | h_nfsserverv2->Set(v8u::Symbol("readlink"), Number::New(nfsserverv2.readlink)); 1144 | h_nfsserverv2->Set(v8u::Symbol("read"), Number::New(nfsserverv2.read)); 1145 | h_nfsserverv2->Set(v8u::Symbol("writecache"), Number::New(nfsserverv2.writecache)); 1146 | h_nfsserverv2->Set(v8u::Symbol("write"), Number::New(nfsserverv2.write)); 1147 | h_nfsserverv2->Set(v8u::Symbol("create"), Number::New(nfsserverv2.create)); 1148 | h_nfsserverv2->Set(v8u::Symbol("remove"), Number::New(nfsserverv2.remove)); 1149 | h_nfsserverv2->Set(v8u::Symbol("rename"), Number::New(nfsserverv2.rename)); 1150 | h_nfsserverv2->Set(v8u::Symbol("link"), Number::New(nfsserverv2.link)); 1151 | h_nfsserverv2->Set(v8u::Symbol("symlink"), Number::New(nfsserverv2.symlink)); 1152 | h_nfsserverv2->Set(v8u::Symbol("mkdir"), Number::New(nfsserverv2.mkdir)); 1153 | h_nfsserverv2->Set(v8u::Symbol("rmdir"), Number::New(nfsserverv2.rmdir)); 1154 | h_nfsserverv2->Set(v8u::Symbol("readdir"), Number::New(nfsserverv2.readdir)); 1155 | h_nfsserverv2->Set(v8u::Symbol("fsstat"), Number::New(nfsserverv2.fsstat)); 1156 | return scope.Close(h_nfsserverv2); 1157 | } V8_CB_END(); 1158 | 1159 | V8_CB(NodeSigar::SigarArpListGet) { 1160 | if(args.Length() != 0) V8_STHROW(v8u::RangeErr("Invalid Argument")); 1161 | V8_M_UNWRAP(NodeSigar, args.This()); 1162 | 1163 | sigar_arp_list_t arplist; 1164 | int status = sigar_arp_list_get(inst->sigar, &arplist); 1165 | if(status != SIGAR_OK) { 1166 | char msg[200]; 1167 | sprintf(msg, "sigar_arp_list_get error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1168 | V8_STHROW(v8u::TypeErr(msg)); 1169 | } 1170 | Handle h_arplist = Array::New(arplist.number); 1171 | unsigned i; 1172 | for (i=0; i h_arp = Object::New(); 1175 | h_arp->Set(v8u::Symbol("ifname"), String::New(arp.ifname)); 1176 | h_arp->Set(v8u::Symbol("type"), String::New(arp.type)); 1177 | h_arp->Set(v8u::Symbol("hwaddr"), node_sigar_net_address_to_string(&arp.hwaddr)); 1178 | h_arp->Set(v8u::Symbol("address"), node_sigar_net_address_to_string(&arp.address)); 1179 | h_arp->Set(v8u::Symbol("flags"), Number::New(arp.flags)); 1180 | h_arplist->Set(i, h_arp); 1181 | } 1182 | sigar_arp_list_destroy(inst->sigar, &arplist); 1183 | return scope.Close(h_arplist); 1184 | } V8_CB_END(); 1185 | 1186 | V8_CB(NodeSigar::SigarRpcPing) { 1187 | if(args.Length() != 4) V8_STHROW(v8u::TypeErr("Invalid argument")); 1188 | V8_M_UNWRAP(NodeSigar, args.This()); 1189 | 1190 | String::Utf8Value hostname(args[0]->ToString()); 1191 | int protocol = args[1]->Int32Value(); 1192 | //int protocol = SIGAR_NETCONN_TCP; 1193 | unsigned long program = args[2]->IntegerValue(); 1194 | unsigned long version = args[3]->IntegerValue(); 1195 | int status = sigar_rpc_ping(*hostname, protocol, program, version); 1196 | if(status != SIGAR_OK) { 1197 | char msg[200]; 1198 | sprintf(msg, "sigar_rpc_ping error: %d (%s)", status, sigar_strerror(inst->sigar, status)); 1199 | V8_STHROW(v8u::TypeErr(msg)); 1200 | } 1201 | return scope.Close(Boolean::New(true)); 1202 | } V8_CB_END(); 1203 | 1204 | //SIGAR_DECLARE(char *) sigar_format_size(sigar_uint64_t size, char *buf); 1205 | 1206 | NODE_DEF_MAIN() { 1207 | NodeSigar::init(target); 1208 | target->Set(v8u::Symbol("FSTYPE_UNKNOWN"), Number::New(SIGAR_FSTYPE_UNKNOWN)); 1209 | target->Set(v8u::Symbol("FSTYPE_NONE"), Number::New(SIGAR_FSTYPE_NONE)); 1210 | target->Set(v8u::Symbol("FSTYPE_LOCAL_DISK"), Number::New(SIGAR_FSTYPE_LOCAL_DISK)); 1211 | target->Set(v8u::Symbol("FSTYPE_NETWORK"), Number::New(SIGAR_FSTYPE_NETWORK)); 1212 | target->Set(v8u::Symbol("FSTYPE_RAM_DISK"), Number::New(SIGAR_FSTYPE_RAM_DISK)); 1213 | target->Set(v8u::Symbol("FSTYPE_CDROM"), Number::New(SIGAR_FSTYPE_CDROM)); 1214 | target->Set(v8u::Symbol("FSTYPE_SWAP"), Number::New(SIGAR_FSTYPE_SWAP)); 1215 | target->Set(v8u::Symbol("FSTYPE_MAX"), Number::New(SIGAR_FSTYPE_MAX)); 1216 | } NODE_DEF_MAIN_END(sigar) 1217 | -------------------------------------------------------------------------------- /src/node_sigar.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include 4 | #include "sigar.h" 5 | #include "sigar_fileinfo.h" 6 | #include "sigar_log.h" 7 | #include "sigar_format.h" 8 | #include "sigar_ptql.h" 9 | #include "./node_sigar_utils.cc" 10 | 11 | #include "v8u.hpp" 12 | 13 | class NodeSigar : public node::ObjectWrap { 14 | public: 15 | NodeSigar(sigar_t* ptr); 16 | ~NodeSigar(); 17 | V8_SCTOR(); 18 | 19 | static V8_SCB(Init); 20 | static V8_SCB(SigarVersionGet); 21 | static V8_SCB(SigarPasswordGet); 22 | static V8_SCB(SigarFormatSize); 23 | 24 | static V8_SCB(SigarTestNetAdress); 25 | 26 | static V8_SCB(GetMem); 27 | static V8_SCB(GetSwap); 28 | static V8_SCB(SigarUptimeGet); 29 | static V8_SCB(SigarLoadavgGet); 30 | static V8_SCB(SigarResourceLimitGet); 31 | static V8_SCB(SigarWhoListGet); 32 | static V8_SCB(SigarSysInfoGet); 33 | static V8_SCB(SigarFqdnGet); 34 | static V8_SCB(SigarCpuGet); 35 | static V8_SCB(SigarCpuListGet); 36 | static V8_SCB(SigarCpuInfoListGet); 37 | static V8_SCB(SigarProcListGet); 38 | static V8_SCB(SigarProcStatGet); 39 | static V8_SCB(SigarProcMemGet); 40 | static V8_SCB(SigarProcCredGet); 41 | static V8_SCB(SigarProcTimeGet); 42 | static V8_SCB(SigarProcCpuGet); 43 | static V8_SCB(SigarProcStateGet); 44 | static V8_SCB(SigarProcArgsGet); 45 | static V8_SCB(SigarProcEnvGet); 46 | static V8_SCB(SigarProcFdGet); 47 | static V8_SCB(SigarProcExeGet); 48 | static V8_SCB(SigarProcModulesGet); 49 | static V8_SCB(SigarProcPortGet); 50 | static V8_SCB(SigarThreadCpuGet); 51 | static V8_SCB(SigarFileSystemListGet); 52 | static V8_SCB(SigarFileSystemUsageGet); 53 | static V8_SCB(SigarFileSystemPingGet); 54 | static V8_SCB(SigarNetInfoGet); 55 | static V8_SCB(SigarNetRouteListGet); 56 | static V8_SCB(SigarNetInterfaceListGet); 57 | static V8_SCB(SigarNetInterfaceConfigGet); 58 | static V8_SCB(SigarNetInterfaceConfigPrimaryGet); 59 | static V8_SCB(SigarNetInterfaceStatGet); 60 | static V8_SCB(SigarNetConnectionListGet); 61 | static V8_SCB(SigarNetListenAddressGet); 62 | static V8_SCB(SigarNetStatGet); 63 | static V8_SCB(SigarNetStatPortGet); 64 | static V8_SCB(SigarTcpGet); 65 | static V8_SCB(SigarNfsClientV2Get); 66 | static V8_SCB(SigarNfsServerV2Get); 67 | static V8_SCB(SigarArpListGet); 68 | static V8_SCB(SigarRpcPing); 69 | 70 | NODE_STYPE(NodeSigar); 71 | private: 72 | sigar_t *sigar; 73 | }; 74 | 75 | -------------------------------------------------------------------------------- /src/node_sigar_format.cc: -------------------------------------------------------------------------------- 1 | 2 | #include "sigar_format.h" 3 | #include 4 | 5 | #if defined(SIGAR_USING_MSC6) 6 | #define sigar_inet_ntop(af, src, dst, size) NULL 7 | #define sigar_inet_ntop_errno SIGAR_ENOTIMPL 8 | #elif defined(WIN32) 9 | static char *sigar_inet_ntop(int af, const void *src, char *dst, int cnt) 10 | { 11 | struct sockaddr_in6 sa; /* note only using this for AF_INET6 */ 12 | 13 | memset(&sa, '\0', sizeof(sa)); 14 | sa.sin6_family = af; 15 | memcpy(&sa.sin6_addr, src, sizeof(sa.sin6_addr)); 16 | 17 | if (getnameinfo((struct sockaddr *)&sa, sizeof(sa), 18 | dst, cnt, NULL, 0, NI_NUMERICHOST)) 19 | { 20 | return NULL; 21 | } 22 | else { 23 | return dst; 24 | } 25 | } 26 | #define sigar_inet_ntop_errno GetLastError() 27 | #else 28 | #define sigar_inet_ntop inet_ntop 29 | #define sigar_inet_ntop_errno errno 30 | #endif 31 | 32 | int sigar_inet_ntoa(sigar_t *sigar, 33 | sigar_uint32_t address, 34 | char *addr_str) 35 | { 36 | char *next=addr_str; 37 | int n=0; 38 | const unsigned char *src = 39 | (const unsigned char *)&address; 40 | 41 | do { 42 | unsigned char u = *src++; 43 | if (u > 99) { 44 | *next++ = '0' + u/100; 45 | u %= 100; 46 | *next++ = '0' + u/10; 47 | u %= 10; 48 | } 49 | else if (u > 9) { 50 | *next++ = '0' + u/10; 51 | u %= 10; 52 | } 53 | *next++ = '0' + u; 54 | *next++ = '.'; 55 | n++; 56 | } while (n < 4); 57 | 58 | *--next = 0; 59 | 60 | return SIGAR_OK; 61 | } 62 | 63 | static int test_sigar_ether_ntoa(char *buff, unsigned char *ptr) 64 | { 65 | sprintf(buff, "%02X:%02X:%02X:%02X:%02X:%02X", 66 | (ptr[0] & 0xff), (ptr[1] & 0xff), (ptr[2] & 0xff), 67 | (ptr[3] & 0xff), (ptr[4] & 0xff), (ptr[5] & 0xff)); 68 | return SIGAR_OK; 69 | } 70 | 71 | 72 | SIGAR_DECLARE(int) sigar_net_address_to_string(sigar_t *sigar, sigar_net_address_t *address, char *addr_str) 73 | { 74 | *addr_str = '\0'; 75 | switch (address->family) { 76 | case sigar_net_address_t::SIGAR_AF_INET6: 77 | if (sigar_inet_ntop(AF_INET6, (const void *)&address->addr.in6, 78 | addr_str, SIGAR_INET6_ADDRSTRLEN)) 79 | { 80 | return SIGAR_OK; 81 | } 82 | else { 83 | return sigar_inet_ntop_errno; 84 | } 85 | case sigar_net_address_t::SIGAR_AF_INET: 86 | return sigar_inet_ntoa(sigar, address->addr.in, addr_str); 87 | case sigar_net_address_t::SIGAR_AF_UNSPEC: 88 | return sigar_inet_ntoa(sigar, 0, addr_str); /*XXX*/ 89 | case sigar_net_address_t::SIGAR_AF_LINK: 90 | return test_sigar_ether_ntoa(addr_str, &address->addr.mac[0]); 91 | default: 92 | return EINVAL; 93 | } 94 | } 95 | 96 | 97 | SIGAR_DECLARE(char *) sigar_format_size(sigar_uint64_t size, char *buf) 98 | { 99 | const char ord[] = "KMGTPE"; 100 | const char *o = ord; 101 | int remain; 102 | 103 | if ((int)size == SIGAR_FIELD_NOTIMPL) { 104 | buf[0] = '-'; 105 | buf[1] = '\0'; 106 | return buf; 107 | } 108 | 109 | if (size < 973) { 110 | sprintf(buf, "%3d ", (int) size); 111 | return buf; 112 | } 113 | 114 | do { 115 | remain = (int)(size & 1023); 116 | size >>= 10; 117 | 118 | if (size >= 973) { 119 | ++o; 120 | continue; 121 | } 122 | 123 | if (size < 9 || (size == 9 && remain < 973)) { 124 | if ((remain = ((remain * 5) + 256) / 512) >= 10) { 125 | ++size; 126 | remain = 0; 127 | } 128 | sprintf(buf, "%d.%d%c", (int) size, remain, *o); 129 | return buf; 130 | } 131 | 132 | if (remain >= 512) { 133 | ++size; 134 | } 135 | 136 | sprintf(buf, "%3d%c", (int) size, *o); 137 | 138 | return buf; 139 | } while (1); 140 | } 141 | -------------------------------------------------------------------------------- /src/node_sigar_utils.cc: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | #include "./node_sigar_format.cc" 6 | 7 | using namespace node; 8 | using namespace v8; 9 | 10 | Handle node_sigar_net_address_to_string(sigar_net_address_t *address) 11 | { 12 | char addr_str[SIGAR_INET6_ADDRSTRLEN]; 13 | sigar_net_address_to_string(NULL, address, addr_str); 14 | return String::New(addr_str); 15 | } 16 | 17 | // TODO: This is completly wrong 18 | int node_sigar_str2net_address(Handle bytes, sigar_net_address_t *address) 19 | { 20 | // long len = bytes->Length(); 21 | // long len = bytes->Utf8Length(); 22 | String::Utf8Value name(bytes->ToString()); 23 | long len = sizeof(name); 24 | switch (len) { 25 | case 4: 26 | address->family = sigar_net_address_t::SIGAR_AF_INET; 27 | break; 28 | case 4*4: 29 | address->family = sigar_net_address_t::SIGAR_AF_INET6; 30 | break; 31 | default: 32 | return EINVAL; 33 | } 34 | memcpy(*name, &address->addr.in6, len); 35 | return SIGAR_OK; 36 | } 37 | 38 | 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /src/v8u.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * V8Utilities - Sugar for your Node C++ addons 3 | * Copyright (c) 2012, Xavier Mendez 4 | * All rights reserved. 5 | * 6 | * Redistribution and use in source and binary forms, with or without 7 | * modification, are permitted provided that the following conditions are met: 8 | * 9 | * - Redistributions of source code must retain the above copyright notice, 10 | * this list of conditions and the following disclaimer. 11 | * - Redistributions in binary form must reproduce the above copyright notice, 12 | * this list of conditions and the following disclaimer in the documentation 13 | * and/or other materials provided with the distribution. 14 | * 15 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 16 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 19 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 | * POSSIBILITY OF SUCH DAMAGE. 26 | */ 27 | 28 | #ifndef V8U_HPP 29 | #define V8U_HPP 30 | 31 | #include 32 | #include 33 | #include 34 | 35 | #include 36 | #include 37 | 38 | namespace v8u { 39 | 40 | // V8 exception wrapping 41 | 42 | #define V8_THROW(VALUE) throw v8::Persistent::New(VALUE) 43 | #define V8_STHROW(VALUE) return v8::ThrowException(VALUE) 44 | #define V8_RET(VALUE) return scope.Close(VALUE) 45 | 46 | #define V8_WRAP_START() \ 47 | v8::HandleScope scope; \ 48 | try { 49 | 50 | #define V8_WRAP_END() \ 51 | } catch (v8::Persistent& err) { \ 52 | v8::Local loc = v8::Local::New(err); \ 53 | err.Dispose(); \ 54 | return ThrowException(loc); \ 55 | } catch (std::exception& err) { \ 56 | return ThrowException(v8::Exception::Error(v8::String::New(err.what()))); \ 57 | } catch (v8::Handle& err) { \ 58 | return ThrowException(err); \ 59 | } catch (v8::Value*& err) { \ 60 | return ThrowException(v8::Handle(err)); \ 61 | } catch (std::string& err) { \ 62 | return ThrowException(v8::Exception::Error(v8::String::New(err.data(), err.length())));\ 63 | } catch (...) { \ 64 | return ThrowException(v8::Exception::Error(v8::String::New("Unknown error!")));\ 65 | } 66 | 67 | #define V8_WRAP_END_NR() \ 68 | } catch (v8::Persistent& err) { \ 69 | v8::Local loc = v8::Local::New(err); \ 70 | err.Dispose(); \ 71 | ThrowException(loc); \ 72 | } catch (std::exception& err) { \ 73 | ThrowException(v8::Exception::Error(v8::String::New(err.what()))); \ 74 | } catch (v8::Handle& err) { \ 75 | ThrowException(err); \ 76 | } catch (v8::Value*& err) { \ 77 | ThrowException(v8::Handle(err)); \ 78 | } catch (std::string& err) { \ 79 | ThrowException(v8::Exception::Error(v8::String::New(err.data(), err.length())));\ 80 | } catch (...) { \ 81 | ThrowException(v8::Exception::Error(v8::String::New("Unknown error!"))); \ 82 | } 83 | 84 | // JS arguments 85 | 86 | inline void CheckArguments(int min, const v8::Arguments& args) { 87 | if (args.Length() < min) 88 | throw v8::Persistent::New(v8::Exception::RangeError(v8::String::New("Not enough arguments."))); 89 | } 90 | 91 | // Internal macros, don't use! ------------------------------------------------- 92 | #define _v8_getter(ID) \ 93 | v8::Handle ID(v8::Local name, \ 94 | const v8::AccessorInfo& info) 95 | #define _v8_setter(ID) \ 96 | void ID(v8::Local name, v8::Local value, \ 97 | const v8::AccessorInfo& info) 98 | #define _v8_ctor { \ 99 | if (args[0]->IsExternal()) return args.This(); \ 100 | if (!args.IsConstructCall()) \ 101 | return v8::ThrowException(v8u::ReferenceErr("You must call this as a constructor"));\ 102 | V8_WRAP_START() \ 103 | v8::Local hdl = args.This(); 104 | //------------------------------------------------------------------------------ 105 | 106 | // V8 callback templates 107 | 108 | #define V8_SCB(IDENTIFIER) \ 109 | v8::Handle IDENTIFIER(const v8::Arguments& args) 110 | 111 | #define V8_CB(IDENTIFIER) \ 112 | V8_SCB(IDENTIFIER) { \ 113 | V8_WRAP_START() 114 | 115 | #define V8_CB_END() V8_WRAP_END() } 116 | 117 | // V8 getter templates 118 | 119 | #define V8_SGET(IDENTIFIER) static _v8_getter(IDENTIFIER) 120 | #define V8_ESGET(TYPE, IDENTIFIER) _v8_getter(TYPE::IDENTIFIER) 121 | 122 | #define V8_GET(IDENTIFIER) \ 123 | V8_SGET(IDENTIFIER) { \ 124 | V8_WRAP_START() 125 | 126 | #define V8_EGET(TYPE, IDENTIFIER) \ 127 | V8_ESGET(TYPE, IDENTIFIER) { \ 128 | V8_WRAP_START() 129 | 130 | #define V8_GET_END() V8_WRAP_END() } 131 | 132 | // V8 setter templates 133 | 134 | #define V8_SSET(IDENTIFIER) static _v8_setter(IDENTIFIER) 135 | #define V8_ESSET(TYPE, IDENTIFIER) _v8_setter(TYPE::IDENTIFIER) 136 | 137 | #define V8_SET(IDENTIFIER) \ 138 | V8_SSET(IDENTIFIER) { \ 139 | V8_WRAP_START() 140 | 141 | #define V8_ESET(TYPE, IDENTIFIER) \ 142 | V8_ESSET(TYPE, IDENTIFIER) { \ 143 | V8_WRAP_START() 144 | 145 | #define V8_SET_END() V8_WRAP_END_NR() } 146 | 147 | 148 | // Other class-specific templates 149 | 150 | #define V8_SCTOR() static V8_SCB(NewInstance) 151 | #define V8_ESCTOR(TYPE) V8_SCB(TYPE::NewInstance) 152 | 153 | #define V8_CTOR() V8_SCTOR() _v8_ctor 154 | #define V8_ECTOR(TYPE) V8_ESCTOR(TYPE) _v8_ctor 155 | 156 | #define V8_CTOR_END() \ 157 | return hdl; \ 158 | V8_CB_END() 159 | 160 | // Special constructors: use within V8_[E]SCTOR() ------------------------------ 161 | #define V8_CTOR_NO_ALL return v8::ThrowException(v8::Exception::TypeError( \ 162 | v8::String::New("No instances of this exact type may be constructed.") \ 163 | )); 164 | #define V8_CTOR_NO_JS \ 165 | if (args[0]->IsExternal()) return args.This(); \ 166 | return v8::ThrowException(v8::Exception::TypeError( \ 167 | v8::String::New("You can't construct instances of this type directly.") \ 168 | )); 169 | //------------------------------------------------------------------------------ 170 | 171 | //// For use with V8_CTOR only! 172 | #define V8_WRAP(INSTANCE) (INSTANCE)->Wrap(hdl) 173 | 174 | #define V8_M_UNWRAP(CPP_TYPE, OBJ) \ 175 | if (!CPP_TYPE::_templ->HasInstance(OBJ)) \ 176 | return v8::ThrowException(v8::Exception::TypeError(v8::String::New("Invalid object unwrapped.")));\ 177 | CPP_TYPE* inst = node::ObjectWrap::Unwrap(OBJ); 178 | 179 | #define V8_STYPE(CPP_TYPE) \ 180 | static v8::FunctionTemplate* _templ; \ 181 | /** 182 | * Returns the unique V8 v8::Object corresponding to this C++ instance. 183 | * For this to work, you should use V8_CL_CTOR. 184 | * 185 | * CALLING Wrapped() WITHIN A CONSTRUCTOR MAY YIELD UNEXPECTED RESULTS, 186 | * EVENTUALLY MAKING YOU BASH YOUR HEAD AGAINST A WALL. YOU HAVE BEEN WARNED. 187 | **/ \ 188 | virtual v8::Local Wrapped(); \ 189 | static bool HasInstance(v8::Handle obj); \ 190 | inline static CPP_TYPE* Unwrap(v8::Handle obj) { \ 191 | if (_templ->HasInstance(obj)) return node::ObjectWrap::Unwrap(obj);\ 192 | V8_THROW(v8::Exception::TypeError(v8::String::New("Invalid object unwrapped.")));\ 193 | } 194 | 195 | #define V8_TYPE(CPP_TYPE) \ 196 | static v8::FunctionTemplate* _templ; \ 197 | /** 198 | * Returns the unique V8 v8::Object corresponding to this C++ instance. 199 | * For this to work, you should use V8_[E]CTOR. 200 | * V8_[E]SCTOR with V8_CTOR_NO_JS will work as well. 201 | * 202 | * CALLING Wrapped() WITHIN A CONSTRUCTOR MAY YIELD UNEXPECTED RESULTS, 203 | * EVENTUALLY MAKING YOU BASH YOUR HEAD AGAINST A WALL. YOU HAVE BEEN WARNED. 204 | **/ \ 205 | virtual v8::Local Wrapped() { \ 206 | v8::HandleScope scope; \ 207 | \ 208 | if (handle_.IsEmpty()) { \ 209 | v8::Handle args [1] = {v8::External::New(this)}; \ 210 | Wrap(_templ->GetFunction()->NewInstance(1,args)); \ 211 | } \ 212 | return scope.Close(handle_); \ 213 | } \ 214 | static bool HasInstance(v8::Handle obj) { \ 215 | v8::HandleScope scope; \ 216 | return _templ->HasInstance(obj); \ 217 | } \ 218 | inline static CPP_TYPE* Unwrap(v8::Handle obj) { \ 219 | if (_templ->HasInstance(obj)) return node::ObjectWrap::Unwrap(obj);\ 220 | V8_THROW(v8::Exception::TypeError(v8::String::New("Invalid object unwrapped.")));\ 221 | } 222 | 223 | #define V8_ETYPE(TYPE) \ 224 | v8::Local TYPE::Wrapped() { \ 225 | v8::HandleScope scope; \ 226 | \ 227 | if (handle_.IsEmpty()) { \ 228 | v8::Handle args [1] = {v8::External::New(this)}; \ 229 | Wrap(_templ->GetFunction()->NewInstance(1,args)); \ 230 | } \ 231 | return scope.Close(handle_); \ 232 | } \ 233 | bool TYPE::HasInstance(v8::Handle obj) { \ 234 | v8::HandleScope scope; \ 235 | return _templ->HasInstance(obj); \ 236 | } 237 | 238 | #define V8_POST_TYPE(CPP_TYPE) v8::FunctionTemplate* CPP_TYPE::_templ = NULL; 239 | 240 | // Dealing with V8 persistent handles 241 | 242 | template inline void ClearPersistent(v8::Persistent& handle) { 243 | if (handle.IsEmpty()) return; 244 | handle.Dispose(); 245 | handle.Clear(); 246 | } 247 | 248 | template inline void SetPersistent(v8::Persistent& handle, v8::Handle value) { 249 | ClearPersistent(handle); 250 | if (value.IsEmpty()) return; 251 | handle = v8::Persistent::New(value); 252 | } 253 | 254 | template inline v8::Persistent Persist(v8::Handle handle) { 255 | return v8::Persistent::New(handle); 256 | } 257 | 258 | template class Persisted { 259 | public: 260 | inline Persisted() {}; 261 | inline Persisted(v8::Handle value) : handle(v8::Persistent::New(value)) {} 262 | inline ~Persisted() { 263 | if (!handle.IsEmpty()) handle.Dispose(); 264 | } 265 | inline Persisted(Persisted& other) : handle(v8::Persistent::New(other.handle)) {} 266 | inline v8::Persistent operator*() const { 267 | return handle; 268 | } 269 | inline Persisted& operator=(const Persisted& other) { 270 | if (&other == this) return *this; 271 | SetPersistent(handle, other.handle); 272 | return *this; 273 | } 274 | inline bool operator==(const Persisted& other) const { 275 | return handle==other.handle; 276 | } 277 | inline bool IsEmpty() const { 278 | return handle.IsEmpty(); 279 | } 280 | inline void Clear() { 281 | ClearPersistent(handle); 282 | } 283 | inline T* operator->() const { 284 | return *handle; 285 | } 286 | private: 287 | v8::Persistent handle; 288 | }; 289 | 290 | // Type shortcuts 291 | 292 | inline v8::Local Int(int64_t integer) { 293 | return v8::Integer::New(integer); 294 | } 295 | 296 | inline v8::Local Uint(uint32_t integer) { 297 | return v8::Integer::NewFromUnsigned(integer); 298 | } 299 | 300 | inline v8::Local Str(const char* data, int length = -1) { 301 | return v8::String::New(data, length); 302 | } 303 | 304 | inline v8::Local Str(std::string str) { 305 | return v8::String::New(str.data(), str.length()); 306 | } 307 | 308 | inline v8::Local Symbol(const char* data, int length = -1) { 309 | return v8::String::NewSymbol(data, length); 310 | } 311 | 312 | inline v8::Local Obj() { 313 | return v8::Object::New(); 314 | } 315 | 316 | inline v8::Local Arr(int length = 0) { 317 | return v8::Array::New(length); 318 | } 319 | 320 | #define __V8_ERROR_CTOR(ERROR) \ 321 | inline v8::Local ERROR##Err(const char* msg) { \ 322 | return v8::Exception::ERROR##Error(v8::String::New(msg)); \ 323 | } 324 | 325 | __V8_ERROR_CTOR() 326 | __V8_ERROR_CTOR(Range) 327 | __V8_ERROR_CTOR(Reference) 328 | __V8_ERROR_CTOR(Syntax) 329 | __V8_ERROR_CTOR(Type) 330 | 331 | inline v8::Local Num(double number) { 332 | return v8::Number::New(number); 333 | } 334 | 335 | inline v8::Handle Bool(bool boolean) { 336 | return v8::Boolean::New(boolean); 337 | } 338 | 339 | inline v8::Local Func(v8::InvocationCallback function) { 340 | return v8::FunctionTemplate::New(function); 341 | } 342 | 343 | // Type casting/unwraping shortcuts 344 | 345 | inline double Num(v8::Handle hdl) { 346 | return hdl->NumberValue(); 347 | } 348 | 349 | inline int32_t Int(v8::Handle hdl) { 350 | return hdl->Int32Value(); 351 | } 352 | 353 | inline uint32_t Uint(v8::Handle hdl) { 354 | return hdl->Uint32Value(); 355 | } 356 | 357 | inline v8::Handle Obj(v8::Handle hdl) { 358 | return v8::Handle::Cast(hdl); 359 | } 360 | inline v8::Local Obj(v8::Local hdl) { 361 | return v8::Local::Cast(hdl); 362 | } 363 | inline v8::Persistent Obj(v8::Persistent hdl) { 364 | return v8::Persistent::Cast(hdl); 365 | } 366 | 367 | inline v8::Handle Arr(v8::Handle hdl) { 368 | return v8::Handle::Cast(hdl); 369 | } 370 | inline v8::Local Arr(v8::Local hdl) { 371 | return v8::Local::Cast(hdl); 372 | } 373 | inline v8::Persistent Arr(v8::Persistent hdl) { 374 | return v8::Persistent::Cast(hdl); 375 | } 376 | 377 | template inline v8::Handle Cast(v8::Handle hdl) { 378 | return v8::Handle::Cast(hdl); 379 | } 380 | template inline v8::Local Cast(v8::Local hdl) { 381 | return v8::Local::Cast(hdl); 382 | } 383 | template inline v8::Persistent Cast(v8::Persistent hdl) { 384 | return v8::Persistent::Cast(hdl); 385 | } 386 | 387 | inline bool Bool(v8::Handle hdl) { 388 | return hdl->BooleanValue(); 389 | } 390 | 391 | // Defining things 392 | 393 | #define V8_DEF_TYPE_PRE() \ 394 | v8::Persistent templ; \ 395 | v8::Local prot; \ 396 | v8::Local inst; \ 397 | v8::Handle __cname; 398 | 399 | #define V8_DEF_TYPE(V8_NAME) \ 400 | templ = v8::Persistent::New( \ 401 | v8::FunctionTemplate::New(NewInstance)); \ 402 | __cname = v8::String::NewSymbol(V8_NAME); \ 403 | templ->SetClassName(__cname); \ 404 | inst = templ->InstanceTemplate(); \ 405 | inst->SetInternalFieldCount(1); \ 406 | prot = templ->PrototypeTemplate(); 407 | 408 | #define V8_DEF_ACC(V8_NAME, GETTER, SETTER) \ 409 | inst->SetAccessor(v8::String::NewSymbol(V8_NAME), GETTER, SETTER) 410 | 411 | #define V8_DEF_GET(V8_NAME, GETTER) \ 412 | inst->SetAccessor(v8::String::NewSymbol(V8_NAME), GETTER) 413 | 414 | //FIXME: add V8_DEF_SET 415 | 416 | #define V8_DEF_CB(V8_NAME, CPP_METHOD) \ 417 | inst->Set(v8::String::NewSymbol(V8_NAME), v8::FunctionTemplate::New(CPP_METHOD)->GetFunction()) 418 | 419 | #define V8_INHERIT(CPP_TYPE) templ->Inherit(CPP_TYPE::_templ) 420 | 421 | // Templates for definition methods on Node 422 | 423 | //// Generic define function 424 | 425 | #define NODE_DEF(IDENTIFIER) \ 426 | void IDENTIFIER(v8::Handle target) 427 | 428 | //// Module define function 429 | 430 | #define NODE_DEF_MAIN() \ 431 | extern "C" { \ 432 | NODE_DEF(init) { \ 433 | v8::HandleScope scope; 434 | 435 | #define NODE_DEF_MAIN_END(MODULE) } \ 436 | NODE_MODULE(MODULE, init); } 437 | 438 | //// Type (class) define function 439 | 440 | #define NODE_SDEF_TYPE() static NODE_DEF(init) 441 | #define NODE_ESDEF_TYPE(TYPE) NODE_DEF(TYPE::init) 442 | 443 | #define NODE_DEF_TYPE(V8_NAME) \ 444 | inline NODE_SDEF_TYPE() { \ 445 | v8::HandleScope scope; \ 446 | V8_DEF_TYPE_PRE() \ 447 | V8_DEF_TYPE(V8_NAME) 448 | 449 | #define NODE_EDEF_TYPE(TYPE, V8_NAME) \ 450 | NODE_ESDEF_TYPE(TYPE) { \ 451 | v8::HandleScope scope; \ 452 | V8_DEF_TYPE_PRE() \ 453 | V8_DEF_TYPE(V8_NAME) 454 | 455 | #define NODE_DEF_TYPE_END() \ 456 | target->Set(__cname, templ->GetFunction()); \ 457 | } 458 | 459 | //// V8_TYPE + NODE_DEF_TYPE = NODE_TYPE 460 | 461 | #define NODE_STYPE(CPP_TYPE) \ 462 | V8_STYPE(CPP_TYPE); \ 463 | NODE_SDEF_TYPE() 464 | 465 | #define NODE_TYPE(CPP_TYPE, V8_NAME) \ 466 | V8_TYPE(CPP_TYPE) \ 467 | inline NODE_SDEF_TYPE() { \ 468 | if (_templ) { \ 469 | target->Set(v8::String::NewSymbol(V8_NAME), v8::Handle(_templ->GetFunction()));\ 470 | return; \ 471 | } \ 472 | v8::HandleScope scope; \ 473 | V8_DEF_TYPE_PRE() \ 474 | V8_DEF_TYPE(V8_NAME) 475 | 476 | #define NODE_ETYPE(TYPE, V8_NAME) \ 477 | V8_ETYPE(TYPE) \ 478 | NODE_ESDEF_TYPE(TYPE) { \ 479 | if (_templ) { \ 480 | target->Set(v8::String::NewSymbol(V8_NAME), v8::Handle(_templ->GetFunction()));\ 481 | return; \ 482 | } \ 483 | v8::HandleScope scope; \ 484 | V8_DEF_TYPE_PRE() \ 485 | V8_DEF_TYPE(V8_NAME) 486 | 487 | #define NODE_TYPE_END() \ 488 | _templ = *templ; \ 489 | NODE_DEF_TYPE_END() 490 | 491 | }; 492 | 493 | #endif /* V8U_HPP */ 494 | -------------------------------------------------------------------------------- /test/cpu.coffee: -------------------------------------------------------------------------------- 1 | 2 | should = require 'should' 3 | sigar = require '..' 4 | 5 | describe 'cpu', -> 6 | 7 | s = sigar() 8 | 9 | it 'should return overall cpu usage', -> 10 | cpu = s.cpu() 11 | # console.log 'cpu', cpu 12 | Object.keys(cpu).should.eql [ 13 | 'user', 'sys', 'nice', 'idle', 'wait', 'irq', 'soft_irq', 'stolen', 'total' 14 | ] 15 | 16 | it 'should list cpu with current usage', -> 17 | cpuList = s.cpuList() 18 | # console.log 'cpuList', cpuList 19 | cpuList.length.should.be.above 0 20 | Object.keys(cpuList[0]).should.eql [ 21 | 'user', 'sys', 'nice', 'idle', 'wait', 'irq', 'soft_irq', 'stolen', 'total' 22 | ] 23 | 24 | it 'should list cpu with information': -> 25 | cpuInfoList = s.cpuInfoList() 26 | # console.log 'cpuInfoList', cpuInfoList 27 | cpuList.length.should.be.above 0 28 | Object.keys(cpuInfoList[0]).should.eql [ 29 | 'vendor', 'model', 'mhz', 'mhz_max', 'mhz_min', 'cache_size', 'total_sockets', 'total_cores', 'cores_per_socket' 30 | ] 31 | -------------------------------------------------------------------------------- /test/file_system.coffee: -------------------------------------------------------------------------------- 1 | 2 | should = require 'should' 3 | sigar = require '..' 4 | 5 | describe 'file_system', -> 6 | 7 | s = sigar() 8 | 9 | it 'should return associated constant code', -> 10 | # console.log 'FSTYPE_UNKNOWN', sigar.FSTYPE_UNKNOWN 11 | # console.log 'FSTYPE_NONE', sigar.FSTYPE_NONE 12 | # console.log 'FSTYPE_LOCAL_DISK', sigar.FSTYPE_LOCAL_DISK 13 | # console.log 'FSTYPE_NETWORK', sigar.FSTYPE_NETWORK 14 | # console.log 'FSTYPE_RAM_DISK', sigar.FSTYPE_RAM_DISK 15 | # console.log 'FSTYPE_CDROM', sigar.FSTYPE_CDROM 16 | # console.log 'FSTYPE_SWAP', sigar.FSTYPE_SWAP 17 | # console.log 'FSTYPE_MAX', sigar.FSTYPE_MAX 18 | sigar.FSTYPE_UNKNOWN.should.eql 0 19 | sigar.FSTYPE_NONE.should.eql 1 20 | sigar.FSTYPE_LOCAL_DISK.should.eql 2 21 | sigar.FSTYPE_NETWORK.should.eql 3 22 | sigar.FSTYPE_RAM_DISK.should.eql 4 23 | sigar.FSTYPE_CDROM.should.eql 5 24 | sigar.FSTYPE_SWAP.should.eql 6 25 | sigar.FSTYPE_MAX.should.eql 7 26 | 27 | it 'should return information for each file system', -> 28 | # Note, doesn't seem to be implemented by thread on osx, return rusage of the current thread 29 | fileSystemList = s.fileSystemList() 30 | # console.log fileSystemList 31 | for fs in fileSystemList 32 | continue unless fs.dir_name is '/' 33 | foundRoot = true 34 | Object.keys(fs).should.eql [ 35 | 'dir_name', 'dev_name', 'type_name', 'sys_type_name', 'options', 'type', 'flags' 36 | ], 37 | foundRoot.should.be.ok 38 | 39 | it 'should print a file system usage', -> 40 | # Note, doesn't seem to be implemented by thread on osx, return rusage of the current thread 41 | fileSystemUsage = s.fileSystemUsage '/' 42 | # console.log 'fileSystemUsage', fileSystemUsage 43 | Object.keys(fileSystemUsage).should.eql [ 44 | 'disk', 'use_percent', 'total', 'free', 'used', 'avail', 'files', 'free_files' 45 | ] 46 | Object.keys(fileSystemUsage.disk).should.eql [ 47 | 'reads', 'writes', 'write_bytes', 'read_bytes', 'rtime', 'wtime', 'qtime', 'time', 'snaptime', 'service_time', 'queue' 48 | ] 49 | 50 | it 'should ping ping the file system', -> 51 | # Note, text decoding is wrong 52 | fileSystemPing = s.fileSystemPing() 53 | # console.log fileSystemPing 54 | Object.keys(fileSystemPing).should.eql [ 55 | 'dir_name', 'dev_name', 'type_name', 'sys_type_name', 'options', 'type', 'flags' 56 | ] 57 | -------------------------------------------------------------------------------- /test/misc.coffee: -------------------------------------------------------------------------------- 1 | 2 | assert = require 'assert' 3 | sigar = require '..' 4 | 5 | describe 'misc', -> 6 | 7 | s = sigar() 8 | 9 | it 'should output formated size', -> 10 | formatSize = s.formatSize 8492389262 11 | # console.log 'formatSize', formatSize 12 | formatSize.should.eql '7.9G' 13 | -------------------------------------------------------------------------------- /test/network.coffee: -------------------------------------------------------------------------------- 1 | 2 | should = require 'should' 3 | sigar = require '..' 4 | 5 | describe 'network', -> 6 | 7 | s = sigar() 8 | 9 | it 'should return info', -> 10 | netInfo = s.netInfo() 11 | # console.log 'netInfo', netInfo 12 | Object.keys(netInfo).should.eql [ 13 | 'default_gateway', 'default_gateway_interface', 'host_name', 'domain_name', 'primary_dns', 'secondary_dns' 14 | ] 15 | 16 | it 'should return route list', -> 17 | netRouteList = s.netRouteList() 18 | netRouteList.length.should.be.above 0 19 | for netRoute in netRouteList 20 | # console.log 'netRoute', netRoute 21 | Object.keys(netRoute).should.eql [ 22 | 'destination', 'gateway', 'mask', 'flags', 'refcnt', 'use', 'metric', 'mtu', 'window', 'irtt', 'ifname' 23 | ] 24 | 25 | it 'should return interface list', -> 26 | netInterfaceList = s.netInterfaceList() 27 | netInterfaceList.length.should.be.above 0 28 | for netInterface in netInterfaceList 29 | /^[\w]+$/.test(netInterface).should.be.ok # Note: might be too restricive 30 | 31 | it 'should return config for a give interface', -> 32 | netInterfaceList = s.netInterfaceList() 33 | for netInterface in netInterfaceList 34 | netInterfaceConfig = s.netInterfaceConfig netInterface 35 | Object.keys(netInterfaceConfig).should.eql [ 36 | 'name', 'type', 'description', 'hwaddr', 37 | 'address', 'destination', 'broadcast', 'netmask', 38 | 'address6', 'prefix6_length', 'scope6', 'flags', 39 | 'mtu', 'metric', 'tx_queue_len' 40 | ] 41 | 42 | it 'should return primary interface configuration', -> 43 | netInterfaceConfigPrimary = s.netInterfaceConfigPrimary() 44 | # console.log 'netInterfaceConfigPrimary', netInterfaceConfigPrimary 45 | Object.keys(netInterfaceConfigPrimary).should.eql [ 46 | 'name', 'type', 'description', 'hwaddr', 47 | 'address', 'destination', 'broadcast', 'netmask', 48 | 'address6', 'prefix6_length', 'scope6', 'flags', 49 | 'mtu', 'metric', 'tx_queue_len' 50 | ] 51 | 52 | it 'should return stat for a given interface', -> 53 | netInterfaceList = s.netInterfaceList() 54 | for netInterface in netInterfaceList 55 | netInterfaceStat = s.netInterfaceStat netInterface 56 | # console.log 'netInterfaceStat', netInterface, netInterfaceStat 57 | Object.keys(netInterfaceStat).should.eql [ 58 | 'rx_packets', 'rx_bytes', 'rx_errors', 'rx_dropped', 59 | 'rx_overruns', 'rx_frame', 'tx_packets', 'tx_bytes', 60 | 'tx_errors', 'tx_dropped', 'tx_overruns', 'tx_collisions', 61 | 'tx_carrier', 'speed' 62 | ] 63 | 64 | it 'should return network connection list', -> 65 | netConnectionList = s.netConnectionList -1 66 | netConnectionList.length.should.be.above 0 67 | for netConnection in netConnectionList 68 | # console.log 'netConnection', netConnection 69 | Object.keys(netConnection).should.eql [ 70 | 'local_port', 'local_address', 'remote_port', 71 | 'remote_address', 'uid', 'inode', 'type', 72 | 'state', 'send_queue', 'receive_queue' 73 | ] 74 | 75 | it 'should return listen address for a give port', -> 76 | try 77 | netListenAddress = s.netListenAddress 22 78 | # console.log 'netListenAddress', netListenAddress 79 | netListenAddress.should.eql '0.0.0.0' 80 | catch e 81 | # SSH port 22 not open 82 | e.message.should.eql 'sigar_net_listen_address_get error: 2 (No such file or directory)' 83 | 84 | it 'should return stat', -> 85 | netStat = s.netStat -1 86 | # Note, tcp_states are: 87 | # SIGAR_TCP_ESTABLISHED = 1, SIGAR_TCP_SYN_SENT, SIGAR_TCP_SYN_RECV, SIGAR_TCP_FIN_WAIT1, 88 | # SIGAR_TCP_FIN_WAIT2, SIGAR_TCP_TIME_WAIT, SIGAR_TCP_CLOSE, SIGAR_TCP_CLOSE_WAIT, SIGAR_TCP_LAST_ACK, 89 | # SIGAR_TCP_LISTEN, SIGAR_TCP_CLOSING, SIGAR_TCP_IDLE, SIGAR_TCP_BOUND, SIGAR_TCP_UNKNOWN 90 | # console.log 'netStat', netStat 91 | Object.keys(netStat).should.eql [ 92 | 'tcp_states', 'tcp_inbound_total', 'tcp_outbound_total', 'all_inbound_total', 'all_outbound_total' 93 | ] 94 | netStat.tcp_states.length.should.eql 14 95 | 96 | it 'should return stat for a give port', -> 97 | netStatPort = s.netStatPort -1, '127.0.0.1', 22 98 | # console.log 'netStatPort', netStatPort 99 | Object.keys(netStatPort).should.eql [ 100 | 'tcp_states', 'tcp_inbound_total', 'tcp_outbound_total', 'all_inbound_total', 'all_outbound_total' 101 | ] 102 | netStatPort.tcp_states.length.should.eql 14 103 | 104 | it 'should return tcp info', -> 105 | tcp = s.tcp() 106 | # console.log 'tcp', tcp 107 | Object.keys(tcp).should.eql [ 108 | 'active_opens', 'passive_opens', 'attempt_fails', 'estab_resets', 'curr_estab', 'in_segs', 'out_segs', 'retrans_segs', 'in_errs', 'out_rsts' 109 | ] 110 | 111 | it 'should return nfsClientV2 info', -> 112 | try 113 | cpu = s.nfsClientV2() 114 | console.log 'nfsClientV2', nfsClientV2 115 | Object.keys(nfsClientV2).should.eql [ 116 | 'null', 'getattr', 'setattr', 'root', 'lookup', 'readlink', 117 | 'read', 'writecache', 'write', 'create', 'remove', 'rename', 'link', 'symlink', 'mkdir', 'rmdir', 'readdir', 'fsstat' 118 | ] 119 | catch e # OSX 120 | e.message.should.eql 'sigar_nfs_client_v2_get error: 20001 (This function has not been implemented on this platform)' 121 | 122 | it 'should return nfsServerV2 info', -> 123 | try 124 | cpu = s.nfsServerV2() 125 | console.log 'nfsServerV2', nfsServerV2 126 | Object.keys(nfsServerV2).should.eql [ 127 | 'null', 'getattr', 'setattr', 'root', 'lookup', 'readlink', 128 | 'read', 'writecache', 'write', 'create', 'remove', 'rename', 'link', 'symlink', 'mkdir', 'rmdir', 'readdir', 'fsstat' 129 | ] 130 | catch e # OSX 131 | e.message.should.eql 'sigar_nfs_server_v2_get error: 20001 (This function has not been implemented on this platform)' 132 | 133 | it 'should list arp', -> 134 | arpList = s.arpList() 135 | # console.log 'arpList', arpList 136 | for arp in arpList 137 | Object.keys(arp).should.eql [ 138 | 'ifname', 'type', 139 | 'hwaddr', 'address', 140 | 'flags' 141 | ] 142 | 143 | 144 | -------------------------------------------------------------------------------- /test/process.coffee: -------------------------------------------------------------------------------- 1 | 2 | should = require 'should' 3 | sigar = require '..' 4 | 5 | describe 'process', -> 6 | 7 | s = sigar() 8 | 9 | it 'should list all of them', -> 10 | procList = s.procList() 11 | # console.log 'procList', procList 12 | procList.should.include process.pid 13 | 14 | it 'should return statistics info', -> 15 | procStat = s.procStat() 16 | # console.log 'procStat', procStat 17 | Object.keys(procStat).should.eql [ 18 | 'total', 'sleeping', 'running', 'zombie', 'stopped', 'idle', 'threads' 19 | ] 20 | 21 | it 'should return memory info', -> 22 | procMem = s.procMem process.pid 23 | # console.log 'procMem', procMem 24 | Object.keys(procMem).should.eql [ 25 | 'size', 'resident', 'share', 'minor_faults', 'major_faults', 'page_faults' 26 | ] 27 | 28 | it 'should return credential info', -> 29 | procCred = s.procCred process.pid 30 | # console.log 'procCred', procCred 31 | Object.keys(procCred).should.eql [ 32 | 'uid', 'gid', 'euid', 'egid' 33 | ] 34 | # procList = s.procList() 35 | # for pid in procList 36 | # console.log pid, s.procCred pid 37 | 38 | it 'should return time info', -> 39 | procTime = s.procTime process.pid 40 | # console.log 'procTime', procTime 41 | Object.keys(procTime).should.eql [ 42 | 'start_time', 'user', 'sys', 'total' 43 | ] 44 | # procList = s.procList() 45 | # for pid in procList 46 | # console.log pid, s.procTime pid 47 | 48 | it 'should return cpu info', -> 49 | procCpu = s.procCpu process.pid 50 | # console.log 'procCpu', procCpu 51 | Object.keys(procCpu).should.eql [ 52 | 'start_time', 'user', 'sys', 'total', 'last_time', 'percent' 53 | ] 54 | # procList = s.procList() 55 | # for pid in procList 56 | # console.log pid, s.procCpu pid 57 | 58 | it 'should return state', -> 59 | procState = s.procState process.pid 60 | # console.log 'procState', procState 61 | Object.keys(procState).should.eql [ 62 | 'name', 'state', 'ppid', 'tty', 'priority', 'nice', 'processor', 'threads' 63 | ] 64 | # procList = s.procList() 65 | # for pid in procList 66 | # state = s.procState pid 67 | # console.log state.name, String.fromCharCode(state.state) 68 | # console.log state.name, state.state 69 | 70 | it 'should return arguments', -> 71 | procArgs = s.procArgs process.pid 72 | # console.log 'procArgs', procArgs 73 | procArgs.length.should.be.above 0 74 | procArgs[0].should.eql 'node' 75 | # procList = s.procList() 76 | # for pid in procList 77 | # console.log pid, s.procArgs pid 78 | 79 | it 'should return environment', -> 80 | procEnv = s.procEnv process.pid 81 | # console.log 'procEnv', procEnv 82 | procEnv['HOME'].should.eql process.env['HOME'] 83 | 84 | it 'should return file descriptor', -> 85 | try 86 | procFd = s.procFd process.pid 87 | # console.log 'procFd', procFd 88 | Object.keys(procFd).should.eql [ 89 | 'total' 90 | ] 91 | catch e # OSX 92 | e.message.should.eql 'sigar_proc_fd_get error: 20001 (This function has not been implemented on this platform)' 93 | 94 | it 'should return exec information', -> 95 | procExe = s.procExe process.pid 96 | # console.log 'procExe', procExe 97 | Object.keys(procExe).should.eql [ 98 | 'name', 'cwd', 'root' 99 | ] 100 | # procList = s.procList() 101 | # for pid in procList 102 | # console.log pid, s.procExe pid 103 | 104 | it 'should return module information', -> 105 | procModules = s.procModules process.pid 106 | # console.log 'procModules', procModules 107 | procModules.should.be.instanceof Array 108 | procModules.length.should.be.above 0 109 | # procList = s.procList() 110 | # for pid in procList 111 | # try 112 | # console.log pid, s.procModules pid 113 | # catch e 114 | # console.log pid, e.message 115 | 116 | it 'should return port information', -> 117 | # TODO: start an http server and compare the return pid with the current pid 118 | # procPort = s.procPort -1, 4000 119 | # console.log 'procPort', procPort 120 | 121 | it 'should return cpu usage per thread', -> 122 | # Note, doesn't seem to be implemented by thread on osx, return rusage of the current thread 123 | # threadCpu = s.threadCpu process.pid 124 | # console.log 'threadCpu', threadCpu 125 | # procList = s.procList() 126 | # for pid in procList 127 | # try 128 | # console.log pid, s.threadCpu pid+23 129 | # catch e 130 | # console.log pid, e.message 131 | 132 | -------------------------------------------------------------------------------- /test/system.coffee: -------------------------------------------------------------------------------- 1 | 2 | should = require 'should' 3 | os = require 'os' 4 | sigar = require '..' 5 | 6 | describe 'system', -> 7 | 8 | s = sigar() 9 | 10 | it 'should return memory', -> 11 | mem = s.mem() 12 | # console.log 'mem', mem 13 | Object.keys(mem).should.eql [ 14 | 'ram', 'total', 'used', 'free', 'actual_used', 'actual_free', 'used_percent', 'free_percent' 15 | ] 16 | 17 | it 'should return swap', -> 18 | swap = s.swap() 19 | # console.log 'swap', swap 20 | Object.keys(swap).should.eql [ 21 | 'total', 'used', 'free','page_in','page_out' 22 | ] 23 | 24 | it 'should return uptime', -> 25 | uptime = s.uptime() 26 | # console.log 'uptime', uptime 27 | uptime.should.be.above 0 28 | 29 | it 'should return loadavg', -> 30 | loadavg = s.loadavg() 31 | # console.log 'loadavg', loadavg 32 | loadavg.length.should.eql 3 33 | loadavg[0].should.be.above 0 34 | 35 | it 'should resource limit', -> 36 | resourceLimit = s.resourceLimit() 37 | # console.log 'resourceLimit', resourceLimit 38 | Object.keys(resourceLimit).should.eql [ 39 | 'cpu_cur', 'cpu_max', 40 | 'file_size_cur', 'file_size_max', 41 | 'pipe_size_cur', 'pipe_size_max', 42 | 'data_cur', 'data_max', 43 | 'stack_cur', 'stack_max', 44 | 'core_cur', 'core_max', 45 | 'memory_cur', 'memory_max', 46 | 'processes_cur', 'processes_max', 47 | 'open_files_cur', 'open_files_max', 48 | 'virtual_memory_cur', 'virtual_memory_max' 49 | ] 50 | 51 | it 'should list who', -> 52 | whoList = s.whoList() 53 | # console.log 'whoList', whoList 54 | for who in whoList 55 | Object.keys(who).should.eql [ 56 | 'user', 'device', 57 | 'host', 'time' 58 | ] 59 | 60 | it 'should return version', -> 61 | version = s.version() 62 | # console.log 'version', version 63 | Object.keys(version).should.eql [ 64 | 'build_date', 'scm_revision', 65 | 'version', 'archname', 66 | 'archlib', 'binname', 'description', 67 | 'major', 'minor', 68 | 'maint', 'build' 69 | ] 70 | 71 | it 'should return system info', -> 72 | sysInfo = s.sysInfo() 73 | # console.log 'sysInfo', sysInfo 74 | Object.keys(sysInfo).should.eql [ 75 | 'name', 'version', 76 | 'arch', 'machine', 77 | 'description', 'patch_level', 78 | 'vendor', 'vendor_version', 79 | 'vendor_name', 'vendor_code_name' 80 | ] 81 | 82 | it 'should return fqdn', -> 83 | fqdn = s.fqdn() 84 | # console.log 'fqdn', fqdn 85 | ( os.hostname() or /^\d+\.\d+\.\d+\.\d+$/.test fqdn ).should.be.ok 86 | 87 | 88 | 89 | 90 | 91 | 92 | -------------------------------------------------------------------------------- /test/todo.coffee: -------------------------------------------------------------------------------- 1 | 2 | should = require 'should' 3 | sigar = require '..' 4 | 5 | describe 'todo', -> 6 | 7 | s = sigar() 8 | 9 | it 'should return net adress', -> 10 | # Ubuntu return "TypeError: node_sigar_str2net_address error" 11 | # testNetAdress = s.testNetAdress '127.0.0.1' 12 | # console.log testNetAdress 13 | # assert.eql testNetAdress, '127.0.0.1' 14 | 15 | it 'should ping rpc', -> 16 | # rpcPing = s.rpcPing '127.0.0.1', 0x10, 2 17 | # console.log 'rpcPing', rpcPing 18 | 19 | # it 'Test password', -> 20 | # s = sigar() 21 | # password = s.password 'Password please' 22 | # console.log 'password', password -------------------------------------------------------------------------------- /wscript: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import sys, os 4 | from os.path import abspath, exists 5 | from shutil import copy, rmtree 6 | 7 | def all(all): 8 | os.system('node-waf clean') 9 | os.system('node-waf configure') 10 | os.system('node-waf') 11 | 12 | def clean(cln): 13 | if exists('build'): rmtree('build') 14 | 15 | def set_options(conf): 16 | conf.tool_options("compiler_cxx") 17 | 18 | def configure(conf): 19 | conf.check_tool("compiler_cxx") 20 | conf.check_tool('node_addon') 21 | 22 | srcpath = abspath("deps/sigar") 23 | buildpath = abspath("build/sigar") 24 | destpath = abspath("build/Release") 25 | cmd = "cp -rp %s %s && cd \"%s\" && ./autogen.sh && ./configure --prefix=%s --with-pic && make && make install" 26 | if os.system(cmd % (srcpath, buildpath, buildpath, destpath)) != 0: 27 | conf.fatal("Configuring sigar failed.") 28 | conf.env.append_value("LIBPATH_SIGAR", abspath("build/Release/lib/")) 29 | conf.env.append_value("CPPPATH_SIGAR", abspath("build/Release/include/")) 30 | conf.env.append_value("STATICLIB_SIGAR", ["sigar"]) 31 | 32 | def build(conf): 33 | t = conf.new_task_gen('cxx', 'shlib', 'node_addon') 34 | t.source = [ 35 | 'src/node_sigar.cc' 36 | ] 37 | #t.cxxflags = ['-g', '-D_FILE_OFFSET_BITS=64', '-D_LARGEFILE_SOURCE', '-Wall'] 38 | t.target = 'sigar' 39 | t.uselib = 'SIGAR' 40 | --------------------------------------------------------------------------------