Golang logger.Errorln函数代码示例

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
}