func (h *RpcHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
oa := CheckAuthorized(w, r, false)
if oa == nil {
return
}
sURL := r.URL.Path[5:]
//log.Println("rpc:", sURL)
mParams := r.URL.Query()
if sURL == "shutdown" {
DoShutdown()
return
}
if sURL == "backupget" {
file := mParams.Get("file")
w.Header().Set("Content-Disposition", "attachment; filename="+file)
http.ServeFile(w, r, "backup/"+file)
return
}
if sURL == "backupload" {
m, h, err := r.FormFile("backup")
if err != nil {
http.Error(w, err.Error(), http.StatusNotFound)
return
}
defer m.Close()
sFile := "backup/" + h.Filename
dst, err := os.Create(sFile)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
_, err = io.Copy(dst, m)
dst.Close()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
finfo, _ := os.Stat(sFile)
w.WriteHeader(200)
w.Write([]byte("Uploaded: " + humanize.Bytes(uint64(finfo.Size()))))
return
}
var err error
var data interface{}
defer func() {
var result = map[string]interface{}{}
if err == nil {
result["result"] = true
if data != nil {
result["data"] = data
}
} else {
log.Println("rpc error:", sURL, err)
result["result"] = false
result["error"] = err.Error()
}
msg, _ := json.Marshal(result)
w.Write(msg)
}()
if sURL == "start" {
err = ServerStart()
return
}
if sURL == "stop" {
err = ServerStop()
return
}
if sURL == "flush" {
err = ServerFlush()
return
}
if sURL == "deploy" {
err = DoDeployServer()
return
}
if sURL == "dobackup" {
err = DoBackup()
return
}
if sURL == "backuplist" {
data, err = GetBackupList()
return
}
if sURL == "backupdel" {
file := mParams.Get("file")
if len(file) < 1 {
err = errors.New("invalid file:" + file)
return
}
sFile := "backup/" + file
err = os.RemoveAll(sFile)
return
}
if sURL == "backuprestore" {
file := mParams.Get("file")
if len(file) < 1 {
err = errors.New("invalid file:" + file)
return
}
sFile := "backup/" + file
err = DoBackupRestore(sFile)
return
}
if sURL == "activate" {
//err = srv.DoActivateVersion(true, mParams.Get("version"))
return
}
if sURL == "deactivate" {
//err = srv.DoActivateVersion(false, mParams.Get("version"))
return
}
if sURL == "autorestart" {
val := mParams.Get("val")
v := false
if val == "true" {
v = true
}
//log.Println("autorestart", val)
SetAutoRestart(v)
return
}
if sURL == "files" {
//d := map[string]interface{}{}
//d["files"], err = srv.GetVersionFiles(mParams.Get("version"))
//data = d
return
}
if sURL == "db" {
data, err = db.DoAdminRpc(mParams)
return
}
if sURL == "status" {
d := map[string]interface{}{}
if len(mParams.Get("log")) > 0 {
t, _ := strconv.Atoi(mParams.Get("logt"))
log, t := srv.GetLog(t)
d["log"] = log
d["logt"] = t
}
if len(mParams.Get("deploy")) > 0 {
d["deploy"] = GetDeployInfo()
}
if len(mParams.Get("server")) > 0 {
d["server"] = ServerStatus()
}
if len(mParams.Get("stats")) > 0 {
d["stats"] = srv.GetStatsCur()
}
if len(mParams.Get("system")) > 0 {
sys := map[string]interface{}{}
var mem perf.Mem
err = mem.Get()
sys["mem_load"] = mem.Load
sys["mem_total"] = mem.Total
sys["mem_used"] = mem.Used
sys["mem_pagetotal"] = mem.PageTotal
sys["mem_pageused"] = mem.PageUsed
sys["mem_cache"] = mem.Cache
uptCtrl := time.Since(timeStart)
uptSys, _ := perf.GetUptime()
//log.Println("x:", uptSys, uptCtrl)
sys["upt_system"] = uptSys / time.Millisecond
sys["upt_ctrl"] = uptCtrl / time.Millisecond
var cpu perf.Cpu
err = cpu.Get()
sys["cpu_loadtotal"] = cpu.LoadTotal
sys["cpu_loadsys"] = cpu.LoadSys
d["system"] = sys
}
data = d
return
}
log.Println("invalid rpc:", sURL)
}
func StatsRun() {
tickSec := time.NewTicker(time.Second)
tickMin := time.NewTicker(time.Minute)
tickHou := time.NewTicker(time.Hour)
defer tickSec.Stop()
defer tickMin.Stop()
defer tickHou.Stop()
var sCurLoadSys int
var sCurLoadTot int
var sCurLoadMem int
var sCurRqCount int
var sCurClientRPCs int
var sCurClientPtlChg int
var sCurClientErrors int
var sCurRqDur int
var sCurMin StatsEntry
var cpu perf.Cpu
var mem perf.Mem
var iCurMinCpu = 0
var iCurMinMem = 0
var iLastMin = -1
var iLastHou = -1
var iLastRqCount int64 = -1
var iLastRqDur int64 = -1
var iLastClientRPCs int64 = -1
var iLastClientErrors int64 = -1
var iLastClientPtlChg int64 = -1
iLastMin = statsToday.LastMinute()
if iLastMin != -1 {
tLast := statsToday.MinutesHour[iLastMin].Time()
now := time.Now()
dist := now.Sub(tLast)
//log.Println(">>>>>>>>>>>>>>>>> lm:", iLastMin, tLast.Hour(), now.Hour(), dist)
if tLast.YearDay() != now.YearDay() || dist > time.Hour*24 {
StatsCycleDay()
}
if tLast.Hour() != now.Hour() || dist > time.Hour {
statsToday.ClearMinutesHour()
}
}
for {
select {
case <-tickSec.C:
if cpu.Get() == nil {
iCurMinCpu++
sCurLoadSys += int(cpu.LoadSys * 100)
if int8(cpu.LoadSys*100) > sCurMin.LoadSysMax {
sCurMin.LoadSysMax = int8(cpu.LoadSys * 100)
}
sCurLoadTot += int(cpu.LoadTotal * 100)
if int8(cpu.LoadTotal*100) > sCurMin.LoadTotalMax {
sCurMin.LoadTotalMax = int8(cpu.LoadTotal * 100)
}
}
if mem.Get() == nil {
iCurMinMem++
sCurLoadMem += int(mem.Load)
if int8(mem.Load) > sCurMin.LoadMemMax {
sCurMin.LoadMemMax = int8(mem.Load)
}
}
if SrvRequestCount > iLastRqCount && iLastRqCount != -1 {
sCurRqCount += int(SrvRequestCount - iLastRqCount)
sCurRqDur += int((SrvRequestDur - iLastRqDur) / 1000)
}
iLastRqCount = SrvRequestCount
iLastRqDur = SrvRequestDur
if SrvClientRPCs > iLastClientRPCs && iLastClientRPCs != -1 {
sCurClientRPCs += int(SrvClientRPCs - iLastClientRPCs)
}
if SrvClientPtlChg > iLastClientPtlChg && iLastClientPtlChg != -1 {
sCurClientPtlChg += int(SrvClientPtlChg - iLastClientPtlChg)
}
if SrvClientErrors > iLastClientErrors && iLastClientErrors != -1 {
sCurClientErrors += int(SrvClientErrors - iLastClientErrors)
}
iLastClientRPCs = SrvClientRPCs
iLastClientPtlChg = SrvClientPtlChg
iLastClientErrors = SrvClientErrors
now := time.Now()
min := now.Minute()
hou := now.Hour()
if min != iLastMin {
//flush minute
iLastMin = min
sCurLoadSys = 0
sCurLoadTot = 0
sCurLoadMem = 0
iCurMinCpu = 0
iCurMinMem = 0
sCurRqCount = 0
sCurRqDur = 0
sCurClientRPCs = 0
sCurClientPtlChg = 0
sCurClientErrors = 0
sCurMin = StatsEntry{}
//statsToday.MinutesHour[min] = StatsEntry{}
StatsSave()
}
if hou != iLastHou {
//flush hour
if iLastHou != -1 {
statsToday.ClearMinutesHour()
}
if iLastHou > hou {
StatsCycleDay()
}
iLastHou = hou
}
cur := &statsToday.MinutesHour[min]
if iCurMinCpu > 0 {
cur.LoadSysCur = int8(sCurLoadSys / iCurMinCpu)
cur.LoadSysMax = sCurMin.LoadSysMax
cur.LoadTotalCur = int8(sCurLoadTot / iCurMinCpu)
cur.LoadTotalMax = sCurMin.LoadTotalMax
}
if iCurMinMem > 0 {
cur.LoadMemCur = int8(sCurLoadMem / iCurMinMem)
cur.LoadMemMax = sCurMin.LoadMemMax
}
cur.RqCount = sCurRqCount
cur.RqDur = sCurRqDur
cur.RPCs = sCurClientRPCs
cur.PortChg = sCurClientPtlChg
cur.CErr = sCurClientErrors
cur.Timestamp = uint64(now.UnixNano()) / (1000 * 1000)
//log.Println(">>>>>>>>>>>>>>>>> :", cur.RqCount, cur.RqDur)
//log.Println(">>>>>>>>>>>>>>>>>:", now, cur.Time())
statsToday.CompactHour(hou)
case <-tickMin.C:
case <-tickHou.C:
case <-quit:
return
}
}
}
