Updated.

http.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"log"
+	"net/http"
+	"time"
+)
+
+var httpClient *http.Client
+var fakeClient = false
+
+func httpPost(url string, data interface{}) error {
+	log.Println("httpPost:url>", url)
+	if fakeClient {
+		log.Println("httpPost:data>", data)
+		return nil
+	}
+	if bs, e := json.Marshal(data); nil != e {
+		return e
+	} else if resp, e := httpClient.Post(url, "application/json", bytes.NewBuffer(bs)); nil != e {
+		return e
+	} else if resp.StatusCode != http.StatusOK {
+		return errors.New("invalid resp status: " + resp.Status)
+	} else {
+		return nil
+	}
+}
+
+func httpGet(url string, resp interface{}) error {
+	return nil
+}
+
+func httpPostEx(url string, data interface{}, retries int) {
+	for i := 0; i < retries; i++ {
+		if e := httpPost(url, data); nil != e {
+			log.Println(">>>", e)
+			time.Sleep(3 * time.Second)
+		} else {
+			return
+		}
+	}
+}
+
+func init() {
+	httpClient = http.DefaultClient
+}

main.go

@@ -1,25 +1,26 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gofiber/fiber/v2"
-    "github.com/spf13/cobra"
-    "log"
-    "os"
+	"fmt"
+	"github.com/gofiber/fiber/v2"
+	"github.com/spf13/cobra"
+	"log"
+	"os"
 )
 
 var listenAddr = ":3000"
 
 var rootCmd = &cobra.Command{
-    Use:   "sport_rec",
-    Short: "Sport Recognition Demo",
-    Long:  "Sport Recognition Demo",
+	Use:   "sport_rec",
+	Short: "Sport Recognition Demo",
+	Long:  "Sport Recognition Demo",
 }
 
 func init() {
-    cobra.OnInitialize(initConfig)
-    rootCmd.PersistentFlags().StringVarP(&listenAddr, "listen", "L", ":3000", "Service listen address")
-    rootCmd.AddCommand(serveCmd)
+	cobra.OnInitialize(initConfig)
+	rootCmd.PersistentFlags().StringVarP(&listenAddr, "listen", "L", ":3000", "Service listen address")
+	rootCmd.PersistentFlags().BoolVarP(&fakeClient, "fake", "F", false, "Fake HTP client instead of pushing")
+	rootCmd.AddCommand(serveCmd)
 }
 
 func initConfig() {
@@ -27,28 +28,28 @@ func initConfig() {
 }
 
 var serveCmd = &cobra.Command{
-    Use:   "run",
-    Short: "Run service",
-    Run: func(cmd *cobra.Command, args []string) {
-        app := fiber.New()
-
-        app.Get("/", func(c *fiber.Ctx) error {
-            return c.SendString("Hello, World!")
-        })
-
-        app.Post("/api/v1/setScene", setScene)
-        app.Post("/api/v1/setTestCmd", setTestCmd)
-        // app.Post("/api/v1/eventHandle")
-        app.Post("/api/v1/stopScene", stopScene)
-        app.Get("/api/v1/getStatus", getStatus)
-
-        log.Fatal(app.Listen(listenAddr))
-    },
+	Use:   "run",
+	Short: "Run service",
+	Run: func(cmd *cobra.Command, args []string) {
+		app := fiber.New()
+
+		app.Get("/", func(c *fiber.Ctx) error {
+			return c.SendString("Hello, World!")
+		})
+
+		app.Post("/api/v1/setScene", setScene)
+		app.Post("/api/v1/setTestCmd", setTestCmd)
+		// app.Post("/api/v1/eventHandle")
+		app.Post("/api/v1/stopScene", stopScene)
+		app.Get("/api/v1/getStatus", getStatus)
+
+		log.Fatal(app.Listen(listenAddr))
+	},
 }
 
 func main() {
-    if err := rootCmd.Execute(); err != nil {
-        fmt.Println(err)
-        os.Exit(1)
-    }
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
 }

recog.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"github.com/gofiber/fiber/v2"
 	"log"
+	"math/rand"
 	"time"
 )
 
