Example #1
0
//Http server
func Domainlist(w http.ResponseWriter, r *http.Request) {
	result := Getdomainlist()
	domainlist, err := json.Marshal(result)
	if err != nil {
		dlog.Errorf("marshal domain list failed. err:", err.Error())
	}
	dlog.Info("Get domianlist succeeded...")
	_, err = w.Write(domainlist)
	if err != nil {
		dlog.Errorf("write result to client failed, err:", err.Error())
	}
}
Example #2
0
//Get records of every domain
func Getdomainrecord(domain_id string) []byte {

	//Read config.toml file
	var inner_data Inner_result
	var inner_body []byte
	timeout := time.Duration(Conf.Timeout.timeout) * time.Millisecond
	client := http.Client{
		Timeout: timeout,
	}
	count := Conf.Retry.Retry_count

	for i := 0; i < count; i++ {

		inner_req, err := client.PostForm(Conf.Userinfo.Record_list, url.Values{"login_email": {"%s", Conf.Userinfo.Login_email}, "login_password": {"%s", Conf.Userinfo.Login_password}, "format": {"json"}, "domain_id": {"%s", domain_id}})
		if err != nil {
			dlog.Errorf("post form error: %s\n", err.Error())
		}
		inner_body, err = ioutil.ReadAll(inner_req.Body)
		dlog.Info("post:", Conf.Userinfo.Record_list)
		dlog.Info("return:", string(inner_body))
		if err != nil {
			dlog.Errorf("read body failed. error: %s\n", err.Error())
		}

		defer inner_req.Body.Close()

		err = json.Unmarshal(inner_body, &inner_data)
		if err != nil {
			dlog.Errorf("Get records failed,check %s err\n", err.Error())
		}
		if len(inner_data.Records) == 0 {
			dlog.Errorf("query from api success, but conten length is zero! Try again...\n")
		} else {
			break
		}
	}

	var record_result []byte
	record_result, err := json.Marshal(inner_data)
	if err != nil {
		dlog.Errorf("marshal domain list failed. err:", err.Error())
	}
	return record_result
}
Example #3
0
func Record(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()
	if r.Method == "GET" {

		domain_id := r.FormValue("id")

		dlog.Info("Get records succeeded...")

		recordlist := Getdomainrecord(domain_id)
		_, err := w.Write(recordlist)
		if err != nil {
			dlog.Errorf("write result to client failed, err:", err.Error())
		}
	}
}
Example #4
0
func Getdomainlist() (Result, error) {

	var data Result
	res, err := http.Get(Conf.Userinfo.Domain_list)
	if err != nil {
		dlog.Errorf("Parse domainlist url failed, error: %s\n", err.Error())
		return data, err
	}

	var result []byte
	result, err = ioutil.ReadAll(res.Body)
	if err != nil {
		dlog.Errorf("Get domainlist failed, error: %s\n", err.Error())
		return data, err
	}
	defer res.Body.Close()

	err = json.Unmarshal(result, &data)
	if err != nil {
		dlog.Errorf("Parse domainlist failed, error: %s\n", err.Error())
		return data, err
	}
	return data, err
}
Example #5
0
func main() {

	data, err := Getdomainlist()
	if err != nil {
		dlog.Errorf("Fail to get data from Getdomainlist, error: %s\n", err.Error())
		return
	}

	var inner_datas []Inner_result
	inner_datas, err = Getdomainrecord(data)
	if err != nil {
		dlog.Errorf("Fail to get data from Getdomainrecord, error: %s\n", err.Error())
		return
	}

	var gitname string
	gitname, err = Writefile(data, inner_datas)
	if err != nil {
		dlog.Errorf("Fail to Wirte file, error: %s\n", err.Error())
		return
	}

	add_cmd := exec.Command("git", "add", gitname)
	err = add_cmd.Run()
	if err != nil {
		dlog.Errorf("Git add file failed, error: %s\n", err.Error())
		return
	}

	commit_cmd := exec.Command("git", "commit", "-m", gitname)
	err = commit_cmd.Run()
	if err != nil {
		dlog.Errorf("Git commit failed, error: %s\n", err.Error())
		return
	}
}
Example #6
0
func Getdomainrecord(data Result) ([]Inner_result, error) {

	var inner_datas []Inner_result
	var err error

	for _, domain := range data.Domains {

		var inner_data Inner_result

		id := domain.Id
		url := fmt.Sprintf("%v?id=%v", Conf.Userinfo.Record_list, id)

		var res *http.Response
		res, err = http.Get(url)
		if err != nil {
			dlog.Errorf("Parse domainrecord url failed, error: %s\n", err.Error())
			return inner_datas, err
		}

		var result []byte
		result, err = ioutil.ReadAll(res.Body)
		if err != nil {
			dlog.Errorf("Get domainrecord failed, error: %s\n", err.Error())
			return inner_datas, err
		}
		defer res.Body.Close()

		err = json.Unmarshal(result, &inner_data)
		if err != nil {
			dlog.Errorf("Parse domainrecord failed, error: %s \n", err.Error())
			return inner_datas, err
		}
		inner_datas = append(inner_datas, inner_data)
	}
	return inner_datas, err
}
Example #7
0
func init() {
	basePath, _ := os.Getwd()
	logPath := fmt.Sprintf("%s/log/", basePath)
	logBackend, err := dlog.NewFileBackend(logPath)
	if err != nil {
		fmt.Println("failed to new log backend")
		os.Exit(1)
	}
	dlog.SetLogging(dlog.INFO, logBackend)

	//loading config.toml
	_, err = toml.DecodeFile("config.toml", &Conf)
	if err != nil {
		dlog.Errorf("unable to decode config file. ")
	}
}
Example #8
0
//Get main domainlists
func Getdomainlist() Result {

	//Read config.toml file
	var body []byte
	var Data Result
	timeout := time.Duration(Conf.Timeout.timeout) * time.Millisecond
	client := http.Client{
		Timeout: timeout,
	}

	count := Conf.Retry.Retry_count
	for i := 0; i < count; i++ {

		rep, err := client.PostForm(Conf.Userinfo.Domain_list, url.Values{"login_email": {"%s", Conf.Userinfo.Login_email}, "login_password": {"%s", Conf.Userinfo.Login_password}, "format": {"json"}})
		if err != nil {
			dlog.Errorf("post form error: %s\n", err.Error())
		}
		body, err = ioutil.ReadAll(rep.Body)
		dlog.Info("post:", Conf.Userinfo.Domain_list)
		dlog.Info("return:", string(body))
		if err != nil {
			dlog.Errorf("read body failed. error: %s\n", err.Error())
		}

		defer rep.Body.Close()

		err = json.Unmarshal(body, &Data)
		if err != nil {
			dlog.Errorf("Get domainlist failed,check %s err\n", err.Error())
		}
		if len(Data.Domains) == 0 {
			dlog.Errorf("query from api success, but conten length is zero! Try again...\n")
		} else {
			break
		}
	}

	var days []int
	for _, v := range Data.Domains {
		nowtime := time.Now()
		end := v.VipEnd
		template := "2006-01-02"
		endtime, errend := time.Parse(template, end)
		if errend != nil {
			dlog.Errorf("Get vip_end_time failed,check %s err\n", errend.Error())
		}

		var result time.Duration
		if endtime.Sub(nowtime) < 0 {
			result = 0
		} else {
			result = endtime.Sub(nowtime)
		}

		restday := int(result.Hours() / 24)
		days = append(days, restday)
	}
	for i := 0; i < len(days); i++ {
		Data.Domains[i].RestDay = days[i]
	}
	return Data
}
Example #9
0
func Writefile(data Result, inner_datas []Inner_result) (string, error) {

	t := time.Now()
	parse_time := t.Format("2006-01-02")
	filename := fmt.Sprintf("%vdnspod.%v", Conf.Userinfo.Path, parse_time)
	gitname := fmt.Sprintf("dnspod.%v", parse_time)

	f, err := os.Create(filename)
	if err != nil {
		dlog.Errorf("Create file failed, error: %s\n", err.Error())
		return gitname, err
	}
	defer f.Close()

	for _, domain := range data.Domains {
		id := fmt.Sprintf("id: %v", domain.Id)
		name := fmt.Sprintf("name: %v", domain.Name)
		vipstart := fmt.Sprintf("vipstart: %v", domain.VipStart)
		vipend := fmt.Sprintf("vipend: %v", domain.VipEnd)
		remark := fmt.Sprintf("remark: %v", domain.Remark)
		restday := fmt.Sprintf("restday: %v", domain.RestDay)

		result := fmt.Sprintf("|%-20s|%-30s|%-30s|%-30s|%-20s|%-20s|\n", id, name, vipstart, vipend, remark, restday)
		_, err = f.WriteString(result)
		if err != nil {
			dlog.Errorf("Write domainlist to file failed, error: %s\n", err.Error())
			return gitname, err
		}
	}

	for _, record := range inner_datas {
		domain_name := fmt.Sprintf("domain: %v\n", record.Domain)
		_, err = f.WriteString(domain_name)
		if err != nil {
			dlog.Errorf("Write domain_name to file failed, error: %s\n", err.Error())
			return gitname, err
		}

		for _, inner_domain := range record.Records {
			name := fmt.Sprintf("name: %v", inner_domain.Name)
			domain_type := fmt.Sprintf("type: %v", inner_domain.Type)
			line := fmt.Sprintf("line: %v", inner_domain.Line)
			value := fmt.Sprintf("value: %v", inner_domain.Value)
			mx := fmt.Sprintf("mx: %v", inner_domain.Mx)
			ttl := fmt.Sprintf("ttl: %v", inner_domain.Ttl)
			remark := fmt.Sprintf("|remark: %v|\n\n", inner_domain.Remark)

			result := fmt.Sprintf("|%-25s|%-15s|%-25s|%-45s|%-15s|%-15s|\n", name, domain_type, line, value, mx, ttl)
			_, err = f.WriteString(result)
			if err != nil {
				dlog.Errorf("Write domainrecord to file failed, error: %s\n", err.Error())
				return gitname, err
			}

			_, err = f.WriteString(remark)
			if err != nil {
				dlog.Errorf("Write domain record remark to file failed, error: %s\n", err.Error())
				return gitname, err
			}

		}
	}

	return gitname, err
}