BlueGit

timfa bluegit

Files

bluegit / internal / state / state.go

state.go

state.go 4.7 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 // Reserved zijn blokken die alleen root mag gebruiken (tune2fs -m).
68 Reserved uint64
69}
70
71// Inspect eist een absoluut pad dat bestaat, een map is, beschrijfbaar is
72// en minstens MinFreeBytes vrij heeft. Bij een te volle of niet beschrijfbare
73// map zitten Free en Total alsnog in het resultaat.
74func Inspect(path string) (Info, error) {
75 path = strings.TrimSpace(path)
76 if path == "" {
77 return Info{}, i18n.E("err.pathMissing")
78 }
79 if strings.ContainsAny(path, "\r\n") {
80 return Info{}, i18n.E("err.pathNewline")
81 }
82 if !filepath.IsAbs(path) {
83 return Info{}, i18n.E("err.pathAbsolute")
84 }
85 path = filepath.Clean(path)
86 info := Info{Path: path}
87 st, err := os.Stat(path)
88 if err != nil {
89 if errors.Is(err, os.ErrNotExist) {
90 return info, i18n.E("err.pathAbsent")
91 }
92 return info, i18n.E("err.pathRead", err.Error())
93 }
94 if !st.IsDir() {
95 return info, i18n.E("err.pathDir")
96 }
97 var stat syscall.Statfs_t
98 if err := syscall.Statfs(path, &stat); err != nil {
99 return info, i18n.E("err.pathFree", err.Error())
100 }
101 info.Free = uint64(stat.Bavail) * uint64(stat.Bsize)
102 info.Total = uint64(stat.Blocks) * uint64(stat.Bsize)
103 if stat.Bfree > stat.Bavail {
104 info.Reserved = (uint64(stat.Bfree) - uint64(stat.Bavail)) * uint64(stat.Bsize)
105 }
106 probe := filepath.Join(path, ".bluegit-write-test")
107 f, err := os.OpenFile(probe, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
108 if err != nil {
109 return info, i18n.E("err.pathWrite")
110 }
111 _ = f.Close()
112 _ = os.Remove(probe)
113 if info.Free < MinFreeBytes {
114 return info, i18n.E("err.pathSpace", Format(info.Free), Format(MinFreeBytes))
115 }
116 return info, nil
117}
118
119// Used is de bezette ruimte: totaal min vrij min gereserveerd.
120// Gereserveerde blokken tellen dus niet als data.
121func (i Info) Used() uint64 {
122 if i.Free+i.Reserved >= i.Total {
123 return 0
124 }
125 return i.Total - i.Free - i.Reserved
126}
127
128// Percent rondt used/total af op een heel percentage.
129// Een leeg totaal is 0. Meer dan vol blijft 100.
130func Percent(used, total uint64) int {
131 if total == 0 {
132 return 0
133 }
134 if used > total {
135 used = total
136 }
137 return int((used*100 + total/2) / total)
138}
139
140// DirSize telt de schijnbare grootte van path, recursief.
141// Symlinks worden niet gevolgd. Een afgelopen context stopt de wandeling
142// en geeft terug wat al geteld is, samen met ctx.Err().
143func DirSize(ctx context.Context, root string) (uint64, error) {
144 var total uint64
145 err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
146 if ctx.Err() != nil {
147 return ctx.Err()
148 }
149 if err != nil {
150 if path == root {
151 return err
152 }
153 return nil
154 }
155 info, ierr := d.Info()
156 if ierr != nil {
157 return nil
158 }
159 if info.Mode()&os.ModeSymlink != 0 {
160 return nil
161 }
162 total += uint64(info.Size())
163 return nil
164 })
165 if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
166 return total, err
167 }
168 return total, err
169}
170
171// Format maakt een korte grootte, bijvoorbeeld "1.5 GiB".
172func Format(n uint64) string {
173 const unit = 1024
174 if n < unit {
175 return fmt.Sprintf("%d B", n)
176 }
177 div := uint64(unit)
178 exp := 0
179 for n/div >= unit && exp < 4 {
180 div *= unit
181 exp++
182 }
183 value := float64(n) / float64(div)
184 return fmt.Sprintf("%.1f %ciB", value, "KMGT"[exp])
185}