diff --git a/go.mod b/go.mod index e8b8a5dfbf29..3c5f09f263bc 100644 --- a/go.mod +++ b/go.mod @@ -4,11 +4,9 @@ go 1.11 require ( github.com/OpenPeeDeeP/depguard v1.0.1 - github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect github.com/fatih/color v1.7.0 github.com/go-critic/go-critic v0.3.5-0.20190904082202-d79a9f0c64db github.com/go-lintpack/lintpack v0.5.2 - github.com/go-ole/go-ole v1.2.4 // indirect github.com/golang/mock v1.3.1 github.com/golangci/check v0.0.0-20180506172741-cfe4005ccda2 github.com/golangci/dupl v0.0.0-20180902072040-3e9179ac440a @@ -30,8 +28,7 @@ require ( github.com/mitchellh/go-ps v0.0.0-20190716172923-621e5597135b github.com/pkg/errors v0.8.1 github.com/securego/gosec v0.0.0-20190912120752-140048b2a218 - github.com/shirou/gopsutil v2.18.12+incompatible - github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4 // indirect + github.com/shirou/gopsutil v0.0.0-20190901111213-e4ec7b275ada // v2.19.8 github.com/sirupsen/logrus v1.4.2 github.com/sourcegraph/go-diff v0.5.1 github.com/spf13/cobra v0.0.5 diff --git a/go.sum b/go.sum index 9f012dddd361..ce56a2198aac 100644 --- a/go.sum +++ b/go.sum @@ -4,8 +4,8 @@ github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= github.com/OpenPeeDeeP/depguard v1.0.1 h1:VlW4R6jmBIv3/u1JNlawEvJMM4J+dPORPaZasQee8Us= github.com/OpenPeeDeeP/depguard v1.0.1/go.mod h1:xsIw86fROiiwelg+jB2uM9PiKihMMmUx/1V+TNhjQvM= -github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d h1:G0m3OIz70MZUWq3EgK3CesDbo8upS2Vm9/P3FtgI+Jk= -github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= +github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8= +github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= @@ -38,8 +38,8 @@ github.com/go-lintpack/lintpack v0.5.2 h1:DI5mA3+eKdWeJ40nU4d6Wc26qmdG8RCi/btYq0 github.com/go-lintpack/lintpack v0.5.2/go.mod h1:NwZuYi2nUHho8XEIZ6SIxihrnPoqBTDqfpXvXAN0sXM= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= -github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI= -github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM= +github.com/go-ole/go-ole v1.2.1 h1:2lOsA72HgjxAuMlKpFiCbHTvu44PIVkZ5hqm3RSdI/E= +github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/go-toolsmith/astcast v1.0.0 h1:JojxlmI6STnFVG9yOImLeGREv8W2ocNUM+iOhR6jE7g= github.com/go-toolsmith/astcast v1.0.0/go.mod h1:mt2OdQTeAQcY4DQgPSArJjHCcOwlX+Wl/kwN+LbLGQ4= @@ -190,8 +190,8 @@ github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFR github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/securego/gosec v0.0.0-20190912120752-140048b2a218 h1:O0yPHYL49quNL4Oj2wVq+zbGMu4dAM6iLoOQtm49TrQ= github.com/securego/gosec v0.0.0-20190912120752-140048b2a218/go.mod h1:q6oYAujd2qyeU4cJqIri4LBIgdHXGvxWHZ1E29HNFRE= -github.com/shirou/gopsutil v2.18.12+incompatible h1:1eaJvGomDnH74/5cF4CTmTbLHAriGFsTZppLXDX93OM= -github.com/shirou/gopsutil v2.18.12+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/shirou/gopsutil v0.0.0-20190901111213-e4ec7b275ada h1:WokF3GuxBeL+n4Lk4Fa8v9mbdjlrl7bHuneF4N1bk2I= +github.com/shirou/gopsutil v0.0.0-20190901111213-e4ec7b275ada/go.mod h1:WWnYX4lzhCH5h/3YBfyVA3VbLYjlMZZAQcW9ojMexNc= github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4 h1:udFKJ0aHUL60LboW/A+DfgoHVedieIzIXE8uylPue0U= github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc= github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e h1:MZM7FHLqUHYI0Y/mQAt3d2aYa0SiNms/hFqC9qJYolM= diff --git a/vendor/github.com/StackExchange/wmi/swbemservices.go b/vendor/github.com/StackExchange/wmi/swbemservices.go index 3ff875630378..9765a53f74db 100644 --- a/vendor/github.com/StackExchange/wmi/swbemservices.go +++ b/vendor/github.com/StackExchange/wmi/swbemservices.go @@ -77,7 +77,7 @@ func (s *SWbemServices) process(initError chan error) { //fmt.Println("process: starting background thread initialization") //All OLE/WMI calls must happen on the same initialized thead, so lock this goroutine runtime.LockOSThread() - defer runtime.UnlockOSThread() + defer runtime.LockOSThread() err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED) if err != nil { diff --git a/vendor/github.com/StackExchange/wmi/wmi.go b/vendor/github.com/StackExchange/wmi/wmi.go index eab18cbfee0d..a951b1258b04 100644 --- a/vendor/github.com/StackExchange/wmi/wmi.go +++ b/vendor/github.com/StackExchange/wmi/wmi.go @@ -285,10 +285,6 @@ func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismat } defer prop.Clear() - if prop.VT == 0x1 { //VT_NULL - continue - } - switch val := prop.Value().(type) { case int8, int16, int32, int64, int: v := reflect.ValueOf(val).Int() @@ -387,7 +383,7 @@ func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismat } f.Set(fArr) } - case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + case reflect.Uint8: safeArray := prop.ToArray() if safeArray != nil { arr := safeArray.ToValueArray() @@ -398,17 +394,6 @@ func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismat } f.Set(fArr) } - case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: - safeArray := prop.ToArray() - if safeArray != nil { - arr := safeArray.ToValueArray() - fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr)) - for i, v := range arr { - s := fArr.Index(i) - s.SetInt(reflect.ValueOf(v).Int()) - } - f.Set(fArr) - } default: return &ErrFieldMismatch{ StructType: of.Type(), diff --git a/vendor/github.com/go-ole/go-ole/.travis.yml b/vendor/github.com/go-ole/go-ole/.travis.yml index 28f740cd5d0a..0c2c02bdf2e6 100644 --- a/vendor/github.com/go-ole/go-ole/.travis.yml +++ b/vendor/github.com/go-ole/go-ole/.travis.yml @@ -2,7 +2,8 @@ language: go sudo: false go: - - 1.9.x - - 1.10.x - - 1.11.x + - 1.1 + - 1.2 + - 1.3 + - 1.4 - tip diff --git a/vendor/github.com/go-ole/go-ole/README.md b/vendor/github.com/go-ole/go-ole/README.md index 7b577558d1cd..0ea9db33c798 100644 --- a/vendor/github.com/go-ole/go-ole/README.md +++ b/vendor/github.com/go-ole/go-ole/README.md @@ -1,4 +1,4 @@ -# Go OLE +#Go OLE [![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28) [![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole) @@ -35,12 +35,12 @@ AppVeyor is used to build on Windows using the (in-development) test COM server. The tests currently do run and do pass and this should be maintained with commits. -## Versioning +##Versioning Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch. This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed. -## LICENSE +##LICENSE Under the MIT License: http://mattn.mit-license.org/2013 diff --git a/vendor/github.com/go-ole/go-ole/com.go b/vendor/github.com/go-ole/go-ole/com.go index 6f986b1894ee..75ebbf13f6c7 100644 --- a/vendor/github.com/go-ole/go-ole/com.go +++ b/vendor/github.com/go-ole/go-ole/com.go @@ -3,7 +3,9 @@ package ole import ( + "errors" "syscall" + "time" "unicode/utf16" "unsafe" ) @@ -19,7 +21,6 @@ var ( procStringFromCLSID, _ = modole32.FindProc("StringFromCLSID") procStringFromIID, _ = modole32.FindProc("StringFromIID") procIIDFromString, _ = modole32.FindProc("IIDFromString") - procCoGetObject, _ = modole32.FindProc("CoGetObject") procGetUserDefaultLCID, _ = modkernel32.FindProc("GetUserDefaultLCID") procCopyMemory, _ = modkernel32.FindProc("RtlMoveMemory") procVariantInit, _ = modoleaut32.FindProc("VariantInit") @@ -208,32 +209,6 @@ func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) { return } -type BindOpts struct { - CbStruct uint32 - GrfFlags uint32 - GrfMode uint32 - TickCountDeadline uint32 -} - -// GetObject retrieves pointer to active object. -func GetObject(programID string, bindOpts *BindOpts, iid *GUID) (unk *IUnknown, err error) { - if bindOpts != nil { - bindOpts.CbStruct = uint32(unsafe.Sizeof(BindOpts{})) - } - if iid == nil { - iid = IID_IUnknown - } - hr, _, _ := procCoGetObject.Call( - uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(programID))), - uintptr(unsafe.Pointer(bindOpts)), - uintptr(unsafe.Pointer(iid)), - uintptr(unsafe.Pointer(&unk))) - if hr != 0 { - err = NewError(hr) - } - return -} - // VariantInit initializes variant. func VariantInit(v *VARIANT) (err error) { hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v))) @@ -342,3 +317,13 @@ func DispatchMessage(msg *Msg) (ret int32) { ret = int32(r0) return } + +// GetVariantDate converts COM Variant Time value to Go time.Time. +func GetVariantDate(value float64) (time.Time, error) { + var st syscall.Systemtime + r, _, _ := procVariantTimeToSystemTime.Call(uintptr(value), uintptr(unsafe.Pointer(&st))) + if r != 0 { + return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil + } + return time.Now(), errors.New("Could not convert to time, passing current time.") +} diff --git a/vendor/github.com/go-ole/go-ole/com_func.go b/vendor/github.com/go-ole/go-ole/com_func.go index cef539d9ddd6..425aad323360 100644 --- a/vendor/github.com/go-ole/go-ole/com_func.go +++ b/vendor/github.com/go-ole/go-ole/com_func.go @@ -169,6 +169,6 @@ func DispatchMessage(msg *Msg) int32 { return int32(0) } -func GetVariantDate(value uint64) (time.Time, error) { +func GetVariantDate(value float64) (time.Time, error) { return time.Now(), NewError(E_NOTIMPL) } diff --git a/vendor/github.com/go-ole/go-ole/go.mod b/vendor/github.com/go-ole/go-ole/go.mod deleted file mode 100644 index df98533ea904..000000000000 --- a/vendor/github.com/go-ole/go-ole/go.mod +++ /dev/null @@ -1,3 +0,0 @@ -module github.com/go-ole/go-ole - -go 1.12 diff --git a/vendor/github.com/go-ole/go-ole/idispatch_windows.go b/vendor/github.com/go-ole/go-ole/idispatch_windows.go index 6ec180b55fd5..020e4f51b02a 100644 --- a/vendor/github.com/go-ole/go-ole/idispatch_windows.go +++ b/vendor/github.com/go-ole/go-ole/idispatch_windows.go @@ -3,7 +3,6 @@ package ole import ( - "math/big" "syscall" "time" "unsafe" @@ -133,8 +132,6 @@ func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{} vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv))) case *float64: vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64))))) - case *big.Int: - vargs[n] = NewVariant(VT_DECIMAL, v.(*big.Int).Int64()) case string: vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string)))))) case *string: diff --git a/vendor/github.com/go-ole/go-ole/safearray_func.go b/vendor/github.com/go-ole/go-ole/safearray_func.go index 0dee670ceb6d..8ff0baa41ddd 100644 --- a/vendor/github.com/go-ole/go-ole/safearray_func.go +++ b/vendor/github.com/go-ole/go-ole/safearray_func.go @@ -124,12 +124,12 @@ func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) { } // safeArrayGetElement retrieves element at given index. -func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error { +func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error { return NewError(E_NOTIMPL) } // safeArrayGetElement retrieves element at given index and converts to string. -func safeArrayGetElementString(safearray *SafeArray, index int32) (string, error) { +func safeArrayGetElementString(safearray *SafeArray, index int64) (string, error) { return "", NewError(E_NOTIMPL) } @@ -146,8 +146,8 @@ func safeArrayGetIID(safearray *SafeArray) (*GUID, error) { // multidimensional array. // // AKA: SafeArrayGetLBound in Windows API. -func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int32, error) { - return int32(0), NewError(E_NOTIMPL) +func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int64, error) { + return int64(0), NewError(E_NOTIMPL) } // safeArrayGetUBound returns upper bounds of SafeArray. @@ -156,8 +156,8 @@ func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int32, error) { // multidimensional array. // // AKA: SafeArrayGetUBound in Windows API. -func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int32, error) { - return int32(0), NewError(E_NOTIMPL) +func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int64, error) { + return int64(0), NewError(E_NOTIMPL) } // safeArrayGetVartype returns data type of SafeArray. diff --git a/vendor/github.com/go-ole/go-ole/safearray_windows.go b/vendor/github.com/go-ole/go-ole/safearray_windows.go index b48a2394d1e5..b27936e24ed0 100644 --- a/vendor/github.com/go-ole/go-ole/safearray_windows.go +++ b/vendor/github.com/go-ole/go-ole/safearray_windows.go @@ -205,7 +205,7 @@ func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) { } // safeArrayGetElement retrieves element at given index. -func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error { +func safeArrayGetElement(safearray *SafeArray, index int64, pv unsafe.Pointer) error { return convertHresultToError( procSafeArrayGetElement.Call( uintptr(unsafe.Pointer(safearray)), @@ -214,7 +214,7 @@ func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) e } // safeArrayGetElementString retrieves element at given index and converts to string. -func safeArrayGetElementString(safearray *SafeArray, index int32) (str string, err error) { +func safeArrayGetElementString(safearray *SafeArray, index int64) (str string, err error) { var element *int16 err = convertHresultToError( procSafeArrayGetElement.Call( @@ -243,7 +243,7 @@ func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) { // multidimensional array. // // AKA: SafeArrayGetLBound in Windows API. -func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int32, err error) { +func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int64, err error) { err = convertHresultToError( procSafeArrayGetLBound.Call( uintptr(unsafe.Pointer(safearray)), @@ -258,7 +258,7 @@ func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int3 // multidimensional array. // // AKA: SafeArrayGetUBound in Windows API. -func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int32, err error) { +func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int64, err error) { err = convertHresultToError( procSafeArrayGetUBound.Call( uintptr(unsafe.Pointer(safearray)), diff --git a/vendor/github.com/go-ole/go-ole/safearrayconversion.go b/vendor/github.com/go-ole/go-ole/safearrayconversion.go index 259f488ec7f9..ffeb2b97b020 100644 --- a/vendor/github.com/go-ole/go-ole/safearrayconversion.go +++ b/vendor/github.com/go-ole/go-ole/safearrayconversion.go @@ -14,7 +14,7 @@ func (sac *SafeArrayConversion) ToStringArray() (strings []string) { totalElements, _ := sac.TotalElements(0) strings = make([]string, totalElements) - for i := int32(0); i < totalElements; i++ { + for i := int64(0); i < totalElements; i++ { strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i) } @@ -25,7 +25,7 @@ func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) { totalElements, _ := sac.TotalElements(0) bytes = make([]byte, totalElements) - for i := int32(0); i < totalElements; i++ { + for i := int64(0); i < totalElements; i++ { safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)])) } @@ -37,59 +37,59 @@ func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) { values = make([]interface{}, totalElements) vt, _ := safeArrayGetVartype(sac.Array) - for i := int32(0); i < totalElements; i++ { + for i := 0; i < int(totalElements); i++ { switch VT(vt) { case VT_BOOL: var v bool - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I1: var v int8 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I2: var v int16 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I4: var v int32 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_I8: var v int64 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI1: var v uint8 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI2: var v uint16 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI4: var v uint32 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_UI8: var v uint64 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_R4: var v float32 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_R8: var v float64 - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_BSTR: var v string - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v case VT_VARIANT: var v VARIANT - safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v)) + safeArrayGetElement(sac.Array, int64(i), unsafe.Pointer(&v)) values[i] = v.Value() default: // TODO @@ -111,14 +111,14 @@ func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) { return safeArrayGetElementSize(sac.Array) } -func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int32, err error) { +func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int64, err error) { if index < 1 { index = 1 } // Get array bounds - var LowerBounds int32 - var UpperBounds int32 + var LowerBounds int64 + var UpperBounds int64 LowerBounds, err = safeArrayGetLBound(sac.Array, index) if err != nil { diff --git a/vendor/github.com/go-ole/go-ole/variant.go b/vendor/github.com/go-ole/go-ole/variant.go index 967a23fea9ab..36969725eba4 100644 --- a/vendor/github.com/go-ole/go-ole/variant.go +++ b/vendor/github.com/go-ole/go-ole/variant.go @@ -88,10 +88,10 @@ func (v *VARIANT) Value() interface{} { return v.ToString() case VT_DATE: // VT_DATE type will either return float64 or time.Time. - d := uint64(v.Val) + d := float64(v.Val) date, err := GetVariantDate(d) if err != nil { - return float64(v.Val) + return d } return date case VT_UNKNOWN: diff --git a/vendor/github.com/go-ole/go-ole/variant_date_386.go b/vendor/github.com/go-ole/go-ole/variant_date_386.go deleted file mode 100644 index 1b970f63f5fb..000000000000 --- a/vendor/github.com/go-ole/go-ole/variant_date_386.go +++ /dev/null @@ -1,22 +0,0 @@ -// +build windows,386 - -package ole - -import ( - "errors" - "syscall" - "time" - "unsafe" -) - -// GetVariantDate converts COM Variant Time value to Go time.Time. -func GetVariantDate(value uint64) (time.Time, error) { - var st syscall.Systemtime - v1 := uint32(value) - v2 := uint32(value >> 32) - r, _, _ := procVariantTimeToSystemTime.Call(uintptr(v1), uintptr(v2), uintptr(unsafe.Pointer(&st))) - if r != 0 { - return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil - } - return time.Now(), errors.New("Could not convert to time, passing current time.") -} diff --git a/vendor/github.com/go-ole/go-ole/variant_date_amd64.go b/vendor/github.com/go-ole/go-ole/variant_date_amd64.go deleted file mode 100644 index 6952f1f0de64..000000000000 --- a/vendor/github.com/go-ole/go-ole/variant_date_amd64.go +++ /dev/null @@ -1,20 +0,0 @@ -// +build windows,amd64 - -package ole - -import ( - "errors" - "syscall" - "time" - "unsafe" -) - -// GetVariantDate converts COM Variant Time value to Go time.Time. -func GetVariantDate(value uint64) (time.Time, error) { - var st syscall.Systemtime - r, _, _ := procVariantTimeToSystemTime.Call(uintptr(value), uintptr(unsafe.Pointer(&st))) - if r != 0 { - return time.Date(int(st.Year), time.Month(st.Month), int(st.Day), int(st.Hour), int(st.Minute), int(st.Second), int(st.Milliseconds/1000), time.UTC), nil - } - return time.Now(), errors.New("Could not convert to time, passing current time.") -} diff --git a/vendor/github.com/go-ole/go-ole/variant_ppc64le.go b/vendor/github.com/go-ole/go-ole/variant_ppc64le.go deleted file mode 100644 index 326427a7d144..000000000000 --- a/vendor/github.com/go-ole/go-ole/variant_ppc64le.go +++ /dev/null @@ -1,12 +0,0 @@ -// +build ppc64le - -package ole - -type VARIANT struct { - VT VT // 2 - wReserved1 uint16 // 4 - wReserved2 uint16 // 6 - wReserved3 uint16 // 8 - Val int64 // 16 - _ [8]byte // 24 -} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu.go b/vendor/github.com/shirou/gopsutil/cpu/cpu.go index ceaf77feeb7b..ec0a85cd0db3 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu.go @@ -4,7 +4,7 @@ import ( "context" "encoding/json" "fmt" - "runtime" + "math" "strconv" "strings" "sync" @@ -28,7 +28,6 @@ type TimesStat struct { Steal float64 `json:"steal"` Guest float64 `json:"guest"` GuestNice float64 `json:"guestNice"` - Stolen float64 `json:"stolen"` } type InfoStat struct { @@ -63,14 +62,11 @@ func init() { lastCPUPercent.Unlock() } +// Counts returns the number of physical or logical cores in the system func Counts(logical bool) (int, error) { return CountsWithContext(context.Background(), logical) } -func CountsWithContext(ctx context.Context, logical bool) (int, error) { - return runtime.NumCPU(), nil -} - func (c TimesStat) String() string { v := []string{ `"cpu":"` + c.CPU + `"`, @@ -84,7 +80,6 @@ func (c TimesStat) String() string { `"steal":` + strconv.FormatFloat(c.Steal, 'f', 1, 64), `"guest":` + strconv.FormatFloat(c.Guest, 'f', 1, 64), `"guestNice":` + strconv.FormatFloat(c.GuestNice, 'f', 1, 64), - `"stolen":` + strconv.FormatFloat(c.Stolen, 'f', 1, 64), } return `{` + strings.Join(v, ",") + `}` @@ -93,7 +88,7 @@ func (c TimesStat) String() string { // Total returns the total number of seconds in a CPUTimesStat func (c TimesStat) Total() float64 { total := c.User + c.System + c.Nice + c.Iowait + c.Irq + c.Softirq + c.Steal + - c.Guest + c.GuestNice + c.Idle + c.Stolen + c.Guest + c.GuestNice + c.Idle return total } @@ -104,7 +99,7 @@ func (c InfoStat) String() string { func getAllBusy(t TimesStat) (float64, float64) { busy := t.User + t.System + t.Nice + t.Iowait + t.Irq + - t.Softirq + t.Steal + t.Guest + t.GuestNice + t.Stolen + t.Softirq + t.Steal + t.Guest + t.GuestNice return busy + t.Idle, busy } @@ -116,9 +111,9 @@ func calculateBusy(t1, t2 TimesStat) float64 { return 0 } if t2All <= t1All { - return 1 + return 100 } - return (t2Busy - t1Busy) / (t2All - t1All) * 100 + return math.Min(100, math.Max(0, (t2Busy-t1Busy)/(t2All-t1All)*100)) } func calculateAllBusy(t1, t2 []TimesStat) ([]float64, error) { diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go index 74d273731724..cd0475d3ce0d 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_darwin.go @@ -4,9 +4,10 @@ package cpu import ( "context" - "os/exec" "strconv" "strings" + + "golang.org/x/sys/unix" ) // sys/resource.h @@ -41,75 +42,62 @@ func Info() ([]InfoStat, error) { func InfoWithContext(ctx context.Context) ([]InfoStat, error) { var ret []InfoStat - sysctl, err := exec.LookPath("/usr/sbin/sysctl") - if err != nil { - return ret, err - } - out, err := invoke.CommandWithContext(ctx, sysctl, "machdep.cpu") - if err != nil { - return ret, err - } c := InfoStat{} - for _, line := range strings.Split(string(out), "\n") { - values := strings.Fields(line) - if len(values) < 1 { - continue + c.ModelName, _ = unix.Sysctl("machdep.cpu.brand_string") + family, _ := unix.SysctlUint32("machdep.cpu.family") + c.Family = strconv.FormatUint(uint64(family), 10) + model, _ := unix.SysctlUint32("machdep.cpu.model") + c.Model = strconv.FormatUint(uint64(model), 10) + stepping, _ := unix.SysctlUint32("machdep.cpu.stepping") + c.Stepping = int32(stepping) + features, err := unix.Sysctl("machdep.cpu.features") + if err == nil { + for _, v := range strings.Fields(features) { + c.Flags = append(c.Flags, strings.ToLower(v)) } - - t, err := strconv.ParseInt(values[1], 10, 64) - // err is not checked here because some value is string. - if strings.HasPrefix(line, "machdep.cpu.brand_string") { - c.ModelName = strings.Join(values[1:], " ") - } else if strings.HasPrefix(line, "machdep.cpu.family") { - c.Family = values[1] - } else if strings.HasPrefix(line, "machdep.cpu.model") { - c.Model = values[1] - } else if strings.HasPrefix(line, "machdep.cpu.stepping") { - if err != nil { - return ret, err - } - c.Stepping = int32(t) - } else if strings.HasPrefix(line, "machdep.cpu.features") { - for _, v := range values[1:] { - c.Flags = append(c.Flags, strings.ToLower(v)) - } - } else if strings.HasPrefix(line, "machdep.cpu.leaf7_features") { - for _, v := range values[1:] { - c.Flags = append(c.Flags, strings.ToLower(v)) - } - } else if strings.HasPrefix(line, "machdep.cpu.extfeatures") { - for _, v := range values[1:] { - c.Flags = append(c.Flags, strings.ToLower(v)) - } - } else if strings.HasPrefix(line, "machdep.cpu.core_count") { - if err != nil { - return ret, err - } - c.Cores = int32(t) - } else if strings.HasPrefix(line, "machdep.cpu.cache.size") { - if err != nil { - return ret, err - } - c.CacheSize = int32(t) - } else if strings.HasPrefix(line, "machdep.cpu.vendor") { - c.VendorID = values[1] + } + leaf7Features, err := unix.Sysctl("machdep.cpu.leaf7_features") + if err == nil { + for _, v := range strings.Fields(leaf7Features) { + c.Flags = append(c.Flags, strings.ToLower(v)) } } + extfeatures, err := unix.Sysctl("machdep.cpu.extfeatures") + if err == nil { + for _, v := range strings.Fields(extfeatures) { + c.Flags = append(c.Flags, strings.ToLower(v)) + } + } + cores, _ := unix.SysctlUint32("machdep.cpu.core_count") + c.Cores = int32(cores) + cacheSize, _ := unix.SysctlUint32("machdep.cpu.cache.size") + c.CacheSize = int32(cacheSize) + c.VendorID, _ = unix.Sysctl("machdep.cpu.vendor") // Use the rated frequency of the CPU. This is a static value and does not // account for low power or Turbo Boost modes. - out, err = invoke.CommandWithContext(ctx, sysctl, "hw.cpufrequency") + cpuFrequency, err := unix.SysctlUint64("hw.cpufrequency") if err != nil { return ret, err } + c.Mhz = float64(cpuFrequency) / 1000000.0 + + return append(ret, c), nil +} - values := strings.Fields(string(out)) - hz, err := strconv.ParseFloat(values[1], 64) +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + var cpuArgument string + if logical { + cpuArgument = "hw.logicalcpu" + } else { + cpuArgument = "hw.physicalcpu" + } + + count, err := unix.SysctlUint32(cpuArgument) if err != nil { - return ret, err + return 0, err } - c.Mhz = hz / 1000000.0 - return append(ret, c), nil + return int(count), nil } diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_fallback.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_fallback.go index e9e7ada2cebb..fbb06083db8f 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_fallback.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_fallback.go @@ -4,6 +4,7 @@ package cpu import ( "context" + "runtime" "github.com/shirou/gopsutil/internal/common" ) @@ -23,3 +24,7 @@ func Info() ([]InfoStat, error) { func InfoWithContext(ctx context.Context) ([]InfoStat, error) { return []InfoStat{}, common.ErrNotImplementedError } + +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + return runtime.NumCPU(), nil +} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go index b6c7186c7bf9..57beffae1174 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd.go @@ -6,6 +6,7 @@ import ( "os/exec" "reflect" "regexp" + "runtime" "strconv" "strings" "unsafe" @@ -25,7 +26,7 @@ var cpuTimesSize int var emptyTimes cpuTimes func init() { - getconf, err := exec.LookPath("/usr/bin/getconf") + getconf, err := exec.LookPath("getconf") if err != nil { return } @@ -166,3 +167,7 @@ func parseDmesgBoot(fileName string) (InfoStat, int, error) { return c, cpuNum, nil } + +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + return runtime.NumCPU(), nil +} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_arm.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_arm.go new file mode 100644 index 000000000000..8b7f4c321eb6 --- /dev/null +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_freebsd_arm.go @@ -0,0 +1,9 @@ +package cpu + +type cpuTimes struct { + User uint32 + Nice uint32 + Sys uint32 + Intr uint32 + Idle uint32 +} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go index 2fffe85b995d..be98dd79fe4f 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_linux.go @@ -16,7 +16,7 @@ import ( var CPUTick = float64(100) func init() { - getconf, err := exec.LookPath("/usr/bin/getconf") + getconf, err := exec.LookPath("getconf") if err != nil { return } @@ -282,3 +282,71 @@ func parseStatLine(line string) (*TimesStat, error) { return ct, nil } + +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + if logical { + ret := 0 + // https://github.com/giampaolo/psutil/blob/d01a9eaa35a8aadf6c519839e987a49d8be2d891/psutil/_pslinux.py#L599 + procCpuinfo := common.HostProc("cpuinfo") + lines, err := common.ReadLines(procCpuinfo) + if err == nil { + for _, line := range lines { + line = strings.ToLower(line) + if strings.HasPrefix(line, "processor") { + ret++ + } + } + } + if ret == 0 { + procStat := common.HostProc("stat") + lines, err = common.ReadLines(procStat) + if err != nil { + return 0, err + } + for _, line := range lines { + if len(line) >= 4 && strings.HasPrefix(line, "cpu") && '0' <= line[3] && line[3] <= '9' { // `^cpu\d` regexp matching + ret++ + } + } + } + return ret, nil + } + // physical cores https://github.com/giampaolo/psutil/blob/d01a9eaa35a8aadf6c519839e987a49d8be2d891/psutil/_pslinux.py#L628 + filename := common.HostProc("cpuinfo") + lines, err := common.ReadLines(filename) + if err != nil { + return 0, err + } + mapping := make(map[int]int) + currentInfo := make(map[string]int) + for _, line := range lines { + line = strings.ToLower(strings.TrimSpace(line)) + if line == "" { + // new section + id, okID := currentInfo["physical id"] + cores, okCores := currentInfo["cpu cores"] + if okID && okCores { + mapping[id] = cores + } + currentInfo = make(map[string]int) + continue + } + fields := strings.Split(line, ":") + if len(fields) < 2 { + continue + } + fields[0] = strings.TrimSpace(fields[0]) + if fields[0] == "physical id" || fields[0] == "cpu cores" { + val, err := strconv.Atoi(strings.TrimSpace(fields[1])) + if err != nil { + continue + } + currentInfo[fields[0]] = val + } + } + ret := 0 + for _, v := range mapping { + ret += v + } + return ret, nil +} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_openbsd.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_openbsd.go index 82b920f66818..92a8bd75c9ab 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_openbsd.go @@ -8,15 +8,17 @@ import ( "encoding/binary" "fmt" "os/exec" + "runtime" "strconv" "strings" + "syscall" "github.com/shirou/gopsutil/internal/common" "golang.org/x/sys/unix" ) // sys/sched.h -const ( +var ( CPUser = 0 CPNice = 1 CPSys = 2 @@ -28,6 +30,9 @@ const ( // sys/sysctl.h const ( CTLKern = 1 // "high kernel": proc, limits + CTLHw = 6 // CTL_HW + SMT = 24 // HW_SMT + NCpuOnline = 25 // HW_NCPUONLINE KernCptime = 40 // KERN_CPTIME KernCptime2 = 71 // KERN_CPTIME2 ) @@ -35,18 +40,52 @@ const ( var ClocksPerSec = float64(128) func init() { - getconf, err := exec.LookPath("/usr/bin/getconf") - if err != nil { - return - } - out, err := invoke.Command(getconf, "CLK_TCK") - // ignore errors - if err == nil { - i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64) + func() { + getconf, err := exec.LookPath("getconf") + if err != nil { + return + } + out, err := invoke.Command(getconf, "CLK_TCK") + // ignore errors if err == nil { - ClocksPerSec = float64(i) + i, err := strconv.ParseFloat(strings.TrimSpace(string(out)), 64) + if err == nil { + ClocksPerSec = float64(i) + } + } + }() + func() { + v, err := unix.Sysctl("kern.osrelease") // can't reuse host.PlatformInformation because of circular import + if err != nil { + return + } + v = strings.ToLower(v) + version, err := strconv.ParseFloat(v, 64) + if err != nil { + return + } + if version >= 6.4 { + CPIntr = 4 + CPIdle = 5 + CPUStates = 6 } + }() +} + +func smt() (bool, error) { + mib := []int32{CTLHw, SMT} + buf, _, err := common.CallSyscall(mib) + if err != nil { + return false, err + } + + var ret bool + br := bytes.NewReader(buf) + if err := binary.Read(br, binary.LittleEndian, &ret); err != nil { + return false, err } + + return ret, nil } func Times(percpu bool) ([]TimesStat, error) { @@ -63,13 +102,27 @@ func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) { ncpu = 1 } + smt, err := smt() + if err == syscall.EOPNOTSUPP { + // if hw.smt is not applicable for this platform (e.g. i386), + // pretend it's enabled + smt = true + } else if err != nil { + return nil, err + } + for i := 0; i < ncpu; i++ { - var cpuTimes [CPUStates]int64 + j := i + if !smt { + j *= 2 + } + + var cpuTimes = make([]int32, CPUStates) var mib []int32 if percpu { - mib = []int32{CTLKern, KernCptime} + mib = []int32{CTLKern, KernCptime2, int32(j)} } else { - mib = []int32{CTLKern, KernCptime2, int32(i)} + mib = []int32{CTLKern, KernCptime} } buf, _, err := common.CallSyscall(mib) if err != nil { @@ -88,10 +141,10 @@ func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) { Idle: float64(cpuTimes[CPIdle]) / ClocksPerSec, Irq: float64(cpuTimes[CPIntr]) / ClocksPerSec, } - if !percpu { - c.CPU = "cpu-total" + if percpu { + c.CPU = fmt.Sprintf("cpu%d", j) } else { - c.CPU = fmt.Sprintf("cpu%d", i) + c.CPU = "cpu-total" } ret = append(ret, c) } @@ -106,14 +159,37 @@ func Info() ([]InfoStat, error) { func InfoWithContext(ctx context.Context) ([]InfoStat, error) { var ret []InfoStat + var err error c := InfoStat{} - v, err := unix.Sysctl("hw.model") + var u32 uint32 + if u32, err = unix.SysctlUint32("hw.cpuspeed"); err != nil { + return nil, err + } + c.Mhz = float64(u32) + + mib := []int32{CTLHw, NCpuOnline} + buf, _, err := common.CallSyscall(mib) if err != nil { return nil, err } - c.ModelName = v + + var ncpu int32 + br := bytes.NewReader(buf) + err = binary.Read(br, binary.LittleEndian, &ncpu) + if err != nil { + return nil, err + } + c.Cores = ncpu + + if c.ModelName, err = unix.Sysctl("hw.model"); err != nil { + return nil, err + } return append(ret, c), nil } + +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + return runtime.NumCPU(), nil +} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_solaris.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_solaris.go index 117fd909d427..3de098424024 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_solaris.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_solaris.go @@ -6,17 +6,16 @@ import ( "fmt" "os/exec" "regexp" + "runtime" "sort" "strconv" "strings" - - "github.com/shirou/gopsutil/internal/common" ) var ClocksPerSec = float64(128) func init() { - getconf, err := exec.LookPath("/usr/bin/getconf") + getconf, err := exec.LookPath("getconf") if err != nil { return } @@ -30,12 +29,97 @@ func init() { } } +//sum all values in a float64 map with float64 keys +func msum(x map[float64]float64) float64 { + total := 0.0 + for _, y := range x { + total += y + } + return total +} + func Times(percpu bool) ([]TimesStat, error) { return TimesWithContext(context.Background(), percpu) } func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) { - return []TimesStat{}, common.ErrNotImplementedError + kstatSys, err := exec.LookPath("kstat") + if err != nil { + return nil, fmt.Errorf("cannot find kstat: %s", err) + } + cpu := make(map[float64]float64) + idle := make(map[float64]float64) + user := make(map[float64]float64) + kern := make(map[float64]float64) + iowt := make(map[float64]float64) + //swap := make(map[float64]float64) + kstatSysOut, err := invoke.CommandWithContext(ctx, kstatSys, "-p", "cpu_stat:*:*:/^idle$|^user$|^kernel$|^iowait$|^swap$/") + if err != nil { + return nil, fmt.Errorf("cannot execute kstat: %s", err) + } + re := regexp.MustCompile(`[:\s]+`) + for _, line := range strings.Split(string(kstatSysOut), "\n") { + fields := re.Split(line, -1) + if fields[0] != "cpu_stat" { + continue + } + cpuNumber, err := strconv.ParseFloat(fields[1], 64) + if err != nil { + return nil, fmt.Errorf("cannot parse cpu number: %s", err) + } + cpu[cpuNumber] = cpuNumber + switch fields[3] { + case "idle": + idle[cpuNumber], err = strconv.ParseFloat(fields[4], 64) + if err != nil { + return nil, fmt.Errorf("cannot parse idle: %s", err) + } + case "user": + user[cpuNumber], err = strconv.ParseFloat(fields[4], 64) + if err != nil { + return nil, fmt.Errorf("cannot parse user: %s", err) + } + case "kernel": + kern[cpuNumber], err = strconv.ParseFloat(fields[4], 64) + if err != nil { + return nil, fmt.Errorf("cannot parse kernel: %s", err) + } + case "iowait": + iowt[cpuNumber], err = strconv.ParseFloat(fields[4], 64) + if err != nil { + return nil, fmt.Errorf("cannot parse iowait: %s", err) + } + //not sure how this translates, don't report, add to kernel, something else? + /*case "swap": + swap[cpuNumber], err = strconv.ParseFloat(fields[4], 64) + if err != nil { + return nil, fmt.Errorf("cannot parse swap: %s", err) + } */ + } + } + ret := make([]TimesStat, 0, len(cpu)) + if percpu { + for _, c := range cpu { + ct := &TimesStat{ + CPU: fmt.Sprintf("cpu%d", int(cpu[c])), + Idle: idle[c] / ClocksPerSec, + User: user[c] / ClocksPerSec, + System: kern[c] / ClocksPerSec, + Iowait: iowt[c] / ClocksPerSec, + } + ret = append(ret, *ct) + } + } else { + ct := &TimesStat{ + CPU: "cpu-total", + Idle: msum(idle) / ClocksPerSec, + User: msum(user) / ClocksPerSec, + System: msum(kern) / ClocksPerSec, + Iowait: msum(iowt) / ClocksPerSec, + } + ret = append(ret, *ct) + } + return ret, nil } func Info() ([]InfoStat, error) { @@ -43,7 +127,7 @@ func Info() ([]InfoStat, error) { } func InfoWithContext(ctx context.Context) ([]InfoStat, error) { - psrInfo, err := exec.LookPath("/usr/sbin/psrinfo") + psrInfo, err := exec.LookPath("psrinfo") if err != nil { return nil, fmt.Errorf("cannot find psrinfo: %s", err) } @@ -52,7 +136,7 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { return nil, fmt.Errorf("cannot execute psrinfo: %s", err) } - isaInfo, err := exec.LookPath("/usr/bin/isainfo") + isaInfo, err := exec.LookPath("isainfo") if err != nil { return nil, fmt.Errorf("cannot find isainfo: %s", err) } @@ -196,3 +280,7 @@ func parseProcessorInfo(cmdOutput string) ([]InfoStat, error) { } return result, nil } + +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + return runtime.NumCPU(), nil +} diff --git a/vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go b/vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go index 3959212b18df..97c0e342f515 100644 --- a/vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go +++ b/vendor/github.com/shirou/gopsutil/cpu/cpu_windows.go @@ -12,29 +12,35 @@ import ( "golang.org/x/sys/windows" ) +var ( + procGetActiveProcessorCount = common.Modkernel32.NewProc("GetActiveProcessorCount") + procGetNativeSystemInfo = common.Modkernel32.NewProc("GetNativeSystemInfo") +) + type Win32_Processor struct { LoadPercentage *uint16 Family uint16 Manufacturer string Name string NumberOfLogicalProcessors uint32 + NumberOfCores uint32 ProcessorID *string Stepping *string MaxClockSpeed uint32 } -type win32_PerfRawData_Counters_ProcessorInformation struct { - Name string - PercentDPCTime uint64 - PercentIdleTime uint64 - PercentUserTime uint64 - PercentProcessorTime uint64 - PercentInterruptTime uint64 - PercentPriorityTime uint64 - PercentPrivilegedTime uint64 - InterruptsPerSec uint32 - ProcessorFrequency uint32 - DPCRate uint32 +// SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION +// defined in windows api doc with the following +// https://docs.microsoft.com/en-us/windows/desktop/api/winternl/nf-winternl-ntquerysysteminformation#system_processor_performance_information +// additional fields documented here +// https://www.geoffchappell.com/studies/windows/km/ntoskrnl/api/ex/sysinfo/processor_performance.htm +type win32_SystemProcessorPerformanceInformation struct { + IdleTime int64 // idle time in 100ns (this is not a filetime). + KernelTime int64 // kernel time in 100ns. kernel time includes idle time. (this is not a filetime). + UserTime int64 // usertime in 100ns (this is not a filetime). + DpcTime int64 // dpc time in 100ns (this is not a filetime). + InterruptTime int64 // interrupt time in 100ns + InterruptCount uint32 } // Win32_PerfFormattedData_PerfOS_System struct to have count of processes and processor queue length @@ -45,6 +51,13 @@ type Win32_PerfFormattedData_PerfOS_System struct { const ( win32_TicksPerSecond = 10000000.0 + + // systemProcessorPerformanceInformationClass information class to query with NTQuerySystemInformation + // https://processhacker.sourceforge.io/doc/ntexapi_8h.html#ad5d815b48e8f4da1ef2eb7a2f18a54e0 + win32_SystemProcessorPerformanceInformationClass = 8 + + // size of systemProcessorPerformanceInfoSize in memory + win32_SystemProcessorPerformanceInfoSize = uint32(unsafe.Sizeof(win32_SystemProcessorPerformanceInformation{})) ) // Times returns times stat per cpu and combined for all CPUs @@ -54,7 +67,7 @@ func Times(percpu bool) ([]TimesStat, error) { func TimesWithContext(ctx context.Context, percpu bool) ([]TimesStat, error) { if percpu { - return perCPUTimesWithContext(ctx) + return perCPUTimes() } var ret []TimesStat @@ -120,20 +133,6 @@ func InfoWithContext(ctx context.Context) ([]InfoStat, error) { return ret, nil } -// PerfInfo returns the performance counter's instance value for ProcessorInformation. -// Name property is the key by which overall, per cpu and per core metric is known. -func perfInfoWithContext(ctx context.Context) ([]win32_PerfRawData_Counters_ProcessorInformation, error) { - var ret []win32_PerfRawData_Counters_ProcessorInformation - - q := wmi.CreateQuery(&ret, "WHERE NOT Name LIKE '%_Total'") - err := common.WMIQueryWithContext(ctx, q, &ret) - if err != nil { - return []win32_PerfRawData_Counters_ProcessorInformation{}, err - } - - return ret, err -} - // ProcInfo returns processes count and processor queue length in the system. // There is a single queue for processor even on multiprocessors systems. func ProcInfo() ([]Win32_PerfFormattedData_PerfOS_System, error) { @@ -151,21 +150,106 @@ func ProcInfoWithContext(ctx context.Context) ([]Win32_PerfFormattedData_PerfOS_ } // perCPUTimes returns times stat per cpu, per core and overall for all CPUs -func perCPUTimesWithContext(ctx context.Context) ([]TimesStat, error) { +func perCPUTimes() ([]TimesStat, error) { var ret []TimesStat - stats, err := perfInfoWithContext(ctx) + stats, err := perfInfo() if err != nil { return nil, err } - for _, v := range stats { + for core, v := range stats { c := TimesStat{ - CPU: v.Name, - User: float64(v.PercentUserTime) / win32_TicksPerSecond, - System: float64(v.PercentPrivilegedTime) / win32_TicksPerSecond, - Idle: float64(v.PercentIdleTime) / win32_TicksPerSecond, - Irq: float64(v.PercentInterruptTime) / win32_TicksPerSecond, + CPU: fmt.Sprintf("cpu%d", core), + User: float64(v.UserTime) / win32_TicksPerSecond, + System: float64(v.KernelTime-v.IdleTime) / win32_TicksPerSecond, + Idle: float64(v.IdleTime) / win32_TicksPerSecond, + Irq: float64(v.InterruptTime) / win32_TicksPerSecond, } ret = append(ret, c) } return ret, nil } + +// makes call to Windows API function to retrieve performance information for each core +func perfInfo() ([]win32_SystemProcessorPerformanceInformation, error) { + // Make maxResults large for safety. + // We can't invoke the api call with a results array that's too small. + // If we have more than 2056 cores on a single host, then it's probably the future. + maxBuffer := 2056 + // buffer for results from the windows proc + resultBuffer := make([]win32_SystemProcessorPerformanceInformation, maxBuffer) + // size of the buffer in memory + bufferSize := uintptr(win32_SystemProcessorPerformanceInfoSize) * uintptr(maxBuffer) + // size of the returned response + var retSize uint32 + + // Invoke windows api proc. + // The returned err from the windows dll proc will always be non-nil even when successful. + // See https://godoc.org/golang.org/x/sys/windows#LazyProc.Call for more information + retCode, _, err := common.ProcNtQuerySystemInformation.Call( + win32_SystemProcessorPerformanceInformationClass, // System Information Class -> SystemProcessorPerformanceInformation + uintptr(unsafe.Pointer(&resultBuffer[0])), // pointer to first element in result buffer + bufferSize, // size of the buffer in memory + uintptr(unsafe.Pointer(&retSize)), // pointer to the size of the returned results the windows proc will set this + ) + + // check return code for errors + if retCode != 0 { + return nil, fmt.Errorf("call to NtQuerySystemInformation returned %d. err: %s", retCode, err.Error()) + } + + // calculate the number of returned elements based on the returned size + numReturnedElements := retSize / win32_SystemProcessorPerformanceInfoSize + + // trim results to the number of returned elements + resultBuffer = resultBuffer[:numReturnedElements] + + return resultBuffer, nil +} + +// SystemInfo is an equivalent representation of SYSTEM_INFO in the Windows API. +// https://msdn.microsoft.com/en-us/library/ms724958%28VS.85%29.aspx?f=255&MSPPError=-2147217396 +// https://github.com/elastic/go-windows/blob/bb1581babc04d5cb29a2bfa7a9ac6781c730c8dd/kernel32.go#L43 +type systemInfo struct { + wProcessorArchitecture uint16 + wReserved uint16 + dwPageSize uint32 + lpMinimumApplicationAddress uintptr + lpMaximumApplicationAddress uintptr + dwActiveProcessorMask uintptr + dwNumberOfProcessors uint32 + dwProcessorType uint32 + dwAllocationGranularity uint32 + wProcessorLevel uint16 + wProcessorRevision uint16 +} + +func CountsWithContext(ctx context.Context, logical bool) (int, error) { + if logical { + // https://github.com/giampaolo/psutil/blob/d01a9eaa35a8aadf6c519839e987a49d8be2d891/psutil/_psutil_windows.c#L97 + err := procGetActiveProcessorCount.Find() + if err == nil { // Win7+ + ret, _, _ := procGetActiveProcessorCount.Call(uintptr(0xffff)) // ALL_PROCESSOR_GROUPS is 0xffff according to Rust's winapi lib https://docs.rs/winapi/*/x86_64-pc-windows-msvc/src/winapi/shared/ntdef.rs.html#120 + if ret != 0 { + return int(ret), nil + } + } + var systemInfo systemInfo + _, _, err = procGetNativeSystemInfo.Call(uintptr(unsafe.Pointer(&systemInfo))) + if systemInfo.dwNumberOfProcessors == 0 { + return 0, err + } + return int(systemInfo.dwNumberOfProcessors), nil + } + // physical cores https://github.com/giampaolo/psutil/blob/d01a9eaa35a8aadf6c519839e987a49d8be2d891/psutil/_psutil_windows.c#L499 + // for the time being, try with unreliable and slow WMI call… + var dst []Win32_Processor + q := wmi.CreateQuery(&dst, "") + if err := common.WMIQueryWithContext(ctx, q, &dst); err != nil { + return 0, err + } + var count uint32 + for _, d := range dst { + count += d.NumberOfCores + } + return int(count), nil +} diff --git a/vendor/github.com/shirou/gopsutil/host/host.go b/vendor/github.com/shirou/gopsutil/host/host.go deleted file mode 100644 index 1e9e9bb686f6..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host.go +++ /dev/null @@ -1,53 +0,0 @@ -package host - -import ( - "encoding/json" - - "github.com/shirou/gopsutil/internal/common" -) - -var invoke common.Invoker = common.Invoke{} - -// A HostInfoStat describes the host status. -// This is not in the psutil but it useful. -type InfoStat struct { - Hostname string `json:"hostname"` - Uptime uint64 `json:"uptime"` - BootTime uint64 `json:"bootTime"` - Procs uint64 `json:"procs"` // number of processes - OS string `json:"os"` // ex: freebsd, linux - Platform string `json:"platform"` // ex: ubuntu, linuxmint - PlatformFamily string `json:"platformFamily"` // ex: debian, rhel - PlatformVersion string `json:"platformVersion"` // version of the complete OS - KernelVersion string `json:"kernelVersion"` // version of the OS kernel (if available) - VirtualizationSystem string `json:"virtualizationSystem"` - VirtualizationRole string `json:"virtualizationRole"` // guest or host - HostID string `json:"hostid"` // ex: uuid -} - -type UserStat struct { - User string `json:"user"` - Terminal string `json:"terminal"` - Host string `json:"host"` - Started int `json:"started"` -} - -type TemperatureStat struct { - SensorKey string `json:"sensorKey"` - Temperature float64 `json:"sensorTemperature"` -} - -func (h InfoStat) String() string { - s, _ := json.Marshal(h) - return string(s) -} - -func (u UserStat) String() string { - s, _ := json.Marshal(u) - return string(s) -} - -func (t TemperatureStat) String() string { - s, _ := json.Marshal(t) - return string(s) -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_darwin.go b/vendor/github.com/shirou/gopsutil/host/host_darwin.go deleted file mode 100644 index 8241fc08bb07..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_darwin.go +++ /dev/null @@ -1,232 +0,0 @@ -// +build darwin - -package host - -import ( - "bytes" - "context" - "encoding/binary" - "io/ioutil" - "os" - "os/exec" - "runtime" - "strconv" - "strings" - "sync/atomic" - "time" - "unsafe" - - "github.com/shirou/gopsutil/internal/common" - "github.com/shirou/gopsutil/process" -) - -// from utmpx.h -const USER_PROCESS = 7 - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - ret := &InfoStat{ - OS: runtime.GOOS, - PlatformFamily: "darwin", - } - - hostname, err := os.Hostname() - if err == nil { - ret.Hostname = hostname - } - - kernelVersion, err := KernelVersionWithContext(ctx) - if err == nil { - ret.KernelVersion = kernelVersion - } - - platform, family, pver, err := PlatformInformation() - if err == nil { - ret.Platform = platform - ret.PlatformFamily = family - ret.PlatformVersion = pver - } - - system, role, err := Virtualization() - if err == nil { - ret.VirtualizationSystem = system - ret.VirtualizationRole = role - } - - boot, err := BootTime() - if err == nil { - ret.BootTime = boot - ret.Uptime = uptime(boot) - } - - procs, err := process.Pids() - if err == nil { - ret.Procs = uint64(len(procs)) - } - - values, err := common.DoSysctrlWithContext(ctx, "kern.uuid") - if err == nil && len(values) == 1 && values[0] != "" { - ret.HostID = strings.ToLower(values[0]) - } - - return ret, nil -} - -// cachedBootTime must be accessed via atomic.Load/StoreUint64 -var cachedBootTime uint64 - -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - t := atomic.LoadUint64(&cachedBootTime) - if t != 0 { - return t, nil - } - values, err := common.DoSysctrlWithContext(ctx, "kern.boottime") - if err != nil { - return 0, err - } - // ex: { sec = 1392261637, usec = 627534 } Thu Feb 13 12:20:37 2014 - v := strings.Replace(values[2], ",", "", 1) - boottime, err := strconv.ParseInt(v, 10, 64) - if err != nil { - return 0, err - } - t = uint64(boottime) - atomic.StoreUint64(&cachedBootTime, t) - - return t, nil -} - -func uptime(boot uint64) uint64 { - return uint64(time.Now().Unix()) - boot -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - boot, err := BootTime() - if err != nil { - return 0, err - } - return uptime(boot), nil -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - utmpfile := "/var/run/utmpx" - var ret []UserStat - - file, err := os.Open(utmpfile) - if err != nil { - return ret, err - } - defer file.Close() - - buf, err := ioutil.ReadAll(file) - if err != nil { - return ret, err - } - - u := Utmpx{} - entrySize := int(unsafe.Sizeof(u)) - count := len(buf) / entrySize - - for i := 0; i < count; i++ { - b := buf[i*entrySize : i*entrySize+entrySize] - - var u Utmpx - br := bytes.NewReader(b) - err := binary.Read(br, binary.LittleEndian, &u) - if err != nil { - continue - } - if u.Type != USER_PROCESS { - continue - } - user := UserStat{ - User: common.IntToString(u.User[:]), - Terminal: common.IntToString(u.Line[:]), - Host: common.IntToString(u.Host[:]), - Started: int(u.Tv.Sec), - } - ret = append(ret, user) - } - - return ret, nil - -} - -func PlatformInformation() (string, string, string, error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) { - platform := "" - family := "" - pver := "" - - sw_vers, err := exec.LookPath("sw_vers") - if err != nil { - return "", "", "", err - } - uname, err := exec.LookPath("uname") - if err != nil { - return "", "", "", err - } - - out, err := invoke.CommandWithContext(ctx, uname, "-s") - if err == nil { - platform = strings.ToLower(strings.TrimSpace(string(out))) - } - - out, err = invoke.CommandWithContext(ctx, sw_vers, "-productVersion") - if err == nil { - pver = strings.ToLower(strings.TrimSpace(string(out))) - } - - return platform, family, pver, nil -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - return "", "", common.ErrNotImplementedError -} - -func KernelVersion() (string, error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (string, error) { - uname, err := exec.LookPath("uname") - if err != nil { - return "", err - } - out, err := invoke.CommandWithContext(ctx, uname, "-r") - if err != nil { - return "", err - } - version := strings.ToLower(strings.TrimSpace(string(out))) - return version, err -} - -func SensorsTemperatures() ([]TemperatureStat, error) { - return SensorsTemperaturesWithContext(context.Background()) -} - -func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) { - return []TemperatureStat{}, common.ErrNotImplementedError -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_darwin_386.go b/vendor/github.com/shirou/gopsutil/host/host_darwin_386.go deleted file mode 100644 index c3596f9f5e96..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_darwin_386.go +++ /dev/null @@ -1,19 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_darwin.go - -package host - -type Utmpx struct { - User [256]int8 - ID [4]int8 - Line [32]int8 - Pid int32 - Type int16 - Pad_cgo_0 [6]byte - Tv Timeval - Host [256]int8 - Pad [16]uint32 -} -type Timeval struct { - Sec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_darwin_amd64.go b/vendor/github.com/shirou/gopsutil/host/host_darwin_amd64.go deleted file mode 100644 index c3596f9f5e96..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_darwin_amd64.go +++ /dev/null @@ -1,19 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_darwin.go - -package host - -type Utmpx struct { - User [256]int8 - ID [4]int8 - Line [32]int8 - Pid int32 - Type int16 - Pad_cgo_0 [6]byte - Tv Timeval - Host [256]int8 - Pad [16]uint32 -} -type Timeval struct { - Sec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_fallback.go b/vendor/github.com/shirou/gopsutil/host/host_fallback.go deleted file mode 100644 index e80d7ea34908..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_fallback.go +++ /dev/null @@ -1,65 +0,0 @@ -// +build !darwin,!linux,!freebsd,!openbsd,!solaris,!windows - -package host - -import ( - "context" - - "github.com/shirou/gopsutil/internal/common" -) - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - return nil, common.ErrNotImplementedError -} - -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - return 0, common.ErrNotImplementedError -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - return 0, common.ErrNotImplementedError -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - return []UserStat{}, common.ErrNotImplementedError -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - return "", "", common.ErrNotImplementedError -} - -func KernelVersion() (string, error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (string, error) { - return "", common.ErrNotImplementedError -} - -func PlatformInformation() (string, string, string, error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) { - return "", "", "", common.ErrNotImplementedError -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_freebsd.go b/vendor/github.com/shirou/gopsutil/host/host_freebsd.go deleted file mode 100644 index 00a8519068f2..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_freebsd.go +++ /dev/null @@ -1,245 +0,0 @@ -// +build freebsd - -package host - -import ( - "bytes" - "context" - "encoding/binary" - "io/ioutil" - "os" - "runtime" - "strings" - "sync/atomic" - "syscall" - "time" - "unsafe" - - "github.com/shirou/gopsutil/internal/common" - "github.com/shirou/gopsutil/process" - "golang.org/x/sys/unix" -) - -const ( - UTNameSize = 16 /* see MAXLOGNAME in */ - UTLineSize = 8 - UTHostSize = 16 -) - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - ret := &InfoStat{ - OS: runtime.GOOS, - PlatformFamily: "freebsd", - } - - hostname, err := os.Hostname() - if err == nil { - ret.Hostname = hostname - } - - platform, family, version, err := PlatformInformation() - if err == nil { - ret.Platform = platform - ret.PlatformFamily = family - ret.PlatformVersion = version - ret.KernelVersion = version - } - - system, role, err := Virtualization() - if err == nil { - ret.VirtualizationSystem = system - ret.VirtualizationRole = role - } - - boot, err := BootTime() - if err == nil { - ret.BootTime = boot - ret.Uptime = uptime(boot) - } - - procs, err := process.Pids() - if err == nil { - ret.Procs = uint64(len(procs)) - } - - hostid, err := unix.Sysctl("kern.hostuuid") - if err == nil && hostid != "" { - ret.HostID = strings.ToLower(hostid) - } - - return ret, nil -} - -// cachedBootTime must be accessed via atomic.Load/StoreUint64 -var cachedBootTime uint64 - -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - t := atomic.LoadUint64(&cachedBootTime) - if t != 0 { - return t, nil - } - buf, err := unix.SysctlRaw("kern.boottime") - if err != nil { - return 0, err - } - - tv := *(*syscall.Timeval)(unsafe.Pointer((&buf[0]))) - atomic.StoreUint64(&cachedBootTime, uint64(tv.Sec)) - - return t, nil -} - -func uptime(boot uint64) uint64 { - return uint64(time.Now().Unix()) - boot -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - boot, err := BootTime() - if err != nil { - return 0, err - } - return uptime(boot), nil -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - utmpfile := "/var/run/utx.active" - if !common.PathExists(utmpfile) { - utmpfile = "/var/run/utmp" // before 9.0 - return getUsersFromUtmp(utmpfile) - } - - var ret []UserStat - file, err := os.Open(utmpfile) - if err != nil { - return ret, err - } - defer file.Close() - - buf, err := ioutil.ReadAll(file) - if err != nil { - return ret, err - } - - entrySize := sizeOfUtmpx - count := len(buf) / entrySize - - for i := 0; i < count; i++ { - b := buf[i*sizeOfUtmpx : (i+1)*sizeOfUtmpx] - var u Utmpx - br := bytes.NewReader(b) - err := binary.Read(br, binary.LittleEndian, &u) - if err != nil || u.Type != 4 { - continue - } - sec := (binary.LittleEndian.Uint32(u.Tv.Sec[:])) / 2 // TODO: - user := UserStat{ - User: common.IntToString(u.User[:]), - Terminal: common.IntToString(u.Line[:]), - Host: common.IntToString(u.Host[:]), - Started: int(sec), - } - - ret = append(ret, user) - } - - return ret, nil - -} - -func PlatformInformation() (string, string, string, error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) { - platform, err := unix.Sysctl("kern.ostype") - if err != nil { - return "", "", "", err - } - - version, err := unix.Sysctl("kern.osrelease") - if err != nil { - return "", "", "", err - } - - return strings.ToLower(platform), "", strings.ToLower(version), nil -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - return "", "", common.ErrNotImplementedError -} - -// before 9.0 -func getUsersFromUtmp(utmpfile string) ([]UserStat, error) { - var ret []UserStat - file, err := os.Open(utmpfile) - if err != nil { - return ret, err - } - defer file.Close() - - buf, err := ioutil.ReadAll(file) - if err != nil { - return ret, err - } - - u := Utmp{} - entrySize := int(unsafe.Sizeof(u)) - count := len(buf) / entrySize - - for i := 0; i < count; i++ { - b := buf[i*entrySize : i*entrySize+entrySize] - var u Utmp - br := bytes.NewReader(b) - err := binary.Read(br, binary.LittleEndian, &u) - if err != nil || u.Time == 0 { - continue - } - user := UserStat{ - User: common.IntToString(u.Name[:]), - Terminal: common.IntToString(u.Line[:]), - Host: common.IntToString(u.Host[:]), - Started: int(u.Time), - } - - ret = append(ret, user) - } - - return ret, nil -} - -func SensorsTemperatures() ([]TemperatureStat, error) { - return SensorsTemperaturesWithContext(context.Background()) -} - -func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) { - return []TemperatureStat{}, common.ErrNotImplementedError -} - -func KernelVersion() (string, error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (string, error) { - _, _, version, err := PlatformInformation() - return version, err -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_freebsd_386.go b/vendor/github.com/shirou/gopsutil/host/host_freebsd_386.go deleted file mode 100644 index 7f06d8f8e256..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_freebsd_386.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_freebsd.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmpx = 197 // TODO why should 197 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type Utmp struct { - Line [8]int8 - Name [16]int8 - Host [16]int8 - Time int32 -} - -type Utmpx struct { - Type int16 - Tv Timeval - Id [8]int8 - Pid int32 - User [32]int8 - Line [16]int8 - Host [125]int8 - // X__ut_spare [64]int8 -} - -type Timeval struct { - Sec [4]byte - Usec [3]byte -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_freebsd_amd64.go b/vendor/github.com/shirou/gopsutil/host/host_freebsd_amd64.go deleted file mode 100644 index 3f015f0fb513..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_freebsd_amd64.go +++ /dev/null @@ -1,44 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_freebsd.go - -package host - -const ( - sizeofPtr = 0x8 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmpx = 197 // TODO: why should 197, not 0x118 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int64 - _C_long_long int64 -) - -type Utmp struct { - Line [8]int8 - Name [16]int8 - Host [16]int8 - Time int32 -} - -type Utmpx struct { - Type int16 - Tv Timeval - Id [8]int8 - Pid int32 - User [32]int8 - Line [16]int8 - Host [125]int8 - // Host [128]int8 - // X__ut_spare [64]int8 -} - -type Timeval struct { - Sec [4]byte - Usec [3]byte -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_freebsd_arm.go b/vendor/github.com/shirou/gopsutil/host/host_freebsd_arm.go deleted file mode 100644 index ac74980ae4e3..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_freebsd_arm.go +++ /dev/null @@ -1,44 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_freebsd.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmpx = 197 // TODO: why should 197, not 0x118 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type Utmp struct { - Line [8]int8 - Name [16]int8 - Host [16]int8 - Time int32 -} - -type Utmpx struct { - Type int16 - Tv Timeval - Id [8]int8 - Pid int32 - User [32]int8 - Line [16]int8 - Host [125]int8 - // Host [128]int8 - // X__ut_spare [64]int8 -} - -type Timeval struct { - Sec [4]byte - Usec [3]byte -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux.go b/vendor/github.com/shirou/gopsutil/host/host_linux.go deleted file mode 100644 index 2c1ac6ba723a..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux.go +++ /dev/null @@ -1,682 +0,0 @@ -// +build linux - -package host - -import ( - "bytes" - "context" - "encoding/binary" - "fmt" - "io/ioutil" - "os" - "os/exec" - "path/filepath" - "regexp" - "runtime" - "strconv" - "strings" - "sync/atomic" - "time" - - "github.com/shirou/gopsutil/internal/common" -) - -type LSB struct { - ID string - Release string - Codename string - Description string -} - -// from utmp.h -const USER_PROCESS = 7 - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - ret := &InfoStat{ - OS: runtime.GOOS, - } - - hostname, err := os.Hostname() - if err == nil { - ret.Hostname = hostname - } - - platform, family, version, err := PlatformInformation() - if err == nil { - ret.Platform = platform - ret.PlatformFamily = family - ret.PlatformVersion = version - } - kernelVersion, err := KernelVersion() - if err == nil { - ret.KernelVersion = kernelVersion - } - - system, role, err := Virtualization() - if err == nil { - ret.VirtualizationSystem = system - ret.VirtualizationRole = role - } - - boot, err := BootTime() - if err == nil { - ret.BootTime = boot - ret.Uptime = uptime(boot) - } - - if numProcs, err := common.NumProcs(); err == nil { - ret.Procs = numProcs - } - - sysProductUUID := common.HostSys("class/dmi/id/product_uuid") - machineID := common.HostEtc("machine-id") - switch { - // In order to read this file, needs to be supported by kernel/arch and run as root - // so having fallback is important - case common.PathExists(sysProductUUID): - lines, err := common.ReadLines(sysProductUUID) - if err == nil && len(lines) > 0 && lines[0] != "" { - ret.HostID = strings.ToLower(lines[0]) - break - } - fallthrough - // Fallback on GNU Linux systems with systemd, readable by everyone - case common.PathExists(machineID): - lines, err := common.ReadLines(machineID) - if err == nil && len(lines) > 0 && len(lines[0]) == 32 { - st := lines[0] - ret.HostID = fmt.Sprintf("%s-%s-%s-%s-%s", st[0:8], st[8:12], st[12:16], st[16:20], st[20:32]) - break - } - fallthrough - // Not stable between reboot, but better than nothing - default: - values, err := common.DoSysctrl("kernel.random.boot_id") - if err == nil && len(values) == 1 && values[0] != "" { - ret.HostID = strings.ToLower(values[0]) - } - } - - return ret, nil -} - -// cachedBootTime must be accessed via atomic.Load/StoreUint64 -var cachedBootTime uint64 - -// BootTime returns the system boot time expressed in seconds since the epoch. -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - t := atomic.LoadUint64(&cachedBootTime) - if t != 0 { - return t, nil - } - - system, role, err := Virtualization() - if err != nil { - return 0, err - } - - statFile := "stat" - if system == "lxc" && role == "guest" { - // if lxc, /proc/uptime is used. - statFile = "uptime" - } else if system == "docker" && role == "guest" { - // also docker, guest - statFile = "uptime" - } - - filename := common.HostProc(statFile) - lines, err := common.ReadLines(filename) - if err != nil { - return 0, err - } - - if statFile == "stat" { - for _, line := range lines { - if strings.HasPrefix(line, "btime") { - f := strings.Fields(line) - if len(f) != 2 { - return 0, fmt.Errorf("wrong btime format") - } - b, err := strconv.ParseInt(f[1], 10, 64) - if err != nil { - return 0, err - } - t = uint64(b) - atomic.StoreUint64(&cachedBootTime, t) - return t, nil - } - } - } else if statFile == "uptime" { - if len(lines) != 1 { - return 0, fmt.Errorf("wrong uptime format") - } - f := strings.Fields(lines[0]) - b, err := strconv.ParseFloat(f[0], 64) - if err != nil { - return 0, err - } - t = uint64(time.Now().Unix()) - uint64(b) - atomic.StoreUint64(&cachedBootTime, t) - return t, nil - } - - return 0, fmt.Errorf("could not find btime") -} - -func uptime(boot uint64) uint64 { - return uint64(time.Now().Unix()) - boot -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - boot, err := BootTime() - if err != nil { - return 0, err - } - return uptime(boot), nil -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - utmpfile := common.HostVar("run/utmp") - - file, err := os.Open(utmpfile) - if err != nil { - return nil, err - } - defer file.Close() - - buf, err := ioutil.ReadAll(file) - if err != nil { - return nil, err - } - - count := len(buf) / sizeOfUtmp - - ret := make([]UserStat, 0, count) - - for i := 0; i < count; i++ { - b := buf[i*sizeOfUtmp : (i+1)*sizeOfUtmp] - - var u utmp - br := bytes.NewReader(b) - err := binary.Read(br, binary.LittleEndian, &u) - if err != nil { - continue - } - if u.Type != USER_PROCESS { - continue - } - user := UserStat{ - User: common.IntToString(u.User[:]), - Terminal: common.IntToString(u.Line[:]), - Host: common.IntToString(u.Host[:]), - Started: int(u.Tv.Sec), - } - ret = append(ret, user) - } - - return ret, nil - -} - -func getOSRelease() (platform string, version string, err error) { - contents, err := common.ReadLines(common.HostEtc("os-release")) - if err != nil { - return "", "", nil // return empty - } - for _, line := range contents { - field := strings.Split(line, "=") - if len(field) < 2 { - continue - } - switch field[0] { - case "ID": // use ID for lowercase - platform = field[1] - case "VERSION": - version = field[1] - } - } - return platform, version, nil -} - -func getLSB() (*LSB, error) { - ret := &LSB{} - if common.PathExists(common.HostEtc("lsb-release")) { - contents, err := common.ReadLines(common.HostEtc("lsb-release")) - if err != nil { - return ret, err // return empty - } - for _, line := range contents { - field := strings.Split(line, "=") - if len(field) < 2 { - continue - } - switch field[0] { - case "DISTRIB_ID": - ret.ID = field[1] - case "DISTRIB_RELEASE": - ret.Release = field[1] - case "DISTRIB_CODENAME": - ret.Codename = field[1] - case "DISTRIB_DESCRIPTION": - ret.Description = field[1] - } - } - } else if common.PathExists("/usr/bin/lsb_release") { - lsb_release, err := exec.LookPath("/usr/bin/lsb_release") - if err != nil { - return ret, err - } - out, err := invoke.Command(lsb_release) - if err != nil { - return ret, err - } - for _, line := range strings.Split(string(out), "\n") { - field := strings.Split(line, ":") - if len(field) < 2 { - continue - } - switch field[0] { - case "Distributor ID": - ret.ID = field[1] - case "Release": - ret.Release = field[1] - case "Codename": - ret.Codename = field[1] - case "Description": - ret.Description = field[1] - } - } - - } - - return ret, nil -} - -func PlatformInformation() (platform string, family string, version string, err error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) { - - lsb, err := getLSB() - if err != nil { - lsb = &LSB{} - } - - if common.PathExists(common.HostEtc("oracle-release")) { - platform = "oracle" - contents, err := common.ReadLines(common.HostEtc("oracle-release")) - if err == nil { - version = getRedhatishVersion(contents) - } - - } else if common.PathExists(common.HostEtc("enterprise-release")) { - platform = "oracle" - contents, err := common.ReadLines(common.HostEtc("enterprise-release")) - if err == nil { - version = getRedhatishVersion(contents) - } - } else if common.PathExists(common.HostEtc("slackware-version")) { - platform = "slackware" - contents, err := common.ReadLines(common.HostEtc("slackware-version")) - if err == nil { - version = getSlackwareVersion(contents) - } - } else if common.PathExists(common.HostEtc("debian_version")) { - if lsb.ID == "Ubuntu" { - platform = "ubuntu" - version = lsb.Release - } else if lsb.ID == "LinuxMint" { - platform = "linuxmint" - version = lsb.Release - } else { - if common.PathExists("/usr/bin/raspi-config") { - platform = "raspbian" - } else { - platform = "debian" - } - contents, err := common.ReadLines(common.HostEtc("debian_version")) - if err == nil { - version = contents[0] - } - } - } else if common.PathExists(common.HostEtc("redhat-release")) { - contents, err := common.ReadLines(common.HostEtc("redhat-release")) - if err == nil { - version = getRedhatishVersion(contents) - platform = getRedhatishPlatform(contents) - } - } else if common.PathExists(common.HostEtc("system-release")) { - contents, err := common.ReadLines(common.HostEtc("system-release")) - if err == nil { - version = getRedhatishVersion(contents) - platform = getRedhatishPlatform(contents) - } - } else if common.PathExists(common.HostEtc("gentoo-release")) { - platform = "gentoo" - contents, err := common.ReadLines(common.HostEtc("gentoo-release")) - if err == nil { - version = getRedhatishVersion(contents) - } - } else if common.PathExists(common.HostEtc("SuSE-release")) { - contents, err := common.ReadLines(common.HostEtc("SuSE-release")) - if err == nil { - version = getSuseVersion(contents) - platform = getSusePlatform(contents) - } - // TODO: slackware detecion - } else if common.PathExists(common.HostEtc("arch-release")) { - platform = "arch" - version = lsb.Release - } else if common.PathExists(common.HostEtc("alpine-release")) { - platform = "alpine" - contents, err := common.ReadLines(common.HostEtc("alpine-release")) - if err == nil && len(contents) > 0 { - version = contents[0] - } - } else if common.PathExists(common.HostEtc("os-release")) { - p, v, err := getOSRelease() - if err == nil { - platform = p - version = v - } - } else if lsb.ID == "RedHat" { - platform = "redhat" - version = lsb.Release - } else if lsb.ID == "Amazon" { - platform = "amazon" - version = lsb.Release - } else if lsb.ID == "ScientificSL" { - platform = "scientific" - version = lsb.Release - } else if lsb.ID == "XenServer" { - platform = "xenserver" - version = lsb.Release - } else if lsb.ID != "" { - platform = strings.ToLower(lsb.ID) - version = lsb.Release - } - - switch platform { - case "debian", "ubuntu", "linuxmint", "raspbian": - family = "debian" - case "fedora": - family = "fedora" - case "oracle", "centos", "redhat", "scientific", "enterpriseenterprise", "amazon", "xenserver", "cloudlinux", "ibm_powerkvm": - family = "rhel" - case "suse", "opensuse": - family = "suse" - case "gentoo": - family = "gentoo" - case "slackware": - family = "slackware" - case "arch": - family = "arch" - case "exherbo": - family = "exherbo" - case "alpine": - family = "alpine" - case "coreos": - family = "coreos" - } - - return platform, family, version, nil - -} - -func KernelVersion() (version string, err error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (version string, err error) { - filename := common.HostProc("sys/kernel/osrelease") - if common.PathExists(filename) { - contents, err := common.ReadLines(filename) - if err != nil { - return "", err - } - - if len(contents) > 0 { - version = contents[0] - } - } - - return version, nil -} - -func getSlackwareVersion(contents []string) string { - c := strings.ToLower(strings.Join(contents, "")) - c = strings.Replace(c, "slackware ", "", 1) - return c -} - -func getRedhatishVersion(contents []string) string { - c := strings.ToLower(strings.Join(contents, "")) - - if strings.Contains(c, "rawhide") { - return "rawhide" - } - if matches := regexp.MustCompile(`release (\d[\d.]*)`).FindStringSubmatch(c); matches != nil { - return matches[1] - } - return "" -} - -func getRedhatishPlatform(contents []string) string { - c := strings.ToLower(strings.Join(contents, "")) - - if strings.Contains(c, "red hat") { - return "redhat" - } - f := strings.Split(c, " ") - - return f[0] -} - -func getSuseVersion(contents []string) string { - version := "" - for _, line := range contents { - if matches := regexp.MustCompile(`VERSION = ([\d.]+)`).FindStringSubmatch(line); matches != nil { - version = matches[1] - } else if matches := regexp.MustCompile(`PATCHLEVEL = ([\d]+)`).FindStringSubmatch(line); matches != nil { - version = version + "." + matches[1] - } - } - return version -} - -func getSusePlatform(contents []string) string { - c := strings.ToLower(strings.Join(contents, "")) - if strings.Contains(c, "opensuse") { - return "opensuse" - } - return "suse" -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - var system string - var role string - - filename := common.HostProc("xen") - if common.PathExists(filename) { - system = "xen" - role = "guest" // assume guest - - if common.PathExists(filepath.Join(filename, "capabilities")) { - contents, err := common.ReadLines(filepath.Join(filename, "capabilities")) - if err == nil { - if common.StringsContains(contents, "control_d") { - role = "host" - } - } - } - } - - filename = common.HostProc("modules") - if common.PathExists(filename) { - contents, err := common.ReadLines(filename) - if err == nil { - if common.StringsContains(contents, "kvm") { - system = "kvm" - role = "host" - } else if common.StringsContains(contents, "vboxdrv") { - system = "vbox" - role = "host" - } else if common.StringsContains(contents, "vboxguest") { - system = "vbox" - role = "guest" - } else if common.StringsContains(contents, "vmware") { - system = "vmware" - role = "guest" - } - } - } - - filename = common.HostProc("cpuinfo") - if common.PathExists(filename) { - contents, err := common.ReadLines(filename) - if err == nil { - if common.StringsContains(contents, "QEMU Virtual CPU") || - common.StringsContains(contents, "Common KVM processor") || - common.StringsContains(contents, "Common 32-bit KVM processor") { - system = "kvm" - role = "guest" - } - } - } - - filename = common.HostProc() - if common.PathExists(filepath.Join(filename, "bc", "0")) { - system = "openvz" - role = "host" - } else if common.PathExists(filepath.Join(filename, "vz")) { - system = "openvz" - role = "guest" - } - - // not use dmidecode because it requires root - if common.PathExists(filepath.Join(filename, "self", "status")) { - contents, err := common.ReadLines(filepath.Join(filename, "self", "status")) - if err == nil { - - if common.StringsContains(contents, "s_context:") || - common.StringsContains(contents, "VxID:") { - system = "linux-vserver" - } - // TODO: guest or host - } - } - - if common.PathExists(filepath.Join(filename, "self", "cgroup")) { - contents, err := common.ReadLines(filepath.Join(filename, "self", "cgroup")) - if err == nil { - if common.StringsContains(contents, "lxc") { - system = "lxc" - role = "guest" - } else if common.StringsContains(contents, "docker") { - system = "docker" - role = "guest" - } else if common.StringsContains(contents, "machine-rkt") { - system = "rkt" - role = "guest" - } else if common.PathExists("/usr/bin/lxc-version") { - system = "lxc" - role = "host" - } - } - } - - if common.PathExists(common.HostEtc("os-release")) { - p, _, err := getOSRelease() - if err == nil && p == "coreos" { - system = "rkt" // Is it true? - role = "host" - } - } - return system, role, nil -} - -func SensorsTemperatures() ([]TemperatureStat, error) { - return SensorsTemperaturesWithContext(context.Background()) -} - -func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) { - var temperatures []TemperatureStat - files, err := filepath.Glob(common.HostSys("/class/hwmon/hwmon*/temp*_*")) - if err != nil { - return temperatures, err - } - if len(files) == 0 { - // CentOS has an intermediate /device directory: - // https://github.com/giampaolo/psutil/issues/971 - files, err = filepath.Glob(common.HostSys("/class/hwmon/hwmon*/device/temp*_*")) - if err != nil { - return temperatures, err - } - } - - // example directory - // device/ temp1_crit_alarm temp2_crit_alarm temp3_crit_alarm temp4_crit_alarm temp5_crit_alarm temp6_crit_alarm temp7_crit_alarm - // name temp1_input temp2_input temp3_input temp4_input temp5_input temp6_input temp7_input - // power/ temp1_label temp2_label temp3_label temp4_label temp5_label temp6_label temp7_label - // subsystem/ temp1_max temp2_max temp3_max temp4_max temp5_max temp6_max temp7_max - // temp1_crit temp2_crit temp3_crit temp4_crit temp5_crit temp6_crit temp7_crit uevent - for _, file := range files { - filename := strings.Split(filepath.Base(file), "_") - if filename[1] == "label" { - // Do not try to read the temperature of the label file - continue - } - - // Get the label of the temperature you are reading - var label string - c, _ := ioutil.ReadFile(filepath.Join(filepath.Dir(file), filename[0]+"_label")) - if c != nil { - //format the label from "Core 0" to "core0_" - label = fmt.Sprintf("%s_", strings.Join(strings.Split(strings.TrimSpace(strings.ToLower(string(c))), " "), "")) - } - - // Get the name of the tempearture you are reading - name, err := ioutil.ReadFile(filepath.Join(filepath.Dir(file), "name")) - if err != nil { - return temperatures, err - } - - // Get the temperature reading - current, err := ioutil.ReadFile(file) - if err != nil { - return temperatures, err - } - temperature, err := strconv.ParseFloat(strings.TrimSpace(string(current)), 64) - if err != nil { - continue - } - - tempName := strings.TrimSpace(strings.ToLower(string(strings.Join(filename[1:], "")))) - temperatures = append(temperatures, TemperatureStat{ - SensorKey: fmt.Sprintf("%s_%s%s", strings.TrimSpace(string(name)), label, tempName), - Temperature: temperature / 1000.0, - }) - } - return temperatures, nil -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_386.go b/vendor/github.com/shirou/gopsutil/host/host_linux_386.go deleted file mode 100644 index 79b5cb5d380c..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_386.go +++ /dev/null @@ -1,45 +0,0 @@ -// ATTENTION - FILE MANUAL FIXED AFTER CGO. -// Fixed line: Tv _Ctype_struct_timeval -> Tv UtTv -// Created by cgo -godefs, MANUAL FIXED -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - ID [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv UtTv - Addr_v6 [4]int32 - X__unused [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type UtTv struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_amd64.go b/vendor/github.com/shirou/gopsutil/host/host_linux_amd64.go deleted file mode 100644 index 9a69652f510a..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_amd64.go +++ /dev/null @@ -1,48 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x8 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int64 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv _Ctype_struct___0 - Addr_v6 [4]int32 - X__glibc_reserved [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int64 - Usec int64 -} - -type _Ctype_struct___0 struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_arm.go b/vendor/github.com/shirou/gopsutil/host/host_linux_arm.go deleted file mode 100644 index e2cf44850963..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_arm.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go | sed "s/uint8/int8/g" - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__glibc_reserved [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_arm64.go b/vendor/github.com/shirou/gopsutil/host/host_linux_arm64.go deleted file mode 100644 index 37dbe5c8c305..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_arm64.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x8 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int64 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__glibc_reserved [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int64 - Usec int64 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_mips.go b/vendor/github.com/shirou/gopsutil/host/host_linux_mips.go deleted file mode 100644 index b0fca093952b..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_mips.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__unused [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_mips64.go b/vendor/github.com/shirou/gopsutil/host/host_linux_mips64.go deleted file mode 100644 index b0fca093952b..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_mips64.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__unused [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_mips64le.go b/vendor/github.com/shirou/gopsutil/host/host_linux_mips64le.go deleted file mode 100644 index b0fca093952b..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_mips64le.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__unused [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_mipsle.go b/vendor/github.com/shirou/gopsutil/host/host_linux_mipsle.go deleted file mode 100644 index b0fca093952b..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_mipsle.go +++ /dev/null @@ -1,43 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x4 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x4 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int32 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__unused [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int32 - Usec int32 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_ppc64le.go b/vendor/github.com/shirou/gopsutil/host/host_linux_ppc64le.go deleted file mode 100644 index d081a0819560..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_ppc64le.go +++ /dev/null @@ -1,45 +0,0 @@ -// +build linux -// +build ppc64le -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x8 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int64 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__glibc_reserved [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int64 - Usec int64 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_linux_s390x.go b/vendor/github.com/shirou/gopsutil/host/host_linux_s390x.go deleted file mode 100644 index 083fbf924af2..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_linux_s390x.go +++ /dev/null @@ -1,45 +0,0 @@ -// +build linux -// +build s390x -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_linux.go - -package host - -const ( - sizeofPtr = 0x8 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x180 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int64 - _C_long_long int64 -) - -type utmp struct { - Type int16 - Pad_cgo_0 [2]byte - Pid int32 - Line [32]int8 - Id [4]int8 - User [32]int8 - Host [256]int8 - Exit exit_status - Session int32 - Tv timeval - Addr_v6 [4]int32 - X__glibc_reserved [20]int8 -} -type exit_status struct { - Termination int16 - Exit int16 -} -type timeval struct { - Sec int64 - Usec int64 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_openbsd.go b/vendor/github.com/shirou/gopsutil/host/host_openbsd.go deleted file mode 100644 index 2ad64d77f6e5..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_openbsd.go +++ /dev/null @@ -1,195 +0,0 @@ -// +build openbsd - -package host - -import ( - "bytes" - "context" - "encoding/binary" - "io/ioutil" - "os" - "os/exec" - "runtime" - "strconv" - "strings" - "time" - "unsafe" - - "github.com/shirou/gopsutil/internal/common" - "github.com/shirou/gopsutil/process" -) - -const ( - UTNameSize = 32 /* see MAXLOGNAME in */ - UTLineSize = 8 - UTHostSize = 16 -) - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - ret := &InfoStat{ - OS: runtime.GOOS, - PlatformFamily: "openbsd", - } - - hostname, err := os.Hostname() - if err == nil { - ret.Hostname = hostname - } - - platform, family, version, err := PlatformInformation() - if err == nil { - ret.Platform = platform - ret.PlatformFamily = family - ret.PlatformVersion = version - } - system, role, err := Virtualization() - if err == nil { - ret.VirtualizationSystem = system - ret.VirtualizationRole = role - } - - procs, err := process.Pids() - if err == nil { - ret.Procs = uint64(len(procs)) - } - - boot, err := BootTime() - if err == nil { - ret.BootTime = boot - ret.Uptime = uptime(boot) - } - - return ret, nil -} - -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - val, err := common.DoSysctrl("kern.boottime") - if err != nil { - return 0, err - } - - boottime, err := strconv.ParseUint(val[0], 10, 64) - if err != nil { - return 0, err - } - - return boottime, nil -} - -func uptime(boot uint64) uint64 { - return uint64(time.Now().Unix()) - boot -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - boot, err := BootTime() - if err != nil { - return 0, err - } - return uptime(boot), nil -} - -func PlatformInformation() (string, string, string, error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (string, string, string, error) { - platform := "" - family := "" - version := "" - uname, err := exec.LookPath("uname") - if err != nil { - return "", "", "", err - } - - out, err := invoke.CommandWithContext(ctx, uname, "-s") - if err == nil { - platform = strings.ToLower(strings.TrimSpace(string(out))) - } - - out, err = invoke.CommandWithContext(ctx, uname, "-r") - if err == nil { - version = strings.ToLower(strings.TrimSpace(string(out))) - } - - return platform, family, version, nil -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - return "", "", common.ErrNotImplementedError -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - var ret []UserStat - utmpfile := "/var/run/utmp" - file, err := os.Open(utmpfile) - if err != nil { - return ret, err - } - defer file.Close() - - buf, err := ioutil.ReadAll(file) - if err != nil { - return ret, err - } - - u := Utmp{} - entrySize := int(unsafe.Sizeof(u)) - count := len(buf) / entrySize - - for i := 0; i < count; i++ { - b := buf[i*entrySize : i*entrySize+entrySize] - var u Utmp - br := bytes.NewReader(b) - err := binary.Read(br, binary.LittleEndian, &u) - if err != nil || u.Time == 0 { - continue - } - user := UserStat{ - User: common.IntToString(u.Name[:]), - Terminal: common.IntToString(u.Line[:]), - Host: common.IntToString(u.Host[:]), - Started: int(u.Time), - } - - ret = append(ret, user) - } - - return ret, nil -} - -func SensorsTemperatures() ([]TemperatureStat, error) { - return SensorsTemperaturesWithContext(context.Background()) -} - -func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) { - return []TemperatureStat{}, common.ErrNotImplementedError -} - -func KernelVersion() (string, error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (string, error) { - _, _, version, err := PlatformInformation() - return version, err -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_openbsd_amd64.go b/vendor/github.com/shirou/gopsutil/host/host_openbsd_amd64.go deleted file mode 100644 index afe0943e77e2..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_openbsd_amd64.go +++ /dev/null @@ -1,31 +0,0 @@ -// Created by cgo -godefs - DO NOT EDIT -// cgo -godefs types_openbsd.go - -package host - -const ( - sizeofPtr = 0x8 - sizeofShort = 0x2 - sizeofInt = 0x4 - sizeofLong = 0x8 - sizeofLongLong = 0x8 - sizeOfUtmp = 0x130 -) - -type ( - _C_short int16 - _C_int int32 - _C_long int64 - _C_long_long int64 -) - -type Utmp struct { - Line [8]int8 - Name [32]int8 - Host [256]int8 - Time int64 -} -type Timeval struct { - Sec int64 - Usec int64 -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_solaris.go b/vendor/github.com/shirou/gopsutil/host/host_solaris.go deleted file mode 100644 index bb83bfc9c15c..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_solaris.go +++ /dev/null @@ -1,248 +0,0 @@ -package host - -import ( - "bufio" - "bytes" - "context" - "fmt" - "io/ioutil" - "os" - "os/exec" - "regexp" - "runtime" - "strconv" - "strings" - "time" - - "github.com/shirou/gopsutil/internal/common" -) - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - result := &InfoStat{ - OS: runtime.GOOS, - } - - hostname, err := os.Hostname() - if err != nil { - return nil, err - } - result.Hostname = hostname - - // Parse versions from output of `uname(1)` - uname, err := exec.LookPath("/usr/bin/uname") - if err != nil { - return nil, err - } - - out, err := invoke.CommandWithContext(ctx, uname, "-srv") - if err != nil { - return nil, err - } - - fields := strings.Fields(string(out)) - if len(fields) >= 1 { - result.PlatformFamily = fields[0] - } - if len(fields) >= 2 { - result.KernelVersion = fields[1] - } - if len(fields) == 3 { - result.PlatformVersion = fields[2] - } - - // Find distribution name from /etc/release - fh, err := os.Open("/etc/release") - if err != nil { - return nil, err - } - defer fh.Close() - - sc := bufio.NewScanner(fh) - if sc.Scan() { - line := strings.TrimSpace(sc.Text()) - switch { - case strings.HasPrefix(line, "SmartOS"): - result.Platform = "SmartOS" - case strings.HasPrefix(line, "OpenIndiana"): - result.Platform = "OpenIndiana" - case strings.HasPrefix(line, "OmniOS"): - result.Platform = "OmniOS" - case strings.HasPrefix(line, "Open Storage"): - result.Platform = "NexentaStor" - case strings.HasPrefix(line, "Solaris"): - result.Platform = "Solaris" - case strings.HasPrefix(line, "Oracle Solaris"): - result.Platform = "Solaris" - default: - result.Platform = strings.Fields(line)[0] - } - } - - switch result.Platform { - case "SmartOS": - // If everything works, use the current zone ID as the HostID if present. - zonename, err := exec.LookPath("/usr/bin/zonename") - if err == nil { - out, err := invoke.CommandWithContext(ctx, zonename) - if err == nil { - sc := bufio.NewScanner(bytes.NewReader(out)) - for sc.Scan() { - line := sc.Text() - - // If we're in the global zone, rely on the hostname. - if line == "global" { - hostname, err := os.Hostname() - if err == nil { - result.HostID = hostname - } - } else { - result.HostID = strings.TrimSpace(line) - break - } - } - } - } - } - - // If HostID is still empty, use hostid(1), which can lie to callers but at - // this point there are no hardware facilities available. This behavior - // matches that of other supported OSes. - if result.HostID == "" { - hostID, err := exec.LookPath("/usr/bin/hostid") - if err == nil { - out, err := invoke.CommandWithContext(ctx, hostID) - if err == nil { - sc := bufio.NewScanner(bytes.NewReader(out)) - for sc.Scan() { - line := sc.Text() - result.HostID = strings.TrimSpace(line) - break - } - } - } - } - - // Find the boot time and calculate uptime relative to it - bootTime, err := BootTime() - if err != nil { - return nil, err - } - result.BootTime = bootTime - result.Uptime = uptimeSince(bootTime) - - // Count number of processes based on the number of entries in /proc - dirs, err := ioutil.ReadDir("/proc") - if err != nil { - return nil, err - } - result.Procs = uint64(len(dirs)) - - return result, nil -} - -var kstatMatch = regexp.MustCompile(`([^\s]+)[\s]+([^\s]*)`) - -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - kstat, err := exec.LookPath("/usr/bin/kstat") - if err != nil { - return 0, err - } - - out, err := invoke.CommandWithContext(ctx, kstat, "-p", "unix:0:system_misc:boot_time") - if err != nil { - return 0, err - } - - kstats := kstatMatch.FindAllStringSubmatch(string(out), -1) - if len(kstats) != 1 { - return 0, fmt.Errorf("expected 1 kstat, found %d", len(kstats)) - } - - return strconv.ParseUint(kstats[0][2], 10, 64) -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - bootTime, err := BootTime() - if err != nil { - return 0, err - } - return uptimeSince(bootTime), nil -} - -func uptimeSince(since uint64) uint64 { - return uint64(time.Now().Unix()) - since -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - return []UserStat{}, common.ErrNotImplementedError -} - -func SensorsTemperatures() ([]TemperatureStat, error) { - return SensorsTemperaturesWithContext(context.Background()) -} - -func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) { - return []TemperatureStat{}, common.ErrNotImplementedError -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - return "", "", common.ErrNotImplementedError -} - -func KernelVersion() (string, error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (string, error) { - // Parse versions from output of `uname(1)` - uname, err := exec.LookPath("/usr/bin/uname") - if err != nil { - return "", err - } - - out, err := invoke.CommandWithContext(ctx, uname, "-srv") - if err != nil { - return "", err - } - - fields := strings.Fields(string(out)) - if len(fields) >= 2 { - return fields[1], nil - } - return "", fmt.Errorf("could not get kernel version") -} - -func PlatformInformation() (platform string, family string, version string, err error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) { - /* This is not finished yet at all. Please contribute! */ - - version, err = KernelVersion() - if err != nil { - return "", "", "", err - } - - return "solaris", "solaris", version, nil -} diff --git a/vendor/github.com/shirou/gopsutil/host/host_windows.go b/vendor/github.com/shirou/gopsutil/host/host_windows.go deleted file mode 100644 index d89e191b7aa9..000000000000 --- a/vendor/github.com/shirou/gopsutil/host/host_windows.go +++ /dev/null @@ -1,295 +0,0 @@ -// +build windows - -package host - -import ( - "context" - "fmt" - "math" - "os" - "runtime" - "strings" - "sync/atomic" - "syscall" - "time" - "unsafe" - - "github.com/StackExchange/wmi" - "github.com/shirou/gopsutil/internal/common" - process "github.com/shirou/gopsutil/process" - "golang.org/x/sys/windows" -) - -var ( - procGetSystemTimeAsFileTime = common.Modkernel32.NewProc("GetSystemTimeAsFileTime") - procGetTickCount32 = common.Modkernel32.NewProc("GetTickCount") - procGetTickCount64 = common.Modkernel32.NewProc("GetTickCount64") - procRtlGetVersion = common.ModNt.NewProc("RtlGetVersion") -) - -// https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_osversioninfoexw -type osVersionInfoExW struct { - dwOSVersionInfoSize uint32 - dwMajorVersion uint32 - dwMinorVersion uint32 - dwBuildNumber uint32 - dwPlatformId uint32 - szCSDVersion [128]uint16 - wServicePackMajor uint16 - wServicePackMinor uint16 - wSuiteMask uint16 - wProductType uint8 - wReserved uint8 -} - -type msAcpi_ThermalZoneTemperature struct { - Active bool - CriticalTripPoint uint32 - CurrentTemperature uint32 - InstanceName string -} - -func Info() (*InfoStat, error) { - return InfoWithContext(context.Background()) -} - -func InfoWithContext(ctx context.Context) (*InfoStat, error) { - ret := &InfoStat{ - OS: runtime.GOOS, - } - - { - hostname, err := os.Hostname() - if err == nil { - ret.Hostname = hostname - } - } - - { - platform, family, version, err := PlatformInformationWithContext(ctx) - if err == nil { - ret.Platform = platform - ret.PlatformFamily = family - ret.PlatformVersion = version - } else { - return ret, err - } - } - - { - boot, err := BootTime() - if err == nil { - ret.BootTime = boot - ret.Uptime, _ = Uptime() - } - } - - { - hostID, err := getMachineGuid() - if err == nil { - ret.HostID = strings.ToLower(hostID) - } - } - - { - procs, err := process.Pids() - if err == nil { - ret.Procs = uint64(len(procs)) - } - } - - return ret, nil -} - -func getMachineGuid() (string, error) { - // there has been reports of issues on 32bit using golang.org/x/sys/windows/registry, see https://github.com/shirou/gopsutil/pull/312#issuecomment-277422612 - // for rationale of using windows.RegOpenKeyEx/RegQueryValueEx instead of registry.OpenKey/GetStringValue - var h windows.Handle - err := windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE, windows.StringToUTF16Ptr(`SOFTWARE\Microsoft\Cryptography`), 0, windows.KEY_READ|windows.KEY_WOW64_64KEY, &h) - if err != nil { - return "", err - } - defer windows.RegCloseKey(h) - - const windowsRegBufLen = 74 // len(`{`) + len(`abcdefgh-1234-456789012-123345456671` * 2) + len(`}`) // 2 == bytes/UTF16 - const uuidLen = 36 - - var regBuf [windowsRegBufLen]uint16 - bufLen := uint32(windowsRegBufLen) - var valType uint32 - err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`MachineGuid`), nil, &valType, (*byte)(unsafe.Pointer(®Buf[0])), &bufLen) - if err != nil { - return "", err - } - - hostID := windows.UTF16ToString(regBuf[:]) - hostIDLen := len(hostID) - if hostIDLen != uuidLen { - return "", fmt.Errorf("HostID incorrect: %q\n", hostID) - } - - return hostID, nil -} - -func Uptime() (uint64, error) { - return UptimeWithContext(context.Background()) -} - -func UptimeWithContext(ctx context.Context) (uint64, error) { - procGetTickCount := procGetTickCount64 - err := procGetTickCount64.Find() - if err != nil { - procGetTickCount = procGetTickCount32 // handle WinXP, but keep in mind that "the time will wrap around to zero if the system is run continuously for 49.7 days." from MSDN - } - r1, _, lastErr := syscall.Syscall(procGetTickCount.Addr(), 0, 0, 0, 0) - if lastErr != 0 { - return 0, lastErr - } - return uint64((time.Duration(r1) * time.Millisecond).Seconds()), nil -} - -func bootTimeFromUptime(up uint64) uint64 { - return uint64(time.Now().Unix()) - up -} - -// cachedBootTime must be accessed via atomic.Load/StoreUint64 -var cachedBootTime uint64 - -func BootTime() (uint64, error) { - return BootTimeWithContext(context.Background()) -} - -func BootTimeWithContext(ctx context.Context) (uint64, error) { - t := atomic.LoadUint64(&cachedBootTime) - if t != 0 { - return t, nil - } - up, err := Uptime() - if err != nil { - return 0, err - } - t = bootTimeFromUptime(up) - atomic.StoreUint64(&cachedBootTime, t) - return t, nil -} - -func PlatformInformation() (platform string, family string, version string, err error) { - return PlatformInformationWithContext(context.Background()) -} - -func PlatformInformationWithContext(ctx context.Context) (platform string, family string, version string, err error) { - // GetVersionEx lies on Windows 8.1 and returns as Windows 8 if we don't declare compatibility in manifest - // RtlGetVersion bypasses this lying layer and returns the true Windows version - // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/nf-wdm-rtlgetversion - // https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/wdm/ns-wdm-_osversioninfoexw - var osInfo osVersionInfoExW - osInfo.dwOSVersionInfoSize = uint32(unsafe.Sizeof(osInfo)) - ret, _, err := procRtlGetVersion.Call(uintptr(unsafe.Pointer(&osInfo))) - if ret != 0 { - return - } - - // Platform - var h windows.Handle // like getMachineGuid(), we query the registry using the raw windows.RegOpenKeyEx/RegQueryValueEx - err = windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE, windows.StringToUTF16Ptr(`SOFTWARE\Microsoft\Windows NT\CurrentVersion`), 0, windows.KEY_READ|windows.KEY_WOW64_64KEY, &h) - if err != nil { - return - } - defer windows.RegCloseKey(h) - var bufLen uint32 - var valType uint32 - err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`ProductName`), nil, &valType, nil, &bufLen) - if err != nil { - return - } - regBuf := make([]uint16, bufLen/2+1) - err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`ProductName`), nil, &valType, (*byte)(unsafe.Pointer(®Buf[0])), &bufLen) - if err != nil { - return - } - platform = windows.UTF16ToString(regBuf[:]) - if !strings.HasPrefix(platform, "Microsoft") { - platform = "Microsoft " + platform - } - err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`CSDVersion`), nil, &valType, nil, &bufLen) // append Service Pack number, only on success - if err == nil { // don't return an error if only the Service Pack retrieval fails - regBuf = make([]uint16, bufLen/2+1) - err = windows.RegQueryValueEx(h, windows.StringToUTF16Ptr(`CSDVersion`), nil, &valType, (*byte)(unsafe.Pointer(®Buf[0])), &bufLen) - if err == nil { - platform += " " + windows.UTF16ToString(regBuf[:]) - } - } - - // PlatformFamily - switch osInfo.wProductType { - case 1: - family = "Standalone Workstation" - case 2: - family = "Server (Domain Controller)" - case 3: - family = "Server" - } - - // Platform Version - version = fmt.Sprintf("%d.%d.%d Build %d", osInfo.dwMajorVersion, osInfo.dwMinorVersion, osInfo.dwBuildNumber, osInfo.dwBuildNumber) - - return platform, family, version, nil -} - -func Users() ([]UserStat, error) { - return UsersWithContext(context.Background()) -} - -func UsersWithContext(ctx context.Context) ([]UserStat, error) { - var ret []UserStat - - return ret, nil -} - -func SensorsTemperatures() ([]TemperatureStat, error) { - return SensorsTemperaturesWithContext(context.Background()) -} - -func SensorsTemperaturesWithContext(ctx context.Context) ([]TemperatureStat, error) { - var ret []TemperatureStat - var dst []msAcpi_ThermalZoneTemperature - q := wmi.CreateQuery(&dst, "") - if err := common.WMIQueryWithContext(ctx, q, &dst, nil, "root/wmi"); err != nil { - return ret, err - } - - for _, v := range dst { - ts := TemperatureStat{ - SensorKey: v.InstanceName, - Temperature: kelvinToCelsius(v.CurrentTemperature, 2), - } - ret = append(ret, ts) - } - - return ret, nil -} - -func kelvinToCelsius(temp uint32, n int) float64 { - // wmi return temperature Kelvin * 10, so need to divide the result by 10, - // and then minus 273.15 to get °Celsius. - t := float64(temp/10) - 273.15 - n10 := math.Pow10(n) - return math.Trunc((t+0.5/n10)*n10) / n10 -} - -func Virtualization() (string, string, error) { - return VirtualizationWithContext(context.Background()) -} - -func VirtualizationWithContext(ctx context.Context) (string, string, error) { - return "", "", common.ErrNotImplementedError -} - -func KernelVersion() (string, error) { - return KernelVersionWithContext(context.Background()) -} - -func KernelVersionWithContext(ctx context.Context) (string, error) { - _, _, version, err := PlatformInformation() - return version, err -} diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common.go b/vendor/github.com/shirou/gopsutil/internal/common/common.go index 71c2257f07f7..4ca8bc972314 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common.go @@ -213,6 +213,12 @@ func ReadInts(filename string) ([]int64, error) { return ret, nil } +// Parse Hex to uint32 without error +func HexToUint32(hex string) uint32 { + vv, _ := strconv.ParseUint(hex, 16, 32) + return uint32(vv) +} + // Parse to int32 without error func mustParseInt32(val string) int32 { vv, _ := strconv.ParseInt(val, 10, 32) @@ -332,49 +338,6 @@ func HostRun(combineWith ...string) string { return GetEnv("HOST_RUN", "/run", combineWith...) } -// https://gist.github.com/kylelemons/1525278 -func Pipeline(cmds ...*exec.Cmd) ([]byte, []byte, error) { - // Require at least one command - if len(cmds) < 1 { - return nil, nil, nil - } - - // Collect the output from the command(s) - var output bytes.Buffer - var stderr bytes.Buffer - - last := len(cmds) - 1 - for i, cmd := range cmds[:last] { - var err error - // Connect each command's stdin to the previous command's stdout - if cmds[i+1].Stdin, err = cmd.StdoutPipe(); err != nil { - return nil, nil, err - } - // Connect each command's stderr to a buffer - cmd.Stderr = &stderr - } - - // Connect the output and error for the last command - cmds[last].Stdout, cmds[last].Stderr = &output, &stderr - - // Start each command - for _, cmd := range cmds { - if err := cmd.Start(); err != nil { - return output.Bytes(), stderr.Bytes(), err - } - } - - // Wait for each command to complete - for _, cmd := range cmds { - if err := cmd.Wait(); err != nil { - return output.Bytes(), stderr.Bytes(), err - } - } - - // Return the pipeline output and the collected standard error - return output.Bytes(), stderr.Bytes(), nil -} - // getSysctrlEnv sets LC_ALL=C in a list of env vars for use when running // sysctl commands (see DoSysctrl). func getSysctrlEnv(env []string) []string { diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_darwin.go b/vendor/github.com/shirou/gopsutil/internal/common/common_darwin.go index 3e85cc06b8ad..dde5c39037a3 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common_darwin.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common_darwin.go @@ -13,7 +13,7 @@ import ( ) func DoSysctrlWithContext(ctx context.Context, mib string) ([]string, error) { - sysctl, err := exec.LookPath("/usr/sbin/sysctl") + sysctl, err := exec.LookPath("sysctl") if err != nil { return []string{}, err } diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_freebsd.go b/vendor/github.com/shirou/gopsutil/internal/common/common_freebsd.go index 107e2c9cf928..85bda0e22cf3 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common_freebsd.go @@ -3,6 +3,7 @@ package common import ( + "fmt" "os" "os/exec" "strings" @@ -11,8 +12,23 @@ import ( "golang.org/x/sys/unix" ) +func SysctlUint(mib string) (uint64, error) { + buf, err := unix.SysctlRaw(mib) + if err != nil { + return 0, err + } + if len(buf) == 8 { // 64 bit + return *(*uint64)(unsafe.Pointer(&buf[0])), nil + } + if len(buf) == 4 { // 32bit + t := *(*uint32)(unsafe.Pointer(&buf[0])) + return uint64(t), nil + } + return 0, fmt.Errorf("unexpected size: %s, %d", mib, len(buf)) +} + func DoSysctrl(mib string) ([]string, error) { - sysctl, err := exec.LookPath("/sbin/sysctl") + sysctl, err := exec.LookPath("sysctl") if err != nil { return []string{}, err } diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_linux.go b/vendor/github.com/shirou/gopsutil/internal/common/common_linux.go index 4e829e057fd6..f558b74b373c 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common_linux.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common_linux.go @@ -3,13 +3,19 @@ package common import ( + "context" + "fmt" "os" "os/exec" + "path/filepath" + "strconv" "strings" + "sync/atomic" + "time" ) func DoSysctrl(mib string) ([]string, error) { - sysctl, err := exec.LookPath("/sbin/sysctl") + sysctl, err := exec.LookPath("sysctl") if err != nil { return []string{}, err } @@ -37,5 +43,222 @@ func NumProcs() (uint64, error) { if err != nil { return 0, err } - return uint64(len(list)), err + var cnt uint64 + + for _, v := range list { + if _, err = strconv.ParseUint(v, 10, 64); err == nil { + cnt++ + } + } + + return cnt, nil +} + +// cachedBootTime must be accessed via atomic.Load/StoreUint64 +var cachedBootTime uint64 + +func BootTimeWithContext(ctx context.Context) (uint64, error) { + t := atomic.LoadUint64(&cachedBootTime) + if t != 0 { + return t, nil + } + + system, role, err := Virtualization() + if err != nil { + return 0, err + } + + statFile := "stat" + if system == "lxc" && role == "guest" { + // if lxc, /proc/uptime is used. + statFile = "uptime" + } else if system == "docker" && role == "guest" { + // also docker, guest + statFile = "uptime" + } + + filename := HostProc(statFile) + lines, err := ReadLines(filename) + if err != nil { + return 0, err + } + + if statFile == "stat" { + for _, line := range lines { + if strings.HasPrefix(line, "btime") { + f := strings.Fields(line) + if len(f) != 2 { + return 0, fmt.Errorf("wrong btime format") + } + b, err := strconv.ParseInt(f[1], 10, 64) + if err != nil { + return 0, err + } + t = uint64(b) + atomic.StoreUint64(&cachedBootTime, t) + return t, nil + } + } + } else if statFile == "uptime" { + if len(lines) != 1 { + return 0, fmt.Errorf("wrong uptime format") + } + f := strings.Fields(lines[0]) + b, err := strconv.ParseFloat(f[0], 64) + if err != nil { + return 0, err + } + t = uint64(time.Now().Unix()) - uint64(b) + atomic.StoreUint64(&cachedBootTime, t) + return t, nil + } + + return 0, fmt.Errorf("could not find btime") +} + +func Virtualization() (string, string, error) { + return VirtualizationWithContext(context.Background()) +} + +func VirtualizationWithContext(ctx context.Context) (string, string, error) { + var system string + var role string + + filename := HostProc("xen") + if PathExists(filename) { + system = "xen" + role = "guest" // assume guest + + if PathExists(filepath.Join(filename, "capabilities")) { + contents, err := ReadLines(filepath.Join(filename, "capabilities")) + if err == nil { + if StringsContains(contents, "control_d") { + role = "host" + } + } + } + } + + filename = HostProc("modules") + if PathExists(filename) { + contents, err := ReadLines(filename) + if err == nil { + if StringsContains(contents, "kvm") { + system = "kvm" + role = "host" + } else if StringsContains(contents, "vboxdrv") { + system = "vbox" + role = "host" + } else if StringsContains(contents, "vboxguest") { + system = "vbox" + role = "guest" + } else if StringsContains(contents, "vmware") { + system = "vmware" + role = "guest" + } + } + } + + filename = HostProc("cpuinfo") + if PathExists(filename) { + contents, err := ReadLines(filename) + if err == nil { + if StringsContains(contents, "QEMU Virtual CPU") || + StringsContains(contents, "Common KVM processor") || + StringsContains(contents, "Common 32-bit KVM processor") { + system = "kvm" + role = "guest" + } + } + } + + filename = HostProc("bus/pci/devices") + if PathExists(filename) { + contents, err := ReadLines(filename) + if err == nil { + if StringsContains(contents, "virtio-pci") { + role = "guest" + } + } + } + + filename = HostProc() + if PathExists(filepath.Join(filename, "bc", "0")) { + system = "openvz" + role = "host" + } else if PathExists(filepath.Join(filename, "vz")) { + system = "openvz" + role = "guest" + } + + // not use dmidecode because it requires root + if PathExists(filepath.Join(filename, "self", "status")) { + contents, err := ReadLines(filepath.Join(filename, "self", "status")) + if err == nil { + + if StringsContains(contents, "s_context:") || + StringsContains(contents, "VxID:") { + system = "linux-vserver" + } + // TODO: guest or host + } + } + + if PathExists(filepath.Join(filename, "self", "cgroup")) { + contents, err := ReadLines(filepath.Join(filename, "self", "cgroup")) + if err == nil { + if StringsContains(contents, "lxc") { + system = "lxc" + role = "guest" + } else if StringsContains(contents, "docker") { + system = "docker" + role = "guest" + } else if StringsContains(contents, "machine-rkt") { + system = "rkt" + role = "guest" + } else if PathExists("/usr/bin/lxc-version") { + system = "lxc" + role = "host" + } + } + } + + if PathExists(HostEtc("os-release")) { + p, _, err := GetOSRelease() + if err == nil && p == "coreos" { + system = "rkt" // Is it true? + role = "host" + } + } + return system, role, nil +} + +func GetOSRelease() (platform string, version string, err error) { + contents, err := ReadLines(HostEtc("os-release")) + if err != nil { + return "", "", nil // return empty + } + for _, line := range contents { + field := strings.Split(line, "=") + if len(field) < 2 { + continue + } + switch field[0] { + case "ID": // use ID for lowercase + platform = trimQuotes(field[1]) + case "VERSION": + version = trimQuotes(field[1]) + } + } + return platform, version, nil +} + +// Remove quotes of the source string +func trimQuotes(s string) string { + if len(s) >= 2 { + if s[0] == '"' && s[len(s)-1] == '"' { + return s[1 : len(s)-1] + } + } + return s } diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_openbsd.go b/vendor/github.com/shirou/gopsutil/internal/common/common_openbsd.go index 398f78542e99..ba73a7eb5072 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common_openbsd.go @@ -12,7 +12,7 @@ import ( ) func DoSysctrl(mib string) ([]string, error) { - sysctl, err := exec.LookPath("/sbin/sysctl") + sysctl, err := exec.LookPath("sysctl") if err != nil { return []string{}, err } diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_unix.go b/vendor/github.com/shirou/gopsutil/internal/common/common_unix.go index 750a5926d071..9e393bcfa8b8 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common_unix.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common_unix.go @@ -23,7 +23,7 @@ func CallLsofWithContext(ctx context.Context, invoke Invoker, pid int32, args .. } out, err := invoke.CommandWithContext(ctx, lsof, cmd...) if err != nil { - // if no pid found, lsof returnes code 1. + // if no pid found, lsof returns code 1. if err.Error() == "exit status 1" && len(out) == 0 { return []string{}, nil } diff --git a/vendor/github.com/shirou/gopsutil/internal/common/common_windows.go b/vendor/github.com/shirou/gopsutil/internal/common/common_windows.go index 0997c9b8abde..dbc8b675d72b 100644 --- a/vendor/github.com/shirou/gopsutil/internal/common/common_windows.go +++ b/vendor/github.com/shirou/gopsutil/internal/common/common_windows.go @@ -4,6 +4,9 @@ package common import ( "context" + "path/filepath" + "strings" + "syscall" "unsafe" "github.com/StackExchange/wmi" @@ -59,6 +62,8 @@ var ( PdhCollectQueryData = ModPdh.NewProc("PdhCollectQueryData") PdhGetFormattedCounterValue = ModPdh.NewProc("PdhGetFormattedCounterValue") PdhCloseQuery = ModPdh.NewProc("PdhCloseQuery") + + procQueryDosDeviceW = Modkernel32.NewProc("QueryDosDeviceW") ) type FILETIME struct { @@ -133,3 +138,23 @@ func WMIQueryWithContext(ctx context.Context, query string, dst interface{}, con return err } } + +// Convert paths using native DOS format like: +// "\Device\HarddiskVolume1\Windows\systemew\file.txt" +// into: +// "C:\Windows\systemew\file.txt" +func ConvertDOSPath(p string) string { + rawDrive := strings.Join(strings.Split(p, `\`)[:3], `\`) + + for d := 'A'; d <= 'Z'; d++ { + szDeviceName := string(d) + ":" + szTarget := make([]uint16, 512) + ret, _, _ := procQueryDosDeviceW.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(szDeviceName))), + uintptr(unsafe.Pointer(&szTarget[0])), + uintptr(len(szTarget))) + if ret != 0 && windows.UTF16ToString(szTarget[:]) == rawDrive { + return filepath.Join(szDeviceName, p[len(rawDrive):]) + } + } + return p +} diff --git a/vendor/github.com/shirou/gopsutil/mem/mem.go b/vendor/github.com/shirou/gopsutil/mem/mem.go index 995364fb94e3..8e444ba0ab7b 100644 --- a/vendor/github.com/shirou/gopsutil/mem/mem.go +++ b/vendor/github.com/shirou/gopsutil/mem/mem.go @@ -58,6 +58,7 @@ type VirtualMemoryStat struct { Shared uint64 `json:"shared"` Slab uint64 `json:"slab"` SReclaimable uint64 `json:"sreclaimable"` + SUnreclaim uint64 `json:"sunreclaim"` PageTables uint64 `json:"pagetables"` SwapCached uint64 `json:"swapcached"` CommitLimit uint64 `json:"commitlimit"` @@ -84,6 +85,9 @@ type SwapMemoryStat struct { UsedPercent float64 `json:"usedPercent"` Sin uint64 `json:"sin"` Sout uint64 `json:"sout"` + PgIn uint64 `json:"pgin"` + PgOut uint64 `json:"pgout"` + PgFault uint64 `json:"pgfault"` } func (m VirtualMemoryStat) String() string { diff --git a/vendor/github.com/shirou/gopsutil/mem/mem_darwin.go b/vendor/github.com/shirou/gopsutil/mem/mem_darwin.go index 4fe7009b3cb2..fac748151c73 100644 --- a/vendor/github.com/shirou/gopsutil/mem/mem_darwin.go +++ b/vendor/github.com/shirou/gopsutil/mem/mem_darwin.go @@ -5,10 +5,9 @@ package mem import ( "context" "encoding/binary" - "strconv" - "strings" + "fmt" + "unsafe" - "github.com/shirou/gopsutil/internal/common" "golang.org/x/sys/unix" ) @@ -27,46 +26,42 @@ func getHwMemsize() (uint64, error) { return total, nil } +// xsw_usage in sys/sysctl.h +type swapUsage struct { + Total uint64 + Avail uint64 + Used uint64 + Pagesize int32 + Encrypted bool +} + // SwapMemory returns swapinfo. func SwapMemory() (*SwapMemoryStat, error) { return SwapMemoryWithContext(context.Background()) } func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { + // https://github.com/yanllearnn/go-osstat/blob/ae8a279d26f52ec946a03698c7f50a26cfb427e3/memory/memory_darwin.go var ret *SwapMemoryStat - swapUsage, err := common.DoSysctrlWithContext(ctx, "vm.swapusage") + value, err := unix.SysctlRaw("vm.swapusage") if err != nil { return ret, err } - - total := strings.Replace(swapUsage[2], "M", "", 1) - used := strings.Replace(swapUsage[5], "M", "", 1) - free := strings.Replace(swapUsage[8], "M", "", 1) - - total_v, err := strconv.ParseFloat(total, 64) - if err != nil { - return nil, err - } - used_v, err := strconv.ParseFloat(used, 64) - if err != nil { - return nil, err - } - free_v, err := strconv.ParseFloat(free, 64) - if err != nil { - return nil, err + if len(value) != 32 { + return ret, fmt.Errorf("unexpected output of sysctl vm.swapusage: %v (len: %d)", value, len(value)) } + swap := (*swapUsage)(unsafe.Pointer(&value[0])) u := float64(0) - if total_v != 0 { - u = ((total_v - free_v) / total_v) * 100.0 + if swap.Total != 0 { + u = ((float64(swap.Total) - float64(swap.Avail)) / float64(swap.Total)) * 100.0 } - // vm.swapusage shows "M", multiply 1024 * 1024 to convert bytes. ret = &SwapMemoryStat{ - Total: uint64(total_v * 1024 * 1024), - Used: uint64(used_v * 1024 * 1024), - Free: uint64(free_v * 1024 * 1024), + Total: swap.Total, + Used: swap.Used, + Free: swap.Avail, UsedPercent: u, } diff --git a/vendor/github.com/shirou/gopsutil/mem/mem_freebsd.go b/vendor/github.com/shirou/gopsutil/mem/mem_freebsd.go index a792281a5abd..f91efc9e374d 100644 --- a/vendor/github.com/shirou/gopsutil/mem/mem_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/mem/mem_freebsd.go @@ -8,6 +8,8 @@ import ( "unsafe" "golang.org/x/sys/unix" + + "github.com/shirou/gopsutil/internal/common" ) func VirtualMemory() (*VirtualMemoryStat, error) { @@ -15,58 +17,59 @@ func VirtualMemory() (*VirtualMemoryStat, error) { } func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) { - pageSize, err := unix.SysctlUint32("vm.stats.vm.v_page_size") + pageSize, err := common.SysctlUint("vm.stats.vm.v_page_size") if err != nil { return nil, err } - physmem, err := unix.SysctlUint64("hw.physmem") + physmem, err := common.SysctlUint("hw.physmem") if err != nil { return nil, err } - free, err := unix.SysctlUint32("vm.stats.vm.v_free_count") + + free, err := common.SysctlUint("vm.stats.vm.v_free_count") if err != nil { return nil, err } - active, err := unix.SysctlUint32("vm.stats.vm.v_active_count") + active, err := common.SysctlUint("vm.stats.vm.v_active_count") if err != nil { return nil, err } - inactive, err := unix.SysctlUint32("vm.stats.vm.v_inactive_count") + inactive, err := common.SysctlUint("vm.stats.vm.v_inactive_count") if err != nil { return nil, err } - buffers, err := unix.SysctlUint64("vfs.bufspace") + buffers, err := common.SysctlUint("vfs.bufspace") if err != nil { return nil, err } - wired, err := unix.SysctlUint32("vm.stats.vm.v_wire_count") + wired, err := common.SysctlUint("vm.stats.vm.v_wire_count") if err != nil { return nil, err } - var cached, laundry uint32 - osreldate, _ := unix.SysctlUint32("kern.osreldate") + var cached, laundry uint64 + osreldate, _ := common.SysctlUint("kern.osreldate") if osreldate < 1102000 { - cached, err = unix.SysctlUint32("vm.stats.vm.v_cache_count") + cached, err = common.SysctlUint("vm.stats.vm.v_cache_count") if err != nil { return nil, err } } else { - laundry, err = unix.SysctlUint32("vm.stats.vm.v_laundry_count") + laundry, err = common.SysctlUint("vm.stats.vm.v_laundry_count") if err != nil { return nil, err } } - p := uint64(pageSize) + p := pageSize ret := &VirtualMemoryStat{ - Total: uint64(physmem), - Free: uint64(free) * p, - Active: uint64(active) * p, - Inactive: uint64(inactive) * p, - Cached: uint64(cached) * p, - Buffers: uint64(buffers), - Wired: uint64(wired) * p, - Laundry: uint64(laundry) * p, + Total: physmem, + Free: free * p, + Active: active * p, + Inactive: inactive * p, + Cached: cached * p, + Buffers: buffers, + Wired: wired * p, + Laundry: laundry * p, } ret.Available = ret.Inactive + ret.Cached + ret.Free + ret.Laundry @@ -84,11 +87,22 @@ func SwapMemory() (*SwapMemoryStat, error) { // Constants from vm/vm_param.h // nolint: golint const ( - XSWDEV_VERSION = 1 + XSWDEV_VERSION11 = 1 + XSWDEV_VERSION = 2 ) // Types from vm/vm_param.h type xswdev struct { + Version uint32 // Version is the version + Dev uint64 // Dev is the device identifier + Flags int32 // Flags is the swap flags applied to the device + NBlks int32 // NBlks is the total number of blocks + Used int32 // Used is the number of blocks used +} + +// xswdev11 is a compatibility for under FreeBSD 11 +// sys/vm/swap_pager.c +type xswdev11 struct { Version uint32 // Version is the version Dev uint32 // Dev is the device identifier Flags int32 // Flags is the swap flags applied to the device @@ -98,7 +112,7 @@ type xswdev struct { func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { // FreeBSD can have multiple swap devices so we total them up - i, err := unix.SysctlUint32("vm.nswapdev") + i, err := common.SysctlUint("vm.nswapdev") if err != nil { return nil, err } @@ -109,11 +123,11 @@ func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { c := int(i) - i, err = unix.SysctlUint32("vm.stats.vm.v_page_size") + i, err = common.SysctlUint("vm.stats.vm.v_page_size") if err != nil { return nil, err } - pageSize := uint64(i) + pageSize := i var buf []byte s := &SwapMemoryStat{} @@ -123,12 +137,23 @@ func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { return nil, err } + // first, try to parse with version 2 xsw := (*xswdev)(unsafe.Pointer(&buf[0])) - if xsw.Version != XSWDEV_VERSION { + if xsw.Version == XSWDEV_VERSION11 { + // this is version 1, so try to parse again + xsw := (*xswdev11)(unsafe.Pointer(&buf[0])) + if xsw.Version != XSWDEV_VERSION11 { + return nil, errors.New("xswdev version mismatch(11)") + } + s.Total += uint64(xsw.NBlks) + s.Used += uint64(xsw.Used) + } else if xsw.Version != XSWDEV_VERSION { return nil, errors.New("xswdev version mismatch") + } else { + s.Total += uint64(xsw.NBlks) + s.Used += uint64(xsw.Used) } - s.Total += uint64(xsw.NBlks) - s.Used += uint64(xsw.Used) + } if s.Total != 0 { diff --git a/vendor/github.com/shirou/gopsutil/mem/mem_linux.go b/vendor/github.com/shirou/gopsutil/mem/mem_linux.go index a3425d70550a..92cf143e207a 100644 --- a/vendor/github.com/shirou/gopsutil/mem/mem_linux.go +++ b/vendor/github.com/shirou/gopsutil/mem/mem_linux.go @@ -4,6 +4,8 @@ package mem import ( "context" + "math" + "os" "strconv" "strings" @@ -11,6 +13,11 @@ import ( "golang.org/x/sys/unix" ) +type VirtualMemoryExStat struct { + ActiveFile uint64 `json:"activefile"` + InactiveFile uint64 `json:"inactivefile"` +} + func VirtualMemory() (*VirtualMemoryStat, error) { return VirtualMemoryWithContext(context.Background()) } @@ -18,10 +25,16 @@ func VirtualMemory() (*VirtualMemoryStat, error) { func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) { filename := common.HostProc("meminfo") lines, _ := common.ReadLines(filename) + // flag if MemAvailable is in /proc/meminfo (kernel 3.14+) memavail := false + activeFile := false // "Active(file)" not available: 2.6.28 / Dec 2008 + inactiveFile := false // "Inactive(file)" not available: 2.6.28 / Dec 2008 + sReclaimable := false // "SReclaimable:" not available: 2.6.19 / Nov 2006 ret := &VirtualMemoryStat{} + retEx := &VirtualMemoryExStat{} + for _, line := range lines { fields := strings.Split(line, ":") if len(fields) != 2 { @@ -51,6 +64,12 @@ func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) { ret.Active = t * 1024 case "Inactive": ret.Inactive = t * 1024 + case "Active(file)": + activeFile = true + retEx.ActiveFile = t * 1024 + case "InActive(file)": + inactiveFile = true + retEx.InactiveFile = t * 1024 case "Writeback": ret.Writeback = t * 1024 case "WritebackTmp": @@ -62,7 +81,10 @@ func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) { case "Slab": ret.Slab = t * 1024 case "SReclaimable": + sReclaimable = true ret.SReclaimable = t * 1024 + case "SUnreclaim": + ret.SUnreclaim = t * 1024 case "PageTables": ret.PageTables = t * 1024 case "SwapCached": @@ -103,8 +125,13 @@ func VirtualMemoryWithContext(ctx context.Context) (*VirtualMemoryStat, error) { ret.Cached += ret.SReclaimable if !memavail { - ret.Available = ret.Free + ret.Buffers + ret.Cached + if activeFile && inactiveFile && sReclaimable { + ret.Available = calcuateAvailVmem(ret, retEx) + } else { + ret.Available = ret.Cached + ret.Free + } } + ret.Used = ret.Total - ret.Free - ret.Buffers - ret.Cached ret.UsedPercent = float64(ret.Used) / float64(ret.Total) * 100.0 @@ -152,7 +179,69 @@ func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { continue } ret.Sout = value * 4 * 1024 + case "pgpgin": + value, err := strconv.ParseUint(fields[1], 10, 64) + if err != nil { + continue + } + ret.PgIn = value * 4 * 1024 + case "pgpgout": + value, err := strconv.ParseUint(fields[1], 10, 64) + if err != nil { + continue + } + ret.PgOut = value * 4 * 1024 + case "pgfault": + value, err := strconv.ParseUint(fields[1], 10, 64) + if err != nil { + continue + } + ret.PgFault = value * 4 * 1024 } } return ret, nil } + +// calcuateAvailVmem is a fallback under kernel 3.14 where /proc/meminfo does not provide +// "MemAvailable:" column. It reimplements an algorithm from the link below +// https://github.com/giampaolo/psutil/pull/890 +func calcuateAvailVmem(ret *VirtualMemoryStat, retEx *VirtualMemoryExStat) uint64 { + var watermarkLow uint64 + + fn := common.HostProc("zoneinfo") + lines, err := common.ReadLines(fn) + + if err != nil { + return ret.Free + ret.Cached // fallback under kernel 2.6.13 + } + + pagesize := uint64(os.Getpagesize()) + watermarkLow = 0 + + for _, line := range lines { + fields := strings.Fields(line) + + if strings.HasPrefix(fields[0], "low") { + lowValue, err := strconv.ParseUint(fields[1], 10, 64) + + if err != nil { + lowValue = 0 + } + watermarkLow += lowValue + } + } + + watermarkLow *= pagesize + + availMemory := ret.Free - watermarkLow + pageCache := retEx.ActiveFile + retEx.InactiveFile + pageCache -= uint64(math.Min(float64(pageCache/2), float64(watermarkLow))) + availMemory += pageCache + availMemory += ret.SReclaimable - uint64(math.Min(float64(ret.SReclaimable/2.0), float64(watermarkLow))) + + if availMemory < 0 { + availMemory = 0 + } + + return availMemory +} diff --git a/vendor/github.com/shirou/gopsutil/mem/mem_solaris.go b/vendor/github.com/shirou/gopsutil/mem/mem_solaris.go index 0736bc41c8b9..08512733c98c 100644 --- a/vendor/github.com/shirou/gopsutil/mem/mem_solaris.go +++ b/vendor/github.com/shirou/gopsutil/mem/mem_solaris.go @@ -52,7 +52,7 @@ func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) { } func zoneName() (string, error) { - zonename, err := exec.LookPath("/usr/bin/zonename") + zonename, err := exec.LookPath("zonename") if err != nil { return "", err } @@ -69,7 +69,7 @@ func zoneName() (string, error) { var globalZoneMemoryCapacityMatch = regexp.MustCompile(`memory size: ([\d]+) Megabytes`) func globalZoneMemoryCapacity() (uint64, error) { - prtconf, err := exec.LookPath("/usr/sbin/prtconf") + prtconf, err := exec.LookPath("prtconf") if err != nil { return 0, err } @@ -96,7 +96,7 @@ func globalZoneMemoryCapacity() (uint64, error) { var kstatMatch = regexp.MustCompile(`([^\s]+)[\s]+([^\s]*)`) func nonGlobalZoneMemoryCapacity() (uint64, error) { - kstat, err := exec.LookPath("/usr/bin/kstat") + kstat, err := exec.LookPath("kstat") if err != nil { return 0, err } diff --git a/vendor/github.com/shirou/gopsutil/net/net.go b/vendor/github.com/shirou/gopsutil/net/net.go index fce86c711a4d..c9a4bafebac9 100644 --- a/vendor/github.com/shirou/gopsutil/net/net.go +++ b/vendor/github.com/shirou/gopsutil/net/net.go @@ -58,6 +58,7 @@ type InterfaceAddr struct { } type InterfaceStat struct { + Index int `json:"index"` MTU int `json:"mtu"` // maximum transmission unit Name string `json:"name"` // e.g., "en0", "lo0", "eth0.100" HardwareAddr string `json:"hardwareaddr"` // IEEE MAC-48, EUI-48 and EUI-64 form @@ -70,6 +71,96 @@ type FilterStat struct { ConnTrackMax int64 `json:"conntrackMax"` } +// ConntrackStat has conntrack summary info +type ConntrackStat struct { + Entries uint32 `json:"entries"` // Number of entries in the conntrack table + Searched uint32 `json:"searched"` // Number of conntrack table lookups performed + Found uint32 `json:"found"` // Number of searched entries which were successful + New uint32 `json:"new"` // Number of entries added which were not expected before + Invalid uint32 `json:"invalid"` // Number of packets seen which can not be tracked + Ignore uint32 `json:"ignore"` // Packets seen which are already connected to an entry + Delete uint32 `json:"delete"` // Number of entries which were removed + DeleteList uint32 `json:"delete_list"` // Number of entries which were put to dying list + Insert uint32 `json:"insert"` // Number of entries inserted into the list + InsertFailed uint32 `json:"insert_failed"` // # insertion attempted but failed (same entry exists) + Drop uint32 `json:"drop"` // Number of packets dropped due to conntrack failure. + EarlyDrop uint32 `json:"early_drop"` // Dropped entries to make room for new ones, if maxsize reached + IcmpError uint32 `json:"icmp_error"` // Subset of invalid. Packets that can't be tracked d/t error + ExpectNew uint32 `json:"expect_new"` // Entries added after an expectation was already present + ExpectCreate uint32 `json:"expect_create"` // Expectations added + ExpectDelete uint32 `json:"expect_delete"` // Expectations deleted + SearchRestart uint32 `json:"search_restart"` // Conntrack table lookups restarted due to hashtable resizes +} + +func NewConntrackStat(e uint32, s uint32, f uint32, n uint32, inv uint32, ign uint32, del uint32, dlst uint32, ins uint32, insfail uint32, drop uint32, edrop uint32, ie uint32, en uint32, ec uint32, ed uint32, sr uint32) *ConntrackStat { + return &ConntrackStat{ + Entries: e, + Searched: s, + Found: f, + New: n, + Invalid: inv, + Ignore: ign, + Delete: del, + DeleteList: dlst, + Insert: ins, + InsertFailed: insfail, + Drop: drop, + EarlyDrop: edrop, + IcmpError: ie, + ExpectNew: en, + ExpectCreate: ec, + ExpectDelete: ed, + SearchRestart: sr, + } +} + +type ConntrackStatList struct { + items []*ConntrackStat +} + +func NewConntrackStatList() *ConntrackStatList { + return &ConntrackStatList{ + items: []*ConntrackStat{}, + } +} + +func (l *ConntrackStatList) Append(c *ConntrackStat) { + l.items = append(l.items, c) +} + +func (l *ConntrackStatList) Items() []ConntrackStat { + items := make([]ConntrackStat, len(l.items), len(l.items)) + for i, el := range l.items { + items[i] = *el + } + return items +} + +// Summary returns a single-element list with totals from all list items. +func (l *ConntrackStatList) Summary() []ConntrackStat { + summary := NewConntrackStat(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + for _, cs := range l.items { + summary.Entries += cs.Entries + summary.Searched += cs.Searched + summary.Found += cs.Found + summary.New += cs.New + summary.Invalid += cs.Invalid + summary.Ignore += cs.Ignore + summary.Delete += cs.Delete + summary.DeleteList += cs.DeleteList + summary.Insert += cs.Insert + summary.InsertFailed += cs.InsertFailed + summary.Drop += cs.Drop + summary.EarlyDrop += cs.EarlyDrop + summary.IcmpError += cs.IcmpError + summary.ExpectNew += cs.ExpectNew + summary.ExpectCreate += cs.ExpectCreate + summary.ExpectDelete += cs.ExpectDelete + summary.SearchRestart += cs.SearchRestart + } + return []ConntrackStat{*summary} +} + var constMap = map[string]int{ "unix": syscall.AF_UNIX, "TCP": syscall.SOCK_STREAM, @@ -108,6 +199,11 @@ func (n InterfaceAddr) String() string { return string(s) } +func (n ConntrackStat) String() string { + s, _ := json.Marshal(n) + return string(s) +} + func Interfaces() ([]InterfaceStat, error) { return InterfacesWithContext(context.Background()) } @@ -138,6 +234,7 @@ func InterfacesWithContext(ctx context.Context) ([]InterfaceStat, error) { } r := InterfaceStat{ + Index: ifi.Index, Name: ifi.Name, MTU: ifi.MTU, HardwareAddr: ifi.HardwareAddr.String(), diff --git a/vendor/github.com/shirou/gopsutil/net/net_darwin.go b/vendor/github.com/shirou/gopsutil/net/net_darwin.go index 0d89280f98ff..1daed86982ea 100644 --- a/vendor/github.com/shirou/gopsutil/net/net_darwin.go +++ b/vendor/github.com/shirou/gopsutil/net/net_darwin.go @@ -6,6 +6,7 @@ import ( "context" "errors" "fmt" + "github.com/shirou/gopsutil/internal/common" "os/exec" "regexp" "strconv" @@ -42,7 +43,7 @@ func parseNetstatLine(line string) (stat *IOCountersStat, linkID *uint, err erro base := 1 numberColumns := len(columns) - // sometimes Address is ommitted + // sometimes Address is omitted if numberColumns < 12 { base = 0 } @@ -174,7 +175,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, retIndex int ) - netstat, err := exec.LookPath("/usr/sbin/netstat") + netstat, err := exec.LookPath("netstat") if err != nil { return nil, err } @@ -204,7 +205,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, } } else { // duplicated interface, list all interfaces - ifconfig, err := exec.LookPath("/sbin/ifconfig") + ifconfig, err := exec.LookPath("ifconfig") if err != nil { return nil, err } @@ -271,6 +272,14 @@ func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for darwin") } +func ConntrackStats(percpu bool) ([]ConntrackStat, error) { + return ConntrackStatsWithContext(context.Background(), percpu) +} + +func ConntrackStatsWithContext(ctx context.Context, percpu bool) ([]ConntrackStat, error) { + return nil, common.ErrNotImplementedError +} + // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. diff --git a/vendor/github.com/shirou/gopsutil/net/net_fallback.go b/vendor/github.com/shirou/gopsutil/net/net_fallback.go index 7c5e632f870c..0991347dd62a 100644 --- a/vendor/github.com/shirou/gopsutil/net/net_fallback.go +++ b/vendor/github.com/shirou/gopsutil/net/net_fallback.go @@ -24,6 +24,14 @@ func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) { return []FilterStat{}, common.ErrNotImplementedError } +func ConntrackStats(percpu bool) ([]ConntrackStat, error) { + return ConntrackStatsWithContext(context.Background(), percpu) +} + +func ConntrackStatsWithContext(ctx context.Context, percpu bool) ([]ConntrackStat, error) { + return nil, common.ErrNotImplementedError +} + func ProtoCounters(protocols []string) ([]ProtoCountersStat, error) { return ProtoCountersWithContext(context.Background(), protocols) } diff --git a/vendor/github.com/shirou/gopsutil/net/net_freebsd.go b/vendor/github.com/shirou/gopsutil/net/net_freebsd.go index ce0241576fed..2284d982c821 100644 --- a/vendor/github.com/shirou/gopsutil/net/net_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/net/net_freebsd.go @@ -17,7 +17,7 @@ func IOCounters(pernic bool) ([]IOCountersStat, error) { } func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, error) { - netstat, err := exec.LookPath("/usr/bin/netstat") + netstat, err := exec.LookPath("netstat") if err != nil { return nil, err } @@ -45,7 +45,7 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, continue } base := 1 - // sometimes Address is ommitted + // sometimes Address is omitted if len(values) < 13 { base = 0 } @@ -112,6 +112,14 @@ func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for freebsd") } +func ConntrackStats(percpu bool) ([]ConntrackStat, error) { + return ConntrackStatsWithContext(context.Background(), percpu) +} + +func ConntrackStatsWithContext(ctx context.Context, percpu bool) ([]ConntrackStat, error) { + return nil, errors.New("ConntrackStats not implemented for freebsd") +} + // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. diff --git a/vendor/github.com/shirou/gopsutil/net/net_linux.go b/vendor/github.com/shirou/gopsutil/net/net_linux.go index 71842fb4a2a0..c8d70ed601e4 100644 --- a/vendor/github.com/shirou/gopsutil/net/net_linux.go +++ b/vendor/github.com/shirou/gopsutil/net/net_linux.go @@ -8,6 +8,7 @@ import ( "encoding/hex" "errors" "fmt" + "io" "io/ioutil" "net" "os" @@ -18,6 +19,26 @@ import ( "github.com/shirou/gopsutil/internal/common" ) +const ( // Conntrack Column numbers + CT_ENTRIES = iota + CT_SEARCHED + CT_FOUND + CT_NEW + CT_INVALID + CT_IGNORE + CT_DELETE + CT_DELETE_LIST + CT_INSERT + CT_INSERT_FAILED + CT_DROP + CT_EARLY_DROP + CT_ICMP_ERROR + CT_EXPECT_NEW + CT_EXPECT_CREATE + CT_EXPECT_DELETE + CT_SEARCH_RESTART +) + // NetIOCounters returnes network I/O statistics for every network // interface installed on the system. If pernic argument is false, // return only sum of all information (which name is 'all'). If true, @@ -232,6 +253,58 @@ func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) { return stats, nil } +// ConntrackStats returns more detailed info about the conntrack table +func ConntrackStats(percpu bool) ([]ConntrackStat, error) { + return ConntrackStatsWithContext(context.Background(), percpu) +} + +// ConntrackStatsWithContext returns more detailed info about the conntrack table +func ConntrackStatsWithContext(ctx context.Context, percpu bool) ([]ConntrackStat, error) { + return conntrackStatsFromFile(common.HostProc("net/stat/nf_conntrack"), percpu) +} + +// conntrackStatsFromFile returns more detailed info about the conntrack table +// from `filename` +// If 'percpu' is false, the result will contain exactly one item with totals/summary +func conntrackStatsFromFile(filename string, percpu bool) ([]ConntrackStat, error) { + lines, err := common.ReadLines(filename) + if err != nil { + return nil, err + } + + statlist := NewConntrackStatList() + + for _, line := range lines { + fields := strings.Fields(line) + if len(fields) == 17 && fields[0] != "entries" { + statlist.Append(NewConntrackStat( + common.HexToUint32(fields[CT_ENTRIES]), + common.HexToUint32(fields[CT_SEARCHED]), + common.HexToUint32(fields[CT_FOUND]), + common.HexToUint32(fields[CT_NEW]), + common.HexToUint32(fields[CT_INVALID]), + common.HexToUint32(fields[CT_IGNORE]), + common.HexToUint32(fields[CT_DELETE]), + common.HexToUint32(fields[CT_DELETE_LIST]), + common.HexToUint32(fields[CT_INSERT]), + common.HexToUint32(fields[CT_INSERT_FAILED]), + common.HexToUint32(fields[CT_DROP]), + common.HexToUint32(fields[CT_EARLY_DROP]), + common.HexToUint32(fields[CT_ICMP_ERROR]), + common.HexToUint32(fields[CT_EXPECT_NEW]), + common.HexToUint32(fields[CT_EXPECT_CREATE]), + common.HexToUint32(fields[CT_EXPECT_DELETE]), + common.HexToUint32(fields[CT_SEARCH_RESTART]), + )) + } + } + + if percpu { + return statlist.Items(), nil + } + return statlist.Summary(), nil +} + // http://students.mimuw.edu.pl/lxr/source/include/net/tcp_states.h var TCPStatuses = map[string]string{ "01": "ESTABLISHED", @@ -581,7 +654,7 @@ func getProcInodesAll(root string, max int) (map[string][]inodeMap, error) { t, err := getProcInodes(root, pid, max) if err != nil { // skip if permission error or no longer exists - if os.IsPermission(err) || os.IsNotExist(err) { + if os.IsPermission(err) || os.IsNotExist(err) || err == io.EOF { continue } return ret, err diff --git a/vendor/github.com/shirou/gopsutil/net/net_openbsd.go b/vendor/github.com/shirou/gopsutil/net/net_openbsd.go index 3e74e8f3addf..3cf0a89d4791 100644 --- a/vendor/github.com/shirou/gopsutil/net/net_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/net/net_openbsd.go @@ -41,7 +41,7 @@ func ParseNetstat(output string, mode string, continue } base := 1 - // sometimes Address is ommitted + // sometimes Address is omitted if len(values) < columns { base = 0 } @@ -156,6 +156,14 @@ func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for openbsd") } +func ConntrackStats(percpu bool) ([]ConntrackStat, error) { + return ConntrackStatsWithContext(context.Background(), percpu) +} + +func ConntrackStatsWithContext(ctx context.Context, percpu bool) ([]ConntrackStat, error) { + return nil, common.ErrNotImplementedError +} + // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. diff --git a/vendor/github.com/shirou/gopsutil/net/net_windows.go b/vendor/github.com/shirou/gopsutil/net/net_windows.go index 61eb6ec20cbb..d40e4163426e 100644 --- a/vendor/github.com/shirou/gopsutil/net/net_windows.go +++ b/vendor/github.com/shirou/gopsutil/net/net_windows.go @@ -19,6 +19,7 @@ var ( modiphlpapi = windows.NewLazySystemDLL("iphlpapi.dll") procGetExtendedTCPTable = modiphlpapi.NewProc("GetExtendedTcpTable") procGetExtendedUDPTable = modiphlpapi.NewProc("GetExtendedUdpTable") + procGetIfEntry2 = modiphlpapi.NewProc("GetIfEntry2") ) const ( @@ -73,6 +74,65 @@ var netConnectionKindMap = map[string][]netConnectionKindType{ "inet6": {kindTCP6, kindUDP6}, } +// https://github.com/microsoft/ethr/blob/aecdaf923970e5a9b4c461b4e2e3963d781ad2cc/plt_windows.go#L114-L170 +type guid struct { + Data1 uint32 + Data2 uint16 + Data3 uint16 + Data4 [8]byte +} + +const ( + maxStringSize = 256 + maxPhysAddressLength = 32 + pad0for64_4for32 = 0 +) + +type mibIfRow2 struct { + InterfaceLuid uint64 + InterfaceIndex uint32 + InterfaceGuid guid + Alias [maxStringSize + 1]uint16 + Description [maxStringSize + 1]uint16 + PhysicalAddressLength uint32 + PhysicalAddress [maxPhysAddressLength]uint8 + PermanentPhysicalAddress [maxPhysAddressLength]uint8 + Mtu uint32 + Type uint32 + TunnelType uint32 + MediaType uint32 + PhysicalMediumType uint32 + AccessType uint32 + DirectionType uint32 + InterfaceAndOperStatusFlags uint32 + OperStatus uint32 + AdminStatus uint32 + MediaConnectState uint32 + NetworkGuid guid + ConnectionType uint32 + padding1 [pad0for64_4for32]byte + TransmitLinkSpeed uint64 + ReceiveLinkSpeed uint64 + InOctets uint64 + InUcastPkts uint64 + InNUcastPkts uint64 + InDiscards uint64 + InErrors uint64 + InUnknownProtos uint64 + InUcastOctets uint64 + InMulticastOctets uint64 + InBroadcastOctets uint64 + OutOctets uint64 + OutUcastPkts uint64 + OutNUcastPkts uint64 + OutDiscards uint64 + OutErrors uint64 + OutUcastOctets uint64 + OutMulticastOctets uint64 + OutBroadcastOctets uint64 + OutQLen uint64 +} + func IOCounters(pernic bool) ([]IOCountersStat, error) { return IOCountersWithContext(context.Background(), pernic) } @@ -82,34 +142,59 @@ func IOCountersWithContext(ctx context.Context, pernic bool) ([]IOCountersStat, if err != nil { return nil, err } - var ret []IOCountersStat + var counters []IOCountersStat + + err = procGetIfEntry2.Find() + if err == nil { // Vista+, uint64 values (issue#693) + for _, ifi := range ifs { + c := IOCountersStat{ + Name: ifi.Name, + } - for _, ifi := range ifs { - c := IOCountersStat{ - Name: ifi.Name, + row := mibIfRow2{InterfaceIndex: uint32(ifi.Index)} + ret, _, err := procGetIfEntry2.Call(uintptr(unsafe.Pointer(&row))) + if ret != 0 { + return nil, os.NewSyscallError("GetIfEntry2", err) + } + c.BytesSent = uint64(row.OutOctets) + c.BytesRecv = uint64(row.InOctets) + c.PacketsSent = uint64(row.OutUcastPkts) + c.PacketsRecv = uint64(row.InUcastPkts) + c.Errin = uint64(row.InErrors) + c.Errout = uint64(row.OutErrors) + c.Dropin = uint64(row.InDiscards) + c.Dropout = uint64(row.OutDiscards) + + counters = append(counters, c) } + } else { // WinXP fallback, uint32 values + for _, ifi := range ifs { + c := IOCountersStat{ + Name: ifi.Name, + } - row := windows.MibIfRow{Index: uint32(ifi.Index)} - e := windows.GetIfEntry(&row) - if e != nil { - return nil, os.NewSyscallError("GetIfEntry", e) + row := windows.MibIfRow{Index: uint32(ifi.Index)} + err = windows.GetIfEntry(&row) + if err != nil { + return nil, os.NewSyscallError("GetIfEntry", err) + } + c.BytesSent = uint64(row.OutOctets) + c.BytesRecv = uint64(row.InOctets) + c.PacketsSent = uint64(row.OutUcastPkts) + c.PacketsRecv = uint64(row.InUcastPkts) + c.Errin = uint64(row.InErrors) + c.Errout = uint64(row.OutErrors) + c.Dropin = uint64(row.InDiscards) + c.Dropout = uint64(row.OutDiscards) + + counters = append(counters, c) } - c.BytesSent = uint64(row.OutOctets) - c.BytesRecv = uint64(row.InOctets) - c.PacketsSent = uint64(row.OutUcastPkts) - c.PacketsRecv = uint64(row.InUcastPkts) - c.Errin = uint64(row.InErrors) - c.Errout = uint64(row.OutErrors) - c.Dropin = uint64(row.InDiscards) - c.Dropout = uint64(row.OutDiscards) - - ret = append(ret, c) } - if pernic == false { - return getIOCountersAll(ret) + if !pernic { + return getIOCountersAll(counters) } - return ret, nil + return counters, nil } // NetIOCountersByFile is an method which is added just a compatibility for linux. @@ -206,6 +291,15 @@ func FilterCountersWithContext(ctx context.Context) ([]FilterStat, error) { return nil, errors.New("NetFilterCounters not implemented for windows") } +func ConntrackStats(percpu bool) ([]ConntrackStat, error) { + return ConntrackStatsWithContext(context.Background(), percpu) +} + +func ConntrackStatsWithContext(ctx context.Context, percpu bool) ([]ConntrackStat, error) { + return nil, common.ErrNotImplementedError +} + + // NetProtoCounters returns network statistics for the entire system // If protocols is empty then all protocols are returned, otherwise // just the protocols in the list are returned. diff --git a/vendor/github.com/shirou/gopsutil/process/process.go b/vendor/github.com/shirou/gopsutil/process/process.go index 036ad917da28..c674b3d4e5b5 100644 --- a/vendor/github.com/shirou/gopsutil/process/process.go +++ b/vendor/github.com/shirou/gopsutil/process/process.go @@ -4,7 +4,9 @@ import ( "context" "encoding/json" "errors" + "math" "runtime" + "sort" "time" "github.com/shirou/gopsutil/cpu" @@ -13,8 +15,9 @@ import ( ) var ( - invoke common.Invoker = common.Invoke{} - ErrorNoChildren = errors.New("process does not have children") + invoke common.Invoker = common.Invoke{} + ErrorNoChildren = errors.New("process does not have children") + ErrorProcessNotRunning = errors.New("process does not exist") ) type Process struct { @@ -43,6 +46,7 @@ type OpenFilesStat struct { type MemoryInfoStat struct { RSS uint64 `json:"rss"` // bytes VMS uint64 `json:"vms"` // bytes + HWM uint64 `json:"hwm"` // bytes Data uint64 `json:"data"` // bytes Stack uint64 `json:"stack"` // bytes Locked uint64 `json:"locked"` // bytes @@ -76,6 +80,13 @@ type NumCtxSwitchesStat struct { Involuntary int64 `json:"involuntary"` } +type PageFaultsStat struct { + MinorFaults uint64 `json:"minorFaults"` + MajorFaults uint64 `json:"majorFaults"` + ChildMinorFaults uint64 `json:"childMinorFaults"` + ChildMajorFaults uint64 `json:"childMajorFaults"` +} + // Resource limit constants are from /usr/include/x86_64-linux-gnu/bits/resource.h // from libc6-dev package in Ubuntu 16.10 const ( @@ -127,23 +138,36 @@ func (p NumCtxSwitchesStat) String() string { return string(s) } -func PidExists(pid int32) (bool, error) { - return PidExistsWithContext(context.Background(), pid) +// Pids returns a slice of process ID list which are running now. +func Pids() ([]int32, error) { + return PidsWithContext(context.Background()) } -func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) { - pids, err := Pids() +func PidsWithContext(ctx context.Context) ([]int32, error) { + pids, err := pidsWithContext(ctx) + sort.Slice(pids, func(i, j int) bool { return pids[i] < pids[j] }) + return pids, err +} + +// NewProcess creates a new Process instance, it only stores the pid and +// checks that the process exists. Other method on Process can be used +// to get more information about the process. An error will be returned +// if the process does not exist. +func NewProcess(pid int32) (*Process, error) { + p := &Process{Pid: pid} + + exists, err := PidExists(pid) if err != nil { - return false, err + return p, err } - - for _, i := range pids { - if i == pid { - return true, err - } + if !exists { + return p, ErrorProcessNotRunning } + return p, nil +} - return false, err +func PidExists(pid int32) (bool, error) { + return PidExistsWithContext(context.Background(), pid) } // Background returns true if the process is in background, false otherwise. @@ -204,7 +228,7 @@ func calculatePercent(t1, t2 *cpu.TimesStat, delta float64, numcpu int) float64 } delta_proc := t2.Total() - t1.Total() overall_percent := ((delta_proc / delta) * 100) * float64(numcpu) - return overall_percent + return math.Min(100, math.Max(0, overall_percent)) } // MemoryPercent returns how many percent of the total RAM this process uses @@ -225,7 +249,7 @@ func (p *Process) MemoryPercentWithContext(ctx context.Context) (float32, error) } used := processMemory.RSS - return (100 * float32(used) / float32(total)), nil + return float32(math.Min(100, math.Max(0, (100*float64(used)/float64(total))))), nil } // CPU_Percent returns how many percent of the CPU time this process uses @@ -250,5 +274,5 @@ func (p *Process) CPUPercentWithContext(ctx context.Context) (float64, error) { return 0, nil } - return 100 * cput.Total() / totalTime, nil + return math.Min(100, math.Max(0, 100*cput.Total()/totalTime)), nil } diff --git a/vendor/github.com/shirou/gopsutil/process/process_darwin.go b/vendor/github.com/shirou/gopsutil/process/process_darwin.go index ca0f18763e0a..98a556686e8e 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_darwin.go +++ b/vendor/github.com/shirou/gopsutil/process/process_darwin.go @@ -44,11 +44,7 @@ type MemoryInfoExStat struct { type MemoryMapsStat struct { } -func Pids() ([]int32, error) { - return PidsWithContext(context.Background()) -} - -func PidsWithContext(ctx context.Context) ([]int32, error) { +func pidsWithContext(ctx context.Context) ([]int32, error) { var ret []int32 pids, err := callPsWithContext(ctx, "pid", 0, false) @@ -108,30 +104,21 @@ func (p *Process) ExeWithContext(ctx context.Context) (string, error) { if err != nil { return "", err } - - awk_bin, err := exec.LookPath("awk") - if err != nil { - return "", err - } - - sed_bin, err := exec.LookPath("sed") + out, err := invoke.CommandWithContext(ctx, lsof_bin, "-p", strconv.Itoa(int(p.Pid)), "-Fpfn") if err != nil { - return "", err + return "", fmt.Errorf("bad call to lsof: %s", err) } - - lsof := exec.CommandContext(ctx, lsof_bin, "-p", strconv.Itoa(int(p.Pid)), "-Fpfn") - awk := exec.CommandContext(ctx, awk_bin, "NR==5{print}") - sed := exec.CommandContext(ctx, sed_bin, "s/n\\//\\//") - - output, _, err := common.Pipeline(lsof, awk, sed) - - if err != nil { - return "", err + txtFound := 0 + lines := strings.Split(string(out), "\n") + for i := 1; i < len(lines); i += 2 { + if lines[i] == "ftxt" { + txtFound++ + if txtFound == 2 { + return lines[i-1][1:], nil + } + } } - - ret := strings.TrimSpace(string(output)) - - return ret, nil + return "", fmt.Errorf("missing txt data returned by lsof") } // Cmdline returns the command line arguments of the process as a string with @@ -389,12 +376,32 @@ func convertCPUTimes(s string) (ret float64, err error) { var _tmp string if strings.Contains(s, ":") { _t := strings.Split(s, ":") - hour, err := strconv.Atoi(_t[0]) - if err != nil { - return ret, err + switch len(_t) { + case 3: + hour, err := strconv.Atoi(_t[0]) + if err != nil { + return ret, err + } + t += hour * 60 * 60 * ClockTicks + + mins, err := strconv.Atoi(_t[1]) + if err != nil { + return ret, err + } + t += mins * 60 * ClockTicks + _tmp = _t[2] + case 2: + mins, err := strconv.Atoi(_t[0]) + if err != nil { + return ret, err + } + t += mins * 60 * ClockTicks + _tmp = _t[1] + case 1, 0: + _tmp = s + default: + return ret, fmt.Errorf("wrong cpu time string") } - t += hour * 60 * 100 - _tmp = _t[1] } else { _tmp = s } @@ -404,7 +411,7 @@ func convertCPUTimes(s string) (ret float64, err error) { return ret, err } h, err := strconv.Atoi(_t[0]) - t += h * 100 + t += h * ClockTicks h, err = strconv.Atoi(_t[1]) t += h return float64(t) / ClockTicks, nil @@ -481,6 +488,14 @@ func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExSta return nil, common.ErrNotImplementedError } +func (p *Process) PageFaults() (*PageFaultsStat, error) { + return p.PageFaultsWithContext(context.Background()) +} + +func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error) { + return nil, common.ErrNotImplementedError +} + func (p *Process) Children() ([]*Process, error) { return p.ChildrenWithContext(context.Background()) } @@ -517,6 +532,15 @@ func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionS return net.ConnectionsPid("all", p.Pid) } +// Connections returns a slice of net.ConnectionStat used by the process at most `max` +func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error) { + return p.ConnectionsMaxWithContext(context.Background(), max) +} + +func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error) { + return net.ConnectionsPidMax("all", p.Pid, max) +} + func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) { return p.NetIOCountersWithContext(context.Background(), pernic) } @@ -606,12 +630,6 @@ func (p *Process) getKProcWithContext(ctx context.Context) (*KinfoProc, error) { return &k, nil } -func NewProcess(pid int32) (*Process, error) { - p := &Process{Pid: pid} - - return p, nil -} - // call ps command. // Return value deletes Header line(you must not input wrong arg). // And splited by Space. Caller have responsibility to manage. diff --git a/vendor/github.com/shirou/gopsutil/process/process_fallback.go b/vendor/github.com/shirou/gopsutil/process/process_fallback.go index 8772440df43d..3201efd10410 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_fallback.go +++ b/vendor/github.com/shirou/gopsutil/process/process_fallback.go @@ -28,11 +28,7 @@ type MemoryMapsStat struct { type MemoryInfoExStat struct { } -func Pids() ([]int32, error) { - return PidsWithContext(context.Background()) -} - -func PidsWithContext(ctx context.Context) ([]int32, error) { +func pidsWithContext(ctx context.Context) ([]int32, error) { return []int32{}, common.ErrNotImplementedError } @@ -44,8 +40,19 @@ func ProcessesWithContext(ctx context.Context) ([]*Process, error) { return nil, common.ErrNotImplementedError } -func NewProcess(pid int32) (*Process, error) { - return nil, common.ErrNotImplementedError +func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) { + pids, err := PidsWithContext(ctx) + if err != nil { + return false, err + } + + for _, i := range pids { + if i == pid { + return true, err + } + } + + return false, err } func (p *Process) Ppid() (int32, error) { @@ -233,6 +240,12 @@ func (p *Process) MemoryInfoEx() (*MemoryInfoExStat, error) { func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExStat, error) { return nil, common.ErrNotImplementedError } +func (p *Process) PageFaults() (*PageFaultsStat, error) { + return p.PageFaultsWithContext(context.Background()) +} +func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error) { + return nil, common.ErrNotImplementedError +} func (p *Process) Children() ([]*Process, error) { return p.ChildrenWithContext(context.Background()) } @@ -254,6 +267,15 @@ func (p *Process) Connections() ([]net.ConnectionStat, error) { func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionStat, error) { return []net.ConnectionStat{}, common.ErrNotImplementedError } + +func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error) { + return p.ConnectionsMaxWithContext(context.Background(), max) +} + +func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error) { + return []net.ConnectionStat{}, common.ErrNotImplementedError +} + func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) { return p.NetIOCountersWithContext(context.Background(), pernic) } diff --git a/vendor/github.com/shirou/gopsutil/process/process_freebsd.go b/vendor/github.com/shirou/gopsutil/process/process_freebsd.go index fd98a8ca6dff..0d4bbfc1d9cc 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_freebsd.go +++ b/vendor/github.com/shirou/gopsutil/process/process_freebsd.go @@ -23,11 +23,7 @@ type MemoryInfoExStat struct { type MemoryMapsStat struct { } -func Pids() ([]int32, error) { - return PidsWithContext(context.Background()) -} - -func PidsWithContext(ctx context.Context) ([]int32, error) { +func pidsWithContext(ctx context.Context) ([]int32, error) { var ret []int32 procs, err := Processes() if err != nil { @@ -371,6 +367,14 @@ func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExSta return nil, common.ErrNotImplementedError } +func (p *Process) PageFaults() (*PageFaultsStat, error) { + return p.PageFaultsWithContext(context.Background()) +} + +func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error) { + return nil, common.ErrNotImplementedError +} + func (p *Process) Children() ([]*Process, error) { return p.ChildrenWithContext(context.Background()) } @@ -407,6 +411,15 @@ func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionS return nil, common.ErrNotImplementedError } +// Connections returns a slice of net.ConnectionStat used by the process at most `max` +func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error) { + return p.ConnectionsMaxWithContext(context.Background(), max) +} + +func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error) { + return []net.ConnectionStat{}, common.ErrNotImplementedError +} + func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) { return p.NetIOCountersWithContext(context.Background(), pernic) } @@ -493,9 +506,3 @@ func (p *Process) getKProcWithContext(ctx context.Context) (*KinfoProc, error) { } return &k, nil } - -func NewProcess(pid int32) (*Process, error) { - p := &Process{Pid: pid} - - return p, nil -} diff --git a/vendor/github.com/shirou/gopsutil/process/process_linux.go b/vendor/github.com/shirou/gopsutil/process/process_linux.go index ecdd7b48bb6b..062b0ae9499b 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_linux.go +++ b/vendor/github.com/shirou/gopsutil/process/process_linux.go @@ -16,7 +16,6 @@ import ( "strings" "github.com/shirou/gopsutil/cpu" - "github.com/shirou/gopsutil/host" "github.com/shirou/gopsutil/internal/common" "github.com/shirou/gopsutil/net" "golang.org/x/sys/unix" @@ -65,26 +64,13 @@ func (m MemoryMapsStat) String() string { return string(s) } -// NewProcess creates a new Process instance, it only stores the pid and -// checks that the process exists. Other method on Process can be used -// to get more information about the process. An error will be returned -// if the process does not exist. -func NewProcess(pid int32) (*Process, error) { - p := &Process{ - Pid: int32(pid), - } - file, err := os.Open(common.HostProc(strconv.Itoa(int(p.Pid)))) - defer file.Close() - return p, err -} - // Ppid returns Parent Process ID of the process. func (p *Process) Ppid() (int32, error) { return p.PpidWithContext(context.Background()) } func (p *Process) PpidWithContext(ctx context.Context) (int32, error) { - _, ppid, _, _, _, _, err := p.fillFromStat() + _, ppid, _, _, _, _, _, err := p.fillFromStat() if err != nil { return -1, err } @@ -150,7 +136,7 @@ func (p *Process) CreateTime() (int64, error) { } func (p *Process) CreateTimeWithContext(ctx context.Context) (int64, error) { - _, _, _, createTime, _, _, err := p.fillFromStat() + _, _, _, createTime, _, _, _, err := p.fillFromStat() if err != nil { return 0, err } @@ -186,7 +172,7 @@ func (p *Process) ParentWithContext(ctx context.Context) (*Process, error) { // Return value could be one of these. // R: Running S: Sleep T: Stop I: Idle // Z: Zombie W: Wait L: Lock -// The charactor is same within all supported platforms. +// The character is same within all supported platforms. func (p *Process) Status() (string, error) { return p.StatusWithContext(context.Background()) } @@ -253,7 +239,7 @@ func (p *Process) Terminal() (string, error) { } func (p *Process) TerminalWithContext(ctx context.Context) (string, error) { - t, _, _, _, _, _, err := p.fillFromStat() + t, _, _, _, _, _, _, err := p.fillFromStat() if err != nil { return "", err } @@ -272,7 +258,7 @@ func (p *Process) Nice() (int32, error) { } func (p *Process) NiceWithContext(ctx context.Context) (int32, error) { - _, _, _, _, _, nice, err := p.fillFromStat() + _, _, _, _, _, nice, _, err := p.fillFromStat() if err != nil { return 0, err } @@ -310,7 +296,7 @@ func (p *Process) RlimitUsageWithContext(ctx context.Context, gatherUsed bool) ( return rlimits, err } - _, _, _, _, rtprio, nice, err := p.fillFromStat() + _, _, _, _, rtprio, nice, _, err := p.fillFromStat() if err != nil { return nil, err } @@ -418,7 +404,7 @@ func (p *Process) ThreadsWithContext(ctx context.Context) (map[int32]*cpu.TimesS } for _, tid := range tids { - _, _, cpuTimes, _, _, _, err := p.fillFromTIDStat(tid) + _, _, cpuTimes, _, _, _, _, err := p.fillFromTIDStat(tid) if err != nil { return nil, err } @@ -434,7 +420,7 @@ func (p *Process) Times() (*cpu.TimesStat, error) { } func (p *Process) TimesWithContext(ctx context.Context) (*cpu.TimesStat, error) { - _, _, cpuTimes, _, _, _, err := p.fillFromStat() + _, _, cpuTimes, _, _, _, _, err := p.fillFromStat() if err != nil { return nil, err } @@ -478,6 +464,20 @@ func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExSta return memInfoEx, nil } +// PageFaultsInfo returns the process's page fault counters +func (p *Process) PageFaults() (*PageFaultsStat, error) { + return p.PageFaultsWithContext(context.Background()) +} + +func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error) { + _, _, _, _, _, _, pageFaults, err := p.fillFromStat() + if err != nil { + return nil, err + } + return pageFaults, nil + +} + // Children returns a slice of Process of the process. func (p *Process) Children() ([]*Process, error) { return p.ChildrenWithContext(context.Background()) @@ -531,6 +531,15 @@ func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionS return net.ConnectionsPid("all", p.Pid) } +// Connections returns a slice of net.ConnectionStat used by the process at most `max` +func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error) { + return p.ConnectionsMaxWithContext(context.Background(), max) +} + +func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error) { + return net.ConnectionsPidMax("all", p.Pid, max) +} + // NetIOCounters returns NetIOCounters of the process. func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) { return p.NetIOCountersWithContext(context.Background(), pernic) @@ -559,6 +568,9 @@ func (p *Process) MemoryMaps(grouped bool) (*[]MemoryMapsStat, error) { func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]MemoryMapsStat, error) { pid := p.Pid var ret []MemoryMapsStat + if grouped { + ret = make([]MemoryMapsStat, 1) + } smapsPath := common.HostProc(strconv.Itoa(int(pid)), "smaps") contents, err := ioutil.ReadFile(smapsPath) if err != nil { @@ -621,7 +633,20 @@ func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]M if err != nil { return &ret, err } - ret = append(ret, g) + if grouped { + ret[0].Size += g.Size + ret[0].Rss += g.Rss + ret[0].Pss += g.Pss + ret[0].SharedClean += g.SharedClean + ret[0].SharedDirty += g.SharedDirty + ret[0].PrivateClean += g.PrivateClean + ret[0].PrivateDirty += g.PrivateDirty + ret[0].Referenced += g.Referenced + ret[0].Anonymous += g.Anonymous + ret[0].Swap += g.Swap + } else { + ret = append(ret, g) + } } // starts new block blocks = make([]string, 16) @@ -1083,6 +1108,13 @@ func (p *Process) fillFromStatusWithContext(ctx context.Context) error { return err } p.memInfo.Swap = v * 1024 + case "VmHWM": + value := strings.Trim(value, " kB") // remove last "kB" + v, err := strconv.ParseUint(value, 10, 64) + if err != nil { + return err + } + p.memInfo.HWM = v * 1024 case "VmData": value := strings.Trim(value, " kB") // remove last "kB" v, err := strconv.ParseUint(value, 10, 64) @@ -1140,11 +1172,11 @@ func (p *Process) fillFromStatusWithContext(ctx context.Context) error { return nil } -func (p *Process) fillFromTIDStat(tid int32) (uint64, int32, *cpu.TimesStat, int64, uint32, int32, error) { +func (p *Process) fillFromTIDStat(tid int32) (uint64, int32, *cpu.TimesStat, int64, uint32, int32, *PageFaultsStat, error) { return p.fillFromTIDStatWithContext(context.Background(), tid) } -func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (uint64, int32, *cpu.TimesStat, int64, uint32, int32, error) { +func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (uint64, int32, *cpu.TimesStat, int64, uint32, int32, *PageFaultsStat, error) { pid := p.Pid var statPath string @@ -1156,7 +1188,7 @@ func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (ui contents, err := ioutil.ReadFile(statPath) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } fields := strings.Fields(string(contents)) @@ -1167,21 +1199,21 @@ func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (ui terminal, err := strconv.ParseUint(fields[i+5], 10, 64) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } ppid, err := strconv.ParseInt(fields[i+2], 10, 32) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } utime, err := strconv.ParseFloat(fields[i+12], 64) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } stime, err := strconv.ParseFloat(fields[i+13], 64) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } cpuTimes := &cpu.TimesStat{ @@ -1190,17 +1222,17 @@ func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (ui System: float64(stime / ClockTicks), } - bootTime, _ := host.BootTime() + bootTime, _ := common.BootTimeWithContext(ctx) t, err := strconv.ParseUint(fields[i+20], 10, 64) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } ctime := (t / uint64(ClockTicks)) + uint64(bootTime) createTime := int64(ctime * 1000) rtpriority, err := strconv.ParseInt(fields[i+16], 10, 32) if err != nil { - return 0, 0, nil, 0, 0, 0, err + return 0, 0, nil, 0, 0, 0, nil, err } if rtpriority < 0 { rtpriority = rtpriority*-1 - 1 @@ -1213,23 +1245,42 @@ func (p *Process) fillFromTIDStatWithContext(ctx context.Context, tid int32) (ui snice, _ := unix.Getpriority(PrioProcess, int(pid)) nice := int32(snice) // FIXME: is this true? - return terminal, int32(ppid), cpuTimes, createTime, uint32(rtpriority), nice, nil + minFault, err := strconv.ParseUint(fields[i+8], 10, 64) + if err != nil { + return 0, 0, nil, 0, 0, 0, nil, err + } + cMinFault, err := strconv.ParseUint(fields[i+9], 10, 64) + if err != nil { + return 0, 0, nil, 0, 0, 0, nil, err + } + majFault, err := strconv.ParseUint(fields[i+10], 10, 64) + if err != nil { + return 0, 0, nil, 0, 0, 0, nil, err + } + cMajFault, err := strconv.ParseUint(fields[i+11], 10, 64) + if err != nil { + return 0, 0, nil, 0, 0, 0, nil, err + } + + faults := &PageFaultsStat{ + MinorFaults: minFault, + MajorFaults: majFault, + ChildMinorFaults: cMinFault, + ChildMajorFaults: cMajFault, + } + + return terminal, int32(ppid), cpuTimes, createTime, uint32(rtpriority), nice, faults, nil } -func (p *Process) fillFromStat() (uint64, int32, *cpu.TimesStat, int64, uint32, int32, error) { +func (p *Process) fillFromStat() (uint64, int32, *cpu.TimesStat, int64, uint32, int32, *PageFaultsStat, error) { return p.fillFromStatWithContext(context.Background()) } -func (p *Process) fillFromStatWithContext(ctx context.Context) (uint64, int32, *cpu.TimesStat, int64, uint32, int32, error) { +func (p *Process) fillFromStatWithContext(ctx context.Context) (uint64, int32, *cpu.TimesStat, int64, uint32, int32, *PageFaultsStat, error) { return p.fillFromTIDStat(-1) } -// Pids returns a slice of process ID list which are running now. -func Pids() ([]int32, error) { - return PidsWithContext(context.Background()) -} - -func PidsWithContext(ctx context.Context) ([]int32, error) { +func pidsWithContext(ctx context.Context) ([]int32, error) { return readPidsFromDir(common.HostProc()) } diff --git a/vendor/github.com/shirou/gopsutil/process/process_openbsd.go b/vendor/github.com/shirou/gopsutil/process/process_openbsd.go index f9e0a0867a47..56e3500cbee9 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_openbsd.go +++ b/vendor/github.com/shirou/gopsutil/process/process_openbsd.go @@ -7,6 +7,8 @@ import ( "bytes" "context" "encoding/binary" + "os/exec" + "strconv" "strings" "unsafe" @@ -24,11 +26,7 @@ type MemoryInfoExStat struct { type MemoryMapsStat struct { } -func Pids() ([]int32, error) { - return PidsWithContext(context.Background()) -} - -func PidsWithContext(ctx context.Context) ([]int32, error) { +func pidsWithContext(ctx context.Context) ([]int32, error) { var ret []int32 procs, err := Processes() if err != nil { @@ -357,6 +355,14 @@ func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExSta return nil, common.ErrNotImplementedError } +func (p *Process) PageFaults() (*PageFaultsStat, error) { + return p.PageFaultsWithContext(context.Background()) +} + +func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error) { + return nil, common.ErrNotImplementedError +} + func (p *Process) Children() ([]*Process, error) { return p.ChildrenWithContext(context.Background()) } @@ -393,6 +399,14 @@ func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionS return nil, common.ErrNotImplementedError } +func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error) { + return p.ConnectionsMaxWithContext(context.Background(), max) +} + +func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error) { + return []net.ConnectionStat{}, common.ErrNotImplementedError +} + func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) { return p.NetIOCountersWithContext(context.Background(), pernic) } @@ -478,12 +492,6 @@ func (p *Process) getKProcWithContext(ctx context.Context) (*KinfoProc, error) { return &k, nil } -func NewProcess(pid int32) (*Process, error) { - p := &Process{Pid: pid} - - return p, nil -} - func CallKernProcSyscall(op int32, arg int32) ([]byte, uint64, error) { return CallKernProcSyscallWithContext(context.Background(), op, arg) } diff --git a/vendor/github.com/shirou/gopsutil/process/process_posix.go b/vendor/github.com/shirou/gopsutil/process/process_posix.go index 8ffb6b797de6..13f0308cefd6 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_posix.go +++ b/vendor/github.com/shirou/gopsutil/process/process_posix.go @@ -4,6 +4,7 @@ package process import ( "context" + "fmt" "os" "os/user" "path/filepath" @@ -69,6 +70,34 @@ func getTerminalMap() (map[uint64]string, error) { return ret, nil } +func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) { + if pid <= 0 { + return false, fmt.Errorf("invalid pid %v", pid) + } + proc, err := os.FindProcess(int(pid)) + if err != nil { + return false, err + } + err = proc.Signal(syscall.Signal(0)) + if err == nil { + return true, nil + } + if err.Error() == "os: process already finished" { + return false, nil + } + errno, ok := err.(syscall.Errno) + if !ok { + return false, err + } + switch errno { + case syscall.ESRCH: + return false, nil + case syscall.EPERM: + return true, nil + } + return false, err +} + // SendSignal sends a unix.Signal to the process. // Currently, SIGSTOP, SIGCONT, SIGTERM and SIGKILL are supported. func (p *Process) SendSignal(sig syscall.Signal) error { diff --git a/vendor/github.com/shirou/gopsutil/process/process_windows.go b/vendor/github.com/shirou/gopsutil/process/process_windows.go index 48a12133cc18..f78c9beef842 100644 --- a/vendor/github.com/shirou/gopsutil/process/process_windows.go +++ b/vendor/github.com/shirou/gopsutil/process/process_windows.go @@ -19,18 +19,17 @@ import ( "golang.org/x/sys/windows" ) -const ( - NoMoreFiles = 0x12 - MaxPathLength = 260 -) - var ( - modpsapi = windows.NewLazySystemDLL("psapi.dll") - procGetProcessMemoryInfo = modpsapi.NewProc("GetProcessMemoryInfo") + modpsapi = windows.NewLazySystemDLL("psapi.dll") + procGetProcessMemoryInfo = modpsapi.NewProc("GetProcessMemoryInfo") + procGetProcessImageFileNameW = modpsapi.NewProc("GetProcessImageFileNameW") advapi32 = windows.NewLazySystemDLL("advapi32.dll") procLookupPrivilegeValue = advapi32.NewProc("LookupPrivilegeValueW") procAdjustTokenPrivileges = advapi32.NewProc("AdjustTokenPrivileges") + + procQueryFullProcessImageNameW = common.Modkernel32.NewProc("QueryFullProcessImageNameW") + procGetPriorityClass = common.Modkernel32.NewProc("GetPriorityClass") ) type SystemProcessInformation struct { @@ -151,11 +150,7 @@ func init() { 0) } -func Pids() ([]int32, error) { - return PidsWithContext(context.Background()) -} - -func PidsWithContext(ctx context.Context) ([]int32, error) { +func pidsWithContext(ctx context.Context) ([]int32, error) { // inspired by https://gist.github.com/henkman/3083408 // and https://github.com/giampaolo/psutil/blob/1c3a15f637521ba5c0031283da39c733fda53e4c/psutil/arch/windows/process_info.c#L315-L329 var ret []int32 @@ -181,6 +176,44 @@ func PidsWithContext(ctx context.Context) ([]int32, error) { } +func PidExistsWithContext(ctx context.Context, pid int32) (bool, error) { + if pid == 0 { // special case for pid 0 System Idle Process + return true, nil + } + if pid < 0 { + return false, fmt.Errorf("invalid pid %v", pid) + } + if pid%4 != 0 { + // OpenProcess will succeed even on non-existing pid here https://devblogs.microsoft.com/oldnewthing/20080606-00/?p=22043 + // so we list every pid just to be sure and be future-proof + pids, err := PidsWithContext(ctx) + if err != nil { + return false, err + } + for _, i := range pids { + if i == pid { + return true, err + } + } + return false, err + } + const STILL_ACTIVE = 259 // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getexitcodeprocess + h, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid)) + if err == windows.ERROR_ACCESS_DENIED { + return true, nil + } + if err == windows.ERROR_INVALID_PARAMETER { + return false, nil + } + if err != nil { + return false, err + } + defer syscall.CloseHandle(syscall.Handle(h)) + var exitCode uint32 + err = windows.GetExitCodeProcess(h, &exitCode) + return exitCode == STILL_ACTIVE, err +} + func (p *Process) Ppid() (int32, error) { return p.PpidWithContext(context.Background()) } @@ -234,24 +267,30 @@ func (p *Process) Exe() (string, error) { } func (p *Process) ExeWithContext(ctx context.Context) (string, error) { - if p.Pid != 0 { // 0 or null is the current process for CreateToolhelp32Snapshot - snap := w32.CreateToolhelp32Snapshot(w32.TH32CS_SNAPMODULE|w32.TH32CS_SNAPMODULE32, uint32(p.Pid)) - if snap != 0 { // don't report errors here, fallback to WMI instead - defer w32.CloseHandle(snap) - var me32 w32.MODULEENTRY32 - me32.Size = uint32(unsafe.Sizeof(me32)) - - if w32.Module32First(snap, &me32) { - szexepath := windows.UTF16ToString(me32.SzExePath[:]) - return szexepath, nil - } + c, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(p.Pid)) + if err != nil { + return "", err + } + defer windows.CloseHandle(c) + buf := make([]uint16, syscall.MAX_LONG_PATH) + size := uint32(syscall.MAX_LONG_PATH) + if err := procQueryFullProcessImageNameW.Find(); err == nil { // Vista+ + ret, _, err := procQueryFullProcessImageNameW.Call( + uintptr(c), + uintptr(0), + uintptr(unsafe.Pointer(&buf[0])), + uintptr(unsafe.Pointer(&size))) + if ret == 0 { + return "", err } + return windows.UTF16ToString(buf[:]), nil } - dst, err := GetWin32ProcWithContext(ctx, p.Pid) - if err != nil { - return "", fmt.Errorf("could not get ExecutablePath: %s", err) + // XP fallback + ret, _, err := procGetProcessImageFileNameW.Call(uintptr(c), uintptr(unsafe.Pointer(&buf[0])), uintptr(size)) + if ret == 0 { + return "", err } - return *dst[0].ExecutablePath, nil + return common.ConvertDOSPath(windows.UTF16ToString(buf[:])), nil } func (p *Process) Cmdline() (string, error) { @@ -335,15 +374,14 @@ func (p *Process) Username() (string, error) { func (p *Process) UsernameWithContext(ctx context.Context) (string, error) { pid := p.Pid - // 0x1000 is PROCESS_QUERY_LIMITED_INFORMATION - c, err := syscall.OpenProcess(0x1000, false, uint32(pid)) + c, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid)) if err != nil { return "", err } - defer syscall.CloseHandle(c) + defer windows.CloseHandle(c) var token syscall.Token - err = syscall.OpenProcessToken(c, syscall.TOKEN_QUERY, &token) + err = syscall.OpenProcessToken(syscall.Handle(c), syscall.TOKEN_QUERY, &token) if err != nil { return "", err } @@ -382,17 +420,38 @@ func (p *Process) TerminalWithContext(ctx context.Context) (string, error) { return "", common.ErrNotImplementedError } +// priorityClasses maps a win32 priority class to its WMI equivalent Win32_Process.Priority +// https://docs.microsoft.com/en-us/windows/desktop/api/processthreadsapi/nf-processthreadsapi-getpriorityclass +// https://docs.microsoft.com/en-us/windows/desktop/cimwin32prov/win32-process +var priorityClasses = map[int]int32{ + 0x00008000: 10, // ABOVE_NORMAL_PRIORITY_CLASS + 0x00004000: 6, // BELOW_NORMAL_PRIORITY_CLASS + 0x00000080: 13, // HIGH_PRIORITY_CLASS + 0x00000040: 4, // IDLE_PRIORITY_CLASS + 0x00000020: 8, // NORMAL_PRIORITY_CLASS + 0x00000100: 24, // REALTIME_PRIORITY_CLASS +} + // Nice returns priority in Windows func (p *Process) Nice() (int32, error) { return p.NiceWithContext(context.Background()) } func (p *Process) NiceWithContext(ctx context.Context) (int32, error) { - dst, err := GetWin32ProcWithContext(ctx, p.Pid) + c, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(p.Pid)) if err != nil { - return 0, fmt.Errorf("could not get Priority: %s", err) + return 0, err } - return int32(dst[0].Priority), nil + defer windows.CloseHandle(c) + ret, _, err := procGetPriorityClass.Call(uintptr(c)) + if ret == 0 { + return 0, err + } + priority, ok := priorityClasses[int(ret)] + if !ok { + return 0, fmt.Errorf("unknown priority class %v", ret) + } + return priority, nil } func (p *Process) IOnice() (int32, error) { return p.IOniceWithContext(context.Background()) @@ -457,11 +516,11 @@ func (p *Process) NumThreads() (int32, error) { } func (p *Process) NumThreadsWithContext(ctx context.Context) (int32, error) { - dst, err := GetWin32ProcWithContext(ctx, p.Pid) + _, ret, _, err := getFromSnapProcess(p.Pid) if err != nil { - return 0, fmt.Errorf("could not get ThreadCount: %s", err) + return 0, err } - return int32(dst[0].ThreadCount), nil + return ret, nil } func (p *Process) Threads() (map[int32]*cpu.TimesStat, error) { return p.ThreadsWithContext(context.Background()) @@ -530,6 +589,14 @@ func (p *Process) MemoryInfoExWithContext(ctx context.Context) (*MemoryInfoExSta return nil, common.ErrNotImplementedError } +func (p *Process) PageFaults() (*PageFaultsStat, error) { + return p.PageFaultsWithContext(context.Background()) +} + +func (p *Process) PageFaultsWithContext(ctx context.Context) (*PageFaultsStat, error) { + return nil, common.ErrNotImplementedError +} + func (p *Process) Children() ([]*Process, error) { return p.ChildrenWithContext(context.Background()) } @@ -543,24 +610,19 @@ func (p *Process) ChildrenWithContext(ctx context.Context) ([]*Process, error) { defer w32.CloseHandle(snap) var pe32 w32.PROCESSENTRY32 pe32.DwSize = uint32(unsafe.Sizeof(pe32)) - if w32.Process32First(snap, &pe32) == false { + if !w32.Process32First(snap, &pe32) { return out, windows.GetLastError() } - - if pe32.Th32ParentProcessID == uint32(p.Pid) { - p, err := NewProcess(int32(pe32.Th32ProcessID)) - if err == nil { - out = append(out, p) - } - } - - for w32.Process32Next(snap, &pe32) { + for { if pe32.Th32ParentProcessID == uint32(p.Pid) { p, err := NewProcess(int32(pe32.Th32ProcessID)) if err == nil { out = append(out, p) } } + if !w32.Process32Next(snap, &pe32) { + break + } } return out, nil } @@ -581,6 +643,14 @@ func (p *Process) ConnectionsWithContext(ctx context.Context) ([]net.ConnectionS return nil, common.ErrNotImplementedError } +func (p *Process) ConnectionsMax(max int) ([]net.ConnectionStat, error) { + return p.ConnectionsMaxWithContext(context.Background(), max) +} + +func (p *Process) ConnectionsMaxWithContext(ctx context.Context, max int) ([]net.ConnectionStat, error) { + return []net.ConnectionStat{}, common.ErrNotImplementedError +} + func (p *Process) NetIOCounters(pernic bool) ([]net.IOCountersStat, error) { return p.NetIOCountersWithContext(context.Background(), pernic) } @@ -606,12 +676,6 @@ func (p *Process) MemoryMapsWithContext(ctx context.Context, grouped bool) (*[]M return &ret, common.ErrNotImplementedError } -func NewProcess(pid int32) (*Process, error) { - p := &Process{Pid: pid} - - return p, nil -} - func (p *Process) SendSignal(sig windows.Signal) error { return p.SendSignalWithContext(context.Background(), sig) } @@ -669,22 +733,19 @@ func getFromSnapProcess(pid int32) (int32, int32, string, error) { defer w32.CloseHandle(snap) var pe32 w32.PROCESSENTRY32 pe32.DwSize = uint32(unsafe.Sizeof(pe32)) - if w32.Process32First(snap, &pe32) == false { + if !w32.Process32First(snap, &pe32) { return 0, 0, "", windows.GetLastError() } - - if pe32.Th32ProcessID == uint32(pid) { - szexe := windows.UTF16ToString(pe32.SzExeFile[:]) - return int32(pe32.Th32ParentProcessID), int32(pe32.CntThreads), szexe, nil - } - - for w32.Process32Next(snap, &pe32) { + for { if pe32.Th32ProcessID == uint32(pid) { szexe := windows.UTF16ToString(pe32.SzExeFile[:]) return int32(pe32.Th32ParentProcessID), int32(pe32.CntThreads), szexe, nil } + if !w32.Process32Next(snap, &pe32) { + break + } } - return 0, 0, "", fmt.Errorf("Couldn't find pid: %d", pid) + return 0, 0, "", fmt.Errorf("couldn't find pid: %d", pid) } // Get processes @@ -747,8 +808,7 @@ func getRusage(pid int32) (*windows.Rusage, error) { func getMemoryInfo(pid int32) (PROCESS_MEMORY_COUNTERS, error) { var mem PROCESS_MEMORY_COUNTERS - // PROCESS_QUERY_LIMITED_INFORMATION is 0x1000 - c, err := windows.OpenProcess(0x1000, false, uint32(pid)) + c, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid)) if err != nil { return mem, err } @@ -782,8 +842,7 @@ type SYSTEM_TIMES struct { func getProcessCPUTimes(pid int32) (SYSTEM_TIMES, error) { var times SYSTEM_TIMES - // PROCESS_QUERY_LIMITED_INFORMATION is 0x1000 - h, err := windows.OpenProcess(0x1000, false, uint32(pid)) + h, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, uint32(pid)) if err != nil { return times, err } diff --git a/vendor/modules.txt b/vendor/modules.txt index 98a021993cb1..43d802db38c9 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -2,7 +2,7 @@ github.com/BurntSushi/toml # github.com/OpenPeeDeeP/depguard v1.0.1 github.com/OpenPeeDeeP/depguard -# github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d +# github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 github.com/StackExchange/wmi # github.com/davecgh/go-spew v1.1.1 github.com/davecgh/go-spew/spew @@ -16,7 +16,7 @@ github.com/go-critic/go-critic/checkers/internal/lintutil # github.com/go-lintpack/lintpack v0.5.2 github.com/go-lintpack/lintpack github.com/go-lintpack/lintpack/astwalk -# github.com/go-ole/go-ole v1.2.4 +# github.com/go-ole/go-ole v1.2.1 github.com/go-ole/go-ole github.com/go-ole/go-ole/oleutil # github.com/go-toolsmith/astcast v1.0.0 @@ -135,9 +135,8 @@ github.com/pmezard/go-difflib/difflib # github.com/securego/gosec v0.0.0-20190912120752-140048b2a218 github.com/securego/gosec github.com/securego/gosec/rules -# github.com/shirou/gopsutil v2.18.12+incompatible +# github.com/shirou/gopsutil v0.0.0-20190901111213-e4ec7b275ada github.com/shirou/gopsutil/cpu -github.com/shirou/gopsutil/host github.com/shirou/gopsutil/internal/common github.com/shirou/gopsutil/mem github.com/shirou/gopsutil/net