init

at-cluster/func.go

@@ -0,0 +1,121 @@
+package main
+
+import (
+	utils "anytunnel/at-common"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"time"
+)
+
+func initTrafficReporter() {
+	//item map[string]uint64{}
+	//url is empty , exit reporter
+	url := cfg.GetString("url.traffic")
+	if url == "" {
+		return
+	}
+	go func() {
+		var trafficReporterLastData = map[string]map[string]uint64{}
+		interval := cfg.GetInt("url.traffic-interval")
+		for {
+			time.Sleep(time.Second * time.Duration(interval))
+			var connCountMap = serverConns.GetTunnelConnCountMap()
+			var trafficReporterNewData = map[string]map[string]uint64{}
+			var reportData = map[string]map[string]interface{}{}
+			reportData = map[string]map[string]interface{}{}
+			trafficReporterNewData = trafficCounter.AllData()
+			var isFirst = false
+			if len(trafficReporterLastData) == 0 {
+				isFirst = true
+				trafficReporterLastData = trafficReporterNewData
+			}
+			//compare
+			for k, vnew := range trafficReporterNewData {
+				if vold, ok := trafficReporterLastData[k]; ok {
+					oldPositiveCount := vold["positive"]
+					oldNegativeCount := vold["negative"]
+					newPositiveCount := vnew["positive"]
+					newNegativeCount := vnew["negative"]
+					positive := uint64(0)
+					negative := uint64(0)
+					if isFirst {
+						positive = newPositiveCount
+						negative = newNegativeCount
+					} else {
+						if newPositiveCount > oldPositiveCount {
+							positive = newPositiveCount - oldPositiveCount
+						}
+						if newNegativeCount > oldNegativeCount {
+							negative = newNegativeCount - oldNegativeCount
+						}
+					}
+					tunnelID, _ := strconv.ParseUint(k, 10, 64)
+					item, ok := connCountMap[tunnelID]
+					if !ok {
+						item := ConnItem{}
+						item.Count = 0
+						item.TunnelID = tunnelID
+					}
+					if positive > 0 || negative > 0 || item.Count > 0 {
+						reportData[k] = map[string]interface{}{
+							"serverToken": item.ServerToken,
+							"tunnelID":    tunnelID,
+							"connCount":   item.Count,
+							"positive":    positive,
+							"negative":    negative,
+							"interval":    interval,
+						}
+					}
+				}
+			}
+			//store last data
+			trafficReporterLastData = trafficReporterNewData
+			//report if needed
+			if len(reportData) > 0 {
+				//log.Warnf("ReportData : %v", reportData)
+				var code int
+				var err error
+				var tryCount = 0
+				for tryCount <= cfg.GetInt("url.fail-retry") {
+					tryCount++
+					d, _ := json.Marshal(reportData)
+					_, code, err = HttpPostRaw(url, string(d), nil)
+					if err == nil && code == cfg.GetInt("url.success-code") {
+						break
+					} else if err != nil {
+						log.Warnf("report traffic fail to url %s, err: %s", url, err)
+					} else {
+						err = fmt.Errorf("token error")
+						log.Warnf("report traffic fail to url %s, code: %d, except: %d", url, code, cfg.GetInt("url.success-code"))
+					}
+					if err != nil && tryCount <= cfg.GetInt("url.fail-retry") {
+						time.Sleep(time.Second * time.Duration(cfg.GetInt("url.fail-wait")))
+					}
+				}
+			}
+		}
+	}()
+}
+func HttpPost(URL string, data map[string]string, header map[string]string) (body []byte, code int, err error) {
+	if cfg.GetBool("url.is-internal") {
+		return utils.HttpPost(URL, data, header)
+	} else {
+		return utils.HttpPostNotInternal(URL, data, header)
+	}
+}
+func HttpPostRaw(URL string, data string, header map[string]string) (body []byte, code int, err error) {
+	if cfg.GetBool("url.is-internal") {
+		return utils.HttpPostRaw(URL, data, header, true)
+	} else {
+		return utils.HttpPostRaw(URL, data, header, false)
+	}
+}
+func HttpGet(URL string) (body []byte, code int, err error) {
+	return utils.HttpGet(URL)
+	if cfg.GetBool("url.is-internal") {
+		return utils.HttpGet(URL)
+	} else {
+		return utils.HttpGetNotInternal(URL)
+	}
+}