338 lines
10 KiB
Go
338 lines
10 KiB
Go
package node
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"maps"
|
|
"oc-discovery/conf"
|
|
"oc-discovery/daemons/node/common"
|
|
"oc-discovery/daemons/node/indexer"
|
|
"oc-discovery/daemons/node/pubsub"
|
|
"oc-discovery/daemons/node/stream"
|
|
"sync"
|
|
"time"
|
|
|
|
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"
|
|
"github.com/google/uuid"
|
|
"github.com/libp2p/go-libp2p"
|
|
pubsubs "github.com/libp2p/go-libp2p-pubsub"
|
|
"github.com/libp2p/go-libp2p/core/crypto"
|
|
pp "github.com/libp2p/go-libp2p/core/peer"
|
|
"github.com/libp2p/go-libp2p/core/protocol"
|
|
)
|
|
|
|
type Node struct {
|
|
*common.LongLivedStreamRecordedService[interface{}] // change type of stream
|
|
PS *pubsubs.PubSub
|
|
IndexerService *indexer.IndexerService
|
|
PubSubService *pubsub.PubSubService
|
|
StreamService *stream.StreamService
|
|
PeerID pp.ID
|
|
isIndexer bool
|
|
peerRecord *indexer.PeerRecord
|
|
|
|
Mu sync.RWMutex
|
|
}
|
|
|
|
func InitNode(isNode bool, isIndexer bool, isNativeIndexer bool) (*Node, error) {
|
|
if !isNode && !isIndexer {
|
|
return nil, errors.New("wait... what ? your node need to at least something. Retry we can't be friend in that case")
|
|
}
|
|
logger := oclib.GetLogger()
|
|
logger.Info().Msg("retrieving private key...")
|
|
priv, err := tools.LoadKeyFromFilePrivate() // your node private key
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
logger.Info().Msg("retrieving psk file...")
|
|
psk, err := common.LoadPSKFromFile() // network common private Network. Public OC PSK is Public Network
|
|
if err != nil {
|
|
return nil, nil
|
|
}
|
|
logger.Info().Msg("open a host...")
|
|
h, err := libp2p.New(
|
|
libp2p.PrivateNetwork(psk),
|
|
libp2p.Identity(priv),
|
|
libp2p.ListenAddrStrings(
|
|
fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", conf.GetConfig().NodeEndpointPort),
|
|
),
|
|
)
|
|
logger.Info().Msg("Host open on " + h.ID().String())
|
|
if err != nil {
|
|
return nil, errors.New("no host no node")
|
|
}
|
|
node := &Node{
|
|
PeerID: h.ID(),
|
|
isIndexer: isIndexer,
|
|
LongLivedStreamRecordedService: common.NewStreamRecordedService[interface{}](h, 1000),
|
|
}
|
|
// Register the bandwidth probe handler so any peer measuring this node's
|
|
// throughput can open a dedicated probe stream and read the echo.
|
|
h.SetStreamHandler(common.ProtocolBandwidthProbe, common.HandleBandwidthProbe)
|
|
var ps *pubsubs.PubSub
|
|
if isNode {
|
|
logger.Info().Msg("generate opencloud node...")
|
|
ps, err = pubsubs.NewGossipSub(context.Background(), node.Host)
|
|
if err != nil {
|
|
panic(err) // can't run your node without a propalgation pubsub, of state of node.
|
|
}
|
|
node.PS = ps
|
|
// buildRecord returns a fresh signed PeerRecord as JSON, embedded in each
|
|
// heartbeat so the receiving indexer can republish it to the DHT directly.
|
|
// peerRecord is nil until claimInfo runs, so the first ~20s heartbeats carry
|
|
// no record — that's fine, claimInfo publishes once synchronously at startup.
|
|
buildRecord := func() json.RawMessage {
|
|
if node.peerRecord == nil {
|
|
return nil
|
|
}
|
|
priv, err := tools.LoadKeyFromFilePrivate()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
fresh := *node.peerRecord
|
|
fresh.PeerRecordPayload.ExpiryDate = time.Now().UTC().Add(2 * time.Minute)
|
|
payload, _ := json.Marshal(fresh.PeerRecordPayload)
|
|
fresh.Signature, err = priv.Sign(payload)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
b, _ := json.Marshal(fresh)
|
|
return json.RawMessage(b)
|
|
}
|
|
logger.Info().Msg("connect to indexers...")
|
|
common.ConnectToIndexers(node.Host, conf.GetConfig().MinIndexer, conf.GetConfig().MaxIndexer, node.PeerID, buildRecord)
|
|
logger.Info().Msg("claims my node...")
|
|
if _, err := node.claimInfo(conf.GetConfig().Name, conf.GetConfig().Hostname); err != nil {
|
|
panic(err)
|
|
}
|
|
logger.Info().Msg("subscribe to decentralized search flow...")
|
|
logger.Info().Msg("run garbage collector...")
|
|
node.StartGC(30 * time.Second)
|
|
|
|
if node.StreamService, err = stream.InitStream(context.Background(), node.Host, node.PeerID, 1000, node); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
if node.PubSubService, err = pubsub.InitPubSub(context.Background(), node.Host, node.PS, node, node.StreamService); err != nil {
|
|
panic(err)
|
|
}
|
|
f := func(ctx context.Context, evt common.Event, topic string) {
|
|
if p, err := node.GetPeerRecord(ctx, evt.From); err == nil && len(p) > 0 {
|
|
node.StreamService.SendResponse(p[0], &evt)
|
|
}
|
|
}
|
|
node.SubscribeToSearch(node.PS, &f)
|
|
logger.Info().Msg("connect to NATS")
|
|
go ListenNATS(node)
|
|
logger.Info().Msg("Node is actually running.")
|
|
}
|
|
if isIndexer {
|
|
logger.Info().Msg("generate opencloud indexer...")
|
|
node.IndexerService = indexer.NewIndexerService(node.Host, ps, 500, isNativeIndexer)
|
|
}
|
|
return node, nil
|
|
}
|
|
|
|
func (d *Node) Close() {
|
|
if d.isIndexer && d.IndexerService != nil {
|
|
d.IndexerService.Close()
|
|
}
|
|
d.PubSubService.Close()
|
|
d.StreamService.Close()
|
|
d.Host.Close()
|
|
}
|
|
|
|
func (d *Node) publishPeerRecord(
|
|
rec *indexer.PeerRecord,
|
|
) error {
|
|
priv, err := tools.LoadKeyFromFilePrivate() // your node private key
|
|
if err != nil {
|
|
return err
|
|
}
|
|
common.StreamMuIndexes.RLock()
|
|
indexerSnapshot := make([]*pp.AddrInfo, 0, len(common.StaticIndexers))
|
|
for _, ad := range common.StaticIndexers {
|
|
indexerSnapshot = append(indexerSnapshot, ad)
|
|
}
|
|
common.StreamMuIndexes.RUnlock()
|
|
|
|
for _, ad := range indexerSnapshot {
|
|
var err error
|
|
if common.StreamIndexers, err = common.TempStream(d.Host, *ad, common.ProtocolPublish, "", common.StreamIndexers, map[protocol.ID]*common.ProtocolInfo{},
|
|
&common.StreamMuIndexes); err != nil {
|
|
continue
|
|
}
|
|
stream := common.StreamIndexers[common.ProtocolPublish][ad.ID]
|
|
base := indexer.PeerRecordPayload{
|
|
Name: rec.Name,
|
|
DID: rec.DID,
|
|
PubKey: rec.PubKey,
|
|
ExpiryDate: time.Now().UTC().Add(2 * time.Minute),
|
|
}
|
|
payload, _ := json.Marshal(base)
|
|
rec.PeerRecordPayload = base
|
|
rec.Signature, err = priv.Sign(payload)
|
|
if err := json.NewEncoder(stream.Stream).Encode(&rec); err != nil { // then publish on stream
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d *Node) GetPeerRecord(
|
|
ctx context.Context,
|
|
pidOrdid string,
|
|
) ([]*peer.Peer, error) {
|
|
var err error
|
|
var info map[string]indexer.PeerRecord
|
|
common.StreamMuIndexes.RLock()
|
|
indexerSnapshot2 := make([]*pp.AddrInfo, 0, len(common.StaticIndexers))
|
|
for _, ad := range common.StaticIndexers {
|
|
indexerSnapshot2 = append(indexerSnapshot2, ad)
|
|
}
|
|
common.StreamMuIndexes.RUnlock()
|
|
|
|
// Build the GetValue request: if pidOrdid is neither a UUID DID nor a libp2p
|
|
// PeerID, treat it as a human-readable name and let the indexer resolve it.
|
|
getReq := indexer.GetValue{Key: pidOrdid}
|
|
isNameSearch := false
|
|
if pidR, pidErr := pp.Decode(pidOrdid); pidErr == nil {
|
|
getReq.PeerID = pidR
|
|
} else if _, uuidErr := uuid.Parse(pidOrdid); uuidErr != nil {
|
|
// Not a UUID DID → treat pidOrdid as a name substring search.
|
|
getReq.Name = pidOrdid
|
|
getReq.Key = ""
|
|
isNameSearch = true
|
|
}
|
|
|
|
for _, ad := range indexerSnapshot2 {
|
|
if common.StreamIndexers, err = common.TempStream(d.Host, *ad, common.ProtocolGet, "",
|
|
common.StreamIndexers, map[protocol.ID]*common.ProtocolInfo{}, &common.StreamMuIndexes); err != nil {
|
|
continue
|
|
}
|
|
stream := common.StreamIndexers[common.ProtocolGet][ad.ID]
|
|
if err := json.NewEncoder(stream.Stream).Encode(getReq); err != nil {
|
|
continue
|
|
}
|
|
var resp indexer.GetResponse
|
|
if err := json.NewDecoder(stream.Stream).Decode(&resp); err != nil {
|
|
continue
|
|
}
|
|
if resp.Found {
|
|
if info == nil {
|
|
info = resp.Records
|
|
} else {
|
|
// Aggregate results from all indexers for name searches.
|
|
maps.Copy(info, resp.Records)
|
|
}
|
|
// For exact lookups (PeerID / DID) stop at the first hit.
|
|
if !isNameSearch {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
var ps []*peer.Peer
|
|
for _, pr := range info {
|
|
if pk, err := pr.Verify(); err != nil {
|
|
return nil, err
|
|
} else if ok, p, err := pr.ExtractPeer(d.PeerID.String(), pr.PeerID, pk); err != nil {
|
|
return nil, err
|
|
} else {
|
|
if ok {
|
|
d.publishPeerRecord(&pr)
|
|
}
|
|
ps = append(ps, p)
|
|
}
|
|
}
|
|
|
|
return ps, err
|
|
}
|
|
|
|
func (d *Node) claimInfo(
|
|
name string,
|
|
endPoint string, // TODO : endpoint is not necesserry StreamAddress
|
|
) (*peer.Peer, error) {
|
|
if endPoint == "" {
|
|
return nil, errors.New("no endpoint found for peer")
|
|
}
|
|
did := uuid.New().String()
|
|
|
|
peers := oclib.NewRequestAdmin(oclib.LibDataEnum(oclib.PEER), nil).Search(&dbs.Filters{
|
|
And: map[string][]dbs.Filter{ // search by name if no filters are provided
|
|
"peer_id": {{Operator: dbs.EQUAL.String(), Value: d.Host.ID().String()}},
|
|
},
|
|
}, "", false)
|
|
if len(peers.Data) > 0 {
|
|
did = peers.Data[0].GetID() // if already existing set up did as made
|
|
}
|
|
priv, err := tools.LoadKeyFromFilePrivate()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pub, err := tools.LoadKeyFromFilePublic()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pubBytes, err := crypto.MarshalPublicKey(pub)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
now := time.Now().UTC()
|
|
expiry := now.Add(150 * time.Second)
|
|
|
|
pRec := indexer.PeerRecordPayload{
|
|
Name: name,
|
|
DID: did, // REAL PEER ID
|
|
PubKey: pubBytes,
|
|
ExpiryDate: expiry,
|
|
}
|
|
d.PeerID = d.Host.ID()
|
|
payload, _ := json.Marshal(pRec)
|
|
|
|
rec := &indexer.PeerRecord{
|
|
PeerRecordPayload: pRec,
|
|
}
|
|
rec.Signature, err = priv.Sign(payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rec.PeerID = d.Host.ID().String()
|
|
rec.APIUrl = endPoint
|
|
rec.StreamAddress = "/ip4/" + conf.GetConfig().Hostname + "/tcp/" + fmt.Sprintf("%v", conf.GetConfig().NodeEndpointPort) + "/p2p/" + rec.PeerID
|
|
rec.NATSAddress = oclib.GetConfig().NATSUrl
|
|
rec.WalletAddress = "my-wallet"
|
|
|
|
if err := d.publishPeerRecord(rec); err != nil {
|
|
return nil, err
|
|
}
|
|
d.peerRecord = rec
|
|
if _, err := rec.Verify(); err != nil {
|
|
return nil, err
|
|
} else {
|
|
_, p, err := rec.ExtractPeer(did, did, pub)
|
|
return p, err
|
|
}
|
|
}
|
|
|
|
/*
|
|
TODO:
|
|
- Le booking est un flow neuf décentralisé :
|
|
On check on attend une réponse, on valide, il passe par discovery, on relais.
|
|
- Le shared workspace est une affaire de décentralisation,
|
|
on communique avec les shared les mouvements
|
|
- Un shared remplace la notion de partnership à l'échelle de partnershipping
|
|
-> quand on share un workspace on devient partenaire temporaire
|
|
qu'on le soit originellement ou non.
|
|
-> on a alors les mêmes privilèges.
|
|
- Les orchestrations admiralty ont le même fonctionnement.
|
|
Un evenement provoque alors une création de clé de service.
|
|
|
|
On doit pouvoir crud avec verification de signature un DBobject.
|
|
*/
|