BlueGit

timfa bluegit

Files

bluegit / internal / state / state.go

state.go

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