chore: moved helpers to internal
51e922c4
2 file(s) · +124 −94
| 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 | + | } |
| 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 | - | } |
|