Merge pull request #1131 from punya/tbarker25-swap-contd

Add swapdevices method (continued from #1120)

mem/mem.go

@@ -91,7 +91,7 @@ type SwapMemoryStat struct {
 
 	// Linux specific numbers
 	// https://www.kernel.org/doc/Documentation/cgroup-v2.txt
-	PgMajFault  uint64  `json:"pgmajfault"`
+	PgMajFault uint64 `json:"pgmajfault"`
 }
 
 func (m VirtualMemoryStat) String() string {
@@ -103,3 +103,14 @@ func (m SwapMemoryStat) String() string {
 	s, _ := json.Marshal(m)
 	return string(s)
 }
+
+type SwapDevice struct {
+	Name      string `json:"name"`
+	UsedBytes uint64 `json:"usedBytes"`
+	FreeBytes uint64 `json:"freeBytes"`
+}
+
+func (m SwapDevice) String() string {
+	s, _ := json.Marshal(m)
+	return string(s)
+}

mem/mem_bsd.go

@@ -0,0 +1,91 @@
+// +build freebsd openbsd
+
+package mem
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+const swapCommand = "swapctl"
+
+// swapctl column indexes
+const (
+	nameCol     = 0
+	totalKiBCol = 1
+	usedKiBCol  = 2
+)
+
+func SwapDevices() ([]*SwapDevice, error) {
+	return SwapDevicesWithContext(context.Background())
+}
+
+func SwapDevicesWithContext(ctx context.Context) ([]*SwapDevice, error) {
+	swapCommandPath, err := exec.LookPath(swapCommand)
+	if err != nil {
+		return nil, fmt.Errorf("could not find command %q: %w", swapCommand, err)
+	}
+	output, err := invoke.CommandWithContext(swapCommandPath, "-lk")
+	if err != nil {
+		return nil, fmt.Errorf("could not execute %q: %w", swapCommand, err)
+	}
+
+	return parseSwapctlOutput(string(output))
+}
+
+func parseSwapctlOutput(output string) ([]*SwapDevice, error) {
+	lines := strings.Split(output, "\n")
+	if len(lines) == 0 {
+		return nil, fmt.Errorf("could not parse output of %q: no lines in %q", swapCommand, output)
+	}
+
+	// Check header headerFields are as expected.
+	header := lines[0]
+	header = strings.ToLower(header)
+	header = strings.ReplaceAll(header, ":", "")
+	headerFields := strings.Fields(header)
+	if len(headerFields) < usedKiBCol {
+		return nil, fmt.Errorf("couldn't parse %q: too few fields in header %q", swapCommand, header)
+	}
+	if headerFields[nameCol] != "device" {
+		return nil, fmt.Errorf("couldn't parse %q: expected %q to be %q", swapCommand, headerFields[nameCol], "device")
+	}
+	if headerFields[totalKiBCol] != "1kb-blocks" && headerFields[totalKiBCol] != "1k-blocks" {
+		return nil, fmt.Errorf("couldn't parse %q: expected %q to be %q", swapCommand, headerFields[totalKiBCol], "1kb-blocks")
+	}
+	if headerFields[usedKiBCol] != "used" {
+		return nil, fmt.Errorf("couldn't parse %q: expected %q to be %q", swapCommand, headerFields[usedKiBCol], "used")
+	}
+
+	var swapDevices []*SwapDevice
+	for _, line := range lines[1:] {
+		if line == "" {
+			continue // the terminal line is typically empty
+		}
+		fields := strings.Fields(line)
+		if len(fields) < usedKiBCol {
+			return nil, fmt.Errorf("couldn't parse %q: too few fields", swapCommand)
+		}
+
+		totalKiB, err := strconv.ParseUint(fields[totalKiBCol], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't parse 'Size' column in %q: %w", swapCommand, err)
+		}
+
+		usedKiB, err := strconv.ParseUint(fields[usedKiBCol], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't parse 'Used' column in %q: %w", swapCommand, err)
+		}
+
+		swapDevices = append(swapDevices, &SwapDevice{
+			Name:      fields[nameCol],
+			UsedBytes: usedKiB * 1024,
+			FreeBytes: (totalKiB - usedKiB) * 1024,
+		})
+	}
+
+	return swapDevices, nil
+}

mem/mem_bsd_test.go

@@ -0,0 +1,63 @@
+// +build freebsd openbsd
+
+package mem
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const validFreeBSD = `Device:       1kB-blocks      Used:
+/dev/gpt/swapfs    1048576          1234
+/dev/md0         1048576          666
+`
+
+const validOpenBSD = `Device       1K-blocks      Used	Avail	Capacity	Priority
+/dev/wd0b    655025          1234	653791	1%	0
+`
+
+const invalid = `Device:       512-blocks      Used:
+/dev/gpt/swapfs    1048576          1234
+/dev/md0         1048576          666
+`
+
+func TestParseSwapctlOutput_FreeBSD(t *testing.T) {
+	assert := assert.New(t)
+	stats, err := parseSwapctlOutput(validFreeBSD)
+	assert.NoError(err)
+
+	assert.Equal(*stats[0], SwapDevice{
+		Name:      "/dev/gpt/swapfs",
+		UsedBytes: 1263616,
+		FreeBytes: 1072478208,
+	})
+
+	assert.Equal(*stats[1], SwapDevice{
+		Name:      "/dev/md0",
+		UsedBytes: 681984,
+		FreeBytes: 1073059840,
+	})
+}
+
+func TestParseSwapctlOutput_OpenBSD(t *testing.T) {
+	assert := assert.New(t)
+	stats, err := parseSwapctlOutput(validOpenBSD)
+	assert.NoError(err)
+
+	assert.Equal(*stats[0], SwapDevice{
+		Name:      "/dev/wd0b",
+		UsedBytes: 1234 * 1024,
+		FreeBytes: 653791 * 1024,
+	})
+}
+
+func TestParseSwapctlOutput_Invalid(t *testing.T) {
+	_, err := parseSwapctlOutput(invalid)
+	assert.Error(t, err)
+}
+
+func TestParseSwapctlOutput_Empty(t *testing.T) {
+	_, err := parseSwapctlOutput("")
+	assert.Error(t, err)
+}

mem/mem_darwin.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"unsafe"
 
+	"github.com/shirou/gopsutil/internal/common"
 	"golang.org/x/sys/unix"
 )
 
@@ -67,3 +68,11 @@ func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
 
 	return ret, nil
 }
