454 lines
9.9 KiB
Go
454 lines
9.9 KiB
Go
package service
|
|
|
|
import (
|
|
json2 "encoding/json"
|
|
"fmt"
|
|
"time"
|
|
|
|
model2 "github.com/IceWhaleTech/CasaOS/model"
|
|
"github.com/IceWhaleTech/CasaOS/model/notify"
|
|
"github.com/IceWhaleTech/CasaOS/service/model"
|
|
"github.com/IceWhaleTech/CasaOS/types"
|
|
"github.com/ambelovsky/gosf"
|
|
socketio "github.com/googollee/go-socket.io"
|
|
"github.com/gorilla/websocket"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var NotifyMsg chan notify.Message
|
|
var ClientCount int = 0
|
|
|
|
type NotifyServer interface {
|
|
GetLog(id string) model.AppNotify
|
|
AddLog(log model.AppNotify)
|
|
UpdateLog(log model.AppNotify)
|
|
UpdateLogByCustomId(log model.AppNotify)
|
|
DelLog(id string)
|
|
GetList(c int) (list []model.AppNotify)
|
|
MarkRead(id string, state int)
|
|
// SendText(m model.AppNotify)
|
|
SendUninstallAppBySocket(app notify.Application)
|
|
SendNetInfoBySocket(netList []model2.IOCountersStat)
|
|
SendCPUInfoBySocket(cpu map[string]interface{})
|
|
SendMemInfoBySocket(mem map[string]interface{})
|
|
SendFileOperateNotify(nowSend bool)
|
|
SendInstallAppBySocket(app notify.Application)
|
|
SendAllHardwareStatusBySocket(mem map[string]interface{}, cpu map[string]interface{}, netList []model2.IOCountersStat)
|
|
SendStorageBySocket(message notify.StorageMessage)
|
|
SendNotify(path string, message map[string]interface{})
|
|
SettingSystemTempData(message map[string]interface{})
|
|
GetSystemTempMap() map[string]interface{}
|
|
}
|
|
|
|
type notifyServer struct {
|
|
db *gorm.DB
|
|
SystemTempMap map[string]interface{}
|
|
}
|
|
|
|
func (i *notifyServer) SettingSystemTempData(message map[string]interface{}) {
|
|
for k, v := range message {
|
|
i.SystemTempMap[k] = v
|
|
}
|
|
}
|
|
|
|
func (i *notifyServer) SendNotify(path string, message map[string]interface{}) {
|
|
msg := gosf.Message{}
|
|
msg.Body = message
|
|
msg.Success = true
|
|
msg.Text = path
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = path
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
|
|
}
|
|
|
|
func (i *notifyServer) SendStorageBySocket(message notify.StorageMessage) {
|
|
body := make(map[string]interface{})
|
|
body["data"] = message
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "storage_status"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "storage_status"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
}
|
|
func (i *notifyServer) SendAllHardwareStatusBySocket(mem map[string]interface{}, cpu map[string]interface{}, netList []model2.IOCountersStat) {
|
|
|
|
body := make(map[string]interface{})
|
|
|
|
body["sys_mem"] = mem
|
|
|
|
body["sys_cpu"] = cpu
|
|
|
|
body["sys_net"] = netList
|
|
|
|
for k, v := range i.SystemTempMap {
|
|
body[k] = v
|
|
}
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "sys_hardware_status"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "sys_hardware_status"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
|
|
}
|
|
|
|
// Send periodic broadcast messages
|
|
func (i *notifyServer) SendFileOperateNotify(nowSend bool) {
|
|
|
|
if nowSend {
|
|
|
|
len := 0
|
|
FileQueue.Range(func(k, v interface{}) bool {
|
|
len++
|
|
return true
|
|
})
|
|
|
|
model := notify.NotifyModel{}
|
|
listMsg := make(map[string]interface{})
|
|
if len == 0 {
|
|
model.Data = []string{}
|
|
|
|
listMsg["file_operate"] = model
|
|
msg := gosf.Message{}
|
|
msg.Success = true
|
|
msg.Body = listMsg
|
|
msg.Text = "file_operate"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "file_operate"
|
|
notify.Msg = msg
|
|
NotifyMsg <- notify
|
|
return
|
|
}
|
|
|
|
model.State = "NORMAL"
|
|
list := []notify.File{}
|
|
OpStrArrbak := OpStrArr
|
|
|
|
for _, v := range OpStrArrbak {
|
|
tempItem, ok := FileQueue.Load(v)
|
|
temp := tempItem.(model2.FileOperate)
|
|
if !ok {
|
|
continue
|
|
}
|
|
task := notify.File{}
|
|
task.Id = v
|
|
task.ProcessedSize = temp.ProcessedSize
|
|
task.TotalSize = temp.TotalSize
|
|
task.To = temp.To
|
|
task.Type = temp.Type
|
|
if task.ProcessedSize == 0 {
|
|
task.Status = "STARTING"
|
|
} else {
|
|
task.Status = "PROCESSING"
|
|
}
|
|
|
|
if temp.Finished || temp.ProcessedSize >= temp.TotalSize {
|
|
|
|
task.Finished = true
|
|
task.Status = "FINISHED"
|
|
FileQueue.Delete(v)
|
|
OpStrArr = OpStrArr[1:]
|
|
go ExecOpFile()
|
|
list = append(list, task)
|
|
continue
|
|
}
|
|
for _, v := range temp.Item {
|
|
if v.Size != v.ProcessedSize {
|
|
task.ProcessingPath = v.From
|
|
break
|
|
}
|
|
}
|
|
|
|
list = append(list, task)
|
|
}
|
|
model.Data = list
|
|
|
|
listMsg["file_operate"] = model
|
|
|
|
msg := gosf.Message{}
|
|
msg.Success = true
|
|
msg.Body = listMsg
|
|
msg.Text = "file_operate"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "file_operate"
|
|
notify.Msg = msg
|
|
NotifyMsg <- notify
|
|
} else {
|
|
for {
|
|
|
|
len := 0
|
|
FileQueue.Range(func(k, v interface{}) bool {
|
|
len++
|
|
return true
|
|
})
|
|
if len == 0 {
|
|
return
|
|
}
|
|
listMsg := make(map[string]interface{})
|
|
model := notify.NotifyModel{}
|
|
model.State = "NORMAL"
|
|
list := []notify.File{}
|
|
OpStrArrbak := OpStrArr
|
|
|
|
for _, v := range OpStrArrbak {
|
|
tempItem, ok := FileQueue.Load(v)
|
|
temp := tempItem.(model2.FileOperate)
|
|
if !ok {
|
|
continue
|
|
}
|
|
task := notify.File{}
|
|
task.Id = v
|
|
task.ProcessedSize = temp.ProcessedSize
|
|
task.TotalSize = temp.TotalSize
|
|
task.To = temp.To
|
|
task.Type = temp.Type
|
|
if task.ProcessedSize == 0 {
|
|
task.Status = "STARTING"
|
|
} else {
|
|
task.Status = "PROCESSING"
|
|
}
|
|
if temp.Finished || temp.ProcessedSize >= temp.TotalSize {
|
|
|
|
task.Finished = true
|
|
task.Status = "FINISHED"
|
|
FileQueue.Delete(v)
|
|
OpStrArr = OpStrArr[1:]
|
|
go ExecOpFile()
|
|
list = append(list, task)
|
|
continue
|
|
}
|
|
for _, v := range temp.Item {
|
|
if v.Size != v.ProcessedSize {
|
|
task.ProcessingPath = v.From
|
|
break
|
|
}
|
|
}
|
|
|
|
list = append(list, task)
|
|
}
|
|
model.Data = list
|
|
|
|
listMsg["file_operate"] = model
|
|
|
|
msg := gosf.Message{}
|
|
msg.Success = true
|
|
msg.Body = listMsg
|
|
msg.Text = "file_operate"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "file_operate"
|
|
notify.Msg = msg
|
|
NotifyMsg <- notify
|
|
time.Sleep(time.Second * 3)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func (i *notifyServer) SendMemInfoBySocket(mem map[string]interface{}) {
|
|
body := make(map[string]interface{})
|
|
body["data"] = mem
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "sys_mem"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "sys_mem"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
}
|
|
|
|
func (i *notifyServer) SendInstallAppBySocket(app notify.Application) {
|
|
body := make(map[string]interface{})
|
|
body["data"] = app
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "app_install"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "app_install"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
}
|
|
|
|
func (i *notifyServer) SendCPUInfoBySocket(cpu map[string]interface{}) {
|
|
body := make(map[string]interface{})
|
|
body["data"] = cpu
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "sys_cpu"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "sys_cpu"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
}
|
|
func (i *notifyServer) SendNetInfoBySocket(netList []model2.IOCountersStat) {
|
|
body := make(map[string]interface{})
|
|
body["data"] = netList
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "sys_net"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "sys_net"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
}
|
|
|
|
func (i *notifyServer) SendUninstallAppBySocket(app notify.Application) {
|
|
body := make(map[string]interface{})
|
|
body["data"] = app
|
|
|
|
msg := gosf.Message{}
|
|
msg.Body = body
|
|
msg.Success = true
|
|
msg.Text = "app_uninstall"
|
|
|
|
notify := notify.Message{}
|
|
notify.Path = "app_uninstall"
|
|
notify.Msg = msg
|
|
|
|
NotifyMsg <- notify
|
|
}
|
|
|
|
func (i *notifyServer) SSR() {
|
|
server := socketio.NewServer(nil)
|
|
fmt.Println(server)
|
|
}
|
|
|
|
func (i notifyServer) GetList(c int) (list []model.AppNotify) {
|
|
i.db.Where("class = ?", c).Where(i.db.Where("state = ?", types.NOTIFY_DYNAMICE).Or("state = ?", types.NOTIFY_UNREAD)).Find(&list)
|
|
return
|
|
}
|
|
|
|
func (i *notifyServer) AddLog(log model.AppNotify) {
|
|
i.db.Create(&log)
|
|
}
|
|
|
|
func (i *notifyServer) UpdateLog(log model.AppNotify) {
|
|
i.db.Save(&log)
|
|
}
|
|
func (i *notifyServer) UpdateLogByCustomId(log model.AppNotify) {
|
|
if len(log.CustomId) == 0 {
|
|
return
|
|
}
|
|
i.db.Model(&model.AppNotify{}).Select("*").Where("custom_id = ? ", log.CustomId).Updates(log)
|
|
}
|
|
func (i *notifyServer) GetLog(id string) model.AppNotify {
|
|
var log model.AppNotify
|
|
i.db.Where("custom_id = ? ", id).First(&log)
|
|
return log
|
|
}
|
|
func (i *notifyServer) MarkRead(id string, state int) {
|
|
if id == "0" {
|
|
i.db.Model(&model.AppNotify{}).Where("1 = ?", 1).Update("state", state)
|
|
return
|
|
}
|
|
i.db.Model(&model.AppNotify{}).Where("id = ? ", id).Update("state", state)
|
|
}
|
|
func (i *notifyServer) DelLog(id string) {
|
|
var log model.AppNotify
|
|
i.db.Where("custom_id = ?", id).Delete(&log)
|
|
}
|
|
|
|
func SendMeg() {
|
|
// for {
|
|
// mt, message, err := ws.ReadMessage()
|
|
// if err != nil {
|
|
// break
|
|
// }
|
|
// notify := model.NotifyMssage{}
|
|
// json2.Unmarshal(message, ¬ify)
|
|
// if notify.Type == "read" {
|
|
// service.MyService.Notify().MarkRead(notify.Data, types.NOTIFY_READ)
|
|
// }
|
|
// if notify.Type == "app" {
|
|
// go func(ws *websocket.Conn) {
|
|
|
|
for {
|
|
list := MyService.Notify().GetList(types.NOTIFY_APP)
|
|
json, _ := json2.Marshal(list)
|
|
|
|
if len(list) > 0 {
|
|
var temp []*websocket.Conn
|
|
for _, v := range WebSocketConns {
|
|
|
|
err := v.WriteMessage(1, json)
|
|
if err == nil {
|
|
temp = append(temp, v)
|
|
}
|
|
}
|
|
WebSocketConns = temp
|
|
for _, v := range list {
|
|
MyService.Notify().MarkRead(v.Id, types.NOTIFY_READ)
|
|
}
|
|
}
|
|
|
|
if len(WebSocketConns) == 0 {
|
|
SocketRun = false
|
|
}
|
|
time.Sleep(time.Second * 2)
|
|
}
|
|
// }(ws)
|
|
// }
|
|
// }
|
|
}
|
|
|
|
// func (i notifyServer) SendText(m model.AppNotify) {
|
|
// list := []model.AppNotify{}
|
|
// list = append(list, m)
|
|
// json, _ := json2.Marshal(list)
|
|
// var temp []*websocket.Conn
|
|
// for _, v := range WebSocketConns {
|
|
|
|
// err := v.WriteMessage(1, json)
|
|
// if err == nil {
|
|
// temp = append(temp, v)
|
|
// }
|
|
// }
|
|
// WebSocketConns = temp
|
|
|
|
// if len(WebSocketConns) == 0 {
|
|
// SocketRun = false
|
|
// }
|
|
|
|
// }
|
|
func (i *notifyServer) GetSystemTempMap() map[string]interface{} {
|
|
|
|
return i.SystemTempMap
|
|
|
|
}
|
|
func NewNotifyService(db *gorm.DB) NotifyServer {
|
|
return ¬ifyServer{db: db, SystemTempMap: make(map[string]interface{})}
|
|
}
|