"time"
"github.com/Unknwon/com"
- "github.com/Unknwon/goconfig"
"github.com/macaron-contrib/oauth2"
"github.com/macaron-contrib/session"
+ "gopkg.in/ini.v1"
"github.com/gogits/gogs/modules/log"
// "github.com/gogits/gogs/modules/ssh"
Langs, Names []string
// Global setting objects.
- Cfg *goconfig.ConfigFile
+ Cfg *ini.File
ConfRootPath string
CustomPath string // Custom directory path.
ProdMode bool
}
ConfRootPath = path.Join(workDir, "conf")
- Cfg, err = goconfig.LoadConfigFile(path.Join(workDir, "conf/app.ini"))
+ Cfg, err = ini.Load(path.Join(workDir, "conf/app.ini"))
if err != nil {
log.Fatal(4, "Fail to parse 'conf/app.ini': %v", err)
}
cfgPath := path.Join(CustomPath, "conf/app.ini")
if com.IsFile(cfgPath) {
- if err = Cfg.AppendFiles(cfgPath); err != nil {
+ if err = Cfg.Append(cfgPath); err != nil {
log.Fatal(4, "Fail to load custom 'conf/app.ini': %v", err)
}
} else {
log.Warn("No custom 'conf/app.ini' found, please go to '/install'")
}
- AppName = Cfg.MustValue("", "APP_NAME", "Gogs: Go Git Service")
- AppUrl = Cfg.MustValue("server", "ROOT_URL", "http://localhost:3000/")
+ LogRootPath = Cfg.Section("log").Key("ROOT_PATH").MustString(path.Join(workDir, "log"))
+
+ sec := Cfg.Section("server")
+ AppName = Cfg.Section("").Key("APP_NAME").MustString("Gogs: Go Git Service")
+ AppUrl = sec.Key("ROOT_URL").MustString("http://localhost:3000/")
if AppUrl[len(AppUrl)-1] != '/' {
AppUrl += "/"
}
AppSubUrl = strings.TrimSuffix(url.Path, "/")
Protocol = HTTP
- if Cfg.MustValue("server", "PROTOCOL") == "https" {
+ if sec.Key("PROTOCOL").String() == "https" {
Protocol = HTTPS
- CertFile = Cfg.MustValue("server", "CERT_FILE")
- KeyFile = Cfg.MustValue("server", "KEY_FILE")
- }
- if Cfg.MustValue("server", "PROTOCOL") == "fcgi" {
+ CertFile = sec.Key("CERT_FILE").String()
+ KeyFile = sec.Key("KEY_FILE").String()
+ } else if sec.Key("PROTOCOL").String() == "fcgi" {
Protocol = FCGI
}
- Domain = Cfg.MustValue("server", "DOMAIN", "localhost")
- HttpAddr = Cfg.MustValue("server", "HTTP_ADDR", "0.0.0.0")
- HttpPort = Cfg.MustValue("server", "HTTP_PORT", "3000")
- SshPort = Cfg.MustInt("server", "SSH_PORT", 22)
- OfflineMode = Cfg.MustBool("server", "OFFLINE_MODE")
- DisableRouterLog = Cfg.MustBool("server", "DISABLE_ROUTER_LOG")
- StaticRootPath = Cfg.MustValue("server", "STATIC_ROOT_PATH", workDir)
- LogRootPath = Cfg.MustValue("log", "ROOT_PATH", path.Join(workDir, "log"))
- EnableGzip = Cfg.MustBool("server", "ENABLE_GZIP")
-
- switch Cfg.MustValue("server", "LANDING_PAGE", "home") {
+ Domain = sec.Key("DOMAIN").MustString("localhost")
+ HttpAddr = sec.Key("HTTP_ADDR").MustString("0.0.0.0")
+ HttpPort = sec.Key("HTTP_PORT").MustString("3000")
+ SshPort = sec.Key("SSH_PORT").MustInt(22)
+ OfflineMode = sec.Key("OFFLINE_MODE").MustBool()
+ DisableRouterLog = sec.Key("DISABLE_ROUTER_LOG").MustBool()
+ StaticRootPath = sec.Key("STATIC_ROOT_PATH").MustString(workDir)
+ EnableGzip = sec.Key("ENABLE_GZIP").MustBool()
+
+ switch sec.Key("LANDING_PAGE").MustString("home") {
case "explore":
LandingPageUrl = LANDING_PAGE_EXPLORE
default:
LandingPageUrl = LANDING_PAGE_HOME
}
- InstallLock = Cfg.MustBool("security", "INSTALL_LOCK")
- SecretKey = Cfg.MustValue("security", "SECRET_KEY")
- LogInRememberDays = Cfg.MustInt("security", "LOGIN_REMEMBER_DAYS")
- CookieUserName = Cfg.MustValue("security", "COOKIE_USERNAME")
- CookieRememberName = Cfg.MustValue("security", "COOKIE_REMEMBER_NAME")
- ReverseProxyAuthUser = Cfg.MustValue("security", "REVERSE_PROXY_AUTHENTICATION_USER", "X-WEBAUTH-USER")
-
- AttachmentPath = Cfg.MustValue("attachment", "PATH", "data/attachments")
- AttachmentAllowedTypes = Cfg.MustValue("attachment", "ALLOWED_TYPES", "image/jpeg|image/png")
- AttachmentMaxSize = Cfg.MustInt64("attachment", "MAX_SIZE", 32)
- AttachmentMaxFiles = Cfg.MustInt("attachment", "MAX_FILES", 10)
- AttachmentEnabled = Cfg.MustBool("attachment", "ENABLE", true)
+ sec = Cfg.Section("security")
+ InstallLock = sec.Key("INSTALL_LOCK").MustBool()
+ SecretKey = sec.Key("SECRET_KEY").String()
+ LogInRememberDays = sec.Key("LOGIN_REMEMBER_DAYS").MustInt()
+ CookieUserName = sec.Key("COOKIE_USERNAME").String()
+ CookieRememberName = sec.Key("COOKIE_REMEMBER_NAME").String()
+ ReverseProxyAuthUser = sec.Key("REVERSE_PROXY_AUTHENTICATION_USER").MustString("X-WEBAUTH-USER")
+
+ sec = Cfg.Section("attachment")
+ AttachmentPath = sec.Key("PATH").MustString("data/attachments")
+ AttachmentAllowedTypes = sec.Key("ALLOWED_TYPES").MustString("image/jpeg|image/png")
+ AttachmentMaxSize = sec.Key("MAX_SIZE").MustInt64(32)
+ AttachmentMaxFiles = sec.Key("MAX_FILES").MustInt(10)
+ AttachmentEnabled = sec.Key("ENABLE").MustBool(true)
TimeFormat = map[string]string{
"ANSIC": time.ANSIC,
"StampMilli": time.StampMilli,
"StampMicro": time.StampMicro,
"StampNano": time.StampNano,
- }[Cfg.MustValue("time", "FORMAT", "RFC1123")]
+ }[Cfg.Section("time").Key("FORMAT").MustString("RFC1123")]
if err = os.MkdirAll(AttachmentPath, os.ModePerm); err != nil {
log.Fatal(4, "Could not create directory %s: %s", AttachmentPath, err)
}
- RunUser = Cfg.MustValue("", "RUN_USER")
+ RunUser = Cfg.Section("").Key("RUN_USER").String()
curUser := os.Getenv("USER")
if len(curUser) == 0 {
curUser = os.Getenv("USERNAME")
if err != nil {
log.Fatal(4, "Fail to get home directory: %v", err)
}
- RepoRootPath = Cfg.MustValue("repository", "ROOT", filepath.Join(homeDir, "gogs-repositories"))
+ sec = Cfg.Section("repository")
+ RepoRootPath = sec.Key("ROOT").MustString(filepath.Join(homeDir, "gogs-repositories"))
if !filepath.IsAbs(RepoRootPath) {
RepoRootPath = filepath.Join(workDir, RepoRootPath)
} else {
RepoRootPath = filepath.Clean(RepoRootPath)
}
-
if err = os.MkdirAll(RepoRootPath, os.ModePerm); err != nil {
log.Fatal(4, "Fail to create repository root path(%s): %v", RepoRootPath, err)
}
- ScriptType = Cfg.MustValue("repository", "SCRIPT_TYPE", "bash")
+ ScriptType = sec.Key("SCRIPT_TYPE").MustString("bash")
- PictureService = Cfg.MustValueRange("picture", "SERVICE", "server", []string{"server"})
- AvatarUploadPath = Cfg.MustValue("picture", "AVATAR_UPLOAD_PATH", "data/avatars")
+ sec = Cfg.Section("picture")
+ PictureService = sec.Key("SERVICE").In("server", []string{"server"})
+ AvatarUploadPath = sec.Key("AVATAR_UPLOAD_PATH").MustString("data/avatars")
os.MkdirAll(AvatarUploadPath, os.ModePerm)
-
- switch Cfg.MustValue("picture", "GRAVATAR_SOURCE", "gravatar") {
+ switch sec.Key("GRAVATAR_SOURCE").MustString("gravatar") {
case "duoshuo":
GravatarSource = "http://gravatar.duoshuo.com/avatar/"
default:
GravatarSource = "//1.gravatar.com/avatar/"
}
- DisableGravatar = Cfg.MustBool("picture", "DISABLE_GRAVATAR")
+ DisableGravatar = sec.Key("DISABLE_GRAVATAR").MustBool()
- MaxGitDiffLines = Cfg.MustInt("git", "MAX_GITDIFF_LINES", 10000)
- GitFsckArgs = Cfg.MustValueArray("git", "FSCK_ARGS", " ")
- GitGcArgs = Cfg.MustValueArray("git", "GC_ARGS", " ")
+ sec = Cfg.Section("git")
+ MaxGitDiffLines = sec.Key("MAX_GITDIFF_LINES").MustInt(10000)
+ GitFsckArgs = sec.Key("FSCK_ARGS").Strings(" ")
+ GitGcArgs = sec.Key("GC_ARGS").Strings(" ")
- Langs = Cfg.MustValueArray("i18n", "LANGS", ",")
- Names = Cfg.MustValueArray("i18n", "NAMES", ",")
+ Langs = Cfg.Section("i18n").Key("LANGS").Strings(",")
+ Names = Cfg.Section("i18n").Key("NAMES").Strings(",")
HasRobotsTxt = com.IsFile(path.Join(CustomPath, "robots.txt"))
}
}
func newService() {
- Service.ActiveCodeLives = Cfg.MustInt("service", "ACTIVE_CODE_LIVE_MINUTES", 180)
- Service.ResetPwdCodeLives = Cfg.MustInt("service", "RESET_PASSWD_CODE_LIVE_MINUTES", 180)
- Service.DisableRegistration = Cfg.MustBool("service", "DISABLE_REGISTRATION")
- Service.RequireSignInView = Cfg.MustBool("service", "REQUIRE_SIGNIN_VIEW")
- Service.EnableCacheAvatar = Cfg.MustBool("service", "ENABLE_CACHE_AVATAR")
- Service.EnableReverseProxyAuth = Cfg.MustBool("service", "ENABLE_REVERSE_PROXY_AUTHENTICATION")
- Service.EnableReverseProxyAutoRegister = Cfg.MustBool("service", "ENABLE_REVERSE_PROXY_AUTO_REGISTERATION")
+ Service.ActiveCodeLives = Cfg.Section("service").Key("ACTIVE_CODE_LIVE_MINUTES").MustInt(180)
+ Service.ResetPwdCodeLives = Cfg.Section("service").Key("RESET_PASSWD_CODE_LIVE_MINUTES").MustInt(180)
+ Service.DisableRegistration = Cfg.Section("service").Key("DISABLE_REGISTRATION").MustBool()
+ Service.RequireSignInView = Cfg.Section("service").Key("REQUIRE_SIGNIN_VIEW").MustBool()
+ Service.EnableCacheAvatar = Cfg.Section("service").Key("ENABLE_CACHE_AVATAR").MustBool()
+ Service.EnableReverseProxyAuth = Cfg.Section("service").Key("ENABLE_REVERSE_PROXY_AUTHENTICATION").MustBool()
+ Service.EnableReverseProxyAutoRegister = Cfg.Section("service").Key("ENABLE_REVERSE_PROXY_AUTO_REGISTERATION").MustBool()
}
var logLevels = map[string]string{
log.Info("%s %s", AppName, AppVer)
// Get and check log mode.
- LogModes = strings.Split(Cfg.MustValue("log", "MODE", "console"), ",")
+ LogModes = strings.Split(Cfg.Section("log").Key("MODE").MustString("console"), ",")
LogConfigs = make([]string, len(LogModes))
for i, mode := range LogModes {
mode = strings.TrimSpace(mode)
- modeSec := "log." + mode
- if _, err := Cfg.GetSection(modeSec); err != nil {
+ sec, err := Cfg.GetSection("log." + mode)
+ if err != nil {
log.Fatal(4, "Unknown log mode: %s", mode)
}
// Log level.
- levelName := Cfg.MustValueRange("log."+mode, "LEVEL", "Trace",
+ levelName := Cfg.Section("log."+mode).Key("LEVEL").In("Trace",
[]string{"Trace", "Debug", "Info", "Warn", "Error", "Critical"})
level, ok := logLevels[levelName]
if !ok {
case "console":
LogConfigs[i] = fmt.Sprintf(`{"level":%s}`, level)
case "file":
- logPath := Cfg.MustValue(modeSec, "FILE_NAME", path.Join(LogRootPath, "gogs.log"))
+ logPath := sec.Key("FILE_NAME").MustString(path.Join(LogRootPath, "gogs.log"))
os.MkdirAll(path.Dir(logPath), os.ModePerm)
LogConfigs[i] = fmt.Sprintf(
`{"level":%s,"filename":"%s","rotate":%v,"maxlines":%d,"maxsize":%d,"daily":%v,"maxdays":%d}`, level,
logPath,
- Cfg.MustBool(modeSec, "LOG_ROTATE", true),
- Cfg.MustInt(modeSec, "MAX_LINES", 1000000),
- 1<<uint(Cfg.MustInt(modeSec, "MAX_SIZE_SHIFT", 28)),
- Cfg.MustBool(modeSec, "DAILY_ROTATE", true),
- Cfg.MustInt(modeSec, "MAX_DAYS", 7))
+ sec.Key("LOG_ROTATE").MustBool(true),
+ sec.Key("MAX_LINES").MustInt(1000000),
+ 1<<uint(sec.Key("MAX_SIZE_SHIFT").MustInt(28)),
+ sec.Key("DAILY_ROTATE").MustBool(true),
+ sec.Key("MAX_DAYS").MustInt(7))
case "conn":
LogConfigs[i] = fmt.Sprintf(`{"level":%s,"reconnectOnMsg":%v,"reconnect":%v,"net":"%s","addr":"%s"}`, level,
- Cfg.MustBool(modeSec, "RECONNECT_ON_MSG"),
- Cfg.MustBool(modeSec, "RECONNECT"),
- Cfg.MustValueRange(modeSec, "PROTOCOL", "tcp", []string{"tcp", "unix", "udp"}),
- Cfg.MustValue(modeSec, "ADDR", ":7020"))
+ sec.Key("RECONNECT_ON_MSG").MustBool(),
+ sec.Key("RECONNECT").MustBool(),
+ sec.Key("PROTOCOL").In("tcp", []string{"tcp", "unix", "udp"}),
+ sec.Key("ADDR").MustString(":7020"))
case "smtp":
LogConfigs[i] = fmt.Sprintf(`{"level":%s,"username":"%s","password":"%s","host":"%s","sendTos":"%s","subject":"%s"}`, level,
- Cfg.MustValue(modeSec, "USER", "example@example.com"),
- Cfg.MustValue(modeSec, "PASSWD", "******"),
- Cfg.MustValue(modeSec, "HOST", "127.0.0.1:25"),
- Cfg.MustValue(modeSec, "RECEIVERS", "[]"),
- Cfg.MustValue(modeSec, "SUBJECT", "Diagnostic message from serve"))
+ sec.Key("USER").MustString("example@example.com"),
+ sec.Key("PASSWD").MustString("******"),
+ sec.Key("HOST").MustString("127.0.0.1:25"),
+ sec.Key("RECEIVERS").MustString("[]"),
+ sec.Key("SUBJECT").MustString("Diagnostic message from serve"))
case "database":
LogConfigs[i] = fmt.Sprintf(`{"level":%s,"driver":"%s","conn":"%s"}`, level,
- Cfg.MustValue(modeSec, "DRIVER"),
- Cfg.MustValue(modeSec, "CONN"))
+ sec.Key("DRIVER").String(),
+ sec.Key("CONN").String())
}
- log.NewLogger(Cfg.MustInt64("log", "BUFFER_LEN", 10000), mode, LogConfigs[i])
+ log.NewLogger(Cfg.Section("log").Key("BUFFER_LEN").MustInt64(10000), mode, LogConfigs[i])
log.Info("Log Mode: %s(%s)", strings.Title(mode), levelName)
}
}
func newCacheService() {
- CacheAdapter = Cfg.MustValueRange("cache", "ADAPTER", "memory", []string{"memory", "redis", "memcache"})
+ CacheAdapter = Cfg.Section("cache").Key("ADAPTER").In("memory", []string{"memory", "redis", "memcache"})
if EnableRedis {
log.Info("Redis Enabled")
}
switch CacheAdapter {
case "memory":
- CacheInternal = Cfg.MustInt("cache", "INTERVAL", 60)
+ CacheInternal = Cfg.Section("cache").Key("INTERVAL").MustInt(60)
case "redis", "memcache":
- CacheConn = strings.Trim(Cfg.MustValue("cache", "HOST"), "\" ")
+ CacheConn = strings.Trim(Cfg.Section("cache").Key("HOST").String(), "\" ")
default:
log.Fatal(4, "Unknown cache adapter: %s", CacheAdapter)
}
}
func newSessionService() {
- SessionConfig.Provider = Cfg.MustValueRange("session", "PROVIDER", "memory",
+ SessionConfig.Provider = Cfg.Section("session").Key("PROVIDER").In("memory",
[]string{"memory", "file", "redis", "mysql"})
- SessionConfig.ProviderConfig = strings.Trim(Cfg.MustValue("session", "PROVIDER_CONFIG"), "\" ")
- SessionConfig.CookieName = Cfg.MustValue("session", "COOKIE_NAME", "i_like_gogits")
+ SessionConfig.ProviderConfig = strings.Trim(Cfg.Section("session").Key("PROVIDER_CONFIG").String(), "\" ")
+ SessionConfig.CookieName = Cfg.Section("session").Key("COOKIE_NAME").MustString("i_like_gogits")
SessionConfig.CookiePath = AppSubUrl
- SessionConfig.Secure = Cfg.MustBool("session", "COOKIE_SECURE")
- SessionConfig.Gclifetime = Cfg.MustInt64("session", "GC_INTERVAL_TIME", 86400)
- SessionConfig.Maxlifetime = Cfg.MustInt64("session", "SESSION_LIFE_TIME", 86400)
+ SessionConfig.Secure = Cfg.Section("session").Key("COOKIE_SECURE").MustBool()
+ SessionConfig.Gclifetime = Cfg.Section("session").Key("GC_INTERVAL_TIME").MustInt64(86400)
+ SessionConfig.Maxlifetime = Cfg.Section("session").Key("SESSION_LIFE_TIME").MustInt64(86400)
log.Info("Session Service Enabled")
}
)
func newMailService() {
+ sec := Cfg.Section("mailer")
// Check mailer setting.
- if !Cfg.MustBool("mailer", "ENABLED") {
+ if !sec.Key("ENABLED").MustBool() {
return
}
MailService = &Mailer{
- Name: Cfg.MustValue("mailer", "NAME", AppName),
- Host: Cfg.MustValue("mailer", "HOST"),
- User: Cfg.MustValue("mailer", "USER"),
- Passwd: Cfg.MustValue("mailer", "PASSWD"),
- SkipVerify: Cfg.MustBool("mailer", "SKIP_VERIFY", false),
+ Name: sec.Key("NAME").MustString(AppName),
+ Host: sec.Key("HOST").String(),
+ User: sec.Key("USER").String(),
+ Passwd: sec.Key("PASSWD").String(),
+ SkipVerify: sec.Key("SKIP_VERIFY").MustBool(),
}
- MailService.From = Cfg.MustValue("mailer", "FROM", MailService.User)
+ MailService.From = sec.Key("FROM").MustString(MailService.User)
log.Info("Mail Service Enabled")
}
func newRegisterMailService() {
- if !Cfg.MustBool("service", "REGISTER_EMAIL_CONFIRM") {
+ if !Cfg.Section("service").Key("REGISTER_EMAIL_CONFIRM").MustBool() {
return
} else if MailService == nil {
log.Warn("Register Mail Service: Mail Service is not enabled")
}
func newNotifyMailService() {
- if !Cfg.MustBool("service", "ENABLE_NOTIFY_MAIL") {
+ if !Cfg.Section("service").Key("ENABLE_NOTIFY_MAIL").MustBool() {
return
} else if MailService == nil {
log.Warn("Notify Mail Service: Mail Service is not enabled")
}
func newWebhookService() {
- WebhookTaskInterval = Cfg.MustInt("webhook", "TASK_INTERVAL", 1)
- WebhookDeliverTimeout = Cfg.MustInt("webhook", "DELIVER_TIMEOUT", 5)
+ WebhookTaskInterval = Cfg.Section("webhook").Key("TASK_INTERVAL").MustInt(1)
+ WebhookDeliverTimeout = Cfg.Section("webhook").Key("DELIVER_TIMEOUT").MustInt(5)
}
func NewServices() {
"strings"
"github.com/Unknwon/com"
- "github.com/Unknwon/goconfig"
"github.com/Unknwon/macaron"
"github.com/go-xorm/xorm"
)
func checkRunMode() {
- switch setting.Cfg.MustValue("", "RUN_MODE") {
+ switch setting.Cfg.Section("").Key("RUN_MODE").String() {
case "prod":
macaron.Env = macaron.PROD
setting.ProdMode = true
}
// Save settings.
- setting.Cfg.SetValue("database", "DB_TYPE", models.DbCfg.Type)
- setting.Cfg.SetValue("database", "HOST", models.DbCfg.Host)
- setting.Cfg.SetValue("database", "NAME", models.DbCfg.Name)
- setting.Cfg.SetValue("database", "USER", models.DbCfg.User)
- setting.Cfg.SetValue("database", "PASSWD", models.DbCfg.Pwd)
- setting.Cfg.SetValue("database", "SSL_MODE", models.DbCfg.SslMode)
- setting.Cfg.SetValue("database", "PATH", models.DbCfg.Path)
-
- setting.Cfg.SetValue("repository", "ROOT", form.RepoRootPath)
- setting.Cfg.SetValue("", "RUN_USER", form.RunUser)
- setting.Cfg.SetValue("server", "DOMAIN", form.Domain)
- setting.Cfg.SetValue("server", "ROOT_URL", form.AppUrl)
+ setting.Cfg.Section("database").Key("DB_TYPE").SetValue(models.DbCfg.Type)
+ setting.Cfg.Section("database").Key("HOST").SetValue(models.DbCfg.Host)
+ setting.Cfg.Section("database").Key("NAME").SetValue(models.DbCfg.Name)
+ setting.Cfg.Section("database").Key("USER").SetValue(models.DbCfg.User)
+ setting.Cfg.Section("database").Key("PASSWD").SetValue(models.DbCfg.Pwd)
+ setting.Cfg.Section("database").Key("SSL_MODE").SetValue(models.DbCfg.SslMode)
+ setting.Cfg.Section("database").Key("PATH").SetValue(models.DbCfg.Path)
+
+ setting.Cfg.Section("repository").Key("ROOT").SetValue(form.RepoRootPath)
+ setting.Cfg.Section("").Key("RUN_USER").SetValue(form.RunUser)
+ setting.Cfg.Section("server").Key("DOMAIN").SetValue(form.Domain)
+ setting.Cfg.Section("server").Key("ROOT_URL").SetValue(form.AppUrl)
if len(strings.TrimSpace(form.SmtpHost)) > 0 {
- setting.Cfg.SetValue("mailer", "ENABLED", "true")
- setting.Cfg.SetValue("mailer", "HOST", form.SmtpHost)
- setting.Cfg.SetValue("mailer", "USER", form.SmtpEmail)
- setting.Cfg.SetValue("mailer", "PASSWD", form.SmtpPasswd)
+ setting.Cfg.Section("mailer").Key("ENABLED").SetValue("true")
+ setting.Cfg.Section("mailer").Key("HOST").SetValue(form.SmtpHost)
+ setting.Cfg.Section("mailer").Key("USER").SetValue(form.SmtpEmail)
+ setting.Cfg.Section("mailer").Key("PASSWD").SetValue(form.SmtpPasswd)
- setting.Cfg.SetValue("service", "REGISTER_EMAIL_CONFIRM", com.ToStr(form.RegisterConfirm == "on"))
- setting.Cfg.SetValue("service", "ENABLE_NOTIFY_MAIL", com.ToStr(form.MailNotify == "on"))
+ setting.Cfg.Section("service").Key("REGISTER_EMAIL_CONFIRM").SetValue(com.ToStr(form.RegisterConfirm == "on"))
+ setting.Cfg.Section("service").Key("ENABLE_NOTIFY_MAIL").SetValue(com.ToStr(form.MailNotify == "on"))
}
- setting.Cfg.SetValue("", "RUN_MODE", "prod")
+ setting.Cfg.Section("").Key("RUN_MODE").SetValue("prod")
- setting.Cfg.SetValue("session", "PROVIDER", "file")
+ setting.Cfg.Section("session").Key("PROVIDER").SetValue("file")
- setting.Cfg.SetValue("log", "MODE", "file")
+ setting.Cfg.Section("log").Key("MODE").SetValue("file")
- setting.Cfg.SetValue("security", "INSTALL_LOCK", "true")
- setting.Cfg.SetValue("security", "SECRET_KEY", base.GetRandomString(15))
+ setting.Cfg.Section("security").Key("INSTALL_LOCK").SetValue("true")
+ setting.Cfg.Section("security").Key("SECRET_KEY").SetValue(base.GetRandomString(15))
os.MkdirAll("custom/conf", os.ModePerm)
- if err := goconfig.SaveConfigFile(setting.Cfg, path.Join(setting.CustomPath, "conf/app.ini")); err != nil {
+ if err := setting.Cfg.SaveTo(path.Join(setting.CustomPath, "conf/app.ini")); err != nil {
ctx.RenderWithErr(ctx.Tr("install.save_config_failed", err), INSTALL, &form)
return
}
projects / gitea.git / commitdiff