731 lines
21 KiB
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
|
|
}
|