@@ -12,31 +13,57 @@ type TestCommand struct {
 	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"`
+}
+
+type TestStat struct {
+	Scene      string   `json:"scene"`
+	Timestamp  int64    `json:"timestamp"`
+	SequenceId int64    `json:"sequenceId"`
+	TestData   TestData `json:"sceneData"`
+}
+
+type TestException struct {
+	Type int
+	Desc string
+}
+
 var currentTest *TestCommand
 
-var testChannel chan *TestCommand
+var random *rand.Rand
+var testExceptChannel chan TestException
 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 {
-		return failureResponse(c, "-1", err.Error(), 400)
+		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", 400)
+		return failureResponse(c, "1", "not in a working scene", 200)
 	} else {
-		currentTest = &testCmd
 		switch testCmd.Command {
 		case "START":
 			log.Println("START ...")
 			if nil != currentTest {
-				return failureResponse(c, "2", "A test already started", 403)
+				return failureResponse(c, "2", "A test already started", 200)
 			}
 			if e := recogTaskProc(&testCmd); nil != e {
-				return failureResponse(c, "3", e.Error(), 409)
+				return failureResponse(c, "3", e.Error(), 200)
 			}
 		case "STOP":
+			testStopChannel <- true
 			log.Println("STOP ...")
 		case "CANCEL":
+			testStopChannel <- true
 			log.Println("CANCEL ...")
 		default:
 			log.Println("UNKNOWN ...")
@@ -46,67 +73,167 @@ func setTestCmd(c *fiber.Ctx) error {
 }
 
 func pullUpTask(seq int64) error {
-	var tk = time.NewTicker(time.Second * 3)
+	var tk = time.NewTicker(time.Millisecond * 200)
 	defer func() {
 		tk.Stop()
 	}()
+	time.Sleep(time.Millisecond * 300)
+	go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", false, false)
+	var started = false
 	for {
 		select {
 		case <-testStopChannel:
+			go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", true, true)
 			return nil
+		case except := <-testExceptChannel:
+			if except.Type != 0 {
+				go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, true)
+			}
 		case <-tk.C:
 			log.Println("===")
+			if !started {
+				go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", true, true)
+				started = true
+			} else {
+				go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "COUNT", true, true)
+			}
 		}
 	}
 }
 
 func standJumpTask(seq int64) error {
-	var tk = time.NewTicker(time.Second * 3)
+	var tk = time.NewTicker(time.Millisecond * 100)
 	defer func() {
 		tk.Stop()
 	}()
+	time.Sleep(time.Millisecond * 500)
+	go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", false, false)
+	var started = false
 	for {
 		select {
 		case <-testStopChannel:
+			go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", true, true)
 			return nil
+		case except := <-testExceptChannel:
+			if except.Type != 0 {
+				go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, true)
+			}
 		case <-tk.C:
 			log.Println("===")
+			if !started {
+				go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", true, true)
+				started = true
+			}
 		}
 	}
 }
 
 func sitUpsTask(seq int64) error {
-	var tk = time.NewTicker(time.Second * 3)
+	var tk = time.NewTicker(time.Millisecond * 200)
 	defer func() {
 		tk.Stop()
 	}()
+	time.Sleep(time.Millisecond * 600)
+	go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", false, false)
+	var started = false
 	for {
 		select {
 		case <-testStopChannel:
+			go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "TEST END", true, true)
 			return nil
+		case except := <-testExceptChannel:
+			if except.Type != 0 {
+				go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, true)
+			}
 		case <-tk.C:
 			log.Println("===")
+			if !started {
+				go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", true, true)
+				started = true
+			} else {
+				go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "COUNT", true, true)
+			}
 		}
 	}
 }
 
 func raceTask(seq int64) error {
-	var tk = time.NewTicker(time.Second * 3)
+	var tk = time.NewTicker(time.Millisecond * 100)
 	defer func() {
 		tk.Stop()
 	}()
+	time.Sleep(time.Millisecond * 800)
+	go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST READY", false, false)
+	var started = false
 	for {
 		select {
 		case <-testStopChannel:
+			go pushEvent(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, "TEST END", true, true)
 			return nil
+		case except := <-testExceptChannel:
+			if except.Type != 0 {
+				go pushException(currentScene.PushUrl, currentScene.Scene, currentTest.SequenceId, except.Type, except.Desc, true)
+			}
 		case <-tk.C:
 			log.Println("===")
+			if !started {
+				go pushEvent(currentScene.PushUrl, currentScene.Scene, seq, "START", true, true)
+				started = true
+			}
+		}
+	}
+}
+
+func pushException(url string, scene string, seq int64, tp int, desc string, img bool) {
+	var st = TestStat{
+		Scene:      scene,
+		Timestamp:  time.Now().Unix(),
+		SequenceId: seq,
+		TestData: TestData{
+			State:         "EXCEPT",
+			ExceptionType: tp,
+			ExceptionDesc: desc,
+		},
+	}
+	if img {
+		st.TestData.Image = IMAGES[random.Intn(len(IMAGES))]
+	}
+	httpPostEx(url, st, 3)
+}
+
+func pushEvent(url string, scene string, seq int64, state string, img bool, val bool) {
+	var st = TestStat{
+		Scene:      scene,
+		Timestamp:  time.Now().Unix(),
+		SequenceId: seq,
+		TestData: TestData{
+			State: state,
+		},
+	}
+	if img {
+		st.TestData.Image = IMAGES[random.Intn(len(IMAGES))]
+	}
+	if val {
+		switch scene {
+		case "pullUp":
+			st.TestData.Counts = random.Intn(20)
+		case "standJump":
+			st.TestData.DistanceCM = random.Intn(300)
+		case "sitUps":
+			st.TestData.Counts = random.Intn(20)
+		case "race":
+			st.TestData.DurationSec = random.Float32()
+		default:
+
 		}
 	}
+	httpPostEx(url, st, 3)
 }
 
 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")
 	}
