bitable/Check_engine/Check_engine.go

731 lines
21 KiB
Go

package main
import (
"Bitable/file"
"fmt"
"io"
//"log"
"io/ioutil"
"os"
"os/exec"
"strings"
"time"
//"path/filepath"
"encoding/json"
"strconv" // convert string to int
)
// scp -P 2224 -r -o 'ProxyJump dh.duyhai@ssh_tunnel.beetai.com' Check_engine root@localhost:/root/monitor/check/
var name_dir_engine string = ""
var state_read_ecf bool = false
var path_base = "/root/monitor"
// var path_base string = "/home/admin/monitor"
var Path_base_engine string = path_base + "/engine/" + name_dir_engine //"count_people_face" // Name dir engine
var Path_log_engine string = path_base + "/log/log_engine"
var Path_log_luncher string = path_base + "/log/log_launcher"
var Path_engine_config string = path_base + "/setup/engine.json" // dia chi duoi file Config.txt
var Path_config string = Path_base_engine + "/data/Config.txt"
// var path = "/root/monitor/log/log_engine.txt"
//var time_sts int = 0
//var cam_sts int = 0
//var Path_config string = "/root/monitor/face_recognition/data/Config.txt"
//engine
var engine_status int = 0
var Path_time string = path_base + "/setup/time_run.txt"
var time_start int = 0
var time_end int = 0
var time_start_defaut int = 5
var time_end_defaut int = 23
var Debug int = 1
var number_run int = 0 // Check so lan run lai engine khi engine loi
var message Message
type Message struct {
Error_code int `json:"error_code"`
Data Datas `json:"data"`
SD_CARD int `json:"sd_card"`
}
// User struct which contains a name
// a type and a list of social links
type Datas struct {
Box_id int `json:"box_id"`
//Box_name string `json:"box_name"`
Engines []Engine `json:"engines"`
}
type Engine struct {
IsConfig string `json:"isConfig,omitempty"`
Active int `json:"active"`
Engine_id int `json:"engine_id"`
Id int `json:"id"`
Link string `json:"link"`
Name string `json:"name"`
Path string `json:"path"`
Version string `json:"version"`
Time_run string `json:"time_run,omitempty"`
}
//============================> Main <==========================
func main() {
fmt.Println("------------------ Start --------------------")
//GetDir() // Check thu muc
fmt.Println("--------------------------")
file.Check_path(Path_log_engine)
file.Write_log("Begin Check, Restart program\n", Path_log_engine)
fmt.Printf("Begin Check, Restart program\n")
ReadEngineConfig(Path_engine_config) // Pharse engine.json to struct Message
// Loop:
for {
fmt.Println("Path base:" + path_base)
fmt.Println("-------------------- 0 ---------------------")
//Check_dir_engine() // Check directory engine , Create Path_base engine
// ReadTimeRun()
//CheckCam()
//CheckTime()
ActionEngine()
fmt.Println("-------------------- 1 ---------------------")
Sleep_ms(5000)
}
}
//========================> END MAIN <====================
//------------------ Function ----------------------------
// func Check_dir_engine() {
// if Debug == 1 {
// fmt.Println("Function Check_dir_engine ()")
// }
// name_dir_engine = strings.Replace(message.Data.Engines[0].Path, ".zip", "", -1)
// Path_base_engine = path_base + "/engine/" + name_dir_engine
// Path_config = Path_base_engine + "/data/Config.txt"
// Path_log_engine = path_base + "/log/log_engine"
// Path_log_luncher = path_base + "/log/log_launcher"
// Path_engine_config = path_base + "/setup/engine.json" // dia chi duoi file Config.txt
// Path_config = Path_base_engine + "/data/Config.txt"
// if Debug == 1 {
// fmt.Printf("Name_dir_engine :" + name_dir_engine + "\t")
// fmt.Println("Path_base_engine :" + Path_base_engine)
// }
// }
func GetDir() {
if file.ReadFile("/root/ver_sys.txt") == "1" {
path_base = "/home/aibox/Documents/monitor"
}
}
func ReadEngineConfig(path string) {
if Debug == 1 {
fmt.Println("Function ReadEngineConfig ()")
}
// Open our jsonFile
jsonFile, err := os.Open(path)
// if we os.Open returns an error then handle it
if err != nil {
fmt.Println(err)
file.Write_log("ReadEngineConfig 1 () "+err.Error(), Path_log_engine)
}
if Debug == 1 {
fmt.Println("Successfully Opened engine.json")
}
defer jsonFile.Close()
byteValue, err := ioutil.ReadAll(jsonFile)
if err != nil {
fmt.Println(err)
file.Write_log("ReadEngineConfig 2 () "+err.Error(), Path_log_engine)
}
json.Unmarshal(byteValue, &message)
state_read_ecf = true
file.Println("\nError_code: " + strconv.Itoa(message.Error_code))
file.Println("Box_id: " + strconv.Itoa(message.Data.Box_id))
// file.Println("---------------------------------------------")
// List engine
for i := 0; i < len(message.Data.Engines); i++ {
file.Println("Isconfig: " + message.Data.Engines[i].IsConfig)
file.Println("Active: " + strconv.Itoa(message.Data.Engines[i].Active))
file.Println("Engine_id: " + strconv.Itoa(message.Data.Engines[i].Engine_id))
file.Println("Id: " + strconv.Itoa(message.Data.Engines[i].Id))
file.Println("Link: " + message.Data.Engines[i].Link)
file.Println("Name: " + message.Data.Engines[i].Name)
file.Println("Path: " + message.Data.Engines[i].Path)
file.Println("Version: " + message.Data.Engines[i].Version)
file.Println("Time_run: " + message.Data.Engines[i].Time_run)
file.Println("---------------------------------------------")
}
}
func ReadTimeRun(time string) (int, int) {
var t_start int
var t_end int
if Debug == 1 {
fmt.Println("Function ReadTimeRun ()")
}
// var value = message.Data.Engines[i].Time_run
fmt.Println("\nTime_run:" + time)
var list = strings.Split(time, ":")
if Debug == 1 {
fmt.Println(list)
for i := 0; i < 2; i++ {
fmt.Print(i)
fmt.Print("_")
fmt.Printf("%T", list[i])
fmt.Print("_")
fmt.Printf("%v\n", list[i])
}
}
var x, _ = strconv.Atoi(list[0])
t_start = x
if t_start < 0 {
t_start = 0
} else if t_start > 23 {
t_start = 23
}
var z, _ = strconv.Atoi(list[1])
t_end = z
if t_end < 0 {
t_end = 0
} else if t_end > 23 {
t_end = 23
}
return t_start, t_end
}
func ActionEngine() {
if Debug == 1 {
fmt.Println("Function ActionEngine ()")
}
for i := 0; i < len(message.Data.Engines); i++ {
var t_stt = CheckTime(message.Data.Engines[i].Time_run)
//var cam_sts = CheckCam(message.Data.Engines[i].Path + "/data/Config.txt")
var cam_sts = 1
var enable, _ = strconv.Atoi(message.Data.Engines[i].IsConfig)
if cam_sts*t_stt*enable == 1 {
STTServerFR()
if stt_serverlocal == 1 {
fmt.Println("Run Status_engine()")
Status_engine()
}
fmt.Println(" Setup Run Engine")
} else {
fmt.Println("Setup off Engine")
if message.Data.Engines[i].Active == 1 {
//var cmd string = "ps -A | grep " + message.Data.Engines[i].Name
var cmd string = "pidof " + message.Data.Engines[i].Name
out2, err := exec.Command("sh", "-c", cmd).Output()
if err != nil {
fmt.Println(err)
//file.Write_log("ActionEngine () "+err.Error(), Path_log_engine)
}
fmt.Println("Lengh :"+cmd+"%v", len(out2))
if len(out2) != 0 {
// sudo kill $(pgrep FaceRecognition)
//var cmd string = "sudo kill $(pgrep " + message.Data.Engines[i].Name + ")"
//var cmd string = "pidof " + message.Data.Engines[i].Name
var cmd string = "sudo kill -9 $(pidof " + message.Data.Engines[i].Name + ")"
fmt.Println("CMD Kill_engine:" + cmd)
_, err := exec.Command("sh", "-c", cmd).Output() // kill $(pgrep FaceRecognition)
//log.Fatal(err)
if err != nil {
file.Write_log("sudo kill engine of ActionEngine() Error \n", Path_log_engine)
fmt.Println("sudo kill engine of ActionEngine() Error")
}
} else {
fmt.Println("Engine kill")
}
out1, _ := exec.Command("sh", "-c", "ps -A | grep loop_run").Output()
if len(out1) != 0 {
_, err := exec.Command("sh", "-c", " sudo kill $(pgrep loop_run)").Output()
if err != nil {
file.Write_log("sudo kill $(pgrep loop_run) of CheckActionEngine() \n", Path_log_engine)
}
//log.Fatal(err) sudo systemctl restart S905X_BI rm /root/monitor/launcher/S905X_BI
} else {
fmt.Println("loop_run kill")
}
} else {
fmt.Println("Engine setting off on engine.json")
}
}
}
}
func CheckTime(time_run string) int {
var time_sts = 0
if Debug == 1 {
fmt.Println("Function CheckTime ()")
}
//ReadTimeRun(time string) (int, int)
t_start, t_end := ReadTimeRun(time_run)
var time_now = time.Now().Hour()
if Debug == 1 {
//fmt.Printf("Kieu time : %T\n", time)
fmt.Printf("time = %v\n", time_now)
}
if time_now >= t_start && time_now <= t_end {
time_sts = 1
//Status_engine()
fmt.Println(" Time Engine's running")
} else {
time_sts = 0
}
return time_sts
}
func FloatToString(input_num float64) string {
fmt.Println("Function FloatToString ()")
// to convert a float number to a string
return strconv.FormatFloat(input_num, 'f', 3, 64)
}
func KillFaceDedect() {
fmt.Println("Function KillFaceDedect()")
var cmd string = "pidof " + message.Data.Engines[0].Name
//out1, err := exec.Command("sh", "-c", "ps -A | grep "+message.Data.Engines[0].Name).Output()
out1, err := exec.Command("sh", "-c", cmd).Output()
if err != nil {
fmt.Println(err)
file.Write_log("KillFaceDedect() "+err.Error(), Path_log_engine)
}
if len(out1) != 0 {
_, err := exec.Command("sh", "-c", "sudo kill $("+cmd+")").Output() // kill $(pgrep FaceRecognition)
//log.Fatal(err)
if err != nil {
file.Write_log("sudo kill "+message.Data.Engines[0].Name+" of KillFaceDedect() \n", Path_log_engine)
}
file.Write_log("KillFaceDedect()\n", Path_log_engine)
Sleep_ms(500)
}
fmt.Printf("KillFaceDedect run and Run engine\n")
}
func Status_engine() {
if Debug == 1 {
fmt.Println("Function Status_engine ()")
}
for i := 0; i < len(message.Data.Engines); i++ {
if message.Data.Engines[i].Active == 1 {
//var cmd string = "ps -A | grep " + message.Data.Engines[i].Name
var cmd string = "pidof " + message.Data.Engines[i].Name
out, err := exec.Command("sh", "-c", cmd).Output()
if err != nil {
fmt.Println(err)
file.Write_log("Status_engine () "+err.Error(), Path_log_engine)
}
if len(out) == 0 {
fmt.Printf(message.Data.Engines[i].Name + "isn't running\n")
file.Write_log(message.Data.Engines[i].Name+"isn't running\n", Path_log_engine)
//KillLoopRun()
RunEngine(message.Data.Engines[i].Name)
} else {
number_run = 0
fmt.Printf(message.Data.Engines[i].Name + " is running\n")
}
} else {
fmt.Println("Engine setting off on engine.json")
}
}
}
func CheckCam(path string) int {
var cam_sts int
if Debug == 1 {
fmt.Println("Function CheckCam ()")
}
for i := 0; i < len(message.Data.Engines); i++ {
var ip string = ""
ip = GetIPCam(path)
fmt.Println("Ip camera: " + ip)
out, err := exec.Command("ping", ip, "-c 5", "-i 0.2", "-w 5").Output()
if err != nil {
fmt.Println(err)
file.Write_log("CheckCam () "+err.Error(), Path_log_engine)
cam_sts = 0
} else {
}
if strings.Contains(string(out), "Destination Host Unreachable") {
fmt.Println("Disconnect camera...")
file.Write_log("Disconnect camera", Path_log_engine)
cam_sts = 0
} else {
fmt.Println("Connected camera...")
cam_sts = 1
}
}
return cam_sts
//fmt.Println("End Function CheckCam")
}
func GetIPCam(path string) string {
if Debug == 1 {
fmt.Println("Function GetIPCam ()")
}
var ip string = ""
str := ReadFile(path)
j := strings.Index(str, "@")
if j > -1 {
fmt.Println(j)
index := str[j+1 : j+20]
t := strings.Index(index, "@")
if t > -1 {
index := str[t+1 : t+15]
fmt.Println(index)
list_0 := strings.Split(index, ":")
ip = list_0[0]
} else {
fmt.Println(index)
list_0 := strings.Split(index, ":")
ip = list_0[0]
}
} else {
i := strings.Index(str, "192")
//fmt.Println("Index: ", i)
if i > -1 {
if Debug == 1 {
fmt.Println(str[i : i+15])
}
index := str[i : i+15]
list := strings.Split(index, ".")
//fmt.Println(list)
k := strings.Index(list[3], "\n")
if k > -1 {
x := strings.Split(list[3], "\n")
list[3] = x[0]
} else {
j := strings.Index(list[3], "/")
if j > -1 {
x := strings.Split(list[3], "/")
list[3] = x[0]
} else {
t := strings.Index(list[3], ":")
if t > -1 {
x := strings.Split(list[3], ":")
list[3] = x[0]
}
}
}
ip = list[0]
for i := 1; i < 4; i++ {
if Debug == 1 {
fmt.Printf("%v_", list[i])
}
ip = ip + "." + list[i]
}
} else {
file.Write_log("cam_id not found", Path_log_engine)
fmt.Println("cam_id not found")
}
}
return ip
}
var stt_serverlocal = 0
var number_run_fr = 0
func STTServerFR() {
if Debug == 1 {
fmt.Println("Function STTServerSocket ()")
}
for i := 0; i < len(message.Data.Engines); i++ {
if message.Data.Engines[i].Active == 1 {
//var cmd string = "ps -A | grep " + message.Data.Engines[i].Name
// var cmd string = "pidof node" // message.Data.Engines[i].Name
var cmd string = "ps -ef | grep socket.js"
out, err := exec.Command("sh", "-c", cmd).Output()
file.Println("=======================")
file.Println(string(out))
res := strings.Contains(string(out), "node ./socket.js")
// fmt.Println(res)
file.Println("=======================")
if err != nil {
fmt.Println(err)
file.Write_log("STTServerSocket () "+err.Error(), Path_log_engine)
}
if res == false {
fmt.Printf("STTServerSocket isn't running\n")
file.Write_log("STTServerSocket isn't running\n", Path_log_engine)
KillFaceDedect()
RunServerFR(message.Data.Engines[i].Name)
time.Sleep(5000)
} else {
number_run_fr = 0
fmt.Printf("STTServerSocket is running\n")
}
} else {
fmt.Println("Engine setting off on engine.json")
}
}
}
func RunServerFR(name string) {
fmt.Println("Function RunEngine ()")
number_run_fr = number_run_fr + 1
if number_run_fr > 25 {
time.Sleep(10000)
// RebootBox()
number_run_fr = 0
file.Write_log(" number_run_fr engine > 25 ----> reset count_number=0 && not reset ", Path_log_engine)
} else {
//while true; do /home/beetsoft/Desktop/face_recognition_20190308/build/FaceRecognition/FaceRecognition ;done
// FaceRecognition/FaceRecognition ../data/Config.txt > /dev/null 2>&1 &
//var cmd = "cd " + path_base + "/engine/" + name + "/build/ && " + "screen -dm -S Engine " + name + "/" + name + " ../data/Config.txt > /dev/null 2>&1 &"
//var cmd = "export DISPLAY=:0&&export OPENBLAS_NUM_THREADS=1&&cd " + path_base + "/engine/" + name + "/build/ " + "&& " + name + "/" + name + " " + name + "/data/Config.txt > /dev/null 2>&1 &"
var cmd = "export DISPLAY=:0&&export OPENBLAS_NUM_THREADS=1&&cd " + path_base + "/engine/" + name + "/sever_socket/" + "&&node ./socket.js > /dev/null 2>&1 &"
if Debug == 1 {
fmt.Println("cmd run RunServerFR", cmd)
}
out, err := exec.Command("sh", "-c", cmd).Output()
if err != nil {
//log.Fatal(err)
stt_serverlocal = 0
file.Write_log("RunServerFR () "+err.Error(), Path_log_engine)
fmt.Printf("RunServerFR() not run \n")
} else {
fmt.Printf("RunServerFR() ok \n")
file.Write_log("RunServerFR() ok \n", Path_log_engine)
stt_serverlocal = 1
//RunEngine(name)
var out1 = string(out)
fmt.Printf(out1)
}
}
}
func RunEngine(name string) {
fmt.Println("Function RunEngine ()")
number_run = number_run + 1
if number_run > 25 {
time.Sleep(10000)
// RebootBox()
number_run = 0
file.Write_log(" Number run engine > 25 ----> reset count_number=0 && not reset ", Path_log_engine)
} else {
//while true; do /home/beetsoft/Desktop/face_recognition_20190308/build/FaceRecognition/FaceRecognition ;done
// FaceRecognition/FaceRecognition ../data/Config.txt > /dev/null 2>&1 &
//var cmd = "cd " + path_base + "/engine/" + name + "/build/ && " + "screen -dm -S Engine " + name + "/" + name + " ../data/Config.txt > /dev/null 2>&1 &"
//var cmd = "export DISPLAY=:0&&export OPENBLAS_NUM_THREADS=1&&cd " + path_base + "/engine/" + name + "/build/ " + "&& " + name + "/" + name + " " + name + "/data/Config.txt > /dev/null 2>&1 &"
var cmd = "export DISPLAY=:0&&export OPENBLAS_NUM_THREADS=1&&cd " + path_base + "/engine/" + name + "/build/ " + "&& " + name + "/" + name + " ../data/Config.txt > /dev/null 2>&1 &"
//var cmd = "export DISPLAY=:0&&export OPENBLAS_NUM_THREADS=1&&cd " + path_base + "/engine/" + name + "/build/ " + "&& " + name + "/" + name + " ../data/Config.txt > /home/admin/monitor/log/logEngine.txt &"
if Debug == 1 {
fmt.Println("cmd run engine", cmd)
}
out, err := exec.Command("sh", "-c", cmd).Output()
if err != nil {
//log.Fatal(err)
engine_status = 1
file.Write_log("RunEngine () "+err.Error(), Path_log_engine)
fmt.Printf("RunEngine() not run \n")
} else {
fmt.Printf("RunEngine() ok \n")
file.Write_log("RunEngine() ok \n", Path_log_engine)
engine_status = 0
var out1 = string(out)
fmt.Printf(out1)
}
}
}
func RebootBox() {
fmt.Println("Function RebootBox()")
_, err := exec.Command("sh", "-c", "reboot").Output()
if err == nil {
file.Write_log("RebootBox()", Path_log_luncher)
}
fmt.Println("End Function RebootBox()")
}
func Sleep_ms(ms time.Duration) {
time.Sleep(time.Millisecond * ms) // sleep(nano second)
}
// Thao tac file
func CreateLogfile(path string) {
fmt.Println("Function CreateLogfile ()")
// detect if file exists
var _, err = os.Stat(path)
// create file if not exists
if os.IsNotExist(err) {
var file, err = os.Create(path)
if err != nil {
fmt.Println(err)
//file.Write_log("CreateLogfile() "+err.Error(), Path_log_engine)
}
defer file.Close()
}
fmt.Println("==> done creating file", path)
}
// func file.file.Write_log(msg string, path string) {
// fmt.Println("Function file.Write_log ()")
// // open file using READ & WRITE permission
// // fmt.Println("==>begin writting ")
// var file, err = os.OpenFile(path, os.O_RDWR|os.O_APPEND, 0777)
// if err != nil {
// fmt.Println(err)
// file.Write_log("file.Write_log 1 () "+err.Error(), Path_log_engine)
// }
// defer file.Close()
// _, err = file.WriteString(time.Now().String())
// if err != nil {
// fmt.Println(err)
// file.Write_log("file.Write_log 2 () "+err.Error(), Path_log_engine)
// }
// // write some text line-by-line to file
// _, err = file.WriteString("\n")
// if err != nil {
// fmt.Println(err)
// file.Write_log("file.Write_log 3 () "+err.Error(), Path_log_engine)
// }
// _, err = file.WriteString("Service Check_engine : " + msg)
// if err != nil {
// fmt.Println(err)
// file.Write_log("file.Write_log 4 () "+err.Error(), Path_log_engine)
// }
// _, err = file.WriteString("\n")
// if err != nil {
// fmt.Println(err)
// file.Write_log("file.Write_log 5 () "+err.Error(), Path_log_engine)
// }
// // save changes
// err = file.Sync()
// if err != nil {
// fmt.Println(err)
// file.Write_log("file.Write_log 6 () "+err.Error(), Path_log_engine)
// }
// //fmt.Println("==> done writing to file")
// }
// func readFile(path string) string {
// if Debug == 1 {
// fmt.Println("Function readFile ()")
// }
// // re-open file
// var msg string = ""
// var file, err = os.OpenFile(path, os.O_RDWR, 0644)
// if err != nil {
// //file.Write_log("readFile 1 () "+err.Error(), Path_log_engine)
// time_start = time_start_defaut
// time_end = time_end_defaut
// } else {
// defer file.Close()
// // read file, line by line
// var text = make([]byte, 1024)
// for {
// _, err = file.Read(text)
// // break if finally arrived at end of file
// if err == io.EOF {
// //file.Write_log("readFile 2() "+err.Error(), Path_log_engine)
// //break
// }
// // break if error occured
// if err != nil && err != io.EOF {
// //file.Write_log("readFile 3() "+err.Error(), Path_log_engine)
// //break
// }
// }
// //fmt.Println(string(text))
// msg = string(text)
// }
// fmt.Println(time_start)
// fmt.Println(time_end)
// fmt.Println("read file done")
// return msg
// }
func DeleteFile(path string) {
fmt.Println("Function DeleteFile ()")
// delete file
var err = os.Remove(path)
if err != nil {
fmt.Println(err)
file.Write_log("DeleteFile () "+err.Error(), Path_log_engine)
}
fmt.Println("==> done deleting file")
}
func IsError(err error) bool {
//fmt.Println("Function IsError ()")
if err != nil {
fmt.Println(err.Error())
}
return (err != nil)
}
func ReadFile(path string) string {
if Debug == 1 {
fmt.Println("Function ReadFile ()")
}
// re-open file
var msg string = ""
var file, err = os.OpenFile(path, os.O_RDWR, 0644)
if err != nil {
fmt.Println(" Open file error")
//file.Write_log("ReadFile 1 () "+err.Error(), Path_log_engine)
}
defer file.Close()
// read file, line by line
var text = make([]byte, 2048)
for {
_, err = file.Read(text)
// break if finally arrived at end of file
if err == io.EOF {
//file.Write_log("ReadFile 2 () "+err.Error(), Path_log_engine)
break
}
// break if error occured
if err != nil && err != io.EOF {
//file.Write_log("ReadFile 3 () "+err.Error(), Path_log_engine)
break
}
}
msg = string(text)
//fmt.Println(msg)
return msg
}