+
+func SwapDevices() ([]*SwapDevice, error) {
+	return SwapDevicesWithContext(context.Background())
+}
+
+func SwapDevicesWithContext(ctx context.Context) ([]*SwapDevice, error) {
+	return nil, common.ErrNotImplementedError
+}

mem/mem_darwin_cgo.go

@@ -1,5 +1,4 @@
-// +build darwin
-// +build cgo
+// +build darwin,cgo
 
 package mem
 

mem/mem_darwin_nocgo.go

@@ -1,5 +1,4 @@
-// +build darwin
-// +build !cgo
+// +build darwin,!cgo
 
 package mem
 

mem/mem_fallback.go

@@ -23,3 +23,11 @@ func SwapMemory() (*SwapMemoryStat, error) {
 func SwapMemoryWithContext(ctx context.Context) (*SwapMemoryStat, error) {
 	return nil, common.ErrNotImplementedError
 }
+
+func SwapDevices() ([]*SwapDevice, error) {
+	return SwapDevicesWithContext(context.Background())
+}
+
+func SwapDevicesWithContext(ctx context.Context) ([]*SwapDevice, error) {
+	return nil, common.ErrNotImplementedError
+}

mem/mem_linux.go

@@ -3,8 +3,11 @@
 package mem
 
 import (
+	"bufio"
 	"context"
 	"encoding/json"
+	"fmt"
+	"io"
 	"math"
 	"os"
 	"strconv"
@@ -426,3 +429,86 @@ func calcuateAvailVmem(ret *VirtualMemoryStat, retEx *VirtualMemoryExStat) uint6
 
 	return availMemory
 }
+
+const swapsFilename = "swaps"
+
+// swaps file column indexes
+const (
+	nameCol = 0
+	// typeCol     = 1
+	totalCol = 2
+	usedCol  = 3
+	// priorityCol = 4
+)
+
+func SwapDevices() ([]*SwapDevice, error) {
+	return SwapDevicesWithContext(context.Background())
+}
+
+func SwapDevicesWithContext(ctx context.Context) ([]*SwapDevice, error) {
+	swapsFilePath := common.HostProc(swapsFilename)
+	f, err := os.Open(swapsFilePath)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	return parseSwapsFile(f)
+}
+
+func parseSwapsFile(r io.Reader) ([]*SwapDevice, error) {
+	swapsFilePath := common.HostProc(swapsFilename)
+	scanner := bufio.NewScanner(r)
+	if !scanner.Scan() {
+		if err := scanner.Err(); err != nil {
+			return nil, fmt.Errorf("couldn't read file %q: %w", swapsFilePath, err)
+		}
+		return nil, fmt.Errorf("unexpected end-of-file in %q", swapsFilePath)
+
+	}
+
+	// Check header headerFields are as expected
+	headerFields := strings.Fields(scanner.Text())
+	if len(headerFields) < usedCol {
+		return nil, fmt.Errorf("couldn't parse %q: too few fields in header", swapsFilePath)
+	}
+	if headerFields[nameCol] != "Filename" {
+		return nil, fmt.Errorf("couldn't parse %q: expected %q to be %q", swapsFilePath, headerFields[nameCol], "Filename")
+	}
+	if headerFields[totalCol] != "Size" {
+		return nil, fmt.Errorf("couldn't parse %q: expected %q to be %q", swapsFilePath, headerFields[totalCol], "Size")
+	}
+	if headerFields[usedCol] != "Used" {
+		return nil, fmt.Errorf("couldn't parse %q: expected %q to be %q", swapsFilePath, headerFields[usedCol], "Used")
+	}
+
+	var swapDevices []*SwapDevice
+	for scanner.Scan() {
+		fields := strings.Fields(scanner.Text())
+		if len(fields) < usedCol {
+			return nil, fmt.Errorf("couldn't parse %q: too few fields", swapsFilePath)
+		}
+
+		totalKiB, err := strconv.ParseUint(fields[totalCol], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't parse 'Size' column in %q: %w", swapsFilePath, err)
+		}
+
+		usedKiB, err := strconv.ParseUint(fields[usedCol], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("couldn't parse 'Used' column in %q: %w", swapsFilePath, err)
+		}
+
+		swapDevices = append(swapDevices, &SwapDevice{
+			Name:      fields[nameCol],
+			UsedBytes: usedKiB * 1024,
+			FreeBytes: (totalKiB - usedKiB) * 1024,
+		})
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("couldn't read file %q: %w", swapsFilePath, err)
+	}
+
+	return swapDevices, nil
+}

mem/mem_linux_test.go

@@ -1,10 +1,15 @@
+// +build linux
+
 package mem
 
 import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"strings"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestVirtualMemoryEx(t *testing.T) {
@@ -115,3 +120,41 @@ func TestVirtualMemoryLinux(t *testing.T) {
 		})
 	}
 }
