Implement psutil-golang: CPU, Memory and Process Information Retrieval for Linux

.github/workflows/ci.yaml

@@ -0,0 +1,55 @@
+name: CI Pipeline
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+      - development
+
+jobs:
+  golangci:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: stable
+      - name: Install golangci-lint
+        run: go install github.com/golangci/golangci-lint/cmd/[email protected]
+      - name: Run golangci-lint
+        run: golangci-lint run ./...
+
+  fmt:
+    name: Format Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: stable
+      - name: Run go fmt
+        run: gofmt -l .
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: stable
+      - name: Install Dependencies
+        run: go mod tidy
+      - name: Run Tests
+        run: go test ./... -v -coverprofile=coverage.out
+      - name: Upload Test Coverage
+        if: success()
+        uses: actions/upload-artifact@v3
+        with:
+          name: coverage
+          path: coverage.out
+

.gitignore

@@ -23,3 +23,4 @@ go.work.sum
 
 # env file
 .env
+.vscode

README.md

@@ -1 +1,87 @@
-# psutil-golang-MohamedFadel
+# psutil-golang
+
+A Go package for retrieving system and process information on Linux systems.
+
+## Project Structure
+
+```
+.
+├── go.mod
+├── go.sum
+├── psutils
+│   ├── cpu.go
+│   ├── erros.go
+│   ├── internal.go
+│   ├── internal_test.go
+│   ├── mem.go
+│   ├── proc.go
+│   └── psutil_test.go
+└── README.md
+```
+
+## Features
+
+- CPU information retrieval
+- Memory information retrieval
+- Process information retrieval
+
+## Installation
+
+To use this package in your Go project, run:
+
+```bash
+go get github.com/codescalersinternships/psutil-golang-MohamedFadel
+```
+
+## Usage
+
+Here's a basic example of how to use the package:
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/codescalersinternships/psutil-golang-MohamedFadel/psutils"
+)
+
+func main() {
+    // Get CPU info
+    cpuInfo, err := psutils.GetCPUInfo()
+    if err != nil {
+        fmt.Printf("Error getting CPU info: %v\n", err)
+    } else {
+        fmt.Printf("CPU Info: %+v\n", cpuInfo)
+    }
+
+    // Get Memory info
+    memInfo, err := psutils.GetMemoryInfo()
+    if err != nil {
+        fmt.Printf("Error getting memory info: %v\n", err)
+    } else {
+        fmt.Printf("Memory Info: %+v\n", memInfo)
+    }
+
+    // Get Process info
+    procInfo, err := psutils.GetProcessInfo()
+    if err != nil {
+        fmt.Printf("Error getting process info: %v\n", err)
+    } else {
+        fmt.Printf("Process Info: %+v\n", procInfo)
+    }
+}
+```
+
+## Testing
+
+To run the tests, navigate to the project root and run:
+
+```bash
+go test ./...
+```
+
+## Dependencies
+
+This project uses the following external dependency:
+
+- github.com/stretchr/testify v1.9.0 (for testing)

go.mod

@@ -0,0 +1,5 @@
+module github.com/codescalersinternships/psutil-golang-MohamedFadel
+
+go 1.23.0
+
+require github.com/stretchr/testify v1.9.0 // indirect

go.sum

@@ -0,0 +1,2 @@
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

psutils/cpu.go

@@ -0,0 +1,142 @@
+package psutils
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// CPUCoreFreq represents the frequency information for a CPU core.
+type CPUCoreFreq struct {
+	Core    string // The name of the CPU core
+	MinFreq int    // The minimum frequency of the core in Hz
+	MaxFreq int    // The maximum frequency of the core in Hz
+}
+
+// CPUInfo contains various information about the CPU.
+type CPUInfo struct {
+	NumOfCores int           // The number of CPU cores
+	ModelName  string        // The model name of the CPU
+	CacheSize  int           // The total cache size in KB
+	CPUMHz     float64       // The average CPU frequency in MHz
+	Frequency  []CPUCoreFreq // Frequency information for each core
+}
+
+var (
+	readFile func(name string) ([]byte, error)
+	readDir  func(name string) ([]fs.DirEntry, error)
+)
+
+func init() {
+	readFile = os.ReadFile
+	readDir = os.ReadDir
+}
+
+/*
+GetCPUInfo retrieves and returns information about the CPU.
+It reads various system files to gather this information.
+Returns a pointer to CPUInfo and an error if any occurred during the process.
+*/
+func GetCPUInfo() (*CPUInfo, error) {
+	var cpuInfo CPUInfo
+
+	data, err := openAndReadFile("/proc/cpuinfo")
+	if err != nil {
+		return nil, err
+	}
+
+	cpuInfo.ModelName = getFieldValue(data, "model name")
+
+	for _, line := range data {
+		if strings.Contains(line, "processor") {
+			cpuInfo.NumOfCores++
+		}
+	}
+
+	var totalMHz float64
+	for _, line := range data {
+		if strings.Contains(line, "cpu MHz") {
+			if mhz, err := strconv.ParseFloat(strings.TrimSpace(strings.Split(line, ":")[1]), 64); err == nil {
+				totalMHz += mhz
+			}
+		}
+	}
+	cpuInfo.CPUMHz = totalMHz / float64(cpuInfo.NumOfCores)
+
+	d, err := readFile("/sys/devices/system/cpu/cpu0/cache/index0/size")
+	if err != nil {
+		return nil, err
+	}
+
+	value := strings.Split(string(d), "\n")[0]
+	value = value[:len(value)-1]
+	l1iCache, err := strconv.Atoi(value)
+	if err != nil {
+		return nil, err
+	}
+
+	d2, err := readFile("/sys/devices/system/cpu/cpu0/cache/index1/size")
+	if err != nil {
+		return nil, err
+	}
+
+	value2 := strings.Split(string(d2), "\n")[0]
+	value2 = value2[:len(value2)-1]
+	l1dCache, err := strconv.Atoi(value2)
+	if err != nil {
+		return nil, err
+	}
+
+	d3, err := readFile("/sys/devices/system/cpu/cpu0/cache/index2/size")
+	if err != nil {
+		return nil, err
+	}
+
+	value3 := strings.Split(string(d3), "\n")[0]
+	value3 = value3[:len(value3)-1]
+	l2Cache, err := strconv.Atoi(value3)
+	if err != nil {
+		return nil, err
+	}
+
+	d4, err := readFile("/sys/devices/system/cpu/cpu0/cache/index3/size")
+	if err != nil {
+		return nil, err
+	}
+
+	value4 := strings.Split(string(d4), "\n")[0]
+	value4 = value4[:len(value4)-1]
+	l3Cache, err := strconv.Atoi(value4)
+	if err != nil {
+		return nil, err
+	}
+
+	cpuInfo.CacheSize = cpuInfo.NumOfCores*(l1iCache+l1dCache+l2Cache) + l3Cache
+
+	for i := 0; i < cpuInfo.NumOfCores; i++ {
+		var cpuCoreFreq CPUCoreFreq
+		cpuCoreFreq.Core = fmt.Sprintf("cpu%d", i)
+
+		dataMin, err := readFile(fmt.Sprintf("/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_min_freq", i))
+		if err != nil {
+			return nil, err
+		}
+		if minFreq, err := strconv.Atoi(strings.TrimSpace(string(dataMin))); err == nil {
+			cpuCoreFreq.MinFreq = minFreq
+		}
+
+		dataMax, err := readFile(fmt.Sprintf("/sys/devices/system/cpu/cpu%d/cpufreq/cpuinfo_max_freq", i))
+		if err != nil {
+			return nil, err
+		}
+		if maxFreq, err := strconv.Atoi(strings.TrimSpace(string(dataMax))); err == nil {
+			cpuCoreFreq.MaxFreq = maxFreq
+		}
+
+		cpuInfo.Frequency = append(cpuInfo.Frequency, cpuCoreFreq)
+	}
+
+	return &cpuInfo, nil
+}

psutils/erros.go

@@ -0,0 +1,7 @@
+package psutils
+
+import "errors"
+
+var (
+	ErrReadingFile = errors.New("error reading file")
+)

psutils/internal.go

@@ -0,0 +1,31 @@
+package psutils
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+var openAndReadFile = func(path string) ([]string, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrReadingFile, err)
+	}
+
+	lines := strings.Split(string(data), "\n")
+	return lines, nil
+}
+
+func getFieldValue(lines []string, field string) string {
+	for _, l := range lines {
+		line := strings.Split(l, ":")
+
+		if strings.TrimSpace(line[0]) != field {
+			continue
+		}
+
+		return strings.TrimSpace(line[1])
+	}
+
+	return ""
+}