430 lines
9.7 KiB
Go
430 lines
9.7 KiB
Go
package dht
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"oc-discovery/conf"
|
|
"oc-discovery/daemons"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
oclib "cloud.o-forge.io/core/oc-lib"
|
|
pp "cloud.o-forge.io/core/oc-lib/models/peer"
|
|
"cloud.o-forge.io/core/oc-lib/models/utils"
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|
"github.com/google/uuid"
|
|
"github.com/libp2p/go-libp2p"
|
|
dht "github.com/libp2p/go-libp2p-kad-dht"
|
|
kad_dht "github.com/libp2p/go-libp2p-kad-dht"
|
|
"github.com/libp2p/go-libp2p/core/crypto"
|
|
"github.com/libp2p/go-libp2p/core/host"
|
|
"github.com/libp2p/go-libp2p/core/peer"
|
|
)
|
|
|
|
type DHTRecord struct {
|
|
Name string `json:"name"`
|
|
State int `json:"state"`
|
|
DID string `json:"did"`
|
|
PeerID string `json:"peer_id"`
|
|
PubKey []byte `json:"pub_key"`
|
|
URL string `json:"url"`
|
|
NATSUrl string `json:"nats_url"`
|
|
Wallet string `json:"wallet"`
|
|
Signature []byte `json:"signature"`
|
|
ExpiryDate time.Time `json:"expiry_date"`
|
|
}
|
|
|
|
type DHTService struct {
|
|
Key string
|
|
Host host.Host
|
|
DHT *dht.IpfsDHT
|
|
Cache []string
|
|
mutex sync.RWMutex
|
|
}
|
|
|
|
// TODO kick connection to base... and send on NATS boy
|
|
var dhtSingletonService *DHTService
|
|
|
|
func GetDHTService() *DHTService {
|
|
return dhtSingletonService
|
|
}
|
|
|
|
func Init(ctx context.Context) (*DHTService, error) {
|
|
service := &DHTService{}
|
|
priv, err := daemons.LoadKeyFromFile(false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
psk, err := daemons.LoadPSKFromFile()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
h, err := libp2p.New(
|
|
libp2p.PrivateNetwork(psk),
|
|
libp2p.Identity(priv),
|
|
libp2p.ListenAddrStrings(
|
|
fmt.Sprintf("/ip4/0.0.0.0/tcp/%d", conf.GetConfig().DHTEndpointPort),
|
|
),
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
service.Host = h
|
|
service.DHT, err = kad_dht.New(ctx, h, kad_dht.MaxRecordAge(24*time.Hour)) // every day DHT will purge expired data... if not used.
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = service.DHT.Bootstrap(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, address := range strings.Split(conf.GetConfig().BootstrapAddresses, ",") {
|
|
pi, err := peer.AddrInfoFromString(address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
logger := oclib.GetLogger()
|
|
if err := h.Connect(ctx, *pi); err != nil {
|
|
logger.Err(fmt.Errorf("Failed to connect to MAIN bootstrap peer %s: %s", pi.ID, err))
|
|
} else {
|
|
logger.Info().Msg(fmt.Sprintf("Connected to MAIN bootstrap peer %s", pi.ID))
|
|
}
|
|
}
|
|
|
|
dhtSingletonService = service
|
|
if daemons.VerifyPubWithPriv() {
|
|
if _, err := dhtSingletonService.ClaimName(context.Background(),
|
|
conf.GetConfig().Name,
|
|
conf.GetConfig().Hostname, false); err == nil {
|
|
go service.Heartbeat(ctx, 2*time.Minute)
|
|
go service.RefreshKeys(ctx, 30*time.Minute)
|
|
}
|
|
}
|
|
|
|
return service, nil
|
|
}
|
|
|
|
func (d *DHTService) Heartbeat(ctx context.Context, interval time.Duration) {
|
|
ticker := time.NewTicker(interval)
|
|
go func() {
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
dhtSingletonService.ClaimName(context.Background(), conf.GetConfig().Name, conf.GetConfig().Hostname, true)
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (d *DHTService) RefreshKeys(ctx context.Context, interval time.Duration) {
|
|
ticker := time.NewTicker(interval)
|
|
go func() {
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
s := []string{}
|
|
d.mutex.Lock()
|
|
s = append(s, d.Cache...)
|
|
d.mutex.Unlock()
|
|
for _, key := range s {
|
|
_, _ = d.GetValue(ctx, key)
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (d *DHTService) PutValue(
|
|
ctx context.Context,
|
|
key string,
|
|
value []byte,
|
|
) error {
|
|
err := d.DHT.PutValue(ctx, key, value)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.mutex.Lock()
|
|
if !slices.Contains(d.Cache, key) {
|
|
d.Cache = append(d.Cache, key)
|
|
}
|
|
d.mutex.Unlock()
|
|
return nil
|
|
}
|
|
|
|
func (d *DHTService) GetValue(
|
|
ctx context.Context,
|
|
key string,
|
|
) (*DHTRecord, error) {
|
|
dht, err := d.DHT.GetValue(ctx, key)
|
|
if err != nil {
|
|
cache := []string{}
|
|
d.mutex.Lock()
|
|
for _, c := range d.Cache {
|
|
if c != key {
|
|
cache = append(cache, c)
|
|
}
|
|
}
|
|
d.Cache = cache
|
|
d.mutex.Unlock()
|
|
return nil, err
|
|
}
|
|
d.mutex.Lock()
|
|
if !slices.Contains(d.Cache, key) {
|
|
d.Cache = append(d.Cache, key)
|
|
}
|
|
d.mutex.Unlock()
|
|
var data DHTRecord
|
|
json.Unmarshal(dht, &data)
|
|
|
|
peerID, err := oclib.GenerateNodeID()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p := &pp.Peer{
|
|
AbstractObject: utils.AbstractObject{
|
|
UUID: uuid.New().String(),
|
|
Name: data.Name,
|
|
},
|
|
State: pp.ONLINE,
|
|
Relation: pp.SELF,
|
|
PeerID: peerID,
|
|
PublicKey: string(data.PubKey),
|
|
Url: data.URL,
|
|
NATSUrl: oclib.GetConfig().NATSUrl,
|
|
WalletAddress: data.Wallet,
|
|
}
|
|
b, err := json.Marshal(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.PEER,
|
|
Method: int(tools.CREATE_PEER),
|
|
Payload: b,
|
|
})
|
|
|
|
/*if founded, _, err := access.Search(nil, fmt.Sprintf("%v", pp.SELF.EnumIndex()), false);
|
|
err == nil && len(founded) > 0 && founded[0].(*pp.Peer).Relation != pp.BLACKLIST {
|
|
f.(*pp.Peer).State = pp.ONLINE
|
|
f.(*pp.Peer).NATSUrl = p.NATSUrl
|
|
f.(*pp.Peer).Url = p.Url
|
|
f.(*pp.Peer).PeerID = p.PeerID
|
|
f.(*pp.Peer).Relation = p.Relation
|
|
f.(*pp.Peer).WalletAddress = p.WalletAddress
|
|
access.UpdateOne(f, f.GetID())
|
|
}*/
|
|
|
|
return &data, err
|
|
}
|
|
|
|
func (d *DHTService) generateKey() (string, error) {
|
|
s, err := oclib.GenerateNodeID()
|
|
if err != nil {
|
|
return s, err
|
|
}
|
|
return "/opencloud/peer/" + s, nil
|
|
}
|
|
|
|
// Create your peer.
|
|
func (d *DHTService) ClaimName(
|
|
ctx context.Context,
|
|
name string,
|
|
endPoint string,
|
|
avoidVerification bool,
|
|
) (*pp.Peer, error) {
|
|
if endPoint == "" {
|
|
return nil, errors.New("no endpoint found for peer" + name)
|
|
}
|
|
|
|
peerID, err := oclib.GenerateNodeID()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
pub := d.Host.Peerstore().PubKey(d.Host.ID())
|
|
pubBytes, _ := pub.Raw()
|
|
|
|
now := time.Now()
|
|
expiry := now.Add(150 * time.Second)
|
|
|
|
rec := DHTRecord{
|
|
Name: name,
|
|
PeerID: peerID,
|
|
PubKey: pubBytes,
|
|
}
|
|
|
|
payload, _ := json.Marshal(rec)
|
|
sig, _ := daemons.Sign(d.Host.Peerstore().PrivKey(d.Host.ID()), payload)
|
|
rec.Signature = sig
|
|
|
|
rec.URL = endPoint
|
|
rec.NATSUrl = oclib.GetConfig().NATSUrl
|
|
rec.State = pp.ONLINE.EnumIndex()
|
|
rec.ExpiryDate = expiry
|
|
|
|
data, _ := json.Marshal(rec)
|
|
|
|
key, err := d.generateKey()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// retrieve your key name in standard
|
|
if !avoidVerification {
|
|
old, err := d.GetValue(ctx, key)
|
|
if err == nil {
|
|
if old.PeerID != peerID { // check if someone claims your name before
|
|
return nil, errors.New("name already claimed by another peer")
|
|
}
|
|
if now.After(old.ExpiryDate) {
|
|
payload, _ := json.Marshal(rec)
|
|
d.PutValue(ctx, key, payload)
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := d.PutValue(ctx, key, data); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
pubStr := base64.StdEncoding.EncodeToString(pubBytes)
|
|
d.Key = key
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
p := &pp.Peer{
|
|
AbstractObject: utils.AbstractObject{
|
|
UUID: uuid.New().String(),
|
|
Name: name,
|
|
},
|
|
State: pp.ONLINE,
|
|
Relation: pp.SELF,
|
|
PeerID: peerID,
|
|
PublicKey: pubStr,
|
|
Url: endPoint,
|
|
NATSUrl: oclib.GetConfig().NATSUrl,
|
|
WalletAddress: "my-wallet",
|
|
}
|
|
|
|
b, err := json.Marshal(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.PEER,
|
|
Method: int(tools.CREATE_PEER),
|
|
Payload: b,
|
|
})
|
|
return p, nil
|
|
}
|
|
|
|
// Discover a specific Peer
|
|
func (d *DHTService) DiscoverPeers(ctx context.Context, name string) ([]*pp.Peer, error) {
|
|
peers := []*pp.Peer{}
|
|
key, err := d.generateKey()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
datas, _ := d.DHT.SearchValue(ctx, key)
|
|
for data := range datas {
|
|
var dht *DHTRecord
|
|
if err := json.Unmarshal(data, dht); err != nil {
|
|
return peers, err
|
|
}
|
|
if p, err := d.treatPeer(ctx, key, dht); err == nil {
|
|
peers = append(peers, p)
|
|
}
|
|
}
|
|
return peers, nil
|
|
}
|
|
|
|
func (d *DHTService) GetPeer(ctx context.Context, name string) (*pp.Peer, error) {
|
|
key, err := d.generateKey()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
data, err := d.GetValue(ctx, key)
|
|
if err != nil {
|
|
return nil, errors.New("no DHT peer not found")
|
|
}
|
|
return d.treatPeer(ctx, key, data)
|
|
}
|
|
|
|
func (d *DHTService) treatPeer(ctx context.Context, key string, rec *DHTRecord) (*pp.Peer, error) {
|
|
pubKey, err := crypto.UnmarshalPublicKey(rec.PubKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
now := time.Now()
|
|
dht := DHTRecord{
|
|
Name: rec.Name,
|
|
PeerID: rec.PeerID,
|
|
PubKey: rec.PubKey,
|
|
}
|
|
payload, _ := json.Marshal(dht)
|
|
|
|
if ok, _ := daemons.Verify(pubKey, payload, rec.Signature); !ok {
|
|
return nil, errors.New("invalid signature")
|
|
}
|
|
pubBytes, _ := pubKey.Raw()
|
|
pubStr := base64.StdEncoding.EncodeToString(pubBytes)
|
|
|
|
rel := pp.NONE
|
|
if d.Key == key {
|
|
rel = pp.SELF
|
|
}
|
|
|
|
p := &pp.Peer{
|
|
AbstractObject: utils.AbstractObject{
|
|
UUID: uuid.New().String(),
|
|
Name: rec.Name,
|
|
},
|
|
State: pp.ONLINE,
|
|
Relation: rel,
|
|
PeerID: rec.PeerID,
|
|
PublicKey: pubStr,
|
|
Url: rec.URL,
|
|
NATSUrl: rec.NATSUrl,
|
|
WalletAddress: rec.Wallet,
|
|
}
|
|
if now.After(rec.ExpiryDate) { // is expired
|
|
rec.State = pp.OFFLINE.EnumIndex()
|
|
p.State = pp.OFFLINE
|
|
payload, _ := json.Marshal(rec)
|
|
d.PutValue(ctx, key, payload)
|
|
|
|
b, err := json.Marshal(p)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
tools.NewNATSCaller().SetNATSPub(tools.CREATE_RESOURCE, tools.NATSResponse{
|
|
FromApp: "oc-discovery",
|
|
Datatype: tools.PEER,
|
|
Method: int(tools.CREATE_PEER),
|
|
Payload: b,
|
|
})
|
|
return nil, errors.New("peer " + key + " is expired")
|
|
}
|
|
if p.State == pp.OFFLINE {
|
|
return nil, errors.New("peer " + key + " is offline")
|
|
}
|
|
return p, nil
|
|
}
|
|
|
|
// TODO : HEARTBEAT
|