@@ -117,17 +244,35 @@ func recogTaskProc(cmd *TestCommand) error {
 	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
-	testChannel = 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},
+	}
 }

scene.go

@@ -15,6 +15,17 @@ type SceneCommand struct {
 	proc       func(int64) error
 }
 
+type SceneData struct {
+	State   string   `json:"state"`
+	LiveUrl []string `json:"liveUrl"`
+}
+
+type SceneReadyResponse struct {
+	Scene     string    `json:"scene"`
+	Timestamp int64     `json:"timestamp"`
+	SceneData SceneData `json:"sceneData"`
+}
+
 var currentScene *SceneCommand
 var sceneStopChannel chan bool
 
@@ -42,15 +53,18 @@ func validateSceneCmd(cmd SceneCommand) error {
 func setScene(c *fiber.Ctx) error {
 	var sceneCmd SceneCommand
 	if err := c.BodyParser(&sceneCmd); nil != err {
-		return failureResponse(c, "-1", err.Error(), 400)
+		log.Println("ERROR:", c.Body())
+		return failureResponse(c, "-1", err.Error(), 200)
 	} else if nil != currentScene {
-		return failureResponse(c, "1", "A working scene is started", 400)
+		return failureResponse(c, "1", "A working scene is started", 200)
 	} else if err = validateSceneCmd(sceneCmd); nil != err {
-		return failureResponse(c, "2", err.Error(), 400)
+		return failureResponse(c, "2", err.Error(), 200)
 	} else {
 		// currentScene = &sceneCmd
+		log.Println("Starting scene ...")
+		log.Println(sceneCmd)
 		if e := sceneTaskProc(&sceneCmd); nil != e {
-			return failureResponse(c, "3", err.Error(), 409)
+			return failureResponse(c, "3", err.Error(), 200)
 		} else {
 			return successResponse(c, "Updated successfully.")
 		}
@@ -97,15 +111,25 @@ func sceneTaskProc(cmd *SceneCommand) error {
 			close(sceneStopChannel)
 			sceneStopChannel = nil
 		}()
-		time.Sleep(time.Second)
 		currentScene = cmd
 		currentScene.proc = f
+		time.Sleep(time.Second)
+		var st = SceneReadyResponse{
+			Scene:     cmd.Scene,
+			Timestamp: time.Now().Unix(),
+			SceneData: SceneData{
+				State:   "SCENE READY",
+				LiveUrl: cmd.CameraUrls,
+			},
+		}
+		go httpPostEx(cmd.PushUrl, st, 3)
 		for {
 			select {
 			case <-tk.C:
-				log.Println(" ...")
+				// log.Println(" ...")
 			case <-sceneStopChannel:
 				log.Println("Scene Stopping...")
+				go pushEvent(cmd.PushUrl, cmd.Scene, 0, "SCENE END", false, false)
 				return
 			}
 		}