oc-discovery/daemons/node/stream/publish.go

package stream

import (
	"context"
	"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/peer"
	"cloud.o-forge.io/core/oc-lib/tools"
	pp "github.com/libp2p/go-libp2p/core/peer"
	"github.com/libp2p/go-libp2p/core/protocol"
)

func (ps *StreamService) PublishVerifyResources(dt *tools.DataType, user string, toPeerID string, resource []byte) (*common.Stream, error) {
	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
	p := access.LoadOne(toPeerID)
	if p.Err != "" {
		return nil, errors.New(p.Err)
	} else {
		ad, err := pp.AddrInfoFromString(p.Data.(*peer.Peer).StreamAddress)
		if err != nil {
			return nil, err
		}
		return ps.write(toPeerID, ad, dt, user, resource, ProtocolVerifyResource)
	}
}

func (ps *StreamService) PublishResources(dt *tools.DataType, user string, toPeerID string, resource []byte) error {
	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
	p := access.LoadOne(toPeerID)
	if p.Err != "" {
		return errors.New(p.Err)
	} else {
		ad, err := pp.AddrInfoFromString(p.Data.(*peer.Peer).StreamAddress)
		if err != nil {
			return err
		}
		ps.write(toPeerID, ad, dt, user, resource, ProtocolSearchResource)
	}
	return nil
}

func (ps *StreamService) SearchKnownPublishEvent(dt *tools.DataType, user string, search string) error {
	access := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil)
	peers := access.Search(&dbs.Filters{ // filter by like name, short_description, description, owner, url if no filters are provided
		And: map[string][]dbs.Filter{
			"": {{Operator: dbs.NOT.String(), Value: dbs.Filters{ // filter by like name, short_description, description, owner, url if no filters are provided
				And: map[string][]dbs.Filter{
					"relation": {{Operator: dbs.EQUAL.String(), Value: peer.BLACKLIST}},
				},
			}}},
		},
	}, search, false)
	if peers.Err != "" {
		return errors.New(peers.Err)
	} else {
		b, err := json.Marshal(map[string]string{"search": search})
		if err != nil {
			return err
		}
		for _, p := range peers.Data {
			ad, err := pp.AddrInfoFromString(p.(*peer.Peer).StreamAddress)
			if err != nil {
				continue
			}
			ps.write(p.GetID(), ad, dt, user, b, ProtocolSearchResource)
		}
	}
	return nil
}

func (ps *StreamService) SearchPartnersPublishEvent(dt *tools.DataType, user string, search string) error {
	if peers, err := ps.searchPeer(fmt.Sprintf("%v", peer.PARTNER.EnumIndex())); err != nil {
		return err
	} else {
		b, err := json.Marshal(map[string]string{"search": search})
		if err != nil {
			return err
		}
		for _, p := range peers {
			ad, err := pp.AddrInfoFromString(p.StreamAddress)
			if err != nil {
				continue
			}
			ps.write(p.GetID(), ad, dt, user, b, ProtocolSearchResource)
		}
	}
	return nil
}

func (ps *StreamService) ToPartnerPublishEvent(
	ctx context.Context, action tools.PubSubAction, dt *tools.DataType, user string, payload []byte) error {
	if *dt == tools.PEER {
		var p peer.Peer
		if err := json.Unmarshal(payload, &p); err != nil {
			return err
		}
		pid, err := pp.Decode(p.PeerID)
		if err != nil {
			return err
		}
		ps.Mu.Lock()
		defer ps.Mu.Unlock()
		if p.Relation == peer.PARTNER {
			if ps.Streams[ProtocolHeartbeatPartner] == nil {
				ps.Streams[ProtocolHeartbeatPartner] = map[pp.ID]*common.Stream{}
			}
			ps.ConnectToPartner(p.StreamAddress)
		} else if ps.Streams[ProtocolHeartbeatPartner] != nil && ps.Streams[ProtocolHeartbeatPartner][pid] != nil {
			for _, pids := range ps.Streams {
				if pids[pid] != nil {
					delete(pids, pid)
				}
			}
		}
		return nil
	}
	if peers, err := ps.searchPeer(fmt.Sprintf("%v", peer.PARTNER.EnumIndex())); err != nil {
		return err
	} else {
		for _, p := range peers {
			for protocol := range protocolsPartners {
				ad, err := pp.AddrInfoFromString(p.StreamAddress)
				if err != nil {
					continue
				}
				ps.write(p.GetID(), ad, dt, user, payload, protocol)
			}
		}
	}
	return nil
}

func (s *StreamService) write(
	did string,
	peerID *pp.AddrInfo,
	dt *tools.DataType,
	user string,
	payload []byte,
	proto protocol.ID) (*common.Stream, error) {
	logger := oclib.GetLogger()
	var err error
	// should create a very temp stream
	if s.Streams, err = common.TempStream(s.Host, *peerID, proto, did, s.Streams, &s.Mu); err != nil {
		return nil, errors.New("no stream available for protocol " + fmt.Sprintf("%v", proto) + " from PID " + peerID.ID.String())

	}
	stream := s.Streams[proto][peerID.ID]
	evt := common.NewEvent(string(proto), peerID.ID.String(), dt, user, payload)
	if err := json.NewEncoder(stream.Stream).Encode(evt); err != nil {
		stream.Stream.Close()
		logger.Err(err)
		return stream, nil
	}
	return stream, nil
}