fix: use server options from DB too (filebrowser#616)

License: MIT Signed-off-by: Henrique Dias <hacdias@gmail.com> Former-commit-id: bb60ec81f56f5d761ef76b2c1e26bbe83210f434 [formerly b28f83c65e0934e138a1710549f52e0f66a158e0] [formerly 7138a3215ceb144afa0ea45be2315f30b052109f [formerly 7206920]] Former-commit-id: 0fb7ae6353f786edd93a9166141bfa446dd3dbf9 [formerly 5cb07e8c96a7cfca1aec5843123e1abc4ca8578a] Former-commit-id: 914c0348516f072a9ccce4e105327feaaddb4cc0
Got99 · Jan 8, 2019 · 870b5b4 · 870b5b4
1 parent 66d485f
commit 870b5b4
Show file tree

Hide file tree

Showing 19 changed files with 270 additions and 179 deletions.
diff --git a/.filebrowser.docker.json b/.filebrowser.docker.json
@@ -0,0 +1,8 @@
+{
+  "port": 80,
+  "baseURL": "",
+  "address": "",
+  "log": "stdout",
+  "database": "/database.db",
+  "root": "/srv"
+}
diff --git a/Dockerfile b/Dockerfile
@@ -6,6 +6,7 @@ VOLUME /tmp
 VOLUME /srv
 EXPOSE 80
 
+COPY .filebrowser.docker.json /.filebrowser.json
 COPY filebrowser /filebrowser
 
-ENTRYPOINT [ "/filebrowser"]
+ENTRYPOINT [ "/filebrowser" ]
diff --git a/cmd/cmds_ls.go b/cmd/cmds_ls.go
@@ -17,7 +17,7 @@ var cmdsLsCmd = &cobra.Command{
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		s, err := d.store.Settings.Get()
 		checkErr(err)
-		evt := mustGetString(cmd, "event")
+		evt := mustGetString(cmd.Flags(), "event")
 
 		if evt == "" {
 			printEvents(s.Commands)

diff --git a/cmd/config.go b/cmd/config.go
@@ -27,6 +27,7 @@ var configCmd = &cobra.Command{
 }
 
 func addConfigFlags(flags *pflag.FlagSet) {
+	addServerFlags(flags)
 	addUserFlags(flags)
 	flags.BoolP("signup", "s", false, "allow users to signup")
 	flags.String("shell", "", "shell command to which other commands should be appended")
@@ -43,12 +44,12 @@ func addConfigFlags(flags *pflag.FlagSet) {
 	flags.Bool("branding.disableExternal", false, "disable external links such as GitHub links")
 }
 
-func getAuthentication(cmd *cobra.Command) (settings.AuthMethod, auth.Auther) {
-	method := settings.AuthMethod(mustGetString(cmd, "auth.method"))
+func getAuthentication(flags *pflag.FlagSet) (settings.AuthMethod, auth.Auther) {
+	method := settings.AuthMethod(mustGetString(flags, "auth.method"))
 
 	var auther auth.Auther
 	if method == auth.MethodProxyAuth {
-		header := mustGetString(cmd, "auth.header")
+		header := mustGetString(flags, "auth.header")
 		if header == "" {
 			panic(nerrors.New("you must set the flag 'auth.header' for method 'proxy'"))
 		}
@@ -62,9 +63,9 @@ func getAuthentication(cmd *cobra.Command) (settings.AuthMethod, auth.Auther) {
 	if method == auth.MethodJSONAuth {
 		jsonAuth := &auth.JSONAuth{}
 
-		host := mustGetString(cmd, "recaptcha.host")
-		key := mustGetString(cmd, "recaptcha.key")
-		secret := mustGetString(cmd, "recaptcha.secret")
+		host := mustGetString(flags, "recaptcha.host")
+		key := mustGetString(flags, "recaptcha.key")
+		secret := mustGetString(flags, "recaptcha.secret")
 
 		if key != "" && secret != "" {
 			jsonAuth.ReCaptcha = &auth.ReCaptcha{
@@ -84,33 +85,41 @@ func getAuthentication(cmd *cobra.Command) (settings.AuthMethod, auth.Auther) {
 	return method, auther
 }
 
-func printSettings(s *settings.Settings, auther auth.Auther) {
+func printSettings(ser *settings.Server, set *settings.Settings, auther auth.Auther) {
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
 
-	fmt.Fprintf(w, "Sign up:\t%t\n", s.Signup)
-	fmt.Fprintf(w, "Auth method:\t%s\n", s.AuthMethod)
-	fmt.Fprintf(w, "Shell:\t%s\t\n", strings.Join(s.Shell, " "))
+	fmt.Fprintf(w, "Sign up:\t%t\n", set.Signup)
+	fmt.Fprintf(w, "Auth method:\t%s\n", set.AuthMethod)
+	fmt.Fprintf(w, "Shell:\t%s\t\n", strings.Join(set.Shell, " "))
 	fmt.Fprintln(w, "\nBranding:")
-	fmt.Fprintf(w, "\tName:\t%s\n", s.Branding.Name)
-	fmt.Fprintf(w, "\tFiles override:\t%s\n", s.Branding.Files)
-	fmt.Fprintf(w, "\tDisable external links:\t%t\n", s.Branding.DisableExternal)
+	fmt.Fprintf(w, "\tName:\t%s\n", set.Branding.Name)
+	fmt.Fprintf(w, "\tFiles override:\t%s\n", set.Branding.Files)
+	fmt.Fprintf(w, "\tDisable external links:\t%t\n", set.Branding.DisableExternal)
+	fmt.Fprintln(w, "\nServer:")
+	fmt.Fprintf(w, "\tLog:\t%s\n", ser.Log)
+	fmt.Fprintf(w, "\tPort:\t%s\n", ser.Port)
+	fmt.Fprintf(w, "\tBase URL:\t%s\n", ser.BaseURL)
+	fmt.Fprintf(w, "\tRoot:\t%s\n", ser.Root)
+	fmt.Fprintf(w, "\tAddress:\t%s\n", ser.Address)
+	fmt.Fprintf(w, "\tTLS Cert:\t%s\n", ser.TLSCert)
+	fmt.Fprintf(w, "\tTLS Key:\t%s\n", ser.TLSKey)
 	fmt.Fprintln(w, "\nDefaults:")
-	fmt.Fprintf(w, "\tScope:\t%s\n", s.Defaults.Scope)
-	fmt.Fprintf(w, "\tLocale:\t%s\n", s.Defaults.Locale)
-	fmt.Fprintf(w, "\tView mode:\t%s\n", s.Defaults.ViewMode)
-	fmt.Fprintf(w, "\tCommands:\t%s\n", strings.Join(s.Defaults.Commands, " "))
+	fmt.Fprintf(w, "\tScope:\t%s\n", set.Defaults.Scope)
+	fmt.Fprintf(w, "\tLocale:\t%s\n", set.Defaults.Locale)
+	fmt.Fprintf(w, "\tView mode:\t%s\n", set.Defaults.ViewMode)
+	fmt.Fprintf(w, "\tCommands:\t%s\n", strings.Join(set.Defaults.Commands, " "))
 	fmt.Fprintf(w, "\tSorting:\n")
-	fmt.Fprintf(w, "\t\tBy:\t%s\n", s.Defaults.Sorting.By)
-	fmt.Fprintf(w, "\t\tAsc:\t%t\n", s.Defaults.Sorting.Asc)
+	fmt.Fprintf(w, "\t\tBy:\t%s\n", set.Defaults.Sorting.By)
+	fmt.Fprintf(w, "\t\tAsc:\t%t\n", set.Defaults.Sorting.Asc)
 	fmt.Fprintf(w, "\tPermissions:\n")
-	fmt.Fprintf(w, "\t\tAdmin:\t%t\n", s.Defaults.Perm.Admin)
-	fmt.Fprintf(w, "\t\tExecute:\t%t\n", s.Defaults.Perm.Execute)
-	fmt.Fprintf(w, "\t\tCreate:\t%t\n", s.Defaults.Perm.Create)
-	fmt.Fprintf(w, "\t\tRename:\t%t\n", s.Defaults.Perm.Rename)
-	fmt.Fprintf(w, "\t\tModify:\t%t\n", s.Defaults.Perm.Modify)
-	fmt.Fprintf(w, "\t\tDelete:\t%t\n", s.Defaults.Perm.Delete)
-	fmt.Fprintf(w, "\t\tShare:\t%t\n", s.Defaults.Perm.Share)
-	fmt.Fprintf(w, "\t\tDownload:\t%t\n", s.Defaults.Perm.Download)
+	fmt.Fprintf(w, "\t\tAdmin:\t%t\n", set.Defaults.Perm.Admin)
+	fmt.Fprintf(w, "\t\tExecute:\t%t\n", set.Defaults.Perm.Execute)
+	fmt.Fprintf(w, "\t\tCreate:\t%t\n", set.Defaults.Perm.Create)
+	fmt.Fprintf(w, "\t\tRename:\t%t\n", set.Defaults.Perm.Rename)
+	fmt.Fprintf(w, "\t\tModify:\t%t\n", set.Defaults.Perm.Modify)
+	fmt.Fprintf(w, "\t\tDelete:\t%t\n", set.Defaults.Perm.Delete)
+	fmt.Fprintf(w, "\t\tShare:\t%t\n", set.Defaults.Perm.Share)
+	fmt.Fprintf(w, "\t\tDownload:\t%t\n", set.Defaults.Perm.Download)
 	w.Flush()
 
 	b, err := json.MarshalIndent(auther, "", "  ")

diff --git a/cmd/config_cat.go b/cmd/config_cat.go
@@ -14,10 +14,12 @@ var configCatCmd = &cobra.Command{
 	Long:  `Prints the configuration.`,
 	Args:  cobra.NoArgs,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := d.store.Settings.Get()
+		set, err := d.store.Settings.Get()
 		checkErr(err)
-		auther, err := d.store.Auth.Get(s.AuthMethod)
+		ser, err := d.store.Settings.GetServer()
 		checkErr(err)
-		printSettings(s, auther)
+		auther, err := d.store.Auth.Get(set.AuthMethod)
+		checkErr(err)
+		printSettings(ser, set, auther)
 	}, pythonConfig{}),
 }
diff --git a/cmd/config_export.go b/cmd/config_export.go
@@ -16,12 +16,16 @@ var configExportCmd = &cobra.Command{
 		settings, err := d.store.Settings.Get()
 		checkErr(err)
 
+		server, err := d.store.Settings.GetServer()
+		checkErr(err)
+
 		auther, err := d.store.Auth.Get(settings.AuthMethod)
 		checkErr(err)
 
 		data := &settingsFile{
 			Settings: settings,
 			Auther:   auther,
+			Server:   server,
 		}
 
 		err = marshal(args[0], data)

diff --git a/cmd/config_import.go b/cmd/config_import.go
@@ -3,6 +3,7 @@ package cmd
 import (
 	"encoding/json"
 	"errors"
+	"path/filepath"
 	"reflect"
 
 	"github.com/filebrowser/filebrowser/v2/auth"
@@ -16,6 +17,7 @@ func init() {
 
 type settingsFile struct {
 	Settings *settings.Settings `json:"settings"`
+	Server   *settings.Server   `json:"server"`
 	Auther   interface{}        `json:"auther"`
 }
 
@@ -45,23 +47,32 @@ database.`,
 		err = d.store.Settings.Save(file.Settings)
 		checkErr(err)
 
-		autherInterf := cleanUpInterfaceMap(file.Auther.(map[interface{}]interface{}))
+		err = d.store.Settings.SaveServer(file.Server)
+		checkErr(err)
+
+		var rawAuther interface{}
+		if filepath.Ext(args[0]) != ".json" {
+			rawAuther = cleanUpInterfaceMap(file.Auther.(map[interface{}]interface{}))
+		} else {
+			rawAuther = file.Auther
+		}
 
 		var auther auth.Auther
 		switch file.Settings.AuthMethod {
 		case auth.MethodJSONAuth:
-			auther = getAuther(auth.JSONAuth{}, autherInterf).(*auth.JSONAuth)
+			auther = getAuther(auth.JSONAuth{}, rawAuther).(*auth.JSONAuth)
 		case auth.MethodNoAuth:
-			auther = getAuther(auth.NoAuth{}, autherInterf).(*auth.NoAuth)
+			auther = getAuther(auth.NoAuth{}, rawAuther).(*auth.NoAuth)
 		case auth.MethodProxyAuth:
-			auther = getAuther(auth.ProxyAuth{}, autherInterf).(*auth.ProxyAuth)
+			auther = getAuther(auth.ProxyAuth{}, rawAuther).(*auth.ProxyAuth)
 		default:
 			checkErr(errors.New("invalid auth method"))
 		}
 
 		err = d.store.Auth.Save(auther)
 		checkErr(err)
-		printSettings(file.Settings, auther)
+
+		printSettings(file.Server, file.Settings, auther)
 	}, pythonConfig{allowNoDB: true}),
 }
 

diff --git a/cmd/config_init.go b/cmd/config_init.go
@@ -24,24 +24,37 @@ override the options.`,
 	Args: cobra.NoArgs,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		defaults := settings.UserDefaults{}
-		getUserDefaults(cmd, &defaults, true)
-		authMethod, auther := getAuthentication(cmd)
+		flags := cmd.Flags()
+		getUserDefaults(flags, &defaults, true)
+		authMethod, auther := getAuthentication(flags)
 
 		s := &settings.Settings{
 			Key:        generateRandomBytes(64), // 256 bit
-			Signup:     mustGetBool(cmd, "signup"),
-			Shell:      strings.Split(strings.TrimSpace(mustGetString(cmd, "shell")), " "),
+			Signup:     mustGetBool(flags, "signup"),
+			Shell:      strings.Split(strings.TrimSpace(mustGetString(flags, "shell")), " "),
 			AuthMethod: authMethod,
 			Defaults:   defaults,
 			Branding: settings.Branding{
-				Name:            mustGetString(cmd, "branding.name"),
-				DisableExternal: mustGetBool(cmd, "branding.disableExternal"),
-				Files:           mustGetString(cmd, "branding.files"),
+				Name:            mustGetString(flags, "branding.name"),
+				DisableExternal: mustGetBool(flags, "branding.disableExternal"),
+				Files:           mustGetString(flags, "branding.files"),
 			},
 		}
 
+		ser := &settings.Server{
+			Address: mustGetString(flags, "address"),
+			Root:    mustGetString(flags, "root"),
+			BaseURL: mustGetString(flags, "baseurl"),
+			TLSKey:  mustGetString(flags, "key"),
+			TLSCert: mustGetString(flags, "cert"),
+			Port:    mustGetString(flags, "port"),
+			Log:     mustGetString(flags, "log"),
+		}
+
 		err := d.store.Settings.Save(s)
 		checkErr(err)
+		err = d.store.Settings.SaveServer(ser)
+		checkErr(err)
 		err = d.store.Auth.Save(auther)
 		checkErr(err)
 
@@ -50,6 +63,6 @@ Congratulations! You've set up your database to use with File Browser.
 Now add your first user via 'filebrowser users new' and then you just
 need to call the main command to boot up the server.
 `)
-		printSettings(s, auther)
+		printSettings(ser, s, auther)
 	}, pythonConfig{noDB: true}),
 }
diff --git a/cmd/config_set.go b/cmd/config_set.go
@@ -20,41 +20,61 @@ var configSetCmd = &cobra.Command{
 you want to change.`,
 	Args: cobra.NoArgs,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := d.store.Settings.Get()
+		flags := cmd.Flags()
+		set, err := d.store.Settings.Get()
+		checkErr(err)
+
+		ser, err := d.store.Settings.GetServer()
 		checkErr(err)
 
 		hasAuth := false
-		cmd.Flags().Visit(func(flag *pflag.Flag) {
+		flags.Visit(func(flag *pflag.Flag) {
 			switch flag.Name {
+			case "baseurl":
+				ser.BaseURL = mustGetString(flags, flag.Name)
+			case "root":
+				ser.Root = mustGetString(flags, flag.Name)
+			case "cert":
+				ser.TLSCert = mustGetString(flags, flag.Name)
+			case "key":
+				ser.TLSKey = mustGetString(flags, flag.Name)
+			case "address":
+				ser.Address = mustGetString(flags, flag.Name)
+			case "port":
+				ser.Port = mustGetString(flags, flag.Name)
+			case "log":
+				ser.Log = mustGetString(flags, flag.Name)
 			case "signup":
-				s.Signup = mustGetBool(cmd, flag.Name)
+				set.Signup = mustGetBool(flags, flag.Name)
 			case "auth.method":
 				hasAuth = true
 			case "shell":
-				s.Shell = strings.Split(strings.TrimSpace(mustGetString(cmd, flag.Name)), " ")
+				set.Shell = strings.Split(strings.TrimSpace(mustGetString(flags, flag.Name)), " ")
 			case "branding.name":
-				s.Branding.Name = mustGetString(cmd, flag.Name)
+				set.Branding.Name = mustGetString(flags, flag.Name)
 			case "branding.disableExternal":
-				s.Branding.DisableExternal = mustGetBool(cmd, flag.Name)
+				set.Branding.DisableExternal = mustGetBool(flags, flag.Name)
 			case "branding.files":
-				s.Branding.Files = mustGetString(cmd, flag.Name)
+				set.Branding.Files = mustGetString(flags, flag.Name)
 			}
 		})
 
-		getUserDefaults(cmd, &s.Defaults, false)
+		getUserDefaults(flags, &set.Defaults, false)
 
 		var auther auth.Auther
 		if hasAuth {
-			s.AuthMethod, auther = getAuthentication(cmd)
+			set.AuthMethod, auther = getAuthentication(flags)
 			err = d.store.Auth.Save(auther)
 			checkErr(err)
 		} else {
-			auther, err = d.store.Auth.Get(s.AuthMethod)
+			auther, err = d.store.Auth.Get(set.AuthMethod)
 			checkErr(err)
 		}
 
-		err = d.store.Settings.Save(s)
+		err = d.store.Settings.Save(set)
+		checkErr(err)
+		err = d.store.Settings.SaveServer(ser)
 		checkErr(err)
-		printSettings(s, auther)
+		printSettings(ser, set, auther)
 	}, pythonConfig{}),
 }
diff --git a/cmd/docs.go b/cmd/docs.go
@@ -40,7 +40,7 @@ var docsCmd = &cobra.Command{
 	Hidden: true,
 	Args:   cobra.NoArgs,
 	Run: func(cmd *cobra.Command, args []string) {
-		dir := mustGetString(cmd, "path")
+		dir := mustGetString(cmd.Flags(), "path")
 		generateDocs(rootCmd, dir)
 		names := []string{}