294 lines
9.4 KiB
Go
294 lines
9.4 KiB
Go
package main
|
|
|
|
|
|
|
|
|
|
func main() {
|
|
//LOAD FROM DOTENV VARS
|
|
//err := godotenv.Load()
|
|
//if err != nil {
|
|
// fmt.Printf("Ошибка чтения .env файла %s", err)
|
|
//}
|
|
// === Logger Example [Using Sentry!] ===
|
|
//logger := logger2.NewLoggerAndExceptionHandler()
|
|
//logger.Info("Hello World")
|
|
//logger.Fatal("Fatal Msg")
|
|
|
|
// === Device status example [Using Redis!] ===
|
|
//ctx := context.Background()
|
|
//redisClient := redis.NewClient(&redis.Options{
|
|
// Addr: "localhost:6379",
|
|
//})
|
|
//ds := device_status.NewDeviceStatus(redisClient)
|
|
//err := ds.SetOnline(ctx, "device_1")
|
|
//if err != nil {
|
|
// fmt.Printf("Error while set online: %s", err)
|
|
//}
|
|
//status, err := ds.GetOnline(ctx, "device_1")
|
|
//if err != nil {
|
|
// fmt.Printf("Error while set offline: %s", err)
|
|
//}
|
|
//fmt.Printf("Device status: %s", status)
|
|
//err = ds.SetOffline(ctx, "device_1")
|
|
//if err != nil {
|
|
// panic(err)
|
|
//}
|
|
|
|
/* DB TEST */
|
|
//database := databases.NewDatabase()
|
|
//// Example query
|
|
//rows, err := database.Query("SELECT * FROM users")
|
|
//if err != nil {
|
|
// log.Fatal(err)
|
|
//}
|
|
//// Process rows
|
|
//for rows.Next() {
|
|
// var id int
|
|
// var name string
|
|
// if err := rows.Scan(&id, &name); err != nil {
|
|
// log.Fatal(err)
|
|
// }
|
|
// fmt.Println(id, name)
|
|
//}
|
|
//database.Close()
|
|
|
|
// /* Clickhouse */
|
|
//ch := databases.NewClickhouse()
|
|
//err := ch.InitDB()
|
|
//if err != nil {
|
|
// log.Fatal(err)
|
|
//}
|
|
//
|
|
//go func() {
|
|
// for {
|
|
// time.Sleep(time.Second)
|
|
//
|
|
// for table, data := range ch.TablesQueues {
|
|
// if len(data) >= ch.NeedCountForTable[table] {
|
|
// err := ch.FlushQueue(table)
|
|
// if err != nil {
|
|
// log.Println("Error flushing queue:", err)
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//}()
|
|
//
|
|
//// Example usage:
|
|
//data := []interface{}{"1", "2", "3"}
|
|
//err = ch.Insert("device_traffic", data)
|
|
//if err != nil {
|
|
// log.Println("Error inserting data:", err)
|
|
//}
|
|
|
|
/* Request controller */
|
|
//rc := lib.NewRequestController()
|
|
//devID := "1#1"
|
|
//data := map[string]interface{}{
|
|
// "k": "v",
|
|
//}
|
|
//ts := time.Now()
|
|
//
|
|
//rc.WriteLog(devID, data, ts)
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
//var libraries = map[string]interface{}{
|
|
// "version": "./lib/data_libs.go/version",
|
|
// "gps": "./lib/data_libs.go/gps",
|
|
// "modemd_info": "./lib/data_libs.go/modemd_info",
|
|
// "traffic": "./lib/data_libs.go/traffic",
|
|
// "system_interfaces": "./lib/data_libs.go/system_interfaces",
|
|
// "hardware_status": "./lib/data_libs.go/hardware_status",
|
|
// "multilinks": "./lib/data_libs.go/multilinks",
|
|
// "iface_state": "./lib/data_libs.go/iface_state",
|
|
// "backup_state": "./lib/data_libs.go/backup_state",
|
|
// "mm_config": "./lib/data_libs.go/config",
|
|
// "log": "./lib/data_libs.go/log",
|
|
// "lora": "./lib/data_libs.go/lora",
|
|
// "rstat": "./lib/data_libs.go/rstat",
|
|
//}
|
|
//
|
|
//func main() {
|
|
// log := logger.NewLoggerAndExceptionHandler()
|
|
// log.Info("Start \"monitoring_consumer\" process")
|
|
//
|
|
// rabbitMQ := lib.NewRabbitMQ()
|
|
// requestController := lib.NewRequestController()
|
|
// deviceRegistry := lib.NewDeviceRegistry(requestController)
|
|
//
|
|
// err := rabbitMQ.Connect()
|
|
// if err != nil {
|
|
// log.Error(fmt.Sprintf("RabbitMQ connection error: %v", err))
|
|
// os.Exit(1)
|
|
// }
|
|
//
|
|
// readyFlag := rabbitMQ.ReadyCheck()
|
|
// if !readyFlag {
|
|
// log.Error(fmt.Sprintf("RabbitMQ not ready: %v", err))
|
|
// os.Exit(1)
|
|
// }
|
|
//
|
|
// go dataQueueConsumer(rabbitMQ, deviceRegistry, requestController)
|
|
// go regQueueConsumer(rabbitMQ, deviceRegistry, requestController)
|
|
// // T__EXECUTOR
|
|
// //if os.Getenv("NODE_TASK_PARSER") != "DISABLE" {
|
|
// // taskExecutor := newT (requestController, rabbitMQ, deviceRegistry)
|
|
// // go rpcQueueConsumer(rabbitMQ, taskExecutor, deviceRegistry)
|
|
// //} else {
|
|
// // logger_and_exception_handler.Info("Task parsing and sender disable by env variable")
|
|
// //}
|
|
//
|
|
// select {}
|
|
//}
|
|
//
|
|
//func dataQueueConsumer(rabbitMQ *lib.RabbitMQ, deviceRegistry *interface{}, requestController *lib.RequestController) {
|
|
// rabbitMQ.Consume(rabbitMQ.DataQueue, "data_queue", func(msg []byte, contentType string) {
|
|
// if contentType == "application/zlib" {
|
|
// buffer, err := base64.StdEncoding.DecodeString(string(msg))
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Error(fmt.Sprintf("[DATA QUEUE] Error decoding base64: %v", err))
|
|
// return
|
|
// }
|
|
//
|
|
// zlibReader, err := zlib.NewReader(bytes.NewReader(buffer))
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Error(fmt.Sprintf("[DATA QUEUE] Error then zlib unpack: %v", err))
|
|
// return
|
|
// }
|
|
// defer zlibReader.Close()
|
|
//
|
|
// unzippedData, err := io.ReadAll(zlibReader)
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Error(fmt.Sprintf("[DATA QUEUE] Error reading unzipped data: %v", err))
|
|
// return
|
|
// }
|
|
//
|
|
// var packets []map[string]interface{}
|
|
// err = json.Unmarshal(unzippedData, &packets)
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Error(fmt.Sprintf("[DATA QUEUE] Unknown error: %v\n%s", err, unzippedData))
|
|
// return
|
|
// }
|
|
//
|
|
// for _, packet := range packets {
|
|
// parsePacket(packet, deviceRegistry, requestController)
|
|
// }
|
|
// } else {
|
|
// var packet map[string]interface{}
|
|
// err := json.Unmarshal(msg, &packet)
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Warning(fmt.Sprintf("%s\n%v\n%v", msg, err.Error(), err))
|
|
// return
|
|
// }
|
|
// parsePacket(packet, deviceRegistry, requestController)
|
|
// }
|
|
// })
|
|
//}
|
|
//
|
|
//func regQueueConsumer(rabbitMQ *lib.RabbitMQ, deviceRegistry *interface{}, requestController *lib.RequestController) {
|
|
// rabbitMQ.Consume(rabbitMQ.RegQueue, "reg_queue", func(msg []byte) {
|
|
// var info map[string]interface{}
|
|
// err := json.Unmarshal(msg, &info)
|
|
// if err != nil {
|
|
// logger_and_exception_handler.SentryCaptureException(err)
|
|
// return
|
|
// }
|
|
//
|
|
// findDevice, err := deviceRegistry.FindDevice(info["mid"].(string))
|
|
// if err != nil {
|
|
// logger_and_exception_handler.SentryCaptureException(err)
|
|
// return
|
|
// }
|
|
//
|
|
// if findDevice == nil {
|
|
// query := `INSERT INTO device(\` + "`desc`, `group_id`, `mid`, `serial`, `add_ts`, `fid`)" +
|
|
// "SELECT \" \", 0, ?, ?, ?, CONCAT('00', first_available_fid) " +
|
|
// "FROM (" +
|
|
// "SELECT IFNULL(MIN(fid_numeric) + 1, 1) AS first_available_fid " +
|
|
// "FROM (" +
|
|
// "SELECT CAST(SUBSTRING(fid, 3) AS UNSIGNED) AS fid_numeric " +
|
|
// "FROM device WHERE fid LIKE '00%' " +
|
|
// "UNION ALL SELECT 0 AS fid_numeric) AS subquery " +
|
|
// "WHERE fid_numeric + 1 NOT IN (SELECT CAST(SUBSTRING(fid, 3) AS UNSIGNED) FROM device WHERE fid LIKE '00%') " +
|
|
// "UNION SELECT 1 AS first_available_fid FROM device WHERE NOT EXISTS (SELECT * FROM device WHERE fid LIKE '00%')) AS subquery;`
|
|
//
|
|
// _, err := requestController.MySQL.Query(query, info["mid"], info["data"].(map[string]interface{})["serial"], time.Now().Unix())
|
|
// if err != nil {
|
|
// logger_and_exception_handler.SentryCaptureException(err)
|
|
// return
|
|
// }
|
|
//
|
|
// findDevice, err = deviceRegistry.FindDevice(info["mid"].(string))
|
|
// if err != nil {
|
|
// logger_and_exception_handler.SentryCaptureException(err)
|
|
// return
|
|
// }
|
|
// }
|
|
//
|
|
// deviceRegistry.CheckOnline(findDevice)
|
|
// deviceRegistry.WriteMMAgentData(findDevice.DeviceID, info["data"].(map[string]interface{})["uptime"], info["data"].(map[string]interface{})["queue_size"])
|
|
// requestController.STOMP.SendMessage("device_update_main", findDevice.DeviceID, map[string]interface{}{
|
|
// "action": "UPDATE",
|
|
// "subtopic": "device_update_main",
|
|
// })
|
|
// })
|
|
//}
|
|
//
|
|
//func rpcQueueConsumer(rabbitMQ *lib.RabbitMQ, deviceRegistry *interface{}, requestController *lib.RequestController) {
|
|
// rabbitMQ.Consume(rabbitMQ.RPCQueue, "rpc_queue", func(msg []byte) {
|
|
// var packet map[string]interface{}
|
|
// err := json.Unmarshal(msg, &packet)
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Warning(fmt.Sprintf("%s\n%v\n%v", msg, err.Error(), err))
|
|
// return
|
|
// }
|
|
//
|
|
// findDevice, err := deviceRegistry.FindDevice(packet["mid"].(string))
|
|
// if err != nil {
|
|
// logger_and_exception_handler.Warning(fmt.Sprintf("%s\n%v\n%v", msg, err.Error(), err))
|
|
// return
|
|
// }
|
|
//
|
|
// deviceRegistry.CheckOnline(findDevice)
|
|
// taskExecutor.TaskParse(packet)
|
|
// })
|
|
//}
|
|
//
|
|
//func parsePacket(packet map[string]interface{}, deviceRegistry *interface{}, requestController *request_controller.RequestController) {
|
|
// if packetType, ok := packet["type"].(string); ok {
|
|
// lib, exists := libraries[packetType]
|
|
// if !exists {
|
|
// logger_and_exception_handler.Warning(fmt.Sprintf("[DATA QUEUE] Undefined type in message - %v", packet))
|
|
// return
|
|
// }
|
|
//
|
|
// findDevice, err := deviceRegistry.FindDevice(packet["mid"].(string))
|
|
// if err != nil || findDevice == nil {
|
|
// logger_and_exception_handler.Warning(fmt.Sprintf("[DATA QUEUE] DEVICE %s not found in database. Return task in queue", packet["mid"]))
|
|
// return
|
|
// }
|
|
//
|
|
// deviceRegistry.CheckOnline(findDevice)
|
|
// requestController.WriteLog(findDevice.DeviceID, packet, time.Now().Unix())
|
|
//
|
|
// if ts, ok := packet["ts"].(int64); ok && ts < 157784630 {
|
|
// packet["ts"] = time.Now().Unix() - ts
|
|
// }
|
|
//
|
|
// lib.GetPacket(requestController, packet["data"].([]interface{})[0], findDevice.DeviceID, packet["ts"].(int64))
|
|
// } else {
|
|
// logger_and_exception_handler.Warning(fmt.Sprintf("[DATA QUEUE] PACKAGE %v doesn't have 'type' param", packet))
|
|
// }
|
|
//}
|
|
//
|
|
//func init() {
|
|
// go func() {
|
|
// for {
|
|
// device_registry.GlobalUpdateTsSync()
|
|
// time.Sleep(10 * time.Second)
|
|
// }
|
|
// }()
|
|
//}
|