func SaveLocalNodes() {
if err := goconfig.SaveConfigFile(LocalNodes,
path.Join(HomeDir+LocalNodesFile)); err != nil {
log.Error("", "Fail to save localnodes.list:")
log.Error("", "\t"+err.Error())
}
}
func InitModels() {
if !com.IsFile(_CFG_PATH) {
os.Create(_CFG_PATH)
}
var err error
Cfg, err = goconfig.LoadConfigFile(_CFG_PATH)
if err == nil {
beego.Info("Initialize app.ini")
}
setGithubCredentials(Cfg.MustValue("github", "client_id"),
Cfg.MustValue("github", "client_secret"))
docLock = new(sync.RWMutex)
blogLock = new(sync.RWMutex)
initMaps()
// Start check ticker.
checkTicker = time.NewTicker(5 * time.Minute)
go checkTickerTimer(checkTicker.C)
// ATTENTION: you'd better comment following code when developing.
if needCheckUpdate() {
checkFileUpdates()
Cfg.SetValue("app", "update_check_time", strconv.Itoa(int(time.Now().Unix())))
goconfig.SaveConfigFile(Cfg, _CFG_PATH)
}
}
func CreateIniFile() error {
f, err := os.OpenFile("./server.ini", os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
return err
}
defer f.Close()
config, err = goconfig.LoadConfigFile("./server.ini")
if err != nil {
return err
}
config.SetSectionComments("App", "")
config.SetSectionComments("User", "")
config.SetValue("App", "IP", "127.0.0.1")
config.SetValue("App", "Port", "8080")
config.SetValue("User", "username", "admin")
config.SetValue("User", "password", helper.MD5("admin"))
err = goconfig.SaveConfigFile(config, "./server.ini")
if err != nil {
return err
}
return nil
}
// scan a directory and gen a gopm file
func runGen(ctx *cli.Context) {
setup(ctx)
if !com.IsExist(".gopmfile") {
os.Create(".gopmfile")
}
gf, err := goconfig.LoadConfigFile(".gopmfile")
if err != nil {
log.Error("gen", "Cannot load gopmfile:")
log.Fatal("", "\t"+err.Error())
}
// Get dependencies.
imports := doc.GetAllImports([]string{workDir},
parseTarget(gf.MustValue("target", "path")), ctx.Bool("example"))
for _, p := range imports {
p = doc.GetProjectPath(p)
if strings.HasSuffix(workDir, p) {
continue
}
if value := gf.MustValue("deps", p); len(value) == 0 {
gf.SetValue("deps", p, "")
}
}
err = goconfig.SaveConfigFile(gf, ".gopmfile")
if err != nil {
log.Error("gen", "Fail to save gopmfile:")
log.Fatal("", "\t"+err.Error())
}
log.Success("SUCC", "gen", "Generate gopmfile successfully!")
}
func main() {
read, err := goconfig.LoadConfigFile("read.ini")
if err != nil {
fmt.Println(err)
}
goconfig.PrettyFormat = false
/*ini cfg配置文件读取*/
fmt.Println(read.GetSectionList()) // 获取选项名称
fmt.Println(read.GetKeyList("Cody")) // 获取Cody选项下的key
fmt.Println(read.GetSection("Cody")) // 以map形式获取Cody选项下的key和value的值
fmt.Println(read.GetSectionComments("work")) // 获取选项work上的以“#”和“;”开头的注解
fmt.Println(read.GetKeyComments("Cody", "sex")) // 获取选项Cody的sex键上的注解
fmt.Println(read.GetValue("Cody", "name")) // 获取选项Cody的name键的值
read.DeleteKey("Cody", "hell")
// /**/
// read.SetValue("Cody", "name", "cody.guo") // 设置选项Cody的name键的值为cody.guo
goconfig.SaveConfigFile(read, "read.ini") // 保存
// read.DeleteKey("work", "work") // 删除选项work中的work键
// goconfig.SaveConfigFile(read, "readWrite.ini") // 另存为readWrite.ini
// read.DeleteSection("work") // 删除选项work
// goconfig.SaveConfigFile(read, "read.ini") // 保存配置文件,会把 " : "的修改为" = "
}
// SaveConfig saves configuration file.
// if configKey has been set, the file will be encrypted.
func SaveConfig() {
if len(configKey) == 0 {
err := goconfig.SaveConfigFile(configData, ConfigPath)
if err != nil {
log.Fatalf("Failed to save config file: %v", err)
}
err = os.Chmod(ConfigPath, 0600)
if err != nil {
ErrorLog(nil, "Failed to set permissions on config file: %v", err)
}
return
}
var buf bytes.Buffer
err := goconfig.SaveConfigData(configData, &buf)
if err != nil {
log.Fatalf("Failed to save config file: %v", err)
}
f, err := os.Create(ConfigPath)
if err != nil {
log.Fatalf("Failed to save config file: %v", err)
}
fmt.Fprintln(f, "# Encrypted rclone configuration File")
fmt.Fprintln(f, "")
fmt.Fprintln(f, "RCLONE_ENCRYPT_V0:")
// Generate new nonce and write it to the start of the ciphertext
var nonce [24]byte
n, _ := rand.Read(nonce[:])
if n != 24 {
log.Fatalf("nonce short read: %d", n)
}
enc := base64.NewEncoder(base64.StdEncoding, f)
_, err = enc.Write(nonce[:])
if err != nil {
log.Fatalf("Failed to write config file: %v", err)
}
var key [32]byte
copy(key[:], configKey[:32])
b := secretbox.Seal(nil, buf.Bytes(), &nonce, &key)
_, err = enc.Write(b)
if err != nil {
log.Fatalf("Failed to write config file: %v", err)
}
_ = enc.Close()
err = f.Close()
if err != nil {
log.Fatalf("Failed to close config file: %v", err)
}
err = os.Chmod(ConfigPath, 0600)
if err != nil {
ErrorLog(nil, "Failed to set permissions on config file: %v", err)
}
}
// SaveConfig saves configuration file.
func SaveConfig() {
err := goconfig.SaveConfigFile(ConfigFile, ConfigPath)
if err != nil {
log.Fatalf("Failed to save config file: %v", err)
}
err = os.Chmod(ConfigPath, 0600)
if err != nil {
log.Printf("Failed to set permissions on config file: %v", err)
}
}
func (p *ProxyConf) Write(proxy []Proxy) {
if len(proxy) == 0 {
return
}
p.load()
for _, pro := range proxy {
switch pro.pTtype {
case HTTP:
p.SetValue(HTTP, pro.ip, pro.port)
case HTTPS:
p.SetValue(HTTPS, pro.ip, pro.port)
}
}
goconfig.SaveConfigFile(p.ConfigFile, proxyFile)
}
func main() {
cfg, err := goconfig.LoadConfigFile("conf.ini")
if err != nil {
log.Fatalf("无法加载配置文件: %s", err)
}
value, err := cfg.GetValue(goconfig.DEFAULT_SECTION, "key_default")
if err != nil {
log.Fatalf("无法获取键值(%s): %s", "key_default", nil)
}
log.Printf("%s > %s: %s", goconfig.DEFAULT_SECTION, "key_default", value)
isInsert := cfg.SetValue(goconfig.DEFAULT_SECTION, "key_default", "这是新的值")
if err != nil {
log.Fatalf("无法设置键值(%s): %s", "key_default", err)
}
log.Printf("设置键值 %s 为插入操作: %v", "key_default", isInsert)
comment := cfg.GetSectionComments("super")
log.Printf("分区 %s 的注释: %s", "super", comment)
v := cfg.SetSectionComments("super", "# 这是新的分区注释")
log.Printf("分区 %s 的注释被插入或删除: %v", "super", v)
vInt, err := cfg.Int("must", "int")
if err != nil {
log.Fatalf("无法获取键值(%s): %s)", "int", err)
}
log.Printf("%s > %s: %v", "must", "int", vInt)
vBool := cfg.MustBool("must", "bool")
log.Printf("%s > %s: %v", "must", "bool", vBool)
vBool = cfg.MustBool("must", "bool404")
log.Printf("%s > %s: %v", "must", "bool", vBool)
ok := cfg.DeleteKey("must", "string")
log.Printf("删除键值 %s 是否成功: %v", "string", ok)
err = goconfig.SaveConfigFile(cfg, "conf_save.ini")
if err != nil {
log.Fatalf("无法保存配置文件: %s", err)
}
}
func runGen(ctx *cli.Context) {
setup(ctx)
if !com.IsExist(".gopmfile") {
os.Create(".gopmfile")
}
gf, err := goconfig.LoadConfigFile(".gopmfile")
if err != nil {
log.Error("gen", "Cannot load gopmfile:")
log.Fatal("", "\t"+err.Error())
}
targetPath := parseTarget(gf.MustValue("target", "path"))
// Get and set dependencies.
imports := doc.GetAllImports([]string{workDir}, targetPath, ctx.Bool("example"), false)
for _, p := range imports {
p = doc.GetProjectPath(p)
// Skip subpackage(s) of current project.
if isSubpackage(p, targetPath) {
continue
}
// Check if user specified the version.
if value := gf.MustValue("deps", p); len(value) == 0 {
gf.SetValue("deps", p, "")
}
}
// Get and set resources.
res := make([]string, 0, len(commonRes))
for _, cr := range commonRes {
if com.IsExist(cr) {
res = append(res, cr)
}
}
gf.SetValue("res", "include", strings.Join(res, "|"))
err = goconfig.SaveConfigFile(gf, ".gopmfile")
if err != nil {
log.Error("gen", "Fail to save gopmfile:")
log.Fatal("", "\t"+err.Error())
}
log.Success("SUCC", "gen", "Generate gopmfile successfully!")
}
func runConfig(ctx *cli.Context) {
setup(ctx)
if len(ctx.Args()) == 0 {
log.Error("config", "Cannot start command:")
log.Fatal("", "\tNo section specified")
}
switch ctx.Args()[0] {
case "github":
if len(ctx.Args()) < 3 {
log.Error("config", "Cannot config section 'github'")
log.Fatal("", "\tNot enough arguments for client_id and client_secret")
}
doc.Cfg.SetValue("github", "client_id", ctx.Args()[1])
doc.Cfg.SetValue("github", "client_secret", ctx.Args()[2])
goconfig.SaveConfigFile(doc.Cfg, path.Join(doc.HomeDir, doc.GOPM_CONFIG_FILE))
}
log.Success("SUCC", "config", "Command executed successfully!")
}
func main() {
cfg, err := goconfig.LoadConfigFile("conf.ini")
if err != nil {
log.Fatalf("无法加载配置文件:%s", err)
}
value, err := cfg.GetValue(goconfig.DEFAULT_SECTION, "key_default")
if err != nil {
log.Fatalf("无法获取值:%s", err)
}
log.Printf("%s > %s:%s", goconfig.DEFAULT_SECTION, "key_default", value)
isInsert := cfg.SetValue(goconfig.DEFAULT_SECTION, "key_default", "这是新的值")
log.Printf("设在键值%s: %v", "key_default", isInsert)
comment := cfg.GetSectionComments("super")
log.Printf("分区%s的注释:%s", "supper", comment)
_ = cfg.SetSectionComments("super", "# 这是一个新的注释")
_, err = cfg.Int("must", "int")
err = goconfig.SaveConfigFile(cfg, "conf_save.ini")
if err != nil {
log.Fatalf("无法获取值:%s", err)
}
}
func (p *ProxyConf) Update() {
p.Read()
ok := make(chan bool)
for _, proxy := range p.proxy {
ip := proxy.ip
prot := proxy.port
go func() {
_, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%s", ip, prot), 10*time.Second)
if err != nil {
fmt.Printf("代理服务器 [%s:%s] 不可用，已删除.\n", ip, prot)
p.DeleteKey(HTTP, ip)
p.DeleteKey(HTTPS, ip)
}
ok <- true
}()
}
for range p.proxy {
<-ok
}
goconfig.SaveConfigFile(p.ConfigFile, proxyFile)
p.Reload()
}
func main() {
// 读取证书文件
rootPEM, err := ioutil.ReadFile("cert.pem")
if err != nil {
log.Println("读取 cert.pem 出错:", err, "请检查文件是否存在")
return
}
roots := x509.NewCertPool()
ok := roots.AppendCertsFromPEM(rootPEM)
if !ok {
log.Println("证书分析失败，请检查证书文件是否正确")
return
}
// 加载配置文件
cfg, err := goconfig.LoadConfigFile("client.ini")
if err != nil {
log.Println("配置文件加载失败，自动重置配置文件:", err)
cfg, err = goconfig.LoadFromData([]byte{})
if err != nil {
log.Println(err)
return
}
}
var (
port, ok1 = cfg.MustValueSet("client", "port", "7071")
key, ok2 = cfg.MustValueSet("client", "key", "eGauUecvzS05U5DIsxAN4n2hadmRTZGBqNd2zsCkrvwEBbqoITj36mAMk4Unw6Pr")
serverHost, ok3 = cfg.MustValueSet("server", "host", "localhost")
serverPort, ok4 = cfg.MustValueSet("server", "port", "8081")
)
// 如果缺少配置则保存为默认配置
if ok1 || ok2 || ok3 || ok4 {
err = goconfig.SaveConfigFile(cfg, "client.ini")
if err != nil {
log.Println("配置文件保存失败:", err)
}
}
ln, err := net.Listen("tcp", ":"+port)
if err != nil {
log.Println(err)
return
}
defer ln.Close()
log.Println("|>>>>>>>>>>>>>>>|<<<<<<<<<<<<<<<|")
log.Println("程序版本:" + VERSION)
log.Println("代理端口:" + port)
log.Println("Key:" + key)
log.Println("服务器地址:" + serverHost + ":" + serverPort)
log.Println("|>>>>>>>>>>>>>>>|<<<<<<<<<<<<<<<|")
s := &serve{
serverHost: serverHost,
serverPort: serverPort,
key: key,
conf: &tls.Config{
RootCAs: roots,
},
}
// 登录
if err = s.updateSession(); err != nil {
log.Println("与服务器连接失败:", err)
return
}
log.Println("登录成功,服务器连接完毕")
go s.updateSessionLoop()
for {
conn, err := ln.Accept()
if err != nil {
log.Println(err)
continue
}
go s.handleConnection(conn)
}
}
// SaveConfig saves configuration file.
func SaveConfig() error {
return goconfig.SaveConfigFile(Cfg, "conf/app.ini")
}
func (c *CliConfig) WriteProfile(p, id, key string) {
cfg := c.ConfigFile
cfg.SetValue(p, "aws_access_key_id", id)
cfg.SetValue(p, "aws_secret_access_key", key)
goconfig.SaveConfigFile(c.ConfigFile, c.CredentialsFile)
}
func main() {
// 创建并获取一个 ConfigFile 对象，以进行后续操作
// 文件名支持相对和绝对路径
cfg, err := goconfig.LoadConfigFile("conf.ini")
if err != nil {
log.Fatalf("无法加载配置文件：%s", err)
}
// 加载完成后所有数据均已存入内存，任何对文件的修改操作都不会影响到已经获取到的对象
// >>>>>>>>>>>>>>> 基本读写操作 >>>>>>>>>>>>>>>
// 对默认分区进行普通读取操作
value, err := cfg.GetValue(goconfig.DEFAULT_SECTION, "key_default")
if err != nil {
log.Fatalf("无法获取键值（%s）：%s", "key_default", err)
}
log.Printf("%s > %s: %s", goconfig.DEFAULT_SECTION, "key_default", value)
// 对已有的键进行值重写操作，返回值为 bool 类型，表示是否为插入操作
isInsert := cfg.SetValue(goconfig.DEFAULT_SECTION, "key_default", "这是新的值")
log.Printf("设置键值 %s 为插入操作：%v", "key_default", isInsert)
// 对不存在的键进行插入操作
isInsert = cfg.SetValue(goconfig.DEFAULT_SECTION, "key_new", "这是新插入的键")
log.Printf("设置键值 %s 为插入操作：%v", "key_new", isInsert)
// 传入空白字符串也可直接操作默认分区
value, err = cfg.GetValue("", "key_default")
if err != nil {
log.Fatalf("无法获取键值（%s）：%s", "key_default", err)
}
log.Printf("%s > %s: %s", goconfig.DEFAULT_SECTION, "key_default", value)
// 获取冒号为分隔符的键值
value, err = cfg.GetValue("super", "key_super2")
if err != nil {
log.Fatalf("无法获取键值（%s）：%s", "key_super2", err)
}
log.Printf("%s > %s: %s", "super", "key_super2", value)
// <<<<<<<<<<<<<<< 基本读写操作 <<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>> 对注释进行读写操作 >>>>>>>>>>>>>>>
// 获取某个分区的注释
comment := cfg.GetSectionComments("super")
log.Printf("分区 %s 的注释：%s", "super", comment)
// 获取某个键的注释
comment = cfg.GetKeyComments("super", "key_super")
log.Printf("键 %s 的注释：%s", "key_super", comment)
// 设置某个键的注释，返回值为 true 时表示注释被插入或删除（空字符串），false 表示注释被重写
v := cfg.SetKeyComments("super", "key_super", "# 这是新的键注释")
log.Printf("键 %s 的注释被插入或删除：%v", "key_super", v)
// 设置某个分区的注释，返回值效果同上
v = cfg.SetSectionComments("super", "# 这是新的分区注释")
log.Printf("分区 %s 的注释被插入或删除：%v", "super", v)
// <<<<<<<<<<<<<<< 对注释进行读写操作 <<<<<<<<<<<<<<<
// >>>>>>>>>>>>>>> 自动转换和 Must 系列方法 >>>>>>>>>>>>>>>
// 自动转换类型读取操作，直接返回指定类型，error 类型用于指示是否发生错误
vInt, err := cfg.Int("must", "int")
if err != nil {
log.Fatalf("无法获取键值（%s）：%s", "int", err)
}
log.Printf("%s > %s: %v", "must", "int", vInt)
// Must 系列方法，一定返回某个类型的值；如果失败则返回零值
vBool := cfg.MustBool("must", "bool")
log.Printf("%s > %s: %v", "must", "bool", vBool)
// 若键不存在则返回零值，此例应返回 false
vBool = cfg.MustBool("must", "bool404")
log.Printf("%s > %s: %v", "must", "bool404", vBool)
// <<<<<<<<<<<<<<< 自动转换和 Must 系列方法 <<<<<<<<<<<<<<<
// 删除键值，返回值用于表示是否删除成功
ok := cfg.DeleteKey("must", "string")
log.Printf("删除键值 %s 是否成功：%v", "string", ok)
// 保存 ConfigFile 对象到文件系统，保存后的键顺序与读取时的一样
err = goconfig.SaveConfigFile(cfg, "conf_save.ini")
if err != nil {
log.Fatalf("无法保存配置文件：%s", err)
}
}
// SaveConfig saves configuration file.
func SaveConfig() error {
os.MkdirAll("custom", os.ModePerm)
return goconfig.SaveConfigFile(Cfg, "custom/app.ini")
}
func main() {
m := macaron.Classic()
m.Get("/", func() string {
return "Hello world!"
})
m.Get("/:username/:leixing", func(ctx *macaron.Context) string {
leixing := ctx.Params(":leixing")
username := ctx.Params(":username")
conf, _ := goconfig.LoadConfigFile("data.ini")
times, _ := conf.Int(username, "times")
if leixing == "use" {
if times > 0 {
times -= 1
stimes := strconv.Itoa(times)
conf.SetValue(username, "times", stimes)
goconfig.SaveConfigFile(conf, "data.ini")
return "yes "
} else {
return "no"
}
} else if leixing == "query" {
return strconv.Itoa(times)
}
return ""
})
m.Get("/:username/:leixing/:num/:password", func(ctx *macaron.Context) string {
leixing := ctx.Params(":leixing")
snum := ctx.Params(":num")
username := ctx.Params(":username")
password := ctx.Params(":password")
conf, _ := goconfig.LoadConfigFile("data.ini")
pwd, _ := conf.GetValue("app", "password")
if password != pwd {
return "sorry!"
}
fmt.Println(username)
times, _ := conf.Int(username, "times")
fmt.Println(times)
num, _ := strconv.Atoi(snum)
if leixing == "remove" {
times = times - num
fmt.Println(times)
stimes := strconv.Itoa(times)
if times > 0 {
conf.SetValue(username, "times", stimes)
goconfig.SaveConfigFile(conf, "data.ini")
}
return "now is " + stimes
} else if leixing == "add" {
times = times + num
stimes := strconv.Itoa(times)
conf.SetValue(username, "times", stimes)
goconfig.SaveConfigFile(conf, "data.ini")
return "now is " + stimes
}
return ""
})
m.Run()
}
func (b *BuildConfig) saveConfigFile() error {
return goconfig.SaveConfigFile(b.configFile, configName)
}
func checkDocUpdates() {
beego.Trace("Checking documentation updates")
var tmpTree struct {
Tree []*docNode
}
err := com.HttpGetJSON(httpClient, "https://api.github.com/repos/beego/beedoc/git/trees/master?recursive=1&"+githubCred, &tmpTree)
if err != nil {
beego.Error("models.checkDocUpdates -> get trees:", err.Error())
return
}
updated := Cfg.MustValue("log", "updated")
// Compare SHA.
files := make([]com.RawFile, 0, len(tmpTree.Tree))
for _, node := range tmpTree.Tree {
// Skip non-md files and "README.MD".
if !strings.HasSuffix(node.Path, ".md") || node.Path == "README.md" {
continue
}
// Trim ".md".
name := node.Path[:len(node.Path)-3]
if checkSHA(name, node.Sha) {
beego.Info("Need to update:", name)
files = append(files, &rawFile{
name: name,
rawURL: "https://raw.github.com/beego/beedoc/master/" + node.Path,
})
}
// For save purpose, reset name.
node.Path = name
// Add to updated list for syncing docs. of multiple languages.
if strings.Index(updated, name+"|") == -1 {
updated += name + "|"
}
}
Cfg.SetValue("log", "updated", updated)
goconfig.SaveConfigFile(Cfg, _CFG_PATH)
// Fetch files.
if err := com.FetchFiles(httpClient, files, nil); err != nil {
beego.Error("models.checkDocUpdates -> fetch files:", err.Error())
return
}
// Update data.
for _, f := range files {
fw, err := os.Create("docs/" + f.Name() + ".md")
if err != nil {
beego.Error("models.checkDocUpdates -> open file:", err.Error())
return
}
_, err = fw.Write(f.Data())
fw.Close()
if err != nil {
beego.Error("models.checkDocUpdates -> write data:", err.Error())
return
}
}
beego.Trace("Finish check documentation updates")
initDocMap()
// Save documentation information.
f, err := os.Create("conf/docTree.json")
if err != nil {
beego.Error("models.checkDocUpdates -> save data:", err.Error())
return
}
defer f.Close()
e := json.NewEncoder(f)
err = e.Encode(&tmpTree)
if err != nil {
beego.Error("models.checkDocUpdates -> encode data:", err.Error())
return
}
}
func InstallPost(ctx *middleware.Context, form auth.InstallForm) {
if setting.InstallLock {
ctx.Handle(404, "install.InstallPost", errors.New("Installation is prohibited"))
return
}
ctx.Data["Title"] = "Install"
ctx.Data["PageIsInstall"] = true
renderDbOption(ctx)
ctx.Data["CurDbOption"] = form.Database
if ctx.HasError() {
ctx.HTML(200, INSTALL)
return
}
if _, err := exec.LookPath("git"); err != nil {
ctx.RenderWithErr("Fail to test 'git' command: "+err.Error(), INSTALL, &form)
return
}
// Pass basic check, now test configuration.
// Test database setting.
dbTypes := map[string]string{"MySQL": "mysql", "PostgreSQL": "postgres", "SQLite3": "sqlite3"}
models.DbCfg.Type = dbTypes[form.Database]
models.DbCfg.Host = form.Host
models.DbCfg.User = form.User
models.DbCfg.Pwd = form.Passwd
models.DbCfg.Name = form.DatabaseName
models.DbCfg.SslMode = form.SslMode
models.DbCfg.Path = form.DatabasePath
// Set test engine.
var x *xorm.Engine
if err := models.NewTestEngine(x); err != nil {
// NOTE: should use core.QueryDriver (github.com/go-xorm/core)
if strings.Contains(err.Error(), `Unknown database type: sqlite3`) {
ctx.RenderWithErr("Your release version does not support SQLite3, please download the official binary version "+
"from http://gogs.io/docs/installation/install_from_binary.md, NOT the gobuild version.", INSTALL, &form)
} else {
ctx.RenderWithErr("Database setting is not correct: "+err.Error(), INSTALL, &form)
}
return
}
// Test repository root path.
if err := os.MkdirAll(form.RepoRootPath, os.ModePerm); err != nil {
ctx.RenderWithErr("Repository root path is invalid: "+err.Error(), INSTALL, &form)
return
}
// Check run user.
curUser := os.Getenv("USER")
if len(curUser) == 0 {
curUser = os.Getenv("USERNAME")
}
// Does not check run user when the install lock is off.
if form.RunUser != curUser {
ctx.RenderWithErr("Run user isn't the current user: "******" -> "+curUser, INSTALL, &form)
return
}
// 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)
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.SetValue("service", "REGISTER_EMAIL_CONFIRM", com.ToStr(form.RegisterConfirm == "on"))
setting.Cfg.SetValue("service", "ENABLE_NOTIFY_MAIL", com.ToStr(form.MailNotify == "on"))
}
setting.Cfg.SetValue("", "RUN_MODE", "prod")
setting.Cfg.SetValue("log", "MODE", "file")
setting.Cfg.SetValue("security", "INSTALL_LOCK", "true")
os.MkdirAll("custom/conf", os.ModePerm)
if err := goconfig.SaveConfigFile(setting.Cfg, path.Join(setting.CustomPath, "conf/app.ini")); err != nil {
ctx.RenderWithErr("Fail to save configuration: "+err.Error(), INSTALL, &form)
return
}
GlobalInit()
// Create admin account.
if err := models.CreateUser(&models.User{Name: form.AdminName, Email: form.AdminEmail, Passwd: form.AdminPasswd,
IsAdmin: true, IsActive: true}); err != nil {
if err != models.ErrUserAlreadyExist {
setting.InstallLock = false
ctx.RenderWithErr("Admin account setting is invalid: "+err.Error(), INSTALL, &form)
return
}
log.Info("Admin account already exist")
}
log.Info("First-time run install finished!")
ctx.Flash.Success("Welcome! We're glad that you choose Gogs, have fun and take care.")
ctx.Redirect("/user/login")
}
func InstallPost(ctx *middleware.Context, form auth.InstallForm) {
if setting.InstallLock {
ctx.Handle(404, "InstallPost", errors.New("Installation is prohibited"))
return
}
ctx.Data["Title"] = ctx.Tr("install.install")
ctx.Data["PageIsInstall"] = true
renderDbOption(ctx)
ctx.Data["CurDbOption"] = form.Database
if ctx.HasError() {
ctx.HTML(200, INSTALL)
return
}
if _, err := exec.LookPath("git"); err != nil {
ctx.RenderWithErr(ctx.Tr("install.test_git_failed", err), INSTALL, &form)
return
}
// Pass basic check, now test configuration.
// Test database setting.
dbTypes := map[string]string{"MySQL": "mysql", "PostgreSQL": "postgres", "SQLite3": "sqlite3"}
models.DbCfg.Type = dbTypes[form.Database]
models.DbCfg.Host = form.DbHost
models.DbCfg.User = form.DbUser
models.DbCfg.Pwd = form.DbPasswd
models.DbCfg.Name = form.DatabaseName
models.DbCfg.SslMode = form.SslMode
models.DbCfg.Path = form.DatabasePath
// Set test engine.
var x *xorm.Engine
if err := models.NewTestEngine(x); err != nil {
// NOTE: should use core.QueryDriver (github.com/go-xorm/core)
if strings.Contains(err.Error(), `Unknown database type: sqlite3`) {
ctx.RenderWithErr(ctx.Tr("install.sqlite3_not_available"), INSTALL, &form)
} else {
ctx.RenderWithErr(ctx.Tr("install.invalid_db_setting", err), INSTALL, &form)
}
return
}
// Test repository root path.
if err := os.MkdirAll(form.RepoRootPath, os.ModePerm); err != nil {
ctx.RenderWithErr(ctx.Tr("install.invalid_repo_path", err), INSTALL, &form)
return
}
// Check run user.
curUser := os.Getenv("USER")
if len(curUser) == 0 {
curUser = os.Getenv("USERNAME")
}
// Does not check run user when the install lock is off.
if form.RunUser != curUser {
ctx.RenderWithErr(ctx.Tr("install.run_user_not_match", form.RunUser, curUser), INSTALL, &form)
return
}
// Check admin password.
if form.AdminPasswd != form.ConfirmPasswd {
ctx.RenderWithErr(ctx.Tr("form.password_not_match"), INSTALL, form)
return
}
// 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)
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.SetValue("service", "REGISTER_EMAIL_CONFIRM", com.ToStr(form.RegisterConfirm == "on"))
setting.Cfg.SetValue("service", "ENABLE_NOTIFY_MAIL", com.ToStr(form.MailNotify == "on"))
}
setting.Cfg.SetValue("", "RUN_MODE", "prod")
setting.Cfg.SetValue("log", "MODE", "file")
setting.Cfg.SetValue("security", "INSTALL_LOCK", "true")
os.MkdirAll("custom/conf", os.ModePerm)
if err := goconfig.SaveConfigFile(setting.Cfg, path.Join(setting.CustomPath, "conf/app.ini")); err != nil {
ctx.RenderWithErr(ctx.Tr("install.save_config_failed", err), INSTALL, &form)
return
}
GlobalInit()
// Create admin account.
if err := models.CreateUser(&models.User{Name: form.AdminName, Email: form.AdminEmail, Passwd: form.AdminPasswd,
IsAdmin: true, IsActive: true}); err != nil {
if err != models.ErrUserAlreadyExist {
setting.InstallLock = false
ctx.RenderWithErr(ctx.Tr("install.invalid_admin_setting", err), INSTALL, &form)
return
}
log.Info("Admin account already exist")
}
log.Info("First-time run install finished!")
ctx.Flash.Success(ctx.Tr("install.install_success"))
ctx.Redirect("/user/login")
}
func Install(ctx *middleware.Context, form auth.InstallForm) {
if base.InstallLock {
ctx.Handle(404, "install.Install", errors.New("Installation is prohibited"))
return
}
ctx.Data["Title"] = "Install"
ctx.Data["PageIsInstall"] = true
if ctx.Req.Method == "GET" {
// Get and assign value to install form.
if len(form.Host) == 0 {
form.Host = models.DbCfg.Host
}
if len(form.User) == 0 {
form.User = models.DbCfg.User
}
if len(form.Passwd) == 0 {
form.Passwd = models.DbCfg.Pwd
}
if len(form.DatabaseName) == 0 {
form.DatabaseName = models.DbCfg.Name
}
if len(form.DatabasePath) == 0 {
form.DatabasePath = models.DbCfg.Path
}
if len(form.RepoRootPath) == 0 {
form.RepoRootPath = base.RepoRootPath
}
if len(form.RunUser) == 0 {
form.RunUser = base.RunUser
}
if len(form.Domain) == 0 {
form.Domain = base.Domain
}
if len(form.AppUrl) == 0 {
form.AppUrl = base.AppUrl
}
auth.AssignForm(form, ctx.Data)
ctx.HTML(200, "install")
return
}
if ctx.HasError() {
ctx.HTML(200, "install")
return
}
// Pass basic check, now test configuration.
// Test database setting.
dbTypes := map[string]string{"mysql": "mysql", "pgsql": "postgres", "sqlite": "sqlite3"}
models.DbCfg.Type = dbTypes[form.Database]
models.DbCfg.Host = form.Host
models.DbCfg.User = form.User
models.DbCfg.Pwd = form.Passwd
models.DbCfg.Name = form.DatabaseName
models.DbCfg.SslMode = form.SslMode
models.DbCfg.Path = form.DatabasePath
// Set test engine.
var x *xorm.Engine
if err := models.NewTestEngine(x); err != nil {
if strings.Contains(err.Error(), `Unknown database type: sqlite3`) {
ctx.RenderWithErr("Your release version does not support SQLite3, please download the official binary version "+
"from https://github.com/gogits/gogs/wiki/Install-from-binary, NOT the gobuild version.", "install", &form)
} else {
ctx.RenderWithErr("Database setting is not correct: "+err.Error(), "install", &form)
}
return
}
// Test repository root path.
if err := os.MkdirAll(form.RepoRootPath, os.ModePerm); err != nil {
ctx.RenderWithErr("Repository root path is invalid: "+err.Error(), "install", &form)
return
}
// Check run user.
curUser := os.Getenv("USERNAME")
if len(curUser) == 0 {
curUser = os.Getenv("USER")
}
// Does not check run user when the install lock is off.
if form.RunUser != curUser {
ctx.RenderWithErr("Run user isn't the current user: "******" -> "+curUser, "install", &form)
return
}
// Save settings.
base.Cfg.SetValue("database", "DB_TYPE", models.DbCfg.Type)
base.Cfg.SetValue("database", "HOST", models.DbCfg.Host)
base.Cfg.SetValue("database", "NAME", models.DbCfg.Name)
base.Cfg.SetValue("database", "USER", models.DbCfg.User)
base.Cfg.SetValue("database", "PASSWD", models.DbCfg.Pwd)
base.Cfg.SetValue("database", "SSL_MODE", models.DbCfg.SslMode)
base.Cfg.SetValue("database", "PATH", models.DbCfg.Path)
base.Cfg.SetValue("repository", "ROOT", form.RepoRootPath)
base.Cfg.SetValue("", "RUN_USER", form.RunUser)
base.Cfg.SetValue("server", "DOMAIN", form.Domain)
base.Cfg.SetValue("server", "ROOT_URL", form.AppUrl)
if len(strings.TrimSpace(form.SmtpHost)) > 0 {
base.Cfg.SetValue("mailer", "ENABLED", "true")
base.Cfg.SetValue("mailer", "HOST", form.SmtpHost)
base.Cfg.SetValue("mailer", "USER", form.SmtpEmail)
base.Cfg.SetValue("mailer", "PASSWD", form.SmtpPasswd)
base.Cfg.SetValue("service", "REGISTER_EMAIL_CONFIRM", base.ToStr(form.RegisterConfirm == "on"))
base.Cfg.SetValue("service", "ENABLE_NOTIFY_MAIL", base.ToStr(form.MailNotify == "on"))
}
base.Cfg.SetValue("", "RUN_MODE", "prod")
base.Cfg.SetValue("security", "INSTALL_LOCK", "true")
os.MkdirAll("custom/conf", os.ModePerm)
if err := goconfig.SaveConfigFile(base.Cfg, "custom/conf/app.ini"); err != nil {
ctx.RenderWithErr("Fail to save configuration: "+err.Error(), "install", &form)
return
}
GlobalInit()
// Create admin account.
if _, err := models.RegisterUser(&models.User{Name: form.AdminName, Email: form.AdminEmail, Passwd: form.AdminPasswd,
IsAdmin: true, IsActive: true}); err != nil {
if err != models.ErrUserAlreadyExist {
ctx.RenderWithErr("Admin account setting is invalid: "+err.Error(), "install", &form)
return
}
log.Info("Admin account already exist")
}
log.Info("First-time run install finished!")
ctx.Redirect("/user/login")
}
func main() {
// 读取配置文件
cfg, err := goconfig.LoadConfigFile("server.ini")
if err != nil {
log.Println("配置文件加载失败，自动重置配置文件", err)
cfg, err = goconfig.LoadFromData([]byte{})
if err != nil {
log.Println(err)
return
}
}
var (
key, ok1 = cfg.MustValueSet("client", "key", "eGauUecvzS05U5DIsxAN4n2hadmRTZGBqNd2zsCkrvwEBbqoITj36mAMk4Unw6Pr")
port, ok2 = cfg.MustValueSet("server", "port", "8081")
)
// 如果缺少配置则保存为默认配置
if ok1 || ok2 {
err = goconfig.SaveConfigFile(cfg, "server.ini")
if err != nil {
log.Println("配置文件保存失败:", err)
}
}
// 读取公私钥
cer, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
if err != nil {
log.Println(err)
return
}
// 监听端口
ln, err := tls.Listen("tcp", ":"+port, &tls.Config{
Certificates: []tls.Certificate{cer},
})
if err != nil {
log.Println(err)
return
}
defer ln.Close()
s := &serve{
key: key,
clients: make(map[string]uint),
}
// 加载完成后输出配置信息
log.Println("|>>>>>>>>>>>>>>>|<<<<<<<<<<<<<<<|")
log.Println("程序版本:" + version)
log.Println("监听端口:" + port)
log.Println("Key:" + key)
log.Println("|>>>>>>>>>>>>>>>|<<<<<<<<<<<<<<<|")
for {
conn, err := ln.Accept()
if err != nil {
log.Println(err)
continue
}
go s.handleConnection(conn)
}
}
func main() {
// 获取当前setup路径
filepath := os.Args[0]
setupPath, _ := path.Split(filepath)
fmt.Println(setupPath)
// 安装xinetd
xinetInserr := GetRpmInfo("xinetd-2.3.14-39.el6_4.i686")
if xinetInserr != nil {
err := InstallRpm(setupPath + "rpm/xinetd-2.3.14-39.el6_4.i686.rpm")
if err != nil {
fmt.Println(err)
}
}
// 安装tftp
tftpInserr := GetRpmInfo("tftp-server-0.49-7.el6.i686")
if tftpInserr != nil {
err := InstallRpm(setupPath + "rpm/tftp-server-0.49-7.el6.i686.rpm")
if err != nil {
fmt.Println(err)
}
}
// 修改tftp配置文件
tftperr := CopyFile(setupPath+"config/tftp", "/etc/xinetd.d/tftp")
if tftperr != nil {
fmt.Println(tftperr)
}
// 创建tftp根目录
os.Mkdir("/data/tftproot", 000)
os.Chmod("/data/tftproot", 0777)
// 启动tftp服务
StartServers("xinetd")
/******************************************************/
// 修改iptables防火墙配置
configerr := CopyFile(setupPath+"config/iptables-config", "/etc/sysconfig/iptables-config")
if configerr != nil {
fmt.Println(configerr)
}
// 修改iptables防火墙配置
iptableserr := CopyFile(setupPath+"config/iptables", "/etc/sysconfig/iptables")
if iptableserr != nil {
fmt.Println(iptableserr)
}
// 重启iptables防火墙
StartServers("iptables")
/******************************************************/
// 修改数据库接收数据的大小
mysql, mysqlerr := goconfig.LoadConfigFile("/etc/my.cnf")
if mysqlerr != nil {
fmt.Println(mysqlerr)
}
mysql.SetValue("mysqld", "max_allowed_packet", "32M")
goconfig.SaveConfigFile(mysql, "/etc/my.cnf")
/******************************************************/
// 升级tomcat重启文件
tomcatErr := CopyFile(setupPath+"config/tomcat", "/etc/init.d/tomcat")
if tomcatErr != nil {
fmt.Println(tomcatErr)
}
os.Chmod("/etc/init.d/tomcat", 0755)
webErr := CopyFile(setupPath+"config/web.xml", "/nac/web/tomcat/conf/web.xml")
if webErr != nil {
fmt.Println(webErr)
}
os.Chmod("/nac/web/tomcat/conf/web.xml", 0755)
}
func main() {
file := os.Args[1]
if _, err := os.Stat(file); err == nil {
config, _ := goconfig.LoadConfigFile(file)
app_name := os.Getenv("APP_NAME")
domain := os.Getenv("DOMAIN")
root_url := os.Getenv("ROOT_URL")
mem_type := os.Getenv("MEM_TYPE")
db_type := os.Getenv("DB_TYPE")
ssh_port := os.Getenv("SSH_PORT")
var mem_addr string
var mem_port string
if mem_type == "redis" {
mem_addr = os.Getenv("REDIS_PORT_6379_TCP_ADDR")
mem_port = os.Getenv("REDIS_PORT_6379_TCP_PORT")
} else if mem_type == "memcache" {
mem_addr = os.Getenv("MEMCACHE_PORT_11211_TCP_ADDR")
mem_port = os.Getenv("MEMCACHE_PORT_11211_TCP_PORT")
} else if mem_type == "memory" {
} else {
// Invalid Memory Type
}
var db_addr string
var db_port string
if db_type == "mysql" {
db_addr = os.Getenv("MYSQL_PORT_3306_TCP_ADDR")
db_port = os.Getenv("MYSQL_PORT_3306_TCP_PORT")
} else if db_type == "postgres" {
db_addr = os.Getenv("POSTGRES_PORT_5432_TCP_ADDR")
db_port = os.Getenv("POSTGRES_PORT_5432_TCP_PORT")
} else if db_type == "sqlite" {
config.SetValue("database", "PATH", "data/gogs.db")
} else {
// Invalid DB Type
}
config.SetValue(goconfig.DEFAULT_SECTION, "APP_NAME", app_name)
// Server
config.SetValue("server", "DOMAIN", domain)
config.SetValue("server", "ROOT_URL", root_url)
if ssh_port != "" {
config.SetValue("server", "SSH_PORT", ssh_port)
}
// Database
config.SetValue("database", "DB_TYPE", db_type)
if db_addr != "" && db_port != "" {
config.SetValue("database", "HOST", fmt.Sprintf("%s:%s", db_addr, db_port))
}
if db_type == "mysql" || db_type == "postgres" {
config.SetValue("database", "NAME", os.Getenv("DB_NAME"))
config.SetValue("database", "USER", os.Getenv("DB_USER"))
config.SetValue("database", "PASSWORD", os.Getenv("DB_PASSWORD"))
}
// Cache
config.SetValue("cache", "ADAPTER", mem_type)
if mem_addr != "" && mem_port != "" {
config.SetValue("cache", "HOST", fmt.Sprintf("%s:%s", mem_addr, mem_port))
}
// Session
if mem_type == "redis" {
config.SetValue("session", "PROVIDER", "redis")
config.SetValue("session", "PROVIDER_CONFIG", fmt.Sprintf("%s:%s,100", mem_addr, mem_port))
} else {
config.SetValue("session", "PROVIDER", "memory")
}
goconfig.SaveConfigFile(config, file)
} else {
fmt.Printf("File does not exist.")
}
}
