128 lines
3.3 KiB
Go
128 lines
3.3 KiB
Go
package node
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"oc-discovery/daemons/node/common"
|
|
"oc-discovery/daemons/node/stream"
|
|
|
|
oclib "cloud.o-forge.io/core/oc-lib"
|
|
"cloud.o-forge.io/core/oc-lib/config"
|
|
"cloud.o-forge.io/core/oc-lib/models/peer"
|
|
"cloud.o-forge.io/core/oc-lib/models/resources"
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|
pp "github.com/libp2p/go-libp2p/core/peer"
|
|
)
|
|
|
|
func ListenNATS(n *Node) {
|
|
tools.NewNATSCaller().ListenNats(map[tools.NATSMethod]func(tools.NATSResponse){
|
|
tools.VERIFY_RESOURCE: func(resp tools.NATSResponse) {
|
|
if resp.FromApp == config.GetAppName() {
|
|
return
|
|
}
|
|
if res, err := resources.ToResource(resp.Datatype.EnumIndex(), resp.Payload); err == nil {
|
|
access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
|
|
p := access.LoadOne(res.GetCreatorID())
|
|
realP := p.ToPeer()
|
|
if realP == nil {
|
|
return
|
|
} else if realP.Relation == peer.SELF {
|
|
pubKey, err := common.PubKeyFromString(realP.PublicKey) // extract pubkey from pubkey str
|
|
if err != nil {
|
|
return
|
|
}
|
|
ok, _ := pubKey.Verify(resp.Payload, res.GetSignature())
|
|
if b, err := json.Marshal(stream.Verify{
|
|
IsVerified: ok,
|
|
}); err == nil {
|
|
tools.NewNATSCaller().SetNATSPub(tools.VERIFY_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Method: int(tools.VERIFY_RESOURCE),
|
|
Payload: b,
|
|
})
|
|
}
|
|
} else if realP.Relation != peer.BLACKLIST {
|
|
n.StreamService.PublishVerifyResources(&resp.Datatype, resp.User, realP.PeerID, resp.Payload)
|
|
}
|
|
}
|
|
},
|
|
tools.CREATE_PEER: func(resp tools.NATSResponse) {
|
|
if resp.FromApp == config.GetAppName() {
|
|
return
|
|
}
|
|
logger := oclib.GetLogger()
|
|
m := map[string]interface{}{}
|
|
err := json.Unmarshal(resp.Payload, &m)
|
|
if err != nil {
|
|
logger.Err(err)
|
|
return
|
|
}
|
|
p := &peer.Peer{}
|
|
p = p.Deserialize(m, p).(*peer.Peer)
|
|
|
|
ad, err := pp.AddrInfoFromString(p.PeerID)
|
|
if err != nil {
|
|
return
|
|
}
|
|
n.StreamService.Mu.Lock()
|
|
defer n.StreamService.Mu.Unlock()
|
|
|
|
n.Mu.Lock()
|
|
n.Peers[ad.ID] = p.State == peer.ONLINE
|
|
n.Mu.Unlock()
|
|
|
|
if p.Relation == peer.PARTNER {
|
|
n.StreamService.ConnectToPartner(ad.ID, ad)
|
|
} else {
|
|
ps := common.ProtocolStream{}
|
|
for p, s := range n.StreamService.Streams {
|
|
m := map[pp.ID]*common.Stream{}
|
|
for k := range s {
|
|
if ad.ID != k {
|
|
m[k] = s[k]
|
|
} else {
|
|
s[k].Stream.Close()
|
|
}
|
|
}
|
|
ps[p] = m
|
|
}
|
|
n.StreamService.Streams = ps
|
|
}
|
|
|
|
},
|
|
tools.PROPALGATION_EVENT: func(resp tools.NATSResponse) {
|
|
var propalgation tools.PropalgationMessage
|
|
err := json.Unmarshal(resp.Payload, &propalgation)
|
|
var dt *tools.DataType
|
|
if propalgation.DataType > 0 {
|
|
dtt := tools.DataType(propalgation.DataType)
|
|
dt = &dtt
|
|
}
|
|
if err == nil {
|
|
switch propalgation.Action {
|
|
case tools.PB_CREATE:
|
|
case tools.PB_UPDATE:
|
|
case tools.PB_DELETE:
|
|
n.StreamService.ToPartnerPublishEvent(
|
|
context.Background(),
|
|
propalgation.Action,
|
|
dt, resp.User,
|
|
propalgation.Payload,
|
|
)
|
|
case tools.PB_SEARCH:
|
|
m := map[string]interface{}{}
|
|
json.Unmarshal(propalgation.Payload, &m)
|
|
n.PubSubService.SearchPublishEvent(
|
|
context.Background(),
|
|
dt,
|
|
fmt.Sprintf("%v", m["type"]),
|
|
resp.User,
|
|
fmt.Sprintf("%v", m["search"]),
|
|
)
|
|
}
|
|
}
|
|
},
|
|
})
|
|
}
|