aboutsummaryrefslogtreecommitdiff
path: root/pkg/config
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/config')
-rw-r--r--pkg/config/action.go23
-rw-r--r--pkg/config/app.go14
-rw-r--r--pkg/config/command.go13
-rw-r--r--pkg/config/config.go12
-rw-r--r--pkg/config/game.go18
-rw-r--r--pkg/config/menu.go27
6 files changed, 52 insertions, 55 deletions
diff --git a/pkg/config/action.go b/pkg/config/action.go
index c63308e..4693040 100644
--- a/pkg/config/action.go
+++ b/pkg/config/action.go
@@ -1,9 +1,8 @@
package config
import (
+ "fmt"
"strings"
-
- "github.com/pkg/errors"
)
func validateAction(action string) error {
@@ -11,44 +10,44 @@ func validateAction(action string) error {
switch tokens[0] {
case "chmail":
if len(tokens) != 1 {
- return errors.New("chmail action takes no arguments")
+ return fmt.Errorf("chmail action takes no arguments")
}
case "login":
if len(tokens) != 1 {
- return errors.New("login action takes no arguments")
+ return fmt.Errorf("login action takes no arguments")
}
case "menu":
if len(tokens) != 2 {
- return errors.New("menu action takes exactly one argument")
+ return fmt.Errorf("menu action takes exactly one argument")
}
// menu existence is tested in global config
case "passwd":
if len(tokens) != 1 {
- return errors.New("passwd action takes no arguments")
+ return fmt.Errorf("passwd action takes no arguments")
}
case "play":
if len(tokens) != 2 {
- return errors.New("play action takes exactly one argument")
+ return fmt.Errorf("play action takes exactly one argument")
}
// game existence is tested in global config
case "register":
if len(tokens) != 1 {
- return errors.New("register action takes no arguments")
+ return fmt.Errorf("register action takes no arguments")
}
case "replay":
if len(tokens) != 1 {
- return errors.New("replay action takes no arguments")
+ return fmt.Errorf("replay action takes no arguments")
}
case "watch":
if len(tokens) != 1 {
- return errors.New("watch action takes no arguments")
+ return fmt.Errorf("watch action takes no arguments")
}
case "quit":
if len(tokens) != 1 {
- return errors.New("quit action takes no arguments")
+ return fmt.Errorf("quit action takes no arguments")
}
default:
- return errors.New("Invalid action : " + tokens[0])
+ return fmt.Errorf("Invalid action : " + tokens[0])
}
return nil
}
diff --git a/pkg/config/app.go b/pkg/config/app.go
index 2787517..d7024c7 100644
--- a/pkg/config/app.go
+++ b/pkg/config/app.go
@@ -1,9 +1,9 @@
package config
import (
+ "fmt"
"os"
- "github.com/pkg/errors"
"golang.org/x/sys/unix"
)
@@ -27,28 +27,28 @@ type App struct {
func (a *App) validate() error {
// WorkingDirectory
if err := os.MkdirAll(a.WorkingDirectory, 0700); err != nil {
- return errors.Wrapf(err, "Invalid WorkingDirectory : %s", a.WorkingDirectory)
+ return fmt.Errorf("Invalid WorkingDirectory %s : %w", a.WorkingDirectory, err)
}
if err := unix.Access(a.WorkingDirectory, unix.W_OK|unix.R_OK|unix.X_OK); err != nil {
- return errors.Wrapf(err, "invalid WorkingDirectory : %s", a.WorkingDirectory)
+ return fmt.Errorf("invalid WorkingDirectory %s : %w", a.WorkingDirectory, err)
}
// MaxUsers
if a.MaxUsers <= 0 {
- return errors.New("MaxUsers must be a positive integer")
+ return fmt.Errorf("MaxUsers must be a positive integer")
}
// AllowRegistration is just a bool, nothing to validate
// MaxNickLen
if a.MaxNickLen <= 0 {
- return errors.New("MaxNickLen must be a positive integer")
+ return fmt.Errorf("MaxNickLen must be a positive integer")
}
// MenuMaxIdleTime
if a.MenuMaxIdleTime <= 0 {
- return errors.New("MenuMaxIdleTime must be a positive integer")
+ return fmt.Errorf("MenuMaxIdleTime must be a positive integer")
}
// PostLoginCommands
for i := 0; i < len(a.PostLoginCommands); i++ {
if err := validateCommand(a.PostLoginCommands[i]); err != nil {
- return errors.Wrap(err, "Failed to validate PostLoginCommands")
+ return fmt.Errorf("Failed to validate PostLoginCommands : %w", err)
}
}
return nil
diff --git a/pkg/config/command.go b/pkg/config/command.go
index 34142cd..ad19142 100644
--- a/pkg/config/command.go
+++ b/pkg/config/command.go
@@ -1,9 +1,8 @@
package config
import (
+ "fmt"
"strings"
-
- "github.com/pkg/errors"
)
func validateCommand(cmd string) error {
@@ -11,22 +10,22 @@ func validateCommand(cmd string) error {
switch tokens[0] {
case "cp":
if len(tokens) != 3 {
- return errors.New("cp command takes exactly two arguments")
+ return fmt.Errorf("cp command takes exactly two arguments")
}
case "exec":
if len(tokens) <= 1 {
- return errors.New("exec command needs arguments")
+ return fmt.Errorf("exec command needs arguments")
}
case "mkdir":
if len(tokens) != 2 {
- return errors.New("mkdir command takes exactly one argument")
+ return fmt.Errorf("mkdir command takes exactly one argument")
}
case "wait":
if len(tokens) != 1 {
- return errors.New("wait command takes no arguments")
+ return fmt.Errorf("wait command takes no arguments")
}
default:
- return errors.New("Invalid command : " + tokens[0])
+ return fmt.Errorf("Invalid command : " + tokens[0])
}
return nil
}
diff --git a/pkg/config/config.go b/pkg/config/config.go
index b68a26a..b363a0c 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -1,9 +1,9 @@
package config
import (
+ "fmt"
"os"
- "github.com/pkg/errors"
"gopkg.in/yaml.v3"
)
@@ -23,7 +23,7 @@ func (c *Config) validate() error {
}
// Menus
if len(c.Menus) < 2 {
- return errors.New("A valid configuration needs at least two menu entries named anonymous and logged_in")
+ return fmt.Errorf("A valid configuration needs at least two menu entries named anonymous and logged_in")
}
for k, v := range c.Menus {
if err := v.validate(k); err != nil {
@@ -44,20 +44,20 @@ func LoadFile(path string) (*Config, error) {
var c *Config
f, errOpen := os.Open(path)
if errOpen != nil {
- return nil, errors.Wrapf(errOpen, "Failed to open configuration file %s", path)
+ return nil, fmt.Errorf("Failed to open configuration file %s : %w", path, errOpen)
}
defer f.Close()
decoder := yaml.NewDecoder(f)
if err := decoder.Decode(&c); err != nil {
- return nil, errors.Wrap(err, "Failed to decode configuration file")
+ return nil, fmt.Errorf("Failed to decode configuration file : %w", err)
}
if err := c.validate(); err != nil {
- return nil, errors.Wrap(err, "Failed to validate configuration")
+ return nil, fmt.Errorf("Failed to validate configuration : %w", err)
}
// If all looks good we validate menu consistency
for _, v := range c.Menus {
if err := v.validateConsistency(c); err != nil {
- return nil, errors.Wrap(err, "Failed menu consistency checks")
+ return nil, fmt.Errorf("Failed menu consistency checks : %w", err)
}
}
return c, nil
diff --git a/pkg/config/game.go b/pkg/config/game.go
index b5f4d39..5326073 100644
--- a/pkg/config/game.go
+++ b/pkg/config/game.go
@@ -1,9 +1,9 @@
package config
import (
+ "fmt"
"regexp"
- "github.com/pkg/errors"
"golang.org/x/sys/unix"
)
@@ -26,23 +26,23 @@ type Game struct {
func (g *Game) validate(name string) error {
// Game name
if ok := reValidGameName.MatchString(name); !ok {
- return errors.New("Invalid Game name, must match regex `^[\\w\\._]+$` : " + name)
+ return fmt.Errorf("Invalid Game name, must match regex `^[\\w\\._]+$` : " + name)
}
// ChrootPath TODO
if err := unix.Access(g.ChrootPath, unix.R_OK|unix.X_OK); err != nil {
- return errors.Wrapf(err, "Invalid ChrootPath : %s", g.ChrootPath)
+ return fmt.Errorf("Invalid ChrootPath %s : %w", g.ChrootPath, err)
}
// FileMode
if ok := reValidFileMode.MatchString(g.FileMode); !ok {
- return errors.New("Invalid File Mode, must match regex `^0[\\d]{3}$` : " + name)
+ return fmt.Errorf("Invalid File Mode, must match regex `^0[\\d]{3}$` : " + name)
}
// Commands
if len(g.Commands) == 0 {
- return errors.New("Invalid game " + name + " has no commands")
+ return fmt.Errorf("Invalid game " + name + " has no commands")
}
for i := 0; i < len(g.Commands); i++ {
if err := validateCommand(g.Commands[i]); err != nil {
- return errors.Wrapf(err, "Failed to validate Commands for game %s", name)
+ return fmt.Errorf("Failed to validate Commands for game %s : %w", name, err)
}
}
// Env
@@ -50,12 +50,12 @@ func (g *Game) validate(name string) error {
for _, c := range k {
switch c {
case '=':
- return errors.New("Environment variable key must not contain equal sign")
+ return fmt.Errorf("Environment variable key must not contain equal sign")
case '\000':
- return errors.New("Environment variable key must not contain null character")
+ return fmt.Errorf("Environment variable key must not contain null character")
}
if reSpace.MatchString(string(c)) {
- return errors.New("Environment variable key must not contain spaces")
+ return fmt.Errorf("Environment variable key must not contain spaces")
}
}
}
diff --git a/pkg/config/menu.go b/pkg/config/menu.go
index 7321c7b..a2c5e1e 100644
--- a/pkg/config/menu.go
+++ b/pkg/config/menu.go
@@ -1,10 +1,9 @@
package config
import (
+ "fmt"
"regexp"
"strings"
-
- "github.com/pkg/errors"
)
var reValidMenuName = regexp.MustCompile(`^[\w\._]+$`)
@@ -31,18 +30,18 @@ type MenuEntry struct {
func (m *Menu) validate(name string) error {
// validate name
if ok := reValidMenuName.MatchString(name); !ok {
- return errors.New("Invalid menu name, must be an alphanumeric word and match regex `^[\\w\\._]+$` : " + name)
+ return fmt.Errorf("Invalid menu name, must be an alphanumeric word and match regex `^[\\w\\._]+$` : " + name)
}
// Banner is just any string, nothing to validate
// MenuEntries
if len(m.MenuEntries) == 0 {
- return errors.New("A Menu needs MenuEntries to be valid")
+ return fmt.Errorf("A Menu needs MenuEntries to be valid")
}
// Duplicate detection is natively handled by the yaml parser
for i := 0; i < len(m.MenuEntries); i++ {
m.MenuEntries[i].validate()
if m.MenuEntries[i].Action == "menu "+name {
- return errors.New("A menu shall not loop on itself")
+ return fmt.Errorf("A menu shall not loop on itself")
}
}
// Loop test
@@ -52,10 +51,10 @@ func (m *Menu) validate(name string) error {
func (m *Menu) validateConsistency(c *Config) error {
// Necessary menus
if _, ok := c.Menus["anonymous"]; !ok {
- return errors.New("No anonymous menu declared")
+ return fmt.Errorf("No anonymous menu declared")
}
if _, ok := c.Menus["logged_in"]; !ok {
- return errors.New("No logged_in menu declared")
+ return fmt.Errorf("No logged_in menu declared")
}
// Validate actions
menus := map[string]bool{
@@ -71,13 +70,13 @@ func (m *Menu) validateConsistency(c *Config) error {
if _, ok := c.Menus[tokens[1]]; ok {
menus[tokens[1]] = true
} else {
- return errors.New("menu action " + tokens[1] + " in menu " + k + " does not exist")
+ return fmt.Errorf("menu action " + tokens[1] + " in menu " + k + " does not exist")
}
case "play":
if _, ok := c.Games[tokens[1]]; ok {
playable[tokens[1]] = true
} else {
- return errors.New("play action " + tokens[1] + " in menu " + k + " does not exist")
+ return fmt.Errorf("play action " + tokens[1] + " in menu " + k + " does not exist")
}
}
}
@@ -85,12 +84,12 @@ func (m *Menu) validateConsistency(c *Config) error {
// Check for unreachables
for k, _ := range c.Menus {
if _, ok := menus[k]; !ok {
- return errors.New("unreachable menu : " + k)
+ return fmt.Errorf("unreachable menu : " + k)
}
}
for k, _ := range c.Games {
if _, ok := playable[k]; !ok {
- return errors.New("unplayable game : " + k)
+ return fmt.Errorf("unplayable game : " + k)
}
}
return nil
@@ -99,15 +98,15 @@ func (m *Menu) validateConsistency(c *Config) error {
func (m *MenuEntry) validate() error {
// Key
if ok := reValidKey.MatchString(m.Key); !ok {
- return errors.New("Invalid Key, must be exactly one alphanumeric character and match regex `^\\w$` : " + m.Key)
+ return fmt.Errorf("Invalid Key, must be exactly one alphanumeric character and match regex `^\\w$` : " + m.Key)
}
// Label
if len(m.Label) <= 0 {
- return errors.New("Invalid Label, cannot be empty")
+ return fmt.Errorf("Invalid Label, cannot be empty")
}
// Action
if err := validateAction(m.Action); err != nil {
- return errors.Wrap(err, "Invalid Action in MenuEntry")
+ return fmt.Errorf("Invalid Action in MenuEntry : %w", err)
}
return nil
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-22 06:52:58 +0000