156 lines
2.9 KiB
Go
156 lines
2.9 KiB
Go
package event_sender_go
|
|
|
|
import (
|
|
"context"
|
|
"google.golang.org/grpc"
|
|
//"git.loafle.net/overflow/agent_api/observer/messages"
|
|
pb "git.loafle.net/overflow/crawler_go/grpc"
|
|
|
|
"git.loafle.net/overflow/agent_api/messages"
|
|
q "git.loafle.net/overflow/queue_go"
|
|
"log"
|
|
"reflect"
|
|
"sync"
|
|
)
|
|
|
|
var (
|
|
instance *EventSender
|
|
once sync.Once
|
|
)
|
|
|
|
const (
|
|
CENTRAL_ADDR = "192.168.1.105:50052"
|
|
SENDER_ID = "OVERFLOW_EVENT_SENDER"
|
|
DEFAULT_INTERVAL = 1
|
|
)
|
|
|
|
type Data struct {
|
|
AgentId string
|
|
SensorId string
|
|
Data map[string]string
|
|
StartedAt uint64
|
|
FinishedAt uint64
|
|
}
|
|
|
|
func GetInstance() *EventSender {
|
|
once.Do(func() {
|
|
instance = &EventSender{}
|
|
})
|
|
return instance
|
|
}
|
|
|
|
//func init() {
|
|
// ch := make(chan interface{}, 0)
|
|
// ch1 := make(chan interface{}, 0)
|
|
// observer.Add(messages.CFG_LOADED, ch)
|
|
// observer.Add(messages.SCF_STOPPED, ch1)
|
|
// handleInit(ch, ch1)
|
|
//}
|
|
//
|
|
//func handleInit(ch chan interface{}, ch1 chan interface{}) {
|
|
// es := GetInstance()
|
|
// go func() {
|
|
// data := <-ch
|
|
// log.Println("handleInit", data)
|
|
// //ds.gconf = data.(cm.ConfigManager).GetGlobalConfig()
|
|
// es.start()
|
|
// observer.Remove(messages.CFG_LOADED, ch)
|
|
// }()
|
|
//
|
|
// go func() {
|
|
// data := <-ch1
|
|
// observer.Notify(messages.QUEUE_EVENT, data)
|
|
// time.Sleep(2 * time.Second)
|
|
// es.Stop()
|
|
// }()
|
|
//}
|
|
|
|
func Start(ch chan bool) (err error) {
|
|
es := GetInstance()
|
|
|
|
es.start()
|
|
|
|
ch <- true
|
|
return nil
|
|
}
|
|
|
|
func Stop() (err error) {
|
|
es := GetInstance()
|
|
es.stop()
|
|
return nil
|
|
}
|
|
func AddEventData(event interface{}) {
|
|
es := GetInstance()
|
|
es.lq.PushItem(event)
|
|
}
|
|
|
|
type EventSender struct {
|
|
once sync.Once
|
|
lq *q.LoafleQueue
|
|
sc chan interface{}
|
|
}
|
|
|
|
func (es *EventSender) start() {
|
|
es.sc = make(chan interface{}, 0)
|
|
|
|
es.lq = q.NewQueue(DEFAULT_INTERVAL, es.sc)
|
|
|
|
go es.checkQueue()
|
|
}
|
|
|
|
func (es *EventSender) stop() {
|
|
if es.sc != nil {
|
|
es.lq.Close()
|
|
close(es.sc)
|
|
es.sc = nil
|
|
}
|
|
}
|
|
|
|
func (es *EventSender) checkQueue() {
|
|
|
|
result := make([]*messages.Event, 0)
|
|
|
|
for sc := range es.sc {
|
|
items := reflect.ValueOf(sc)
|
|
if items.Kind() != reflect.Slice {
|
|
log.Println("ddddd")
|
|
}
|
|
|
|
for i := 0; i < items.Len(); i++ {
|
|
item := items.Index(i).Elem().Interface()
|
|
tempCollectedData := item.(q.Item)
|
|
collectedData := tempCollectedData.Value.(messages.Event)
|
|
//collectedData.AgentId = agentIdentifier()
|
|
result = append(result, &collectedData)
|
|
//log.Println("Result Len: ", len(result))
|
|
}
|
|
//es.send(result)
|
|
result = nil
|
|
}
|
|
|
|
}
|
|
|
|
func (es *EventSender) send(data []*messages.Event) {
|
|
log.Println("Send Started")
|
|
conn, err := grpc.Dial(CENTRAL_ADDR, grpc.WithInsecure())
|
|
|
|
if err != nil {
|
|
log.Fatal("Connection Error :", err.Error())
|
|
return
|
|
}
|
|
defer conn.Close()
|
|
|
|
client := pb.NewStatusClient(conn)
|
|
out, err := client.Status(context.Background(), &pb.Empty{})
|
|
|
|
if err != nil {
|
|
log.Fatal("client Error:", err.Error())
|
|
return
|
|
}
|
|
log.Print(out)
|
|
}
|
|
|
|
func agentIdentifier() string {
|
|
return "agentID_000000001"
|
|
}
|