235 lines
7.0 KiB
Go
235 lines
7.0 KiB
Go
package stream
|
|
|
|
import (
|
|
"context"
|
|
"crypto/subtle"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"oc-discovery/daemons/node/common"
|
|
|
|
oclib "cloud.o-forge.io/core/oc-lib"
|
|
"cloud.o-forge.io/core/oc-lib/dbs"
|
|
"cloud.o-forge.io/core/oc-lib/models/booking/planner"
|
|
"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"
|
|
)
|
|
|
|
type Verify struct {
|
|
IsVerified bool `json:"is_verified"`
|
|
}
|
|
|
|
func (ps *StreamService) handleEvent(protocol string, evt *common.Event) error {
|
|
fmt.Println("handleEvent")
|
|
ps.handleEventFromPartner(evt, protocol)
|
|
/*if protocol == ProtocolVerifyResource {
|
|
if evt.DataType == -1 {
|
|
tools.NewNATSCaller().SetNATSPub(tools.VERIFY_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Method: int(tools.VERIFY_RESOURCE),
|
|
Payload: evt.Payload,
|
|
})
|
|
} else if err := ps.verifyResponse(evt); err != nil {
|
|
return err
|
|
}
|
|
}*/
|
|
if protocol == ProtocolSendPlanner {
|
|
if err := ps.sendPlanner(evt); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if protocol == ProtocolSearchResource && evt.DataType > -1 {
|
|
if err := ps.retrieveResponse(evt); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if protocol == ProtocolConsidersResource {
|
|
if err := ps.pass(evt, tools.PB_CONSIDERS); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if protocol == ProtocolAdmiraltyConfigResource {
|
|
if err := ps.pass(evt, tools.PB_ADMIRALTY_CONFIG); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if protocol == ProtocolMinioConfigResource {
|
|
if err := ps.pass(evt, tools.PB_MINIO_CONFIG); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return errors.New("no action authorized available : " + protocol)
|
|
}
|
|
|
|
func (abs *StreamService) verifyResponse(event *common.Event) error { //
|
|
res, err := resources.ToResource(int(event.DataType), event.Payload)
|
|
if err != nil || res == nil {
|
|
return nil
|
|
}
|
|
verify := Verify{
|
|
IsVerified: false,
|
|
}
|
|
access := oclib.NewRequestAdmin(oclib.LibDataEnum(event.DataType), nil)
|
|
data := access.LoadOne(res.GetID())
|
|
if data.Err == "" && data.Data != nil {
|
|
if b, err := json.Marshal(data.Data); err == nil {
|
|
if res2, err := resources.ToResource(int(event.DataType), b); err == nil {
|
|
verify.IsVerified = subtle.ConstantTimeCompare(res.GetSignature(), res2.GetSignature()) == 1
|
|
}
|
|
}
|
|
}
|
|
if b, err := json.Marshal(verify); err == nil {
|
|
abs.PublishCommon(nil, "", event.From, ProtocolVerifyResource, b)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (abs *StreamService) sendPlanner(event *common.Event) error { //
|
|
if len(event.Payload) == 0 {
|
|
if plan, err := planner.GenerateShallow(&tools.APIRequest{Admin: true}); err == nil {
|
|
if b, err := json.Marshal(plan); err == nil {
|
|
abs.PublishCommon(nil, event.User, event.From, ProtocolSendPlanner, b)
|
|
} else {
|
|
return err
|
|
}
|
|
} else {
|
|
m := map[string]interface{}{}
|
|
if err := json.Unmarshal(event.Payload, &m); err == nil {
|
|
m["peer_id"] = event.From
|
|
if pl, err := json.Marshal(m); err == nil {
|
|
if b, err := json.Marshal(tools.PropalgationMessage{
|
|
DataType: -1,
|
|
Action: tools.PB_PLANNER,
|
|
Payload: pl,
|
|
}); err == nil {
|
|
go tools.NewNATSCaller().SetNATSPub(tools.PROPALGATION_EVENT, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.DataType(oclib.BOOKING),
|
|
Method: int(tools.PROPALGATION_EVENT),
|
|
Payload: b,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (abs *StreamService) retrieveResponse(event *common.Event) error { //
|
|
res, err := resources.ToResource(int(event.DataType), event.Payload)
|
|
if err != nil || res == nil {
|
|
return nil
|
|
}
|
|
b, err := json.Marshal(res.Serialize(res))
|
|
go tools.NewNATSCaller().SetNATSPub(tools.SEARCH_EVENT, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.DataType(event.DataType),
|
|
Method: int(tools.SEARCH_EVENT),
|
|
Payload: b,
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (abs *StreamService) pass(event *common.Event, action tools.PubSubAction) error { //
|
|
if b, err := json.Marshal(&tools.PropalgationMessage{
|
|
Action: action,
|
|
DataType: int(event.DataType),
|
|
Payload: event.Payload,
|
|
}); err == nil {
|
|
go tools.NewNATSCaller().SetNATSPub(tools.PROPALGATION_EVENT, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.DataType(event.DataType),
|
|
Method: int(tools.PROPALGATION_EVENT),
|
|
Payload: b,
|
|
})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ps *StreamService) handleEventFromPartner(evt *common.Event, protocol string) error {
|
|
switch protocol {
|
|
case ProtocolSearchResource:
|
|
m := map[string]interface{}{}
|
|
err := json.Unmarshal(evt.Payload, &m)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if search, ok := m["search"]; ok {
|
|
access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
|
|
peers := access.Search(&dbs.Filters{
|
|
And: map[string][]dbs.Filter{
|
|
"peer_id": {{Operator: dbs.EQUAL.String(), Value: evt.From}},
|
|
},
|
|
}, evt.From, false)
|
|
if len(peers.Data) > 0 {
|
|
p := peers.Data[0].(*peer.Peer)
|
|
fmt.Println(evt.From, p.GetID(), peers.Data)
|
|
|
|
ps.SendResponse(p, evt, fmt.Sprintf("%v", search))
|
|
} else if p, err := ps.Node.GetPeerRecord(context.Background(), evt.From, false); err == nil && len(p) > 0 { // peer from is peerID
|
|
ps.SendResponse(p[0], evt, fmt.Sprintf("%v", search))
|
|
}
|
|
} else {
|
|
fmt.Println("SEND SEARCH_EVENT SetNATSPub", m)
|
|
go tools.NewNATSCaller().SetNATSPub(tools.SEARCH_EVENT, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.DataType(evt.DataType),
|
|
Method: int(tools.SEARCH_EVENT),
|
|
Payload: evt.Payload,
|
|
})
|
|
}
|
|
case ProtocolCreateResource, ProtocolUpdateResource:
|
|
fmt.Println("RECEIVED Protocol.Update")
|
|
go tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.DataType(evt.DataType),
|
|
Method: int(tools.CREATE_RESOURCE),
|
|
Payload: evt.Payload,
|
|
})
|
|
case ProtocolDeleteResource:
|
|
go tools.NewNATSCaller().SetNATSPub(tools.REMOVE_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.DataType(evt.DataType),
|
|
Method: int(tools.REMOVE_RESOURCE),
|
|
Payload: evt.Payload,
|
|
})
|
|
default:
|
|
return errors.New("no action authorized available : " + protocol)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (abs *StreamService) SendResponse(p *peer.Peer, event *common.Event, search string) error {
|
|
dts := []tools.DataType{tools.DataType(event.DataType)}
|
|
if event.DataType == -1 { // expect all resources
|
|
dts = []tools.DataType{
|
|
tools.COMPUTE_RESOURCE,
|
|
tools.STORAGE_RESOURCE,
|
|
tools.PROCESSING_RESOURCE,
|
|
tools.DATA_RESOURCE,
|
|
tools.WORKFLOW_RESOURCE,
|
|
}
|
|
}
|
|
if self, err := oclib.GetMySelf(); err != nil {
|
|
return err
|
|
} else {
|
|
for _, dt := range dts {
|
|
access := oclib.NewRequestAdmin(oclib.LibDataEnum(dt), nil)
|
|
peerID := p.GetID()
|
|
searched := access.Search(abs.FilterPeer(self.GetID(), search), "", false)
|
|
fmt.Println("SEND SEARCH_EVENT", self.GetID(), dt, len(searched.Data), peerID)
|
|
for _, ss := range searched.Data {
|
|
if j, err := json.Marshal(ss); err == nil {
|
|
_, err := abs.PublishCommon(&dt, event.User, p.PeerID, ProtocolSearchResource, j)
|
|
fmt.Println("Publish ERR", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|