func LoadServers() (servers *Servers, err error) {
servers = new(Servers)
*servers = make(Servers)
MergedConfig, err := revel.LoadConfig(SERVERS_CONF)
if err != nil {
if err.Error() == "not found" {
err = nil
return
}
err = errors.New(fmt.Sprintf("Could not load config file \"%s\" : %s", SERVERS_CONF, err.Error()))
return
}
for _, sectionName := range MergedConfig.Raw().Sections() {
if sectionName == "DEFAULT" || strings.HasSuffix(sectionName, CMD_SECTION_SUFFIX) {
continue
}
MergedConfig.SetSection(sectionName)
server := NewServerFromConfig(MergedConfig)
(*server).Label = sectionName
if MergedConfig.HasSection(sectionName + CMD_SECTION_SUFFIX) {
MergedConfig.SetSection(sectionName + CMD_SECTION_SUFFIX)
(*server).Commands = *LoadOptionsFromConfig(MergedConfig)
}
(*servers)[sectionName] = server
}
return
}
func InitEmail() {
conf, err := revel.LoadConfig("app.conf")
if err != nil {
revel.INFO.Panicln("Email Load app.conf failed")
}
config = fmt.Sprintf(
`{"username":"******","password":"******","host":"%s","port":%d,"from":"%s"}`,
conf.StringDefault("mail.loginUsername", ""),
conf.StringDefault("mail.loginPassword", ""),
conf.StringDefault("mail.host", ""),
conf.IntDefault("mail.port", 25),
conf.StringDefault("mail.from", ""),
)
queueSize := conf.IntDefault("mail.queueSize", 20)
revel.INFO.Printf(mate, queueSize)
sendChannel = make(chan *Email, queueSize)
go func() {
for {
select {
case m, ok := <-sendChannel:
if !ok {
revel.INFO.Println("email send successful", m)
return
}
if err := m.Send(); err != nil {
revel.ERROR.Println("SendMail:", err.Error())
}
}
}
}()
}
func loadPriorConfig(filename string) (*revel.MergedConfig, error) {
filename = addSuffix(filename)
// load overrided config
if revel.RunMode != "test" {
c, err := loadOverrideConfig(filename)
if err == nil {
return c, err
}
}
// load enviromental config
c, err := revel.LoadConfig(revel.RunMode + getSeparator() + filename)
if err == nil {
return c, err
}
// load root config
return revel.LoadConfig(filename)
}
func InitCorn() {
conf, err := revel.LoadConfig("app.conf")
if err != nil {
revel.ERROR.Panicln("读取app.conf失败")
}
cronPoolSize, _ := conf.Raw().Int(revel.RunMode, "cron.poolSize")
workPool = make(chan bool, cronPoolSize)
mainCron = cron.New()
// job := NewCommandJob("11111", "zhangsan", "ls")
// mainCron.Schedule(Every(5*time.Second+5*time.Nanosecond), job)
// AddJob("1 1 10 14,18 9 ?", job)
mainCron.Start()
revel.INFO.Printf(mate, cronPoolSize)
}
func revel_db(project_dir string) (*sql.DB, error) {
CONFIG, err := revel.LoadConfig("app.conf")
if err != nil {
return nil, err
}
driver := CONFIG.StringDefault("db.driver", "mysql")
host := CONFIG.StringDefault("db.host", "127.0.0.1")
port := CONFIG.IntDefault("db.port", 3306)
user := CONFIG.StringDefault("db.username", "mym_dev_user")
pass := CONFIG.StringDefault("db.password", "mym_dev_pass")
name := CONFIG.StringDefault("db.database", "mym_dev")
dsn := symbol.DSNFormat(host, port, user, pass, name)
return sql.Open(driver, dsn)
}
func InitDB() *gorp.DbMap {
// connect to db using standard Go database/sql API
// use whatever database/sql driver you wish
conf, err := revel.LoadConfig("app.conf")
CheckErr(err, "Load app.conf failed")
mysqluser, _ := conf.Raw().String(revel.RunMode, "mysql.user")
mysqlpass, _ := conf.Raw().String(revel.RunMode, "mysql.pass")
mysqlurls, _ := conf.Raw().String(revel.RunMode, "mysql.urls")
mysqldb, _ := conf.Raw().String(revel.RunMode, "mysql.db")
db, err := sql.Open("mymysql",
fmt.Sprintf("tcp:%s:3306*%s/%s/%s",
mysqlurls,
mysqldb,
mysqluser,
mysqlpass,
),
)
CheckErr(err, "mysql.Open.failed")
// construct a gorp DbMap
dbmap = &gorp.DbMap{Db: db, Dialect: gorp.MySQLDialect{"InnoDB", "UTF8"}}
setColumnSizes := func(t *gorp.TableMap, colSizes map[string]int) {
for col, size := range colSizes {
t.ColMap(col).MaxSize = size
}
}
userTable := dbmap.AddTableWithName(User{}, "s_user")
userTable.SetKeys(false, "UserId")
userTable.ColMap("Username").SetUnique(true).SetNotNull(true)
userTable.ColMap("Password").SetNotNull(true)
userTable.ColMap("Role").SetNotNull(true)
setColumnSizes(userTable, map[string]int{
"UserId": 50,
"Username": 50,
"Password": 50,
"Role": 1,
})
agentAable := dbmap.AddTableWithName(Agent{}, "o_agent")
agentAable.SetKeys(false, "AgentId")
agentAable.ColMap("Host").SetNotNull(true)
agentAable.ColMap("Port").SetNotNull(true)
agentAable.ColMap("LoginName").SetNotNull(true)
agentAable.ColMap("LoginPass").SetNotNull(true)
setColumnSizes(agentAable, map[string]int{
"Host": 100,
"Port": 4,
"LoginName": 30,
"LoginPass": 100,
"InitShellCmd": 2000,
"Memo": 500,
"UserId": 45,
})
cmdAable := dbmap.AddTableWithName(Cmd{}, "o_cmd")
cmdAable.SetKeys(false, "CmdId")
cmdAable.ColMap("Shell").SetNotNull(true)
setColumnSizes(cmdAable, map[string]int{
"Shell": 100,
"CmdId": 45,
"AgentId": 45,
})
serverAable := dbmap.AddTableWithName(Server{}, "p_server")
serverAable.SetKeys(false, "ServerId")
serverAable.ColMap("Theme").SetNotNull(true)
serverAable.ColMap("Content").SetNotNull(true)
// setColumnSizes(serverAable, map[string]int{
// "Theme": 100,
// "Content": 30000,
// })
// Task
taskTable := dbmap.AddTableWithName(Task{}, "t_task")
taskTable.SetKeys(false, "TaskId")
taskTable.ColMap("TaskName").SetNotNull(true)
taskTable.ColMap("Command").SetNotNull(true)
setColumnSizes(taskTable, map[string]int{
"TaskName": 100,
"Command": 3000,
"NotifyContent": 3000,
})
taskGroupTable := dbmap.AddTableWithName(TaskGroup{}, "t_task_group")
taskGroupTable.SetKeys(false, "TaskGroupId")
taskGroupTable.ColMap("GroupName").SetNotNull(true)
setColumnSizes(taskGroupTable, map[string]int{
"TaskGroupId": 45,
"GroupName": 300,
"Description": 2000,
})
taskLogTable := dbmap.AddTableWithName(TaskLog{}, "t_task_log")
taskLogTable.SetKeys(false, "TaskLogId")
setColumnSizes(taskLogTable, map[string]int{
"TaskName": 100,
"Output": 30000,
"Error": 30000,
})
dbmap.TraceOn("[gorp]", revel.INFO)
err = dbmap.CreateTablesIfNotExists()
CheckErr(err, "Create tables failed")
return dbmap
}
func loadOverrideConfig(filename string) (*revel.MergedConfig, error) {
return revel.LoadConfig(overrideDir + getSeparator() + filename)
}
