BlueGit

timfa bluegit

Files

bluegit / internal / state / state.go

state.go

feat: toon map- en schijfverbruik op het opslagtabblad
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
Failed 54b73354 History
state.go 4.5 KiB Download Raw
1// Package state bewaart wat BlueGit nodig heeft vóór de datadisk gekozen is:
2// de database, de sleutel en het gekozen opslagpad. De standaardmap is
3// /var/lib/bluegit, de StateDirectory van systemd.
4package state
5
6import (
7 "context"
8 "errors"
9 "fmt"
10 "io/fs"
11 "os"
12 "path/filepath"
13 "strings"
14 "syscall"
15
16 "gitlab.com/Timfa/bluegit/internal/i18n"
17)
18
19// DefaultDir is de state-map als state_path leeg is.
20const DefaultDir = "/var/lib/bluegit"
21
22// File is de naam van het bestand met het gekozen opslagpad.
23const File = "storage_path"
24
25// MinFreeBytes is de kleinste vrije ruimte die een datadisk mag hebben.
26const MinFreeBytes = 1 << 30
27
28// Dir kiest de state-map. Een gezet pad wint van de standaard.
29func Dir(configured string) string {
30 if strings.TrimSpace(configured) != "" {
31 return strings.TrimSpace(configured)
32 }
33 return DefaultDir
34}
35
36// Read leest het opgeslagen pad. Een ontbrekend bestand is geen fout
37// en geeft een lege string.
38func Read(dir string) (string, error) {
39 b, err := os.ReadFile(filepath.Join(dir, File))
40 if errors.Is(err, os.ErrNotExist) {
41 return "", nil
42 }
43 if err != nil {
44 return "", err
45 }
46 return strings.TrimSpace(string(b)), nil
47}
48
49// Write zet het pad atomisch neer.
50func Write(dir, path string) error {
51 if err := os.MkdirAll(dir, 0o750); err != nil {
52 return err
53 }
54 target := filepath.Join(dir, File)
55 tmp := target + ".tmp"
56 if err := os.WriteFile(tmp, []byte(path+"\n"), 0o640); err != nil {
57 return err
58 }
59 return os.Rename(tmp, target)
60}
61
62// Info is het resultaat van een schijfcontrole.
63type Info struct {
64 Path string
65 Free uint64
66 Total uint64
67}
68
69// Inspect eist een absoluut pad dat bestaat, een map is, beschrijfbaar is
70// en minstens MinFreeBytes vrij heeft. Bij een te volle of niet beschrijfbare
71// map zitten Free en Total alsnog in het resultaat.
72func Inspect(path string) (Info, error) {
73 path = strings.TrimSpace(path)
74 if path == "" {
75 return Info{}, i18n.E("err.pathMissing")
76 }
77 if strings.ContainsAny(path, "\r\n") {
78 return Info{}, i18n.E("err.pathNewline")
79 }
80 if !filepath.IsAbs(path) {
81 return Info{}, i18n.E("err.pathAbsolute")
82 }
83 path = filepath.Clean(path)
84 info := Info{Path: path}
85 st, err := os.Stat(path)
86 if err != nil {
87 if errors.Is(err, os.ErrNotExist) {
88 return info, i18n.E("err.pathAbsent")
89 }
90 return info, i18n.E("err.pathRead", err.Error())
91 }
92 if !st.IsDir() {
93 return info, i18n.E("err.pathDir")
94 }
95 var stat syscall.Statfs_t
96 if err := syscall.Statfs(path, &stat); err != nil {
97 return info, i18n.E("err.pathFree", err.Error())
98 }
99 info.Free = uint64(stat.Bavail) * uint64(stat.Bsize)
100 info.Total = uint64(stat.Blocks) * uint64(stat.Bsize)
101 probe := filepath.Join(path, ".bluegit-write-test")
102 f, err := os.OpenFile(probe, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
103 if err != nil {
104 return info, i18n.E("err.pathWrite")
105 }
106 _ = f.Close()
107 _ = os.Remove(probe)
108 if info.Free < MinFreeBytes {
109 return info, i18n.E("err.pathSpace", Format(info.Free), Format(MinFreeBytes))
110 }
111 return info, nil
112}
113
114// Used is de bezette ruimte: totaal min wat nog vrij is.
115// Vrij komt uit Bavail, dus gereserveerde blokken tellen als bezet.
116func (i Info) Used() uint64 {
117 if i.Free >= i.Total {
118 return 0
119 }
120 return i.Total - i.Free
121}
122
123// Percent rondt used/total af op een heel percentage.
124// Een leeg totaal is 0. Meer dan vol blijft 100.
125func Percent(used, total uint64) int {
126 if total == 0 {
127 return 0
128 }
129 if used > total {
130 used = total
131 }
132 return int((used*100 + total/2) / total)
133}
134
135// DirSize telt de schijnbare grootte van path, recursief.
136// Symlinks worden niet gevolgd. Een afgelopen context stopt de wandeling
137// en geeft terug wat al geteld is, samen met ctx.Err().
138func DirSize(ctx context.Context, root string) (uint64, error) {
139 var total uint64
140 err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
141 if ctx.Err() != nil {
142 return ctx.Err()
143 }
144 if err != nil {
145 if path == root {
146 return err
147 }
148 return nil
149 }
150 info, ierr := d.Info()
151 if ierr != nil {
152 return nil
153 }
154 if info.Mode()&os.ModeSymlink != 0 {
155 return nil
156 }
157 total += uint64(info.Size())
158 return nil
159 })
160 if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
161 return total, err
162 }
163 return total, err
164}
165
166// Format maakt een korte grootte, bijvoorbeeld "1.5 GiB".
167func Format(n uint64) string {
168 const unit = 1024
169 if n < unit {
170 return fmt.Sprintf("%d B", n)
171 }
172 div := uint64(unit)
173 exp := 0
174 for n/div >= unit && exp < 4 {
175 div *= unit
176 exp++
177 }
178 value := float64(n) / float64(div)
179 return fmt.Sprintf("%.1f %ciB", value, "KMGT"[exp])
180}