chore: moved helpers to internal 51e922c4
Steve · 2026-11-08 13:43 2 file(s) · +124 −94
internal/helpers.go (added) +111 −0
1 +
package helpers
2 +
3 +
import (
4 +
	"bufio"
5 +
	"fmt"
6 +
	"os"
7 +
	"strconv"
8 +
	"strings"
9 +
	"syscall"
10 +
	"time"
11 +
)
12 +
13 +
func GetHostname() (string, error) {
14 +
	hostname, err := os.Hostname()
15 +
	if err != nil {
16 +
		return "", err
17 +
	}
18 +
	user := os.Getenv("USER")
19 +
	if user == "" {
20 +
		return "", err
21 +
	}
22 +
	return fmt.Sprintf("%s@%s\n", user, hostname), nil
23 +
}
24 +
25 +
func GetDistro() (string, error) {
26 +
	file, err := os.Open("/etc/os-release")
27 +
	if err != nil {
28 +
		return "", err
29 +
	}
30 +
	defer file.Close()
31 +
32 +
	scanner := bufio.NewScanner(file)
33 +
	for scanner.Scan() {
34 +
		line := scanner.Text()
35 +
		if strings.HasPrefix(line, "PRETTY_NAME=") {
36 +
			value := strings.TrimPrefix(line, "PRETTY_NAME=")
37 +
			return strings.Trim(value, `"`), nil
38 +
		}
39 +
	}
40 +
	return "", scanner.Err()
41 +
}
42 +
43 +
func GetMachine() (string, error) {
44 +
	brandFile, err := os.ReadFile("/sys/class/dmi/id/sys_vendor")
45 +
	if err != nil {
46 +
		return "", err
47 +
	}
48 +
	productFile, err := os.ReadFile("/sys/class/dmi/id/product_name")
49 +
	if err != nil {
50 +
		return "", err
51 +
	}
52 +
53 +
	brand := strings.TrimSpace(string(brandFile))
54 +
	product := strings.TrimSpace(string(productFile))
55 +
	
56 +
 return fmt.Sprintf("%s %s", brand, product), nil
57 +
}
58 +
59 +
func GetMemory() (string, error) {
60 +
	var memTotal string
61 +
	var memAvailable string
62 +
	file, err := os.Open("/proc/meminfo")
63 +
	if err != nil {
64 +
		return "", err
65 +
	}
66 +
	defer file.Close()
67 +
68 +
	scanner := bufio.NewScanner(file)
69 +
	for scanner.Scan() {
70 +
		line := scanner.Text()
71 +
		if strings.HasPrefix(line, "MemTotal:") {
72 +
			value := strings.TrimPrefix(line, "MemTotal:")
73 +
74 +
			memTotal = strings.Trim(value, ` kB`)
75 +
		}
76 +
		if strings.HasPrefix(line, "MemAvailable:") {
77 +
			value := strings.TrimPrefix(line, "MemAvailable:")
78 +
79 +
			memAvailable = strings.Trim(value, ` kB`)
80 +
		}
81 +
	}
82 +
	memTotalInt, err := strconv.Atoi(memTotal)
83 +
	if err != nil {
84 +
		fmt.Println("Problem convering mem total to int", err)
85 +
		os.Exit(1)
86 +
	}
87 +
	memAvailableInt, err := strconv.Atoi(memAvailable)
88 +
	if err != nil {
89 +
		fmt.Println("Problem convering mem available to int", err)
90 +
		os.Exit(1)
91 +
	}
92 +
93 +
	memTotalGb := float64(memTotalInt) / float64(1024) / float64(1024)
94 +
	memAvailableGb := float64(memAvailableInt) / float64(1024) / float64(1024)
95 +
	memUsed := memTotalGb - memAvailableGb
96 +
97 +
	result := fmt.Sprintf("%.2f Gb / %.2f Gb", memUsed, memTotalGb)
98 +
	return result, scanner.Err()
99 +
}
100 +
101 +
func GetUptime() (string, error) {
102 +
	var si syscall.Sysinfo_t
103 +
	syscall.Sysinfo(&si)
104 +
105 +
	uptime := time.Duration(float64(si.Uptime) * float64(time.Second))
106 +
107 +
	hours := int(uptime.Hours())
108 +
	minutes := int(uptime.Minutes()) % 60
109 +
110 +
	return fmt.Sprintf("%d hours, %d mins", hours, minutes), nil
111 +
}
main.go +13 −94
1 1
package main
2 2
3 3
import (
4 -
	"bufio"
5 4
	"fmt"
6 5
	"os"
7 -
	"strconv"
8 -
	"strings"
9 -
	"syscall"
10 -
	"time"
6 +
	internal "github.com/stevedylandev/gobble/internal"
11 7
)
12 8
13 9
// Gobble: fetch in go for fun
15 11
//
16 12
// Order:
17 13
// Host - Done
18 -
// Machine /sys/class/dmi/id/sys_vendor + /sys/class/dmi/id/product_name
14 +
// Machine - Done
19 15
// Kernal - /proc/sys/kernal/osrelease
20 16
// Distro - Done
21 17
// Packages - /lib/apk/db/installed count P:
29 25
// Need to figure out colors and printing design
30 26
31 27
func main() {
32 -
	hostname, err := getHostname()
28 +
	hostname, err := internal.GetHostname()
33 29
	if err != nil {
34 30
		fmt.Println("error:", err)
35 31
		os.Exit(1)
36 32
	}
37 -
	fmt.Println(hostname)
33 +
	fmt.Printf(hostname)
38 34
	fmt.Println("-----------------------------")
39 -
	distro, err := getDistro()
35 +
	machine, err := internal.GetMachine()
36 +
	if err != nil {
37 +
		fmt.Println("error:", err)
38 +
		os.Exit(1)
39 +
	}
40 +
	fmt.Println("Machine: ", machine)
41 +
	distro, err := internal.GetDistro()
40 42
	if err != nil {
41 43
		fmt.Println("error:", err)
42 44
		os.Exit(1)
43 45
	}
44 46
	fmt.Println("Disto: ", distro)
45 -
	memory, err := getMemory()
47 +
	memory, err := internal.GetMemory()
46 48
	if err != nil {
47 49
		fmt.Println("error:", err)
48 50
		os.Exit(1)
49 51
	}
50 52
	fmt.Println("Memory: ", memory)
51 53
52 -
	uptime, err := getUptime()
54 +
	uptime, err := internal.GetUptime()
53 55
	if err != nil {
54 56
		fmt.Println("error:", err)
55 57
		os.Exit(1)
59 61
	os.Exit(0)
60 62
}
61 63
62 -
func getHostname() (string, error) {
63 -
	hostname, err := os.Hostname()
64 -
	if err != nil {
65 -
		return "", err
66 -
	}
67 -
	user := os.Getenv("USER")
68 -
	if user == "" {
69 -
		return "", err
70 -
	}
71 -
	return fmt.Sprintf("%s@%s\n", user, hostname), nil
72 -
}
73 -
74 -
func getDistro() (string, error) {
75 -
	file, err := os.Open("/etc/os-release")
76 -
	if err != nil {
77 -
		return "", err
78 -
	}
79 -
	defer file.Close()
80 -
81 -
	scanner := bufio.NewScanner(file)
82 -
	for scanner.Scan() {
83 -
		line := scanner.Text()
84 -
		if strings.HasPrefix(line, "PRETTY_NAME=") {
85 -
			value := strings.TrimPrefix(line, "PRETTY_NAME=")
86 -
			return strings.Trim(value, `"`), nil
87 -
		}
88 -
	}
89 -
	return "", scanner.Err()
90 -
}
91 -
92 -
func getMemory() (string, error) {
93 -
	var memTotal string
94 -
	var memAvailable string
95 -
	file, err := os.Open("/proc/meminfo")
96 -
	if err != nil {
97 -
		return "", err
98 -
	}
99 -
	defer file.Close()
100 -
101 -
	scanner := bufio.NewScanner(file)
102 -
	for scanner.Scan() {
103 -
		line := scanner.Text()
104 -
		if strings.HasPrefix(line, "MemTotal:") {
105 -
			value := strings.TrimPrefix(line, "MemTotal:")
106 -
107 -
			memTotal = strings.Trim(value, ` kB`)
108 -
		}
109 -
		if strings.HasPrefix(line, "MemAvailable:") {
110 -
			value := strings.TrimPrefix(line, "MemAvailable:")
111 -
112 -
			memAvailable = strings.Trim(value, ` kB`)
113 -
		}
114 -
	}
115 -
	memTotalInt, err := strconv.Atoi(memTotal)
116 -
	if err != nil {
117 -
		fmt.Println("Problem convering mem total to int", err)
118 -
		os.Exit(1)
119 -
	}
120 -
	memAvailableInt, err := strconv.Atoi(memAvailable)
121 -
	if err != nil {
122 -
		fmt.Println("Problem convering mem available to int", err)
123 -
		os.Exit(1)
124 -
	}
125 -
126 -
	memTotalGb := float64(memTotalInt) / float64(1024) / float64(1024)
127 -
	memAvailableGb := float64(memAvailableInt) / float64(1024) / float64(1024)
128 -
	memUsed := memTotalGb - memAvailableGb
129 -
130 -
	result := fmt.Sprintf("%.2f Gb / %.2f Gb", memUsed, memTotalGb)
131 -
	return result, scanner.Err()
132 -
}
133 -
134 -
func getUptime() (string, error) {
135 -
	var si syscall.Sysinfo_t
136 -
	syscall.Sysinfo(&si)
137 -
138 -
	uptime := time.Duration(float64(si.Uptime) * float64(time.Second))
139 -
140 -
	hours := int(uptime.Hours())
141 -
	minutes := int(uptime.Minutes()) % 60
142 -
143 -
	return fmt.Sprintf("%d hours, %d mins", hours, minutes), nil
144 -
}