+
+const validFile = `Filename				Type		Size		Used		Priority
+/dev/dm-2                               partition	67022844	490788		-2
+/swapfile                               file		2		1		-3
+`
+
+const invalidFile = `INVALID				Type		Size		Used		Priority
+/dev/dm-2                               partition	67022844	490788		-2
+/swapfile                               file		1048572		0		-3
+`
+
+func TestParseSwapsFile_ValidFile(t *testing.T) {
+	assert := assert.New(t)
+	stats, err := parseSwapsFile(strings.NewReader(validFile))
+	assert.NoError(err)
+
+	assert.Equal(*stats[0], SwapDevice{
+		Name:      "/dev/dm-2",
+		UsedBytes: 502566912,
+		FreeBytes: 68128825344,
+	})
+
+	assert.Equal(*stats[1], SwapDevice{
+		Name:      "/swapfile",
+		UsedBytes: 1024,
+		FreeBytes: 1024,
+	})
+}
+
+func TestParseSwapsFile_InvalidFile(t *testing.T) {
+	_, err := parseSwapsFile(strings.NewReader(invalidFile))
+	assert.Error(t, err)
+}
+
+func TestParseSwapsFile_EmptyFile(t *testing.T) {
+	_, err := parseSwapsFile(strings.NewReader(""))
+	assert.Error(t, err)
+}