qixiaoning
2025-08-26 7799d5acb4a25526625b3e99c2f7fd71d1be39ff
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package models
 
import (
    "basic.com/pubsub/protomsg.git"
    "basic.com/valib/logger.git"
    "github.com/gogo/protobuf/proto"
    "nanomsg.org/go-mangos"
    "nanomsg.org/go-mangos/protocol/req"
    "nanomsg.org/go-mangos/transport/ipc"
    "nanomsg.org/go-mangos/transport/tcp"
    "strconv"
    "time"
    "vamicro/config"
)
 
var syncSdkCompareCacheChan = make(chan []byte, 512)
 
func PublishSdkCompareCacheChange(b []byte) {
    syncSdkCompareCacheChan <- b
}
 
func InitSync() {
    go func() {
        logger.Debug("syncDbTablePerson:recv doUpdateCompareCacheRequest msg")
        var sock mangos.Socket
        var err error
        if sock, err = req.NewSocket(); err != nil {
            logger.Debug("comp cache can't new req socket:%s", err.Error())
            return
        }
        sock.AddTransport(ipc.NewTransport())
        sock.AddTransport(tcp.NewTransport())
        var url = "tcp://" + config.DbPersonCompare.Ip + ":" + strconv.Itoa(config.DbPersonCompare.Port)
        logger.Debug("doUpdateCompareCacheRequest url:", url)
        if err = sock.Dial(url); err != nil {
            logger.Debug("comp cache can't dial on req socket:%s", err.Error())
            return
        }
        sock.SetOption(mangos.OptionMaxRecvSize, 1024*1024*100)
        sock.SetOption(mangos.OptionRecvDeadline, time.Second*2)
        defer sock.Close()
 
        for {
            select {
            case b := <-syncSdkCompareCacheChan:
                logger.Debug("SyncSdkCompareCache in,len(b):", len(b))
                // doUpdateCompareCacheRequest(b)
                if err = sock.Send(b); err != nil {
                    logger.Debug("comp cache can't send message on push socket:%s", err.Error())
                    continue
                }
                if msg, err := sock.Recv(); err != nil {
                    logger.Debugf("comp cache sock.Recv receive err:%s\n", err.Error())
                    continue
                } else {
                    logger.Debug("comp cache sock.Recv msg:", string(msg))
                }
            }
        }
    }()
}
 
func SyncSdkCompareCache(analyServerId string, cacheChangeType protomsg.EsCacheChanged, tableId string, personId string, faceFeature string, dbAction protomsg.DbAction, enable int32, carNo string) {
    msg := protomsg.EsPersonCacheChange{
        Type:     cacheChangeType,
        TableId:  []string{tableId},
        PersonId: personId,
        Feature:  faceFeature,
        Action:   dbAction,
        Enable:   enable,
        CarNo:    carNo,
    }
    b, err := proto.Marshal(&msg)
    logger.Debug("SyncSdkCompareCache proto.err:", err)
    if err != nil {
        return
    }
    logger.Debug("SyncSdkCompareCache analyServerId:", analyServerId)
 
    PublishSdkCompareCacheChange(b)
}
 
func doUpdateCompareCacheRequest(b []byte) {
    logger.Debug("syncDbTablePerson:recv doUpdateCompareCacheRequest msg")
    var sock mangos.Socket
    var err error
    if sock, err = req.NewSocket(); err != nil {
        logger.Debug("comp cache can't new req socket:%s", err.Error())
        return
    }
    sock.AddTransport(ipc.NewTransport())
    sock.AddTransport(tcp.NewTransport())
    var url = "tcp://" + config.DbPersonCompare.Ip + ":" + strconv.Itoa(config.DbPersonCompare.Port)
    logger.Debug("doUpdateCompareCacheRequest url:", url)
    if err = sock.Dial(url); err != nil {
        logger.Debug("comp cache can't dial on req socket:%s", err.Error())
        return
    }
    sock.SetOption(mangos.OptionMaxRecvSize, 1024*1024*100)
    sock.SetOption(mangos.OptionRecvDeadline, time.Second*2)
    if err = sock.Send(b); err != nil {
        logger.Debug("comp cache can't send message on push socket:%s", err.Error())
        return
    }
    if msg, err := sock.Recv(); err != nil {
        logger.Debug("comp cache sock.Recv receive err:%s", err.Error())
        return
    } else {
        logger.Debug("comp cache sock.Recv msg:", string(msg))
    }
    sock.Close()
}
 
func ReInitDbPersonCompareData() {
    logger.Debug("加入集群后重新初始化底库比对数据")
    var sock mangos.Socket
    var err error
    if sock, err = req.NewSocket(); err != nil {
        logger.Debug("ReInitDbPersonCompareData can't new req socket:%s", err.Error())
        return
    }
    sock.AddTransport(ipc.NewTransport())
    sock.AddTransport(tcp.NewTransport())
    var url = "tcp://" + config.DbPersonCompare.Ip + ":" + strconv.Itoa(config.DbPersonCompare.Port)
    if err = sock.Dial(url); err != nil {
        logger.Debug("ReInitDbPersonCompareData can't dial on req socket:%s", err.Error())
        return
    }
    sock.SetOption(mangos.OptionMaxRecvSize, 1024*1024)
    //sock.SetOption(mangos.OptionRecvDeadline, time.Second*10)
    msg := protomsg.CompareEvent{
        EventType: protomsg.CompareEventType_ReInitCache,
        Payload:   []byte(""),
    }
    b, err := proto.Marshal(&msg)
    if err != nil {
        logger.Debug("ReInitDbPersonCompareData msg marshal err", err)
    }
    if err = sock.Send(b); err != nil {
        logger.Debug("ReInitDbPersonCompareData can't send message on push socket:%s", err.Error())
        return
    }
    if msg, err := sock.Recv(); err != nil {
        logger.Debug("ReInitDbPersonCompareData sock.Recv receive err:%s", err.Error())
        return
    } else {
        logger.Debug("ReInitDbPersonCompareData sock.Recv msg:", string(msg))
    }
    sock.Close()
}