oc-discovery/daemons/node/stream/handler.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/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:
		if evt.DataType < 0 {
			access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
			peers := access.Search(nil, evt.From, false)
			if len(peers.Data) > 0 {
				p := peers.Data[0].(*peer.Peer)
				// TODO : something if peer is missing in our side !
				ps.SendResponse(p, evt)
			} else if p, err := ps.Node.GetPeerRecord(context.Background(), evt.From); err == nil && len(p) > 0 { // peer from is peerID
				ps.SendResponse(p[0], evt)
			}
		}
	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) error {
	dts := []oclib.LibDataEnum{oclib.LibDataEnum(event.DataType)}
	if event.DataType == -1 { // expect all resources
		dts = []oclib.LibDataEnum{
			oclib.LibDataEnum(oclib.COMPUTE_RESOURCE),
			oclib.LibDataEnum(oclib.STORAGE_RESOURCE),
			oclib.LibDataEnum(oclib.PROCESSING_RESOURCE),
			oclib.LibDataEnum(oclib.DATA_RESOURCE),
			oclib.LibDataEnum(oclib.WORKFLOW_RESOURCE)}
	}
	var m map[string]string
	err := json.Unmarshal(event.Payload, &m)
	if err != nil {
		return err
	}
	for _, dt := range dts {
		access := oclib.NewRequestAdmin(oclib.LibDataEnum(event.DataType), nil)
		peerID := p.GetID()
		searched := access.Search(abs.FilterPeer(peerID, m["search"]), "", false)
		for _, ss := range searched.Data {
			if j, err := json.Marshal(ss); err == nil {
				if event.DataType != -1 {
					ndt := tools.DataType(dt.EnumIndex())
					abs.PublishCommon(&ndt, event.User, peerID, ProtocolSearchResource, j)
				} else {
					abs.PublishCommon(nil, event.User, peerID, ProtocolSearchResource, j)
				}
			}
		}
	}
	return nil
}