From 51d4c936538b39c3bbed5540413562cc983e0610 Mon Sep 17 00:00:00 2001 From: Mingcai SHEN Date: Tue, 20 Sep 2022 09:48:06 +0800 Subject: [PATCH] Add logs. --- recog.go | 546 ++++++++++++++++++++++++++++--------------------------- 1 file changed, 274 insertions(+), 272 deletions(-) diff --git a/recog.go b/recog.go index 67f1647..5e9190a 100644 --- a/recog.go +++ b/recog.go @@ -1,42 +1,42 @@ package main import ( - "bytes" - "encoding/base64" - "errors" - "github.com/gofiber/fiber/v2" - "image" - "image/jpeg" - "log" - "math/rand" - "time" + "bytes" + "encoding/base64" + "errors" + "github.com/gofiber/fiber/v2" + "image" + "image/jpeg" + "log" + "math/rand" + "time" ) type TestCommand struct { - Command string `json:"cmd"` - SequenceId int64 `json:"sequenceId"` + Command string `json:"cmd"` + SequenceId int64 `json:"sequenceId"` } type TestData struct { - State string `json:"state"` - ExceptionType int `json:"exceptionType,omitempty"` - ExceptionDesc string `json:"exceptionDesc,omitempty"` - Image string `json:"image,omitempty"` - DistanceCM int `json:"distanceCM,omitempty"` - Counts int `json:"counts,omitempty"` - DurationSec float32 `json:"durationSec,omitempty"` + State string `json:"state"` + ExceptionType int `json:"exceptionType,omitempty"` + ExceptionDesc string `json:"exceptionDesc,omitempty"` + Image string `json:"image,omitempty"` + DistanceCM int `json:"distanceCM,omitempty"` + Counts int `json:"counts,omitempty"` + DurationSec float32 `json:"durationSec,omitempty"` } type TestStat struct { - Scene string `json:"scene"` - Timestamp int64 `json:"timestamp"` - SequenceId int64 `json:"sequenceId"` - TestData TestData `json:"sceneData"` + Scene string `json:"scene"` + Timestamp int64 `json:"timestamp"` + SequenceId int64 `json:"sequenceId"` + TestData TestData `json:"sceneData"` } type TestException struct { - Type int - Desc string + Type int + Desc string } var currentTest *TestCommand @@ -47,281 +47,283 @@ var testStopChannel chan bool var testDurations map[string][2]int func setTestCmd(c *fiber.Ctx) error { - var testCmd TestCommand - if err := c.BodyParser(&testCmd); nil != err { - log.Println("ERROR:", c.Body()) - return failureResponse(c, "-1", err.Error(), 200) - } else if nil == currentScene { - return failureResponse(c, "1", "not in a working scene", 200) - } else { - switch testCmd.Command { - case "START": - log.Println("START ...") - if nil != currentTest { - return failureResponse(c, "2", "A test already started", 200) - } - if e := recogTaskProc(&testCmd); nil != e { - return failureResponse(c, "3", e.Error(), 200) - } - case "STOP": - if nil != testStopChannel { - testStopChannel <- true - log.Println("STOP ...") - } + var testCmd TestCommand + if err := c.BodyParser(&testCmd); nil != err { + log.Println("ERROR:", c.Body()) + return failureResponse(c, "-1", err.Error(), 200) + } else if nil == currentScene { + return failureResponse(c, "1", "not in a working scene", 200) + } else { + switch testCmd.Command { + case "START": + log.Println("START ...") + if nil != currentTest { + return failureResponse(c, "2", "A test already started", 200) + } + if e := recogTaskProc(&testCmd); nil != e { + return failureResponse(c, "3", e.Error(), 200) + } + case "STOP": + if nil != testStopChannel { + testStopChannel <- true + log.Println("STOP ...") + } - case "CANCEL": - if nil != testStopChannel { - testStopChannel <- true - log.Println("CANCEL ...") - } - default: - log.Println("UNKNOWN ...") - } - return successResponse(c, "Updated successfully.") - } + case "CANCEL": + if nil != testStopChannel { + testStopChannel <- true + log.Println("CANCEL ...") + } + default: + log.Println("UNKNOWN ...") + } + return successResponse(c, "Updated successfully.") + } } func pullUpTask(seq int64) error { - var tk = time.NewTicker(time.Millisecond * time.Duration(1500+random.Intn(800))) - defer func() { - tk.Stop() - }() - time.Sleep(time.Millisecond * 1300) - total := 3 + random.Intn(10) - n := 0 - go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) - var started = false - for { - select { - case <-testStopChannel: - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) - return nil - case except := <-testExceptChannel: - if except.Type != 0 { - go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) - } - case <-tk.C: - log.Println("===") - if !started { - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage, n) - started = true - } else if n >= total { - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) - return nil - } else { - n += 1 - go func() { - if e := pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "COUNT", capturedImage, n); nil != e { - log.Println("pushEvent failed:>", e) - testStopChannel <- true - } - }() - } - } - } + var tk = time.NewTicker(time.Millisecond * time.Duration(1500+random.Intn(800))) + defer func() { + tk.Stop() + }() + time.Sleep(time.Millisecond * 1300) + total := 3 + random.Intn(10) + n := 0 + go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) + var started = false + for { + select { + case <-testStopChannel: + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) + return nil + case except := <-testExceptChannel: + if except.Type != 0 { + go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) + } + case <-tk.C: + log.Println("===") + if !started { + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage, n) + started = true + } else if n >= total { + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) + return nil + } else { + n += 1 + go func() { + if e := pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "COUNT", capturedImage, n); nil != e { + log.Println("pushEvent failed:>", e) + testStopChannel <- true + } + }() + } + } + } } func standJumpTask(seq int64) error { - var tk = time.NewTicker(time.Millisecond * 400) - defer func() { - tk.Stop() - }() - time.Sleep(time.Millisecond * 500) - go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) - var started = false - for { - select { - case <-testStopChannel: - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, 1000+random.Intn(1000)) - return nil - case except := <-testExceptChannel: - if except.Type != 0 { - go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) - } - case <-tk.C: - log.Println("===") - if !started { - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage) - started = true - } - } - } + var tk = time.NewTicker(time.Millisecond * 400) + defer func() { + tk.Stop() + }() + time.Sleep(time.Millisecond * 500) + go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) + var started = false + for { + select { + case <-testStopChannel: + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, 1000+random.Intn(1000)) + return nil + case except := <-testExceptChannel: + if except.Type != 0 { + go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) + } + case <-tk.C: + log.Println("===") + if !started { + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage) + started = true + } + } + } } func sitUpsTask(seq int64) error { - var tk = time.NewTicker(time.Millisecond * 500) - defer func() { - tk.Stop() - }() - time.Sleep(time.Millisecond * 600) - total := 40 + random.Intn(20) - n := 0 - go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) - var started = false - for { - select { - case <-testStopChannel: - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) - return nil - case except := <-testExceptChannel: - if except.Type != 0 { - go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) - } - case <-tk.C: - log.Println("===") - if !started { - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage, n) - started = true - } else if n >= total { - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) - return nil - } else { - n += 1 - go func() { - if e := pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "COUNT", capturedImage, n); nil != e { - log.Println("pushEvent failed:>", e) - testStopChannel <- true - } - }() - } - } - } + var tk = time.NewTicker(time.Millisecond * 500) + defer func() { + tk.Stop() + }() + time.Sleep(time.Millisecond * 600) + total := 40 + random.Intn(20) + n := 0 + go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) + var started = false + for { + select { + case <-testStopChannel: + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) + return nil + case except := <-testExceptChannel: + if except.Type != 0 { + go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) + } + case <-tk.C: + log.Println("===") + if !started { + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage, n) + started = true + } else if n >= total { + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", capturedImage, n) + return nil + } else { + n += 1 + go func() { + if e := pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "COUNT", capturedImage, n); nil != e { + log.Println("pushEvent failed:>", e) + testStopChannel <- true + } + }() + } + } + } } func raceTask(seq int64) error { - var tk = time.NewTicker(time.Millisecond * 800) - defer func() { - tk.Stop() - }() - time.Sleep(time.Millisecond * 800) - go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) - var started = false - for { - select { - case <-testStopChannel: - go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST END", capturedImage, random.Intn(40)+100) - return nil - case except := <-testExceptChannel: - if except.Type != 0 { - go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) - } - case <-tk.C: - log.Println("===") - if !started { - go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage) - started = true - } - } - } + var tk = time.NewTicker(time.Millisecond * 800) + defer func() { + tk.Stop() + }() + time.Sleep(time.Millisecond * 800) + go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", nil) + var started = false + for { + select { + case <-testStopChannel: + go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST END", capturedImage, random.Intn(40)+100) + return nil + case except := <-testExceptChannel: + if except.Type != 0 { + go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, capturedImage) + } + case <-tk.C: + log.Println("===") + if !started { + go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", capturedImage) + started = true + } + } + } } func encodeImage(img image.Image) string { - if nil == img { - return "" - } - log.Println("encodeImage:> Bounds:", img.Bounds()) - //_ = saveToFile(img) - buf := new(bytes.Buffer) - if e := jpeg.Encode(buf, img, &jpeg.Options{ - Quality: 60, - }); nil != e { - log.Println("encodeImage:> failed:", e) - } - log.Println("encodeImage:> image size:", buf.Len()) - s := base64.StdEncoding.EncodeToString(buf.Bytes()) - log.Println("encodeImage:> encoded len:", len(s)) - return s + if nil == img { + return "" + } + log.Println("encodeImage:> Bounds:", img.Bounds()) + // _ = saveToFile(img) + buf := new(bytes.Buffer) + if e := jpeg.Encode(buf, img, &jpeg.Options{ + Quality: 60, + }); nil != e { + log.Println("encodeImage:> failed:", e) + } + log.Println("encodeImage:> image size:", buf.Len()) + s := base64.StdEncoding.EncodeToString(buf.Bytes()) + log.Println("encodeImage:> encoded len:", len(s)) + return s } func pushException(url string, scene string, seq int64, tp int, desc string, img image.Image) { - var st = TestStat{ - Scene: scene, - Timestamp: time.Now().Unix(), - SequenceId: seq, - TestData: TestData{ - State: "EXCEPT", - ExceptionType: tp, - ExceptionDesc: desc, - }, - } - if nil != img { - st.TestData.Image = encodeImage(img) - } - httpPostEx(url, st, 2) + log.Println("pushException:>", scene, seq, tp, desc, time.Now()) + var st = TestStat{ + Scene: scene, + Timestamp: time.Now().Unix(), + SequenceId: seq, + TestData: TestData{ + State: "EXCEPT", + ExceptionType: tp, + ExceptionDesc: desc, + }, + } + if nil != img { + st.TestData.Image = encodeImage(img) + } + httpPostEx(url, st, 2) } func pushEvent(url string, scene string, seq int64, state string, img image.Image, vals ...int) error { - var st = TestStat{ - Scene: scene, - Timestamp: time.Now().Unix(), - SequenceId: seq, - TestData: TestData{ - State: state, - }, - } - if nil != img { - st.TestData.Image = encodeImage(img) - } - if len(vals) > 0 { - switch scene { - case "pullUp": - st.TestData.Counts = vals[0] - case "standJump": - st.TestData.DistanceCM = vals[0] - case "sitUps": - st.TestData.Counts = vals[0] - case "race": - st.TestData.DurationSec = float32(vals[0]) / 10.0 - default: + log.Println("pushEvent:>", scene, seq, state, vals, time.Now()) + var st = TestStat{ + Scene: scene, + Timestamp: time.Now().Unix(), + SequenceId: seq, + TestData: TestData{ + State: state, + }, + } + if nil != img { + st.TestData.Image = encodeImage(img) + } + if len(vals) > 0 { + switch scene { + case "pullUp": + st.TestData.Counts = vals[0] + case "standJump": + st.TestData.DistanceCM = vals[0] + case "sitUps": + st.TestData.Counts = vals[0] + case "race": + st.TestData.DurationSec = float32(vals[0]) / 10.0 + default: - } - } - return httpPostEx(url, st, 2) + } + } + return httpPostEx(url, st, 2) } func recogTaskProc(cmd *TestCommand) error { - testStopChannel = make(chan bool) - testExceptChannel = make(chan TestException) - random = rand.New(rand.NewSource(time.Now().UnixNano())) - if nil == currentScene { - return errors.New("invalid scene state") - } - if nil == currentScene.proc { - return errors.New("invalid scene mode processor") - } - currentTest = cmd - go func() { - defer func() { - close(testStopChannel) - close(testExceptChannel) - testStopChannel = nil - testExceptChannel = nil - currentTest = nil - }() - if e := currentScene.proc(cmd.SequenceId); nil != e { - log.Println(">>>>", e) - } - }() - go func() { - var min = testDurations[currentScene.Scene][0] - var max = testDurations[currentScene.Scene][1] - for i := 0; i < random.Intn(max-min)+min; i++ { - time.Sleep(time.Second) - } - testStopChannel <- true - }() - return nil + testStopChannel = make(chan bool) + testExceptChannel = make(chan TestException) + random = rand.New(rand.NewSource(time.Now().UnixNano())) + if nil == currentScene { + return errors.New("invalid scene state") + } + if nil == currentScene.proc { + return errors.New("invalid scene mode processor") + } + currentTest = cmd + go func() { + defer func() { + close(testStopChannel) + close(testExceptChannel) + testStopChannel = nil + testExceptChannel = nil + currentTest = nil + }() + if e := currentScene.proc(cmd.SequenceId); nil != e { + log.Println(">>>>", e) + } + }() + go func() { + var min = testDurations[currentScene.Scene][0] + var max = testDurations[currentScene.Scene][1] + for i := 0; i < random.Intn(max-min)+min; i++ { + time.Sleep(time.Second) + } + testStopChannel <- true + }() + return nil } func init() { - random = rand.New(rand.NewSource(time.Now().UnixNano())) - currentTest = nil - testExceptChannel = nil - testStopChannel = nil - testDurations = map[string][2]int{ - "pullUp": [2]int{30, 80}, - "standJump": [2]int{10, 30}, - "sitUps": [2]int{60, 70}, - "race": [2]int{9, 15}, - } + random = rand.New(rand.NewSource(time.Now().UnixNano())) + currentTest = nil + testExceptChannel = nil + testStopChannel = nil + testDurations = map[string][2]int{ + "pullUp": [2]int{30, 80}, + "standJump": [2]int{10, 30}, + "sitUps": [2]int{60, 70}, + "race": [2]int{9, 15}, + } }