chore(gonf): fix errcheck and shadow errors

pkg/commands.go

@@ -6,15 +6,12 @@ import (
 	"os/exec"
 )
 
-// ----- Globals ---------------------------------------------------------------
 var commands []*CommandPromise
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	commands = make([]*CommandPromise, 0)
 }
 
-// ----- Public ----------------------------------------------------------------
 func Command(cmd string, args ...string) *CommandPromise {
 	return CommandWithEnv([]string{}, cmd, args...)
 }
@@ -81,7 +78,6 @@ func (c CommandPromise) Status() Status {
 	return c.status
 }
 
-// ----- Internal --------------------------------------------------------------
 func resolveCommands() (status Status) {
 	status = KEPT
 	for _, c := range commands {

pkg/files.go

@@ -11,15 +11,12 @@ import (
 	"path/filepath"
 )
 
-// ----- Globals ---------------------------------------------------------------
 var files []*FilePromise
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	files = make([]*FilePromise, 0)
 }
 
-// ----- Public ----------------------------------------------------------------
 type FilePromise struct {
 	chain          []Promise
 	contents       Value
@@ -62,7 +59,6 @@ func (f *FilePromise) Template(contents any) *FilePromise {
 	return f
 }
 
-// We want to satisfy the Promise interface
 func (f *FilePromise) IfRepaired(p ...Promise) Promise {
 	f.chain = append(f.chain, p...)
 	return f
@@ -127,7 +123,6 @@ func (f FilePromise) Status() Status {
 	return f.status
 }
 
-// ----- Internal --------------------------------------------------------------
 func resolveFiles() (status Status) {
 	status = KEPT
 	for _, f := range files {
@@ -144,12 +139,16 @@ func resolveFiles() (status Status) {
 	return
 }
 
-func sha256sumOfFile(filename string) ([]byte, error) {
+func sha256sumOfFile(filename string) (hash []byte, err error) {
 	f, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
-	defer f.Close()
+	defer func() {
+		if e := f.Close(); err == nil {
+			err = e
+		}
+	}()
 	h := sha256.New()
 	if _, err := io.Copy(h, f); err != nil {
 		return nil, err
@@ -157,12 +156,16 @@ func sha256sumOfFile(filename string) ([]byte, error) {
 	return h.Sum(nil), nil
 }
 
-func writeFile(filename string, contents []byte) error {
+func writeFile(filename string, contents []byte) (err error) {
 	f, err := os.Create(filename)
 	if err != nil {
 		return err
 	}
-	defer f.Close()
+	defer func() {
+		if e := f.Close(); err == nil {
+			err = e
+		}
+	}()
 	_, err = f.Write(contents)
 	return err
 }

pkg/packages.go

@@ -2,20 +2,16 @@ package gonf
 
 import "log/slog"
 
-// ----- Globals ---------------------------------------------------------------
 var packages []*PackagePromise
 
-// packages management functions
-var packages_install_function func([]string) (Status, []string)
+var packagesInstallFunction func([]string) (Status, []string)
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	packages = make([]*PackagePromise, 0)
 }
 
-// ----- Public ----------------------------------------------------------------
 func SetPackagesConfiguration(install func([]string) (Status, []string), update *CommandPromise) {
-	packages_install_function = install
+	packagesInstallFunction = install
 }
 
 func Package(names ...string) *PackagePromise {
@@ -45,7 +41,7 @@ func (p *PackagePromise) Promise() Promise {
 }
 
 func (p *PackagePromise) Resolve() {
-	status, affected := packages_install_function(p.names)
+	status, affected := packagesInstallFunction(p.names)
 	switch status {
 	case BROKEN:
 		slog.Error("package", "names", p.names, "status", status, "broke", affected)
@@ -63,7 +59,6 @@ func (p PackagePromise) Status() Status {
 	return p.status
 }
 
-// ----- Internal --------------------------------------------------------------
 func resolvePackages() (status Status) {
 	status = KEPT
 	for _, c := range packages {

pkg/permissions.go

@@ -29,10 +29,10 @@ func (p *Permissions) resolve(filename string) (Status, error) {
 		if group, err := user.LookupGroup(p.group.String()); err != nil {
 			return BROKEN, err
 		} else {
-			if groupId, err := strconv.Atoi(group.Gid); err != nil {
+			if groupID, err := strconv.Atoi(group.Gid); err != nil {
 				return BROKEN, err
 			} else {
-				g = &IntValue{groupId}
+				g = &IntValue{groupID}
 				p.group = g
 			}
 		}
@@ -46,10 +46,10 @@ func (p *Permissions) resolve(filename string) (Status, error) {
 		if user, err := user.Lookup(p.user.String()); err != nil {
 			return BROKEN, err
 		} else {
-			if userId, err := strconv.Atoi(user.Uid); err != nil {
+			if userID, err := strconv.Atoi(user.Uid); err != nil {
 				return BROKEN, err
 			} else {
-				u = &IntValue{userId}
+				u = &IntValue{userID}
 				p.group = u
 			}
 		}

pkg/services.go

@@ -2,18 +2,14 @@ package gonf
 
 import "log/slog"
 
-// ----- Globals ---------------------------------------------------------------
 var services []*ServicePromise
 
-// service management function
 var serviceFunction func(string, string) (Status, error)
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	services = make([]*ServicePromise, 0)
 }
 
-// ----- Public ----------------------------------------------------------------
 func SetServiceFunction(f func(string, string) (Status, error)) {
 	serviceFunction = f
 }
@@ -82,7 +78,6 @@ func (s ServicePromise) Status() Status {
 	return s.status
 }
 
-// ----- Internal --------------------------------------------------------------
 func resolveServices() (status Status) {
 	status = KEPT
 	for _, c := range services {

pkg/templates.go

@@ -7,17 +7,14 @@ import (
 	"text/template"
 )
 
-// ----- Globals ---------------------------------------------------------------
 var templates *template.Template
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	templates = template.New("")
 	templates.Option("missingkey=error")
 	templates.Funcs(builtinTemplateFunctions)
 }
 
-// ----- Public ----------------------------------------------------------------
 type TemplateValue struct {
 	contents []byte
 	data     string

pkg/users.go

@@ -4,20 +4,16 @@ import (
 	"log/slog"
 )
 
-// ----- Globals ---------------------------------------------------------------
 var users []*UserPromise
 
-// users management functions
-var user_add_function func(data UserData) (Status, error)
+var userAddFunction func(data UserData) (Status, error)
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	users = make([]*UserPromise, 0)
 }
 
-// ----- Public ----------------------------------------------------------------
 func SetUsersConfiguration(useradd func(data UserData) (Status, error)) {
-	user_add_function = useradd
+	userAddFunction = useradd
 }
 
 func User(data UserData) *UserPromise {
@@ -57,7 +53,7 @@ func (u *UserPromise) Promise() Promise {
 
 func (u *UserPromise) Resolve() {
 	var err error
-	u.status, err = user_add_function(u.data)
+	u.status, err = userAddFunction(u.data)
 	switch u.status {
 	case BROKEN:
 		slog.Error("user", "name", u.data.Name, "status", u.status, "error", err)
@@ -77,7 +73,6 @@ func (u UserPromise) Status() Status {
 	return u.status
 }
 
-// ----- Internal --------------------------------------------------------------
 func resolveUsers() (status Status) {
 	status = KEPT
 	for _, c := range users {

pkg/utils.go

@@ -28,15 +28,19 @@ func FilterSlice[T any](slice *[]T, predicate func(T) bool) {
 func makeDirectoriesHierarchy(dir string, perms *Permissions) (Status, error) {
 	if _, err := os.Lstat(dir); err != nil {
 		if errors.Is(err, fs.ErrNotExist) {
-			if status, err := makeDirectoriesHierarchy(filepath.Dir(dir), perms); err != nil {
-				return status, err
-			}
-			m, err := perms.mode.Int()
-			if err != nil {
+			if _, err = makeDirectoriesHierarchy(filepath.Dir(dir), perms); err != nil {
+				return BROKEN, err
+			}
+			var m int
+			if m, err = perms.mode.Int(); err != nil {
+				return BROKEN, err
+			}
+			if err = os.Mkdir(dir, fs.FileMode(m)); err != nil {
+				return BROKEN, err
+			}
+			if _, err = perms.resolve(dir); err != nil {
 				return BROKEN, err
 			}
-			os.Mkdir(dir, fs.FileMode(m))
-			perms.resolve(dir)
 			return REPAIRED, nil
 		} else {
 			return BROKEN, err

pkg/values.go

@@ -47,7 +47,6 @@ func interfaceToTemplateValue(v any) Value {
 	panic(fmt.Sprintf("interfaceToTemplateValue cannot take type %T as argument. Value was %#v.", v, v))
 }
 
-// ----- BytesValue ------------------------------------------------------------
 type BytesValue struct {
 	value []byte
 }
@@ -62,7 +61,6 @@ func (b BytesValue) String() string {
 	return string(b.value[:])
 }
 
-// ----- IntValue --------------------------------------------------------------
 type IntValue struct {
 	value int
 }
@@ -77,7 +75,6 @@ func (i IntValue) String() string {
 	return fmt.Sprint(i.value)
 }
 
-// ----- StringsListValue ------------------------------------------------------
 type StringsListValue struct {
 	value []string
 }
@@ -95,7 +92,6 @@ func (s StringsListValue) String() string {
 	return strings.Join(s.value, "\n")
 }
 
-// ----- StringValue -----------------------------------------------------------
 type StringValue struct {
 	value string
 }

pkg/variables.go

@@ -5,15 +5,12 @@ import (
 	"log/slog"
 )
 
-// ----- Globals ---------------------------------------------------------------
 var variables map[string]*VariablePromise
 
-// ----- Init ------------------------------------------------------------------
 func init() {
 	variables = make(map[string]*VariablePromise)
 }
 
-// ----- Public ----------------------------------------------------------------
 func AppendVariable(name string, values ...string) *VariablePromise {
 	if v, ok := variables[name]; ok {
 		if l, ok := v.value.(*StringsListValue); ok {
@@ -66,7 +63,6 @@ type VariablePromise struct {
 	value     Value
 }
 
-// We want VariablePromise to satisfy the Value interface
 func (s VariablePromise) Bytes() []byte {
 	return s.value.Bytes()
 }
@@ -77,7 +73,6 @@ func (s VariablePromise) String() string {
 	return s.value.String()
 }
 
-// ----- Internal --------------------------------------------------------------
 func getVariable(name string) string {
 	if v, ok := variables[name]; ok {
 		return v.value.String()