sctrld/http.go at master · dshumko/sctrld · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
package main

import (
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"runtime"
	"strconv"
)

type TAnswerRuntime struct {
	Memheap    uint64 `json:"memheap"`
	Memidle    uint64 `json:"memidle"`
	Meminuse   uint64 `json:"meminuse"`
	Goroutines int    `json:"goroutines"`
	NextGC     uint64 `json:"nextgc"`
}

type TAnswerStat struct {
	Ip            string     `json:"ip"`
	Traffic       TIpTraffic `json:"stat"`
	Limit         TIpTraffic `json:"limit"`
	OffCountStart int        `json:"offstart"`
	OffCountStop  int        `json:"offstop"`
	SpeedUp       string     `json:"speedup"`
	SpeedDown     string     `json:"speeddown"`
}

type TAnswerLimitAdd struct {
	Ip    string     `json:"ip"`
	Limit TIpTraffic `json:"limit_add"`
}

type TAnswerError struct {
	Error string `json:"error"`
}

func httpGetRuntime(w http.ResponseWriter, r *http.Request) {
	var vAnswer TAnswerRuntime

	memStats := runtime.MemStats{}
	runtime.ReadMemStats(&memStats)

	vAnswer.Memheap = memStats.HeapSys
	vAnswer.Memidle = memStats.HeapIdle
	vAnswer.Meminuse = memStats.HeapInuse
	vAnswer.Goroutines = runtime.NumGoroutine()
	vAnswer.NextGC = memStats.NextGC

	js, _ := json.Marshal(vAnswer)

	w.Header().Set("Content-Type", "application/json")
	w.Write(js)
}

func httpGetStat(w http.ResponseWriter, r *http.Request) {
	var vAnswer TAnswerStat
	var vError TAnswerError
	var js []byte
	w.Header().Set("Content-Type", "application/json")
	v := r.URL.Query()
	ip_adr := v.Get("ip")
	IPAddress := net.ParseIP(ip_adr)
	if IPAddress == nil {
		vError.Error = fmt.Sprintf("ip format error %s", ip_adr)
		js, _ = json.Marshal(vError)
	} else {
		response := GetIpInfo(netIpToInt(IPAddress))
		if response.Found {
			vAnswer.Ip = ip_adr
			vAnswer.Limit = response.IpRec.Limit
			vAnswer.OffCountStart = response.IpRec.OffCountStart
			vAnswer.OffCountStop = response.IpRec.OffCountStop
			vAnswer.SpeedUp = response.IpRec.SpeedUp
			vAnswer.SpeedDown = response.IpRec.SpeedDown
			vAnswer.Traffic = response.IpRec.Traffic
			js, _ = json.Marshal(vAnswer)

		} else {
			vError.Error = fmt.Sprintf("%s not found", ip_adr)
			js, _ = json.Marshal(vError)
		}
	}

	w.Write(js)
}

func httpAddLimit(w http.ResponseWriter, r *http.Request) {
	var vAnswer TAnswerLimitAdd
	var vError TAnswerError
	var js []byte
	w.Header().Set("Content-Type", "application/json")
	v := r.URL.Query()
	ip_adr := v.Get("ip")
	IPAddress := net.ParseIP(ip_adr)
	if IPAddress == nil {
		vError.Error = fmt.Sprintf("ip format error %s", ip_adr)
		js, _ = json.Marshal(vError)
	} else {
		traf, err := strconv.Atoi(v.Get("limit"))
		if err != nil {
			vError.Error = fmt.Sprintf("limit error %s", v.Get("limit"))
			js, _ = json.Marshal(vError)
		} else {
			AddLimitToIp(netIpToInt(IPAddress), TIpTraffic(traf))
			vAnswer.Ip = ip_adr
			vAnswer.Limit = TIpTraffic(traf)
			js, _ = json.Marshal(vAnswer)
		}
	}
	w.Write(js)
}

func httpSetLimit(w http.ResponseWriter, r *http.Request) {
	var vAnswer TAnswerStat
	var vError TAnswerError
	var js []byte
	var rec TipRecord
	w.Header().Set("Content-Type", "application/json")
	v := r.URL.Query()
	ip_adr := v.Get("ip")
	IPAddress := net.ParseIP(ip_adr)

	if IPAddress == nil {
		vError.Error = fmt.Sprintf("ip format error %s", ip_adr)
		js, _ = json.Marshal(vError)
	} else {
		traf, err := strconv.Atoi(v.Get("limit"))
		if err != nil {
			vError.Error = fmt.Sprintf("limit error %s", v.Get("limit"))
			js, _ = json.Marshal(vError)
		} else {
			offstart, err := strconv.Atoi(v.Get("offstart"))
			if err != nil {
				vError.Error = fmt.Sprintf("offstart error %s", v.Get("offstart"))
				js, _ = json.Marshal(vError)
			} else {
				offstop, err := strconv.Atoi(v.Get("offstop"))
				if err != nil {
					vError.Error = fmt.Sprintf("offstop error %s", v.Get("offstop"))
					js, _ = json.Marshal(vError)
				} else {
					rec.Limit = TIpTraffic(traf)
					rec.OffCountStart = offstart
					rec.OffCountStop = offstop
					rec.SpeedUp = v.Get("speedup")
					rec.SpeedDown = v.Get("speeddown")
					SetLimitToIp(netIpToInt(IPAddress), rec)
					vAnswer.Ip = ip_adr
					vAnswer.Traffic = rec.Traffic
					vAnswer.Limit = rec.Limit
					vAnswer.OffCountStart = rec.OffCountStart
					vAnswer.OffCountStop = rec.OffCountStop
					vAnswer.SpeedUp = rec.SpeedUp
					vAnswer.SpeedDown = rec.SpeedDown
					js, _ = json.Marshal(vAnswer)
				}
			}
		}
	}
	w.Write(js)
}