func InsureNewVersionFiles(da *model.DesiredAgent) error { if FilesReady(da) { return nil } downloadTarballCmd := BuildCommand(da.RunUser, "wget", "-q", da.TarballUrl, "-O", path.Join(da.AgentVersionDir, da.TarballFilename)) downloadTarballCmd.Dir = file.SelfDir() _, err := ExecuteCommandWithOutput(downloadTarballCmd) if err != nil { logger.Errorln("wget -q", da.TarballUrl, "-O", da.TarballFilename, "fail", err) return err } downloadMd5Cmd := BuildCommand(da.RunUser, "wget", "-q", da.Md5Url, "-O", path.Join(da.AgentVersionDir, da.Md5Filename)) downloadMd5Cmd.Dir = file.SelfDir() _, err = ExecuteCommandWithOutput(downloadMd5Cmd) if err != nil { log.Println("wget -q", da.Md5Url, "-O", da.Md5Filename, "fail", err) return err } if "" != da.ConfigFileName && "" != da.ConfigRemoteUrl { downloadConfigCmd := BuildCommand(da.RunUser, "wget", "-q", da.ConfigRemoteUrl, "-O", path.Join(da.AgentVersionDir, da.ConfigFileName)) downloadConfigCmd.Dir = file.SelfDir() _, err := ExecuteCommandWithOutput(downloadConfigCmd) if err != nil { logger.Errorln("wget -q", da.ConfigRemoteUrl, "-O", da.ConfigFileName, "fail", err) } return err } return Md5sumCheck(da.RunUser, da.AgentVersionDir, da.TarballFilename, da.Md5Filename) }
func StartDesiredAgent(da *model.DesiredAgent, last *model.DesiredAgent) error { if err := InsureRunUserExists(da); nil != err { return err } var lastRunUser, lastWorkDir string if nil != last { lastRunUser = last.RunUser lastWorkDir = last.WorkDir } if err := StopAgentOf(da, lastRunUser, lastWorkDir); err != nil { return err } if err := InsureNewVersion(da); nil != err { return err } if err := ControlStartIn(da.RunUser, da.AgentVersionDir); err != nil { logger.Errorln("ControlStartIn error", err) return err } if err := WriteVersion(da); nil != err { logger.Errorln("WriteVersion error", err) return err } return nil }
func QueryRelEndpointGroupList(queryDto QueryRelEndpointGroupDto, pageInfo *PageInfo) ([]RelEndpointGroup, *PageInfo) { var rows []RelEndpointGroup query := db.NewOrm().QueryTable(RelEndpointGroup{}) if 0 < queryDto.HostGroupId { query = query.Filter("HostGroupId", queryDto.HostGroupId) } if "" != queryDto.RelType { query = query.Filter("RelType", queryDto.RelType) } if "" != queryDto.PropName { query = query.Filter("PropName", queryDto.PropName) } if "" != queryDto.PropValue { query = query.Filter("PropValue", queryDto.PropValue) } rowCount, err := query.Count() if nil != err { logger.Errorln("queryCount error", err) pageInfo.SetRowCount(0) return nil, pageInfo } pageInfo.SetRowCount(rowCount) _, err = query.OrderBy("RelType").Offset(pageInfo.GetStartIndex()).Limit(pageInfo.PageSize).All(&rows) if nil != err { logger.Errorln("QueryRelEndpointGroupList error", err) } return rows, pageInfo }
func QueryUserList(queryDto QueryUserDto, pageInfo *PageInfo) ([]User, *PageInfo) { var rows []User query := db.NewOrm().QueryTable(User{}) if "" != queryDto.UserName { query = query.Filter("user_name__contains", queryDto.UserName) } if "" != queryDto.RealName { query = query.Filter("RealName", queryDto.RealName) } if "" != queryDto.RoleName { query = query.Filter("RoleName", queryDto.RoleName) } rowCount, err := query.Count() if nil != err { logger.Errorln("queryCount error", err) pageInfo.SetRowCount(0) return nil, pageInfo } pageInfo.SetRowCount(rowCount) _, err = query.OrderBy("Id").Offset(pageInfo.GetStartIndex()).Limit(pageInfo.PageSize).All(&rows, "UserName", "RealName", "PhoneNo", "Email", "RoleName", "AccountStatus") if nil != err { logger.Errorln("QueryUserList error", err) } return rows, pageInfo }
func ModifyRecord(domainId int, recordId, subDomain, strIp string) bool { data := url.Values{} data.Add("login_email", g.Config().LoginEmail) data.Add("login_password", g.Config().LoginPassword) data.Add("format", "json") data.Add("domain_id", strconv.Itoa(domainId)) data.Add("record_id", recordId) data.Add("sub_domain", subDomain) data.Add("record_type", "A") data.Add("record_line", "默认") data.Add("value", strIp) strResponse, err := Post("https://dnsapi.cn/Record.Modify", data) if nil != err { logger.Errorln("RECORD_MODIFY ERROR", err) } else { logger.Infoln("RECORD_MODIFY_RESPONSE:", strResponse, err) if "" != strResponse && strings.Contains(strResponse, `"code":"1"`) { return true } else { logger.Infoln("domainId:%d,recordId:%s,sub_domain:%s\n", domainId, recordId, subDomain) } } return false }
func (this *HeartbeatController) Post() { jsonResult := make(map[string]interface{}) jsonResult["success"] = false var req model.HeartbeatRequest if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); nil != err { logger.Errorln("parseForm error", err) jsonResult["message"] = fmt.Sprintf("parseForm error: %v", err.Error()) } else if "" == req.Hostname { jsonResult["message"] = "hostname is blank" } else { logger.Debugln("Heartbeat Request===>>>", req) strIp := this.Ctx.Request.Header.Get("X-Forwarded-For") if "" == strIp { strIp = this.Ctx.Request.Header.Get("Proxy-Client-IP") } if "" == strIp { strIp = this.Ctx.Request.Header.Get("WL-Proxy-Client-IP") } if "" == strIp { ip, _, err := net.SplitHostPort(this.Ctx.Request.RemoteAddr) if nil != err { logger.Errorln("SplitHostPort error", this.Ctx.Request.RemoteAddr) } else { strIp = ip } } go store.ParseHeartbeatRequest(&req, strIp) resp := model.HeartbeatResponse{ ErrorMessage: "", DesiredAgents: store.HostAgents.Status(req.Hostname), } logger.Debugln("Heartbeat Response<<<===", resp) this.Data["json"] = &resp jsonResult["success"] = true } if false == jsonResult["success"] { this.Data["json"] = &jsonResult } this.ServeJSON() }
func QueryEndpointAgentList(hostname string) []EndpointAgent { var rows []EndpointAgent _, err := db.NewOrm().QueryTable(EndpointAgent{}).Filter("Hostname", hostname).All(&rows) if nil != err { logger.Errorln("QueryEndpointAgentList error", err) } return rows }
func QueryRelAgentGroupList(agentId int64) ([]RelAgentGroupDto, error) { var rows []RelAgentGroupDto _, err := db.NewOrm().Raw("select t.id, t.gmt_create,t.gmt_modified, t.host_group_id, a.group_name from t_rel_agent_group t, t_host_group a where t.agent_id=? and t.host_group_id=a.id", agentId).QueryRows(&rows) if nil != err { logger.Errorln("QueryRelAgentGroupList error", err) } return rows, err }
func GetUserById(userId int64) *User { var u User strSql := `select id, user_name, real_name, phone_no, email, role_name, account_status from t_user where id=?` err := db.NewOrm().Raw(strSql, userId).QueryRow(&u) if nil != err { logger.Errorln("query error", err) } return &u }
func (this *User) Update() (int64, error) { strSql := `update t_user set real_name=?, phone_no=?, email=?, role_name=? where id=?` result, err := db.NewOrm().Raw(strSql, this.RealName, this.PhoneNo, this.Email, this.RoleName, this.Id).Exec() if nil != err { logger.Errorln("update error", err) return 0, err } return result.RowsAffected() }
func ReadDesiredAgents() []*model.DesiredAgent { var desiredAgents []*model.DesiredAgent strJson, err := f.ToTrimString(path.Join(f.SelfDir(), "desired_agent.json")) if nil != err { logger.Errorln("read desired agent file error", err) return desiredAgents } err = json.Unmarshal([]byte(strJson), &desiredAgents) if nil != err { logger.Errorln("unmarshal json error", strJson, err) } for _, da := range desiredAgents { actualVersion := ReadVersion(da.RunUser, path.Join(da.WorkDir, da.Name)) if "" != actualVersion { da.Version = actualVersion } } return desiredAgents }
func QueryHostGroupList(queryDto QueryHostGroupDto, pageInfo *PageInfo) ([]HostGroup, *PageInfo) { var rows []HostGroup query := db.NewOrm().QueryTable(HostGroup{}) if "" != queryDto.GroupName { query = query.Filter("GroupName__contains", queryDto.GroupName) } rowCount, err := query.Count() if nil != err { logger.Errorln("queryCount error", err) pageInfo.SetRowCount(0) return nil, pageInfo } pageInfo.SetRowCount(rowCount) _, err = query.OrderBy("GroupName").Offset(pageInfo.GetStartIndex()).Limit(pageInfo.PageSize).All(&rows) if nil != err { logger.Errorln("QueryHostGroupList error", err) } return rows, pageInfo }
func SelectSessionBySig(sig string) *Session { if sig == "" { return nil } obj := Session{Sig: sig} err := orm.NewOrm().Read(&obj, "Sig") if err != nil { if err != orm.ErrNoRows { logger.Errorln(err) } return nil } return &obj }
func QueryEndpointList(queryDto QueryEndpointDto, pageInfo *PageInfo) ([]Endpoint, *PageInfo) { var rows []Endpoint query := db.NewOrm().QueryTable(Endpoint{}) if "" != queryDto.Hostname { query = query.Filter("hostname__icontains", queryDto.Hostname) } if "" != queryDto.Ip { query = query.Filter("ip__contains", queryDto.Ip) } rowCount, err := query.Count() if nil != err { logger.Errorln("queryCount error", err) pageInfo.SetRowCount(0) return nil, pageInfo } pageInfo.SetRowCount(rowCount) _, err = query.OrderBy("-GmtModified").Offset(pageInfo.GetStartIndex()).Limit(pageInfo.PageSize).All(&rows) if nil != err { logger.Errorln("QueryEndpointList error", err) } return rows, pageInfo }
func SelectUserById(id int64) *User { if id <= 0 { return nil } obj := User{Id: id} err := orm.NewOrm().Read(&obj, "Id") if err != nil { if err != orm.ErrNoRows { logger.Errorln(err) } return nil } return &obj }
func QueryAgentList(queryDto QueryAgentDto, pageInfo *PageInfo) ([]Agent, *PageInfo) { var rows []Agent query := db.NewOrm().QueryTable(Agent{}) if "" != queryDto.AgentName { query = query.Filter("Name", queryDto.AgentName) } if "" != queryDto.RunUser { query = query.Filter("RunUser", queryDto.RunUser) } rowCount, err := query.Count() if nil != err { logger.Errorln("queryCount error", err) pageInfo.SetRowCount(0) return nil, pageInfo } pageInfo.SetRowCount(rowCount) _, err = query.OrderBy("Name").Offset(pageInfo.GetStartIndex()).Limit(pageInfo.PageSize).All(&rows) if nil != err { logger.Errorln("QueryAgentList error", err) } return rows, pageInfo }
func heartbeat() { hostname, err := utils.Hostname(g.Config().Hostname) if err != nil { return } desiredAgents := ReadDesiredAgents() heartbeatRequest := BuildHeartbeatRequest(hostname, desiredAgents) logger.Debugln("===>>>", heartbeatRequest) bs, err := json.Marshal(heartbeatRequest) if err != nil { logger.Errorln("encode heartbeat request fail", err) return } url := fmt.Sprintf("http://%s/api/heartbeat", g.Config().Server) httpRequest := httplib.Post(url).SetTimeout(time.Second*10, time.Minute) httpRequest.Body(bs) httpResponse, err := httpRequest.Bytes() if err != nil { log.Printf("curl %s fail %v", url, err) return } var heartbeatResponse model.HeartbeatResponse err = json.Unmarshal(httpResponse, &heartbeatResponse) if err != nil { logger.Errorln("decode heartbeat response fail", err) return } logger.Debugln("<<<<====", heartbeatResponse) HandleHeartbeatResponse(&heartbeatResponse, desiredAgents) }
func CheckFileOrDirExists(username, fp, fileType string) bool { if CurrentUser == username { return file.IsExist(fp) } else { cmd := BuildCommand(username, "sh", "check_file.sh", fileType, fp) cmd.Dir = file.SelfDir() strOut, err := ExecuteCommandWithOutput(cmd) if nil != err { logger.Errorln("check dir exists", strOut, err) return false } result, _ := strconv.ParseBool(strings.Replace(strOut, "\n", "", -1)) return result } return false }
func BuildHeartbeatRequest(hostname string, desiredAgents []*model.DesiredAgent) model.HeartbeatRequest { req := model.HeartbeatRequest{Hostname: hostname} req.Ip = utils.GetLocalIP() req.UpdaterVersion = g.VERSION req.RunUser = CurrentUser realAgents := []*model.RealAgent{} now := time.Now().Unix() for _, da := range desiredAgents { agentDir := path.Join(da.WorkDir, da.Name) // 如果目录下没有.version,我们认为这根本不是一个agent version := ReadVersion(da.RunUser, agentDir) if "" == version { logger.Error("read %s/.version fail\n", agentDir) continue } controlFile := path.Join(agentDir, version, "control") if !CheckFileExists(da.RunUser, controlFile) { logger.Errorln(controlFile, "is nonexistent, user:"******"control"), "status") cmd.Dir = f.SelfDir() status, err := ExecuteCommandWithOutput(cmd) if err != nil { status = err.Error() } realAgent := &model.RealAgent{ Name: da.Name, Version: version, Status: status, Timestamp: now, } realAgent.RunUser = da.RunUser realAgent.WorkDir = da.WorkDir realAgents = append(realAgents, realAgent) } req.RealAgents = realAgents return req }
func (this *AgentController) Query() { jsonResult := make(map[string]interface{}) pageInfo := models.NewPageInfo(this.Ctx.Request) queryDto := models.QueryAgentDto{} if err := this.ParseForm(&queryDto); nil != err { logger.Errorln("parseForm error", err) } list, pageInfo := models.QueryAgentList(queryDto, pageInfo) jsonResult["items"] = list jsonResult["total"] = pageInfo.RowCount this.Data["json"] = &jsonResult this.ServeJSON() }
func (this *Endpoint) Insert() (int64, error) { num, err := db.NewOrm().QueryTable(Endpoint{}).Filter("Hostname", this.Hostname).Count() if nil != err { return 0, err } else if 0 == num { this.GmtCreate = time.Now() this.GmtModified = time.Now() return db.NewOrm().Insert(this) } else { strSql := `update t_endpoint set gmt_modified=?, ip = ?, updater_version = ?, run_user = ? where hostname=?` result, err := db.NewOrm().Raw(strSql, utils.FormatUTCTime(time.Now()), this.Ip, this.UpdaterVersion, this.RunUser, this.Hostname).Exec() if nil != err { logger.Errorln("insert endpoint fail: ", err) return 0, err } return result.RowsAffected() } }
func (this *LoginController) Post() { jsonResult := make(map[string]interface{}) jsonResult["success"] = false userName := this.GetString("userName") loginPwd := this.GetString("loginPwd") if "" == userName { jsonResult["message"] = "用户名不能为空" } else if "" == loginPwd { jsonResult["message"] = "登陆密码不能为空" } else { user, err := models.CheckLogin(userName, loginPwd) if nil != err { if "<QuerySeter> no row found" == err.Error() { jsonResult["message"] = "用户名或密码错误" } else { logger.Errorln("checkLogin error", userName, loginPwd, err) jsonResult["message"] = err.Error() } } else if nil == user { jsonResult["message"] = "用户名或密码错误" } else { this.SetSession(cache.SESSION_UID, user.Id) this.SetSession(cache.SESSION_USERNAME, user.RealName) this.SetSession(cache.SESSION_ROLENAME, user.RoleName) jsonResult["success"] = true originURL := this.GetString("originURL") if "" == originURL { originURL = "" } jsonResult["message"] = originURL } } this.Data["json"] = &jsonResult this.ServeJSON() }
func GetDomainList() []g.DomainResult { data := url.Values{} data.Add("login_email", g.Config().LoginEmail) data.Add("login_password", g.Config().LoginPassword) data.Add("format", "json") strResponse, err := Post("https://dnsapi.cn/Domain.List", data) if nil == err && "" != strResponse && strings.Contains(strResponse, `"code":"1"`) { var dlr g.DomainListResult err = json.Unmarshal(bytes.NewBufferString(strResponse).Bytes(), &dlr) if nil != err { logger.Errorln("decode DOMAIN_LIST response fail %v\n", err) } else { for _, domain := range dlr.Domains { logger.Info("domain_id:%d,name:%s,created:%v,updated:%v\n", domain.Id, domain.Name, domain.Created, domain.Updated) } return dlr.Domains } } else { logger.Error("GET_DOMAIN_LIST RESPONSE<<<====%s, error: %v", strResponse, err) } return nil }
func getIp() string { strUrl := g.Config().GetIpApi logger.Debug("REQUEST_URL:%s\n", strUrl) httpRequest := httplib.Get(strUrl).SetTimeout(3*time.Second, 10*time.Second) httpResponse, err := httpRequest.Bytes() if nil != err { logger.Errorln("GET_IP error", err) return "" } strIp := "" var resp g.ServletResponse err = json.Unmarshal(httpResponse, &resp) if err != nil { logger.Error("decode GET_IP response fail %v\n", err) } else if false == resp.Success { logger.Error("GET_IP fail %s\n", resp.Message) } else { strIp = resp.Message } logger.Infoln("RESPONSE_IP:", strIp) return strIp }
func (this *AgentController) Save() { jsonResult := g.JsonResult{} item := models.Agent{} if err := this.ParseForm(&item); nil != err { logger.Errorln("parseForm error", err) jsonResult.Message = err.Error() } else { if 0 >= item.Id { item.GmtCreate = time.Now() } result, err := item.Insert() if nil != err { jsonResult.Message = err.Error() } else if 0 < result { jsonResult.Success = true } else { jsonResult.Message = "保存失败,未知错误" } } this.Data["json"] = &jsonResult this.ServeJSON() }