refactor(param): use regular type for user info

Author: marjune163

src/param/cli.go

@@ -375,17 +375,17 @@ func ParseCli() (params []*Param, printVersion, printHelp bool, errs []error) {
 
 		// users
 		arrUsersPlain, _ := result.GetStrings("users")
-		param.UsersPlain = EntriesToUsers(arrUsersPlain)
+		param.UsersPlain = entriesToUsers(arrUsersPlain)
 		arrUsersBase64, _ := result.GetStrings("usersbase64")
-		param.UsersBase64 = EntriesToUsers(arrUsersBase64)
+		param.UsersBase64 = entriesToUsers(arrUsersBase64)
 		arrUsersMd5, _ := result.GetStrings("usersmd5")
-		param.UsersMd5 = EntriesToUsers(arrUsersMd5)
+		param.UsersMd5 = entriesToUsers(arrUsersMd5)
 		arrUsersSha1, _ := result.GetStrings("userssha1")
-		param.UsersSha1 = EntriesToUsers(arrUsersSha1)
+		param.UsersSha1 = entriesToUsers(arrUsersSha1)
 		arrUsersSha256, _ := result.GetStrings("userssha256")
-		param.UsersSha256 = EntriesToUsers(arrUsersSha256)
+		param.UsersSha256 = entriesToUsers(arrUsersSha256)
 		arrUsersSha512, _ := result.GetStrings("userssha512")
-		param.UsersSha512 = EntriesToUsers(arrUsersSha512)
+		param.UsersSha512 = entriesToUsers(arrUsersSha512)
 
 		// listen
 		listens, _ := result.GetStrings("listens")

src/param/main.go

@@ -7,11 +7,6 @@ import (
 	"os"
 )
 
-type user struct {
-	Username string
-	Password string
-}
-
 type Param struct {
 	Root      string
 	EmptyRoot bool
@@ -52,15 +47,16 @@ type Param struct {
 	CorsUrls   []string
 	CorsDirs   []string
 
-	GlobalAuth    bool
-	AuthUrls      []string
-	AuthDirs      []string
-	UsersPlain    []*user
-	UsersBase64   []*user
-	UsersMd5      []*user
-	UsersSha1     []*user
-	UsersSha256   []*user
-	UsersSha512   []*user
+	GlobalAuth bool
+	AuthUrls   []string
+	AuthDirs   []string
+	// value: [username, password]
+	UsersPlain    [][2]string
+	UsersBase64   [][2]string
+	UsersMd5      [][2]string
+	UsersSha1     [][2]string
+	UsersSha256   [][2]string
+	UsersSha512   [][2]string
 	UserMatchCase bool
 
 	Certificates []tls.Certificate

src/param/objUtil.go

@@ -10,8 +10,8 @@ func loadCertificates(certFiles, keyFiles []string) ([]tls.Certificate, []error)
 	return goVirtualHost.LoadCertificates(certFiles, keyFiles)
 }
 
-func EntriesToUsers(entries []string) []*user {
-	users := make([]*user, 0, len(entries))
+func entriesToUsers(entries []string) [][2]string {
+	users := make([][2]string, 0, len(entries))
 	for _, userEntry := range entries {
 		username := userEntry
 		password := ""
@@ -22,7 +22,7 @@ func EntriesToUsers(entries []string) []*user {
 			password = userEntry[colonIndex+1:]
 		}
 
-		users = append(users, &user{username, password})
+		users = append(users, [2]string{username, password})
 	}
 	return users
 }

src/param/objUtil_test.go

@@ -8,26 +8,26 @@ func TestEntriesToUsers(t *testing.T) {
 		"user2:",
 		"user3:pass3",
 	}
-	users := EntriesToUsers(entries)
+	users := entriesToUsers(entries)
 	if len(users) != 3 {
 		t.Fatal("user count is not 3")
 	}
-	if users[0].Username != "" {
+	if users[0][0] != "" {
 		t.Fail()
 	}
-	if users[0].Password != "pass1" {
+	if users[0][1] != "pass1" {
 		t.Fail()
 	}
-	if users[1].Username != "user2" {
+	if users[1][0] != "user2" {
 		t.Fail()
 	}
-	if users[1].Password != "" {
+	if users[1][1] != "" {
 		t.Fail()
 	}
-	if users[2].Username != "user3" {
+	if users[2][0] != "user3" {
 		t.Fail()
 	}
-	if users[2].Password != "pass3" {
+	if users[2][1] != "pass3" {
 		t.Fail()
 	}
 }

src/serverHandler/vhostHandler.go

@@ -18,22 +18,22 @@ func NewVhostHandler(
 	// users
 	users := user.NewList(p.UserMatchCase)
 	for _, u := range p.UsersPlain {
-		errs = serverError.AppendError(errs, users.AddPlain(u.Username, u.Password))
+		errs = serverError.AppendError(errs, users.AddPlain(u[0], u[1]))
 	}
 	for _, u := range p.UsersBase64 {
-		errs = serverError.AppendError(errs, users.AddBase64(u.Username, u.Password))
+		errs = serverError.AppendError(errs, users.AddBase64(u[0], u[1]))
 	}
 	for _, u := range p.UsersMd5 {
-		errs = serverError.AppendError(errs, users.AddMd5(u.Username, u.Password))
+		errs = serverError.AppendError(errs, users.AddMd5(u[0], u[1]))
 	}
 	for _, u := range p.UsersSha1 {
-		errs = serverError.AppendError(errs, users.AddSha1(u.Username, u.Password))
+		errs = serverError.AppendError(errs, users.AddSha1(u[0], u[1]))
 	}
 	for _, u := range p.UsersSha256 {
-		errs = serverError.AppendError(errs, users.AddSha256(u.Username, u.Password))
+		errs = serverError.AppendError(errs, users.AddSha256(u[0], u[1]))
 	}
 	for _, u := range p.UsersSha512 {
-		errs = serverError.AppendError(errs, users.AddSha512(u.Username, u.Password))
+		errs = serverError.AppendError(errs, users.AddSha512(u[0], u[1]))
 	}
 
 	shows, err := wildcardToRegexp(p.Shows)