mirror of
https://github.com/EnumeratedDev/stormfetch.git
synced 2026-09-15 23:46:12 +00:00
Moved go files to src/ folder
This commit is contained in:
+19
@@ -0,0 +1,19 @@
|
||||
module stormfetch
|
||||
|
||||
go 1.22
|
||||
|
||||
require (
|
||||
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240506104042-037f3cc74f2a
|
||||
github.com/jackmordaunt/ghw v1.0.4
|
||||
github.com/mitchellh/go-ps v1.0.0
|
||||
gopkg.in/yaml.v3 v3.0.1
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/go-ole/go-ole v1.2.6 // indirect
|
||||
github.com/jackmordaunt/pcidb v1.0.1 // indirect
|
||||
github.com/jackmordaunt/wmi v1.2.4 // indirect
|
||||
github.com/kr/pretty v0.1.0 // indirect
|
||||
golang.org/x/sys v0.3.0 // indirect
|
||||
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
|
||||
)
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240506104042-037f3cc74f2a h1:vxnBhFDDT+xzxf1jTJKMKZw3H0swfWk9RpWbBbDK5+0=
|
||||
github.com/go-gl/glfw/v3.3/glfw v0.0.0-20240506104042-037f3cc74f2a/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
|
||||
github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
|
||||
github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
|
||||
github.com/jackmordaunt/ghw v1.0.4 h1:as+COFuPuXaNQC3WqzoHS/E2JYWZU7gN8ompNTUxNxs=
|
||||
github.com/jackmordaunt/ghw v1.0.4/go.mod h1:4dReYvJ36CoAzIxlEx8du25Qi/YqKYvEGE9QJoRXiK8=
|
||||
github.com/jackmordaunt/pcidb v1.0.1 h1:uLLZa6kD5P39r2cwMyJJkxmuHfH9Wq19gYQEbYcB0Z4=
|
||||
github.com/jackmordaunt/pcidb v1.0.1/go.mod h1:OMmhrZOZVu2hYXhBDZXddypxwKR/dp4DbIgzCkQDxdQ=
|
||||
github.com/jackmordaunt/wmi v1.2.4 h1:/XyuMiKby0qXNQp1j0uU0JqTWLM0QGOVok1Hf5Yagtg=
|
||||
github.com/jackmordaunt/wmi v1.2.4/go.mod h1:K/+FH4467Vk2fJXhYQTZzhctkCMMR7PwHqKbnizFySo=
|
||||
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
|
||||
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
|
||||
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
|
||||
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
|
||||
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
|
||||
github.com/mitchellh/go-ps v1.0.0 h1:i6ampVEEF4wQFF+bkYfwYgY+F/uYJDktmvLPf7qIgjc=
|
||||
github.com/mitchellh/go-ps v1.0.0/go.mod h1:J4lOc8z8yJs6vUwklHw2XEIiT4z4C40KtWVN3nvg8Pg=
|
||||
golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.3.0 h1:w8ZOecv6NaNa/zC8944JTU3vz4u6Lagfk4RPQxv92NQ=
|
||||
golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
|
||||
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||
@@ -0,0 +1,70 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/go-gl/glfw/v3.3/glfw"
|
||||
"github.com/jackmordaunt/ghw"
|
||||
"os"
|
||||
"os/exec"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func GetCPUModel() string {
|
||||
cpu, err := ghw.CPU()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
if len(cpu.Processors) == 0 {
|
||||
return ""
|
||||
}
|
||||
return cpu.Processors[0].Model
|
||||
}
|
||||
|
||||
func GetCPUThreads() int {
|
||||
cpu, err := ghw.CPU()
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
return int(cpu.TotalThreads)
|
||||
}
|
||||
|
||||
func GetGPUModels() []string {
|
||||
var ret []string
|
||||
cmd := exec.Command("/bin/bash", "-c", "lspci -v -m | grep 'VGA' -A6 | grep '^Device:' | sed 's/^Device://' | awk '{$1=$1};1'")
|
||||
bytes, err := cmd.Output()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
for _, name := range strings.Split(string(bytes), "\n") {
|
||||
name = strings.TrimSpace(name)
|
||||
if name == "" {
|
||||
continue
|
||||
}
|
||||
ret = append(ret, name)
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func GetMotherboardModel() string {
|
||||
bytes, err := os.ReadFile("/sys/devices/virtual/dmi/id/board_name")
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(string(bytes))
|
||||
}
|
||||
|
||||
func GetMonitorResolution() []string {
|
||||
var monitors []string
|
||||
if GetDisplayProtocol() != "" {
|
||||
err := glfw.Init()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
for _, monitor := range glfw.GetMonitors() {
|
||||
mode := monitor.GetVideoMode()
|
||||
monitors = append(monitors, fmt.Sprintf("%dx%d %dHz", mode.Width, mode.Height, mode.RefreshRate))
|
||||
}
|
||||
defer glfw.Terminate()
|
||||
}
|
||||
return monitors
|
||||
}
|
||||
+310
@@ -0,0 +1,310 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"gopkg.in/yaml.v3"
|
||||
"log"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
var systemConfigDir = "/etc/"
|
||||
|
||||
var configPath = ""
|
||||
var fetchScriptPath = ""
|
||||
|
||||
var TimeTaken = false
|
||||
|
||||
var config = StormfetchConfig{
|
||||
Ascii: "auto",
|
||||
FetchScript: "auto",
|
||||
AnsiiColors: make([]int, 0),
|
||||
ForceConfigAnsii: false,
|
||||
DependencyWarning: true,
|
||||
ShowFSType: false,
|
||||
HiddenPartitions: make([]string, 0),
|
||||
HiddenGPUS: make([]int, 0),
|
||||
}
|
||||
|
||||
type StormfetchConfig struct {
|
||||
Ascii string `yaml:"distro_ascii"`
|
||||
DistroName string `yaml:"distro_name"`
|
||||
FetchScript string `yaml:"fetch_script"`
|
||||
AnsiiColors []int `yaml:"ansii_colors"`
|
||||
ForceConfigAnsii bool `yaml:"force_config_ansii"`
|
||||
DependencyWarning bool `yaml:"dependency_warning"`
|
||||
ShowFSType bool `yaml:"show_fs_type"`
|
||||
HiddenPartitions []string `yaml:"hidden_partitions"`
|
||||
HiddenFilesystems []string `yaml:"hidden_filesystems"`
|
||||
HiddenGPUS []int `yaml:"hidden_gpus"`
|
||||
}
|
||||
|
||||
func main() {
|
||||
readConfig()
|
||||
readFlags()
|
||||
checkDependencies()
|
||||
runStormfetch()
|
||||
}
|
||||
|
||||
func readConfig() {
|
||||
// Get home directory
|
||||
userConfigDir, _ := os.UserConfigDir()
|
||||
// Find valid config directory
|
||||
if _, err := os.Stat(path.Join(userConfigDir, "stormfetch/config.yaml")); err == nil {
|
||||
configPath = path.Join(userConfigDir, "stormfetch/config.yaml")
|
||||
} else if _, err := os.Stat(path.Join(systemConfigDir, "stormfetch/config.yaml")); err == nil {
|
||||
configPath = path.Join(systemConfigDir, "stormfetch/config.yaml")
|
||||
} else {
|
||||
log.Fatalf("Config file not found: %s", err.Error())
|
||||
}
|
||||
// Parse config
|
||||
bytes, err := os.ReadFile(configPath)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
err = yaml.Unmarshal(bytes, &config)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
if config.FetchScript == "" {
|
||||
log.Fatalf("Fetch script path is empty")
|
||||
} else if config.FetchScript != "auto" {
|
||||
stat, err := os.Stat(config.FetchScript)
|
||||
if err != nil {
|
||||
log.Fatalf("Fetch script file not found: %s", err.Error())
|
||||
} else if stat.IsDir() {
|
||||
log.Fatalf("Fetch script path points to a directory")
|
||||
}
|
||||
}
|
||||
if _, err := os.Stat(path.Join(userConfigDir, "stormfetch/fetch_script.sh")); err == nil {
|
||||
fetchScriptPath = path.Join(userConfigDir, "stormfetch/fetch_script.sh")
|
||||
} else if _, err := os.Stat(path.Join(systemConfigDir, "stormfetch/fetch_script.sh")); err == nil {
|
||||
fetchScriptPath = path.Join(systemConfigDir, "stormfetch/fetch_script.sh")
|
||||
} else {
|
||||
log.Fatalf("Fetch script file not found: %s", err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
func readFlags() {
|
||||
flag.StringVar(&config.Ascii, "ascii", config.Ascii, "Set distro ascii")
|
||||
flag.StringVar(&config.DistroName, "distro-name", config.DistroName, "Set distro name")
|
||||
flag.BoolVar(&TimeTaken, "time-taken", false, "Show time taken for fetched information")
|
||||
flag.Parse()
|
||||
}
|
||||
|
||||
func checkDependencies() {
|
||||
// Show Dependency warning if enabled
|
||||
if config.DependencyWarning {
|
||||
var dependencies []string
|
||||
var missing []string
|
||||
for _, depend := range dependencies {
|
||||
if _, err := os.Stat(path.Join("/usr/bin/", depend)); err != nil {
|
||||
missing = append(missing, depend)
|
||||
}
|
||||
}
|
||||
if len(missing) != 0 {
|
||||
fmt.Println("[WARNING] Stormfetch functionality may be limited due to the following dependencies not being installed:")
|
||||
for _, depend := range missing {
|
||||
fmt.Println(depend)
|
||||
}
|
||||
fmt.Println("You can disable this warning through your stormfetch config")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func SetupFetchEnv(showTimeTaken bool) []string {
|
||||
var env = make(map[string]string)
|
||||
setVariable := func(key string, setter func() string) {
|
||||
start := time.Now().UnixMilli()
|
||||
env[key] = setter()
|
||||
end := time.Now().UnixMilli()
|
||||
if showTimeTaken {
|
||||
fmt.Println(fmt.Sprintf("Setting '%s' took %d milliseconds", key, end-start))
|
||||
}
|
||||
}
|
||||
setVariable("PACKAGES", func() string { return GetInstalledPackages() })
|
||||
setVariable("DISTRO_LONG_NAME", func() string { return GetDistroInfo().LongName })
|
||||
setVariable("DISTRO_SHORT_NAME", func() string { return GetDistroInfo().ShortName })
|
||||
setVariable("CPU_MODEL", func() string { return GetCPUModel() })
|
||||
setVariable("MOTHERBOARD", func() string { return GetMotherboardModel() })
|
||||
setVariable("CPU_THREADS", func() string { return strconv.Itoa(GetCPUThreads()) })
|
||||
start := time.Now().UnixMilli()
|
||||
memory := GetMemoryInfo()
|
||||
end := time.Now().UnixMilli()
|
||||
if showTimeTaken {
|
||||
fmt.Println(fmt.Sprintf("Setting '%s' took %d milliseconds", "MEM_*", end-start))
|
||||
}
|
||||
if memory != nil {
|
||||
env["MEM_TOTAL"] = strconv.Itoa(memory.MemTotal)
|
||||
env["MEM_USED"] = strconv.Itoa(memory.MemTotal - memory.MemAvailable)
|
||||
env["MEM_FREE"] = strconv.Itoa(memory.MemAvailable)
|
||||
}
|
||||
start = time.Now().UnixMilli()
|
||||
partitions := GetMountedPartitions(config.HiddenPartitions, config.HiddenFilesystems)
|
||||
end = time.Now().UnixMilli()
|
||||
if showTimeTaken {
|
||||
fmt.Println(fmt.Sprintf("Setting '%s' took %d milliseconds", "PARTITION_*", end-start))
|
||||
}
|
||||
if len(partitions) != 0 {
|
||||
env["MOUNTED_PARTITIONS"] = strconv.Itoa(len(partitions))
|
||||
for i, part := range partitions {
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_DEVICE"] = part.Device
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_MOUNTPOINT"] = part.MountPoint
|
||||
if part.Label != "" {
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_LABEL"] = part.Label
|
||||
}
|
||||
if part.FileystemType != "" && config.ShowFSType {
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_TYPE"] = part.FileystemType
|
||||
}
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_TOTAL_SIZE"] = FormatBytes(part.TotalSize)
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_USED_SIZE"] = FormatBytes(part.UsedSize)
|
||||
env["PARTITION"+strconv.Itoa(i+1)+"_FREE_SIZE"] = FormatBytes(part.FreeSize)
|
||||
}
|
||||
}
|
||||
setVariable("DE_WM", func() string { return GetDEWM() })
|
||||
setVariable("USER_SHELL", func() string { return GetShell() })
|
||||
setVariable("DISPLAY_PROTOCOL", func() string { return GetDisplayProtocol() })
|
||||
setVariable("LIBC", func() string { return GetLibc() })
|
||||
setVariable("INIT_SYSTEM", func() string { return GetInitSystem() })
|
||||
setVariable("LOCAL_IPV4", func() string { return GetLocalIP() })
|
||||
start = time.Now().UnixMilli()
|
||||
monitors := GetMonitorResolution()
|
||||
end = time.Now().UnixMilli()
|
||||
if showTimeTaken {
|
||||
fmt.Println(fmt.Sprintf("Setting '%s' took %d milliseconds", "MONITOR_*", end-start))
|
||||
}
|
||||
if len(monitors) != 0 {
|
||||
env["CONNECTED_MONITORS"] = strconv.Itoa(len(monitors))
|
||||
for i, monitor := range monitors {
|
||||
env["MONITOR"+strconv.Itoa(i+1)] = monitor
|
||||
}
|
||||
}
|
||||
start = time.Now().UnixMilli()
|
||||
gpus := GetGPUModels()
|
||||
end = time.Now().UnixMilli()
|
||||
if showTimeTaken {
|
||||
fmt.Println(fmt.Sprintf("Setting '%s' took %d milliseconds", "GPU_*", end-start))
|
||||
}
|
||||
if len(gpus) != 0 {
|
||||
env["CONNECTED_GPUS"] = strconv.Itoa(len(gpus))
|
||||
for i, gpu := range gpus {
|
||||
if gpu == "" {
|
||||
continue
|
||||
}
|
||||
env["GPU"+strconv.Itoa(i+1)] = gpu
|
||||
}
|
||||
}
|
||||
|
||||
var ret = make([]string, len(env))
|
||||
i := 0
|
||||
for key, value := range env {
|
||||
ret[i] = fmt.Sprintf("%s=%s", key, value)
|
||||
i++
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
func runStormfetch() {
|
||||
// Fetch ascii art and apply colors
|
||||
colorMap := make(map[string]string)
|
||||
colorMap["C0"] = "\033[0m"
|
||||
setColorMap := func() {
|
||||
for i := 0; i < 6; i++ {
|
||||
if i > len(config.AnsiiColors)-1 {
|
||||
colorMap["C"+strconv.Itoa(i+1)] = "\033[0m"
|
||||
continue
|
||||
}
|
||||
colorMap["C"+strconv.Itoa(i+1)] = fmt.Sprintf("\033[1m\033[38;5;%dm", config.AnsiiColors[i])
|
||||
}
|
||||
}
|
||||
setColorMap()
|
||||
ascii := GetDistroAsciiArt()
|
||||
if strings.HasPrefix(ascii, "#/") {
|
||||
firstLine := strings.Split(ascii, "\n")[0]
|
||||
if !config.ForceConfigAnsii {
|
||||
ansiiColors := strings.Split(strings.TrimPrefix(firstLine, "#/"), ";")
|
||||
for i, color := range ansiiColors {
|
||||
atoi, err := strconv.Atoi(color)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
if i < len(config.AnsiiColors) {
|
||||
config.AnsiiColors[i] = atoi
|
||||
} else {
|
||||
config.AnsiiColors = append(config.AnsiiColors, atoi)
|
||||
}
|
||||
}
|
||||
setColorMap()
|
||||
}
|
||||
ascii = os.Expand(ascii, func(s string) string {
|
||||
return colorMap[s]
|
||||
})
|
||||
ascii = strings.TrimPrefix(ascii, firstLine+"\n")
|
||||
} else {
|
||||
ascii = os.Expand(ascii, func(s string) string {
|
||||
return colorMap[s]
|
||||
})
|
||||
}
|
||||
asciiSplit := strings.Split(ascii, "\n")
|
||||
asciiNoColor := StripAnsii(ascii)
|
||||
//Execute fetch script
|
||||
cmd := exec.Command("/bin/bash", fetchScriptPath)
|
||||
cmd.Dir = path.Dir(fetchScriptPath)
|
||||
cmd.Env = os.Environ()
|
||||
cmd.Env = append(cmd.Env, SetupFetchEnv(TimeTaken)...)
|
||||
cmd.Env = append(cmd.Env, "C0=\033[0m")
|
||||
for key, value := range colorMap {
|
||||
cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%s", key, value))
|
||||
}
|
||||
out, err := cmd.Output()
|
||||
if err != nil {
|
||||
log.Fatalf("Error: Could not run fetch script: %s", err)
|
||||
}
|
||||
// Print Distro Information
|
||||
maxWidth := 0
|
||||
for _, line := range strings.Split(asciiNoColor, "\n") {
|
||||
if len(line) > maxWidth {
|
||||
maxWidth = len(line)
|
||||
}
|
||||
}
|
||||
final := ""
|
||||
y := len(asciiSplit)
|
||||
if len(asciiSplit) < len(strings.Split(string(out), "\n")) {
|
||||
y = len(strings.Split(string(out), "\n"))
|
||||
}
|
||||
for lineIndex := 0; lineIndex < y; lineIndex++ {
|
||||
line := ""
|
||||
for i := 0; i < maxWidth+5; i++ {
|
||||
line = line + " "
|
||||
}
|
||||
lastAsciiColor := ""
|
||||
if lineIndex < len(asciiSplit) {
|
||||
line = asciiSplit[lineIndex]
|
||||
lineVisibleLength := len(strings.Split(asciiNoColor, "\n")[lineIndex])
|
||||
if lineIndex != 0 {
|
||||
r := regexp.MustCompile("\033[38;5;[0-9]+m")
|
||||
matches := r.FindAllString(asciiSplit[lineIndex-1], -1)
|
||||
if len(matches) != 0 {
|
||||
lastAsciiColor = r.FindAllString(asciiSplit[lineIndex-1], -1)[len(matches)-1]
|
||||
}
|
||||
}
|
||||
for i := lineVisibleLength; i < maxWidth+5; i++ {
|
||||
line = line + " "
|
||||
}
|
||||
asciiSplit[lineIndex] = lastAsciiColor + line
|
||||
}
|
||||
str := string(out)
|
||||
if lineIndex < len(strings.Split(str, "\n")) {
|
||||
line = line + colorMap["C0"] + strings.Split(str, "\n")[lineIndex]
|
||||
}
|
||||
final += lastAsciiColor + line + "\n"
|
||||
}
|
||||
final = strings.TrimRight(final, "\n\t ")
|
||||
fmt.Println(final + "\033[0m")
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type Memory struct {
|
||||
MemTotal int
|
||||
MemFree int
|
||||
MemAvailable int
|
||||
}
|
||||
|
||||
func GetMemoryInfo() *Memory {
|
||||
toInt := func(raw string) int {
|
||||
if raw == "" {
|
||||
return 0
|
||||
}
|
||||
res, err := strconv.Atoi(raw)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return res
|
||||
}
|
||||
|
||||
parseLine := func(raw string) (key string, value int) {
|
||||
text := strings.ReplaceAll(raw[:len(raw)-2], " ", "")
|
||||
keyValue := strings.Split(text, ":")
|
||||
return keyValue[0], toInt(keyValue[1])
|
||||
}
|
||||
|
||||
if _, err := os.Stat("/proc/meminfo"); err != nil {
|
||||
return nil
|
||||
}
|
||||
file, err := os.Open("/proc/meminfo")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer file.Close()
|
||||
bufio.NewScanner(file)
|
||||
scanner := bufio.NewScanner(file)
|
||||
res := Memory{}
|
||||
for scanner.Scan() {
|
||||
key, value := parseLine(scanner.Text())
|
||||
switch key {
|
||||
case "MemTotal":
|
||||
res.MemTotal = value / 1024
|
||||
case "MemFree":
|
||||
res.MemFree = value / 1024
|
||||
case "MemAvailable":
|
||||
res.MemAvailable = value / 1024
|
||||
}
|
||||
}
|
||||
return &res
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package main
|
||||
|
||||
import "net"
|
||||
|
||||
func GetLocalIP() string {
|
||||
conn, err := net.Dial("udp", "8.8.8.8:80")
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
defer conn.Close()
|
||||
|
||||
localAddr := conn.LocalAddr().(*net.UDPAddr)
|
||||
|
||||
return localAddr.IP.String()
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strings"
|
||||
"syscall"
|
||||
)
|
||||
|
||||
type partition struct {
|
||||
Device string
|
||||
MountPoint string
|
||||
Label string
|
||||
FileystemType string
|
||||
TotalSize uint64
|
||||
UsedSize uint64
|
||||
FreeSize uint64
|
||||
}
|
||||
|
||||
func GetMountedPartitions(hiddenPartitions, hiddenFilesystems []string) []partition {
|
||||
// Get all filesystem and partition labels
|
||||
fslabels, err := os.ReadDir("/dev/disk/by-label")
|
||||
if err != nil && !os.IsNotExist(err) {
|
||||
return nil
|
||||
}
|
||||
partlabels, err := os.ReadDir("/dev/disk/by-partlabel")
|
||||
if err != nil && !os.IsNotExist(err) {
|
||||
return nil
|
||||
}
|
||||
labels := make(map[string]string)
|
||||
for _, entry := range partlabels {
|
||||
link, err := filepath.EvalSymlinks(filepath.Join("/dev/disk/by-partlabel/", entry.Name()))
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
labels[link] = entry.Name()
|
||||
}
|
||||
for _, entry := range fslabels {
|
||||
link, err := filepath.EvalSymlinks(filepath.Join("/dev/disk/by-label/", entry.Name()))
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
labels[link] = entry.Name()
|
||||
}
|
||||
|
||||
// Get all mounted partitions
|
||||
file, err := os.ReadFile("/proc/mounts")
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
var partitions []partition
|
||||
for _, entry := range strings.Split(string(file), "\n") {
|
||||
fields := strings.Fields(entry)
|
||||
if entry == "" {
|
||||
continue
|
||||
}
|
||||
|
||||
// Skip virtual partitions not under /dev
|
||||
if !strings.HasPrefix(fields[0], "/dev") {
|
||||
continue
|
||||
}
|
||||
|
||||
// Skip partition if explicitly hidden
|
||||
if slices.Contains(hiddenPartitions, fields[0]) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Skip filesystem if explicitely hidden
|
||||
if slices.Contains(hiddenFilesystems, fields[2]) {
|
||||
continue
|
||||
}
|
||||
|
||||
p := partition{
|
||||
fields[0],
|
||||
fields[1],
|
||||
"",
|
||||
fields[2],
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
}
|
||||
|
||||
// Skip already added partitions
|
||||
skip := false
|
||||
for _, part := range partitions {
|
||||
if part.Device == p.Device {
|
||||
skip = true
|
||||
}
|
||||
}
|
||||
if skip {
|
||||
continue
|
||||
}
|
||||
|
||||
// Set partition label if available
|
||||
if value, ok := labels[p.Device]; ok {
|
||||
p.Label = value
|
||||
}
|
||||
|
||||
// Get partition total, used and free space
|
||||
buf := new(syscall.Statfs_t)
|
||||
err = syscall.Statfs(p.MountPoint, buf)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
totalBlocks := buf.Blocks
|
||||
freeBlocks := buf.Bfree
|
||||
usedBlocks := totalBlocks - freeBlocks
|
||||
blockSize := uint64(buf.Bsize)
|
||||
|
||||
p.TotalSize = totalBlocks * blockSize
|
||||
p.FreeSize = freeBlocks * blockSize
|
||||
p.UsedSize = usedBlocks * blockSize
|
||||
|
||||
partitions = append(partitions, p)
|
||||
}
|
||||
return partitions
|
||||
}
|
||||
+53
@@ -0,0 +1,53 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type PackageManager struct {
|
||||
Name string
|
||||
ExecutableName string
|
||||
PackageListCommand string
|
||||
}
|
||||
|
||||
var PackageManagers = []PackageManager{
|
||||
{Name: "dpkg", ExecutableName: "dpkg", PackageListCommand: "dpkg-query -f '${Package}\\n' -W"},
|
||||
{Name: "pacman", ExecutableName: "pacman", PackageListCommand: "pacman -Q"},
|
||||
{Name: "rpm", ExecutableName: "rpm", PackageListCommand: "rpm -qa"},
|
||||
{Name: "xbps", ExecutableName: "xbps-query", PackageListCommand: "xbps-query -l"},
|
||||
{Name: "bpm", ExecutableName: "bpm", PackageListCommand: "bpm list -n"},
|
||||
{Name: "portage", ExecutableName: "emerge", PackageListCommand: "find /var/db/pkg/*/ -mindepth 1 -maxdepth 1"},
|
||||
{Name: "flatpak", ExecutableName: "flatpak", PackageListCommand: "flatpak list"},
|
||||
{Name: "snap", ExecutableName: "snap", PackageListCommand: "snap list | tail +2"},
|
||||
}
|
||||
|
||||
func (pm *PackageManager) CountPackages() int {
|
||||
// Return 0 if package manager is not found
|
||||
if _, err := exec.LookPath(pm.ExecutableName); err != nil {
|
||||
return 0
|
||||
}
|
||||
|
||||
output, err := exec.Command("/bin/sh", "-c", pm.PackageListCommand).Output()
|
||||
if err != nil {
|
||||
return 0
|
||||
}
|
||||
|
||||
return strings.Count(string(output), "\n")
|
||||
}
|
||||
|
||||
func GetInstalledPackages() (ret string) {
|
||||
for _, pm := range PackageManagers {
|
||||
count := pm.CountPackages()
|
||||
if count > 0 {
|
||||
if ret == "" {
|
||||
ret += fmt.Sprintf("%d (%s)", count, pm.Name)
|
||||
} else {
|
||||
ret += fmt.Sprintf(" %d (%s)", count, pm.Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ret
|
||||
}
|
||||
+153
@@ -0,0 +1,153 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/go-ps"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type DistroInfo struct {
|
||||
ID string
|
||||
LongName string
|
||||
ShortName string
|
||||
}
|
||||
|
||||
func GetDistroInfo() DistroInfo {
|
||||
info := DistroInfo{
|
||||
ID: "unknown",
|
||||
LongName: "Unknown",
|
||||
ShortName: "Unknown",
|
||||
}
|
||||
if strings.TrimSpace(config.DistroName) != "" {
|
||||
info.LongName = strings.TrimSpace(config.DistroName)
|
||||
info.ShortName = strings.TrimSpace(config.DistroName)
|
||||
}
|
||||
var releaseMap = make(map[string]string)
|
||||
if _, err := os.Stat("/etc/os-release"); err == nil {
|
||||
releaseMap, err = ReadKeyValueFile("/etc/os-release")
|
||||
if err != nil {
|
||||
return info
|
||||
}
|
||||
}
|
||||
if id, ok := releaseMap["ID"]; ok {
|
||||
info.ID = id
|
||||
}
|
||||
if longName, ok := releaseMap["PRETTY_NAME"]; ok && info.LongName == "Unknown" {
|
||||
info.LongName = longName
|
||||
}
|
||||
if shortName, ok := releaseMap["NAME"]; ok && info.ShortName == "Unknown" {
|
||||
info.ShortName = shortName
|
||||
}
|
||||
return info
|
||||
}
|
||||
|
||||
func GetDistroAsciiArt() string {
|
||||
defaultAscii :=
|
||||
` .--.
|
||||
|o_o |
|
||||
|:_/ |
|
||||
// \ \
|
||||
(| | )
|
||||
/'\_ _/'\
|
||||
\___)=(___/ `
|
||||
var id string
|
||||
if config.Ascii == "auto" {
|
||||
id = GetDistroInfo().ID
|
||||
} else {
|
||||
id = config.Ascii
|
||||
}
|
||||
userConfDir, err := os.UserConfigDir()
|
||||
if err != nil {
|
||||
if _, err := os.Stat(path.Join(systemConfigDir, "stormfetch/ascii/", id)); err == nil {
|
||||
bytes, err := os.ReadFile(path.Join(systemConfigDir, "stormfetch/ascii/", id))
|
||||
if err != nil {
|
||||
return defaultAscii
|
||||
}
|
||||
return string(bytes)
|
||||
} else {
|
||||
return defaultAscii
|
||||
}
|
||||
}
|
||||
if _, err := os.Stat(path.Join(userConfDir, "stormfetch/ascii/", id)); err == nil {
|
||||
bytes, err := os.ReadFile(path.Join(userConfDir, "stormfetch/ascii/", id))
|
||||
if err != nil {
|
||||
return defaultAscii
|
||||
}
|
||||
return string(bytes)
|
||||
} else if _, err := os.Stat(path.Join(systemConfigDir, "stormfetch/ascii/", id)); err == nil {
|
||||
bytes, err := os.ReadFile(path.Join(systemConfigDir, "stormfetch/ascii/", id))
|
||||
if err != nil {
|
||||
return defaultAscii
|
||||
}
|
||||
return strings.TrimRight(string(bytes), "\n\t ")
|
||||
} else {
|
||||
return defaultAscii
|
||||
}
|
||||
}
|
||||
|
||||
func GetInitSystem() string {
|
||||
runCommand := func(command string) string {
|
||||
cmd := exec.Command("/bin/bash", "-c", command)
|
||||
workdir, err := os.Getwd()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
cmd.Dir = workdir
|
||||
cmd.Env = os.Environ()
|
||||
out, err := cmd.Output()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(string(out))
|
||||
}
|
||||
|
||||
process, err := ps.FindProcess(1)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
|
||||
// Special cases
|
||||
// OpenRC check
|
||||
if _, err := os.Stat("/usr/sbin/openrc"); err == nil {
|
||||
return "OpenRC " + runCommand("openrc --version | awk '{print $3}'")
|
||||
}
|
||||
|
||||
// Default PID 1 process name checking
|
||||
switch process.Executable() {
|
||||
case "systemd":
|
||||
return "Systemd " + runCommand("systemctl --version | head -n1 | awk '{print $2}'")
|
||||
case "runit":
|
||||
return "Runit"
|
||||
case "dinit":
|
||||
return "Dinit " + runCommand("dinit --version | head -n1 | awk '{print substr($3, 1, length($3)-1)}'")
|
||||
case "enit":
|
||||
return "Enit " + runCommand("enit --version | awk '{print $3}'")
|
||||
default:
|
||||
return process.Executable()
|
||||
}
|
||||
}
|
||||
|
||||
func GetLibc() string {
|
||||
checkLibcOutput, err := exec.Command("ldd", "/usr/bin/ls").Output()
|
||||
if err != nil {
|
||||
return "Unknown"
|
||||
}
|
||||
|
||||
if strings.Contains(string(checkLibcOutput), "ld-musl") {
|
||||
// Using Musl Libc
|
||||
output, _ := exec.Command("ldd").CombinedOutput()
|
||||
return "Musl " + strings.TrimPrefix(strings.Split(strings.TrimSpace(string(output)), "\n")[1], "Version ")
|
||||
} else {
|
||||
// Using Glibc
|
||||
cmd := exec.Command("ldd", "--version")
|
||||
output, err := cmd.Output()
|
||||
if err != nil {
|
||||
return "Glibc"
|
||||
}
|
||||
outputSplit := strings.Split(strings.Split(strings.TrimSpace(string(output)), "\n")[0], " ")
|
||||
ver := outputSplit[len(outputSplit)-1]
|
||||
return "Glibc " + ver
|
||||
}
|
||||
}
|
||||
+127
@@ -0,0 +1,127 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"github.com/mitchellh/go-ps"
|
||||
"log"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"slices"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func GetShell() string {
|
||||
runCommand := func(command string) string {
|
||||
cmd := exec.Command("/bin/bash", "-c", command)
|
||||
workdir, err := os.Getwd()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
cmd.Dir = workdir
|
||||
cmd.Env = os.Environ()
|
||||
out, err := cmd.Output()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(string(out))
|
||||
}
|
||||
file, err := os.ReadFile("/etc/passwd")
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
str := string(file)
|
||||
shell := ""
|
||||
|
||||
for _, line := range strings.Split(str, "\n") {
|
||||
if strings.TrimSpace(line) == "" {
|
||||
continue
|
||||
}
|
||||
userInfo := strings.Split(line, ":")
|
||||
if userInfo[2] == strconv.Itoa(os.Getuid()) {
|
||||
shell = userInfo[6]
|
||||
}
|
||||
}
|
||||
shellName := filepath.Base(shell)
|
||||
switch shellName {
|
||||
case "dash":
|
||||
return "Dash"
|
||||
case "bash":
|
||||
return "Bash " + runCommand("echo $BASH_VERSION")
|
||||
case "zsh":
|
||||
return "Zsh " + runCommand("$SHELL --version | awk '{print $2}'")
|
||||
case "fish":
|
||||
return "Fish " + runCommand("$SHELL --version | awk '{print $3}'")
|
||||
case "nu":
|
||||
return "Nushell " + runCommand("$SHELL --version")
|
||||
default:
|
||||
return "Unknown"
|
||||
}
|
||||
}
|
||||
|
||||
func GetDEWM() string {
|
||||
processes, err := ps.Processes()
|
||||
if err != nil {
|
||||
log.Fatalf("Error: could not get processes: %s", err)
|
||||
}
|
||||
var executables []string
|
||||
for _, process := range processes {
|
||||
executables = append(executables, process.Executable())
|
||||
}
|
||||
|
||||
processExists := func(process string) bool {
|
||||
return slices.Contains(executables, process)
|
||||
}
|
||||
runCommand := func(command string) string {
|
||||
cmd := exec.Command("/bin/bash", "-c", command)
|
||||
workdir, err := os.Getwd()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
cmd.Dir = workdir
|
||||
cmd.Env = os.Environ()
|
||||
out, err := cmd.Output()
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(string(out))
|
||||
}
|
||||
if processExists("plasmashell") {
|
||||
return "KDE Plasma " + runCommand("plasmashell --version | awk '{print $2}'")
|
||||
} else if processExists("gnome-session") {
|
||||
return "Gnome " + runCommand("gnome-shell --version | awk '{print $3}'")
|
||||
} else if processExists("xfce4-session") {
|
||||
return "XFCE " + runCommand("xfce4-session --version | head -n1 | awk '{print $2}'")
|
||||
} else if processExists("cinnamon") {
|
||||
return "Cinnamon " + runCommand("cinnamon --version | awk '{print $3}'")
|
||||
} else if processExists("mate-panel") {
|
||||
return "MATE " + runCommand("mate-about --version | awk '{print $4}'")
|
||||
} else if processExists("lxsession") {
|
||||
return "LXDE"
|
||||
} else if processExists("i3") || processExists("i3-with-shmlog") {
|
||||
return "i3 " + runCommand("i3 --version | awk '{print $3}'")
|
||||
} else if processExists("sway") {
|
||||
if runCommand("sway --version | awk '{print $1}'") == "swayfx" {
|
||||
return "SwayFX " + runCommand("sway --version | awk '{print $3}'")
|
||||
} else {
|
||||
return "Sway " + runCommand("sway --version | awk '{print $3}'")
|
||||
}
|
||||
} else if processExists("bspwm") {
|
||||
return "Bspwm " + runCommand("bspwm -v")
|
||||
} else if processExists("Hyprland") {
|
||||
return "Hyprland " + runCommand("hyprctl version | sed -n 3p | awk '{print $2}' | tr -d 'v,'")
|
||||
} else if processExists("icewm-session") {
|
||||
return "IceWM " + runCommand("icewm --version | awk '{print $2}'")
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func GetDisplayProtocol() string {
|
||||
protocol := os.Getenv("XDG_SESSION_TYPE")
|
||||
if protocol == "x11" {
|
||||
return "X11"
|
||||
} else if protocol == "wayland" {
|
||||
return "Wayland"
|
||||
}
|
||||
return ""
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"os"
|
||||
"regexp"
|
||||
"strings"
|
||||
)
|
||||
|
||||
func FormatBytes(bytes uint64) string {
|
||||
var suffixes [6]string
|
||||
suffixes[0] = "B"
|
||||
suffixes[1] = "KiB"
|
||||
suffixes[2] = "MiB"
|
||||
suffixes[3] = "GiB"
|
||||
suffixes[4] = "TiB"
|
||||
suffixes[5] = "PiB"
|
||||
|
||||
bf := float64(bytes)
|
||||
for _, unit := range suffixes {
|
||||
if math.Abs(bf) < 1024.0 {
|
||||
return fmt.Sprintf("%3.1f %s", bf, unit)
|
||||
}
|
||||
bf /= 1024.0
|
||||
}
|
||||
return fmt.Sprintf("%.1fYiB", bf)
|
||||
}
|
||||
|
||||
func StripAnsii(str string) string {
|
||||
const ansi = "[\u001B\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))"
|
||||
var re = regexp.MustCompile(ansi)
|
||||
return re.ReplaceAllString(str, "")
|
||||
}
|
||||
|
||||
func ReadKeyValueFile(filepath string) (map[string]string, error) {
|
||||
ret := make(map[string]string)
|
||||
if _, err := os.Stat(filepath); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
bytes, err := os.ReadFile(filepath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
str := string(bytes)
|
||||
lines := strings.Split(str, "\n")
|
||||
for _, line := range lines {
|
||||
if len(strings.Split(line, "=")) >= 2 {
|
||||
key := strings.SplitN(line, "=", 2)[0]
|
||||
value := strings.SplitN(line, "=", 2)[1]
|
||||
if strings.HasPrefix(value, "\"") && strings.HasSuffix(value, "\"") {
|
||||
value = value[1 : len(value)-1]
|
||||
}
|
||||
ret[key] = value
|
||||
}
|
||||
}
|
||||
return ret, nil
|
||||
}
|
||||
Reference in New Issue
Block a user