sendnrw/netbird
2
0
Fork 0
mirror of https://github.com/netbirdio/netbird.git synced 2026-04-20 09:16:40 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
c6d16724fbccb1f7fe8a92ffc9af6c7b30182048
netbird/management/server/management_test.go
Pascal Fischer 3556d6a1fc disable suite test
2025-01-17 02:15:59 +01:00

534 lines
19 KiB
Go
Raw Blame History

package server_test
//
// import (
// "context"
// "math/rand"
// "net"
// "os"
// "runtime"
// "strconv"
// sync2 "sync"
// "time"
//
// pb "github.com/golang/protobuf/proto" //nolint
// . "github.com/onsi/ginkgo"
// . "github.com/onsi/gomega"
// log "github.com/sirupsen/logrus"
// "golang.zx2c4.com/wireguard/wgctrl/wgtypes"
// "google.golang.org/grpc"
// "google.golang.org/grpc/credentials/insecure"
// "google.golang.org/grpc/keepalive"
//
// "github.com/netbirdio/netbird/encryption"
// mgmtProto "github.com/netbirdio/netbird/management/proto"
// "github.com/netbirdio/netbird/management/server"
// "github.com/netbirdio/netbird/management/server/activity"
// "github.com/netbirdio/netbird/management/server/settings"
// "github.com/netbirdio/netbird/management/server/store"
// "github.com/netbirdio/netbird/management/server/telemetry"
// "github.com/netbirdio/netbird/util"
// )
//
// const (
// ValidSetupKey = "A2C8E62B-38F5-4553-B31E-DD66C696CEBB"
// AccountKey = "bf1c8084-ba50-4ce7-9439-34653001fc3b"
// )
//
// var _ = Describe("Management service", func() {
// var (
// addr string
// s *grpc.Server
// dataDir string
// client mgmtProto.ManagementServiceClient
// serverPubKey wgtypes.Key
// conn *grpc.ClientConn
// )
//
// BeforeEach(func() {
// level, _ := log.ParseLevel("Debug")
// log.SetLevel(level)
// var err error
// dataDir, err = os.MkdirTemp("", strconv.Itoa(rand.Int())+"wiretrustee_mgmt_test_tmp_*")
// Expect(err).NotTo(HaveOccurred())
//
// var listener net.Listener
//
// config := &server.Config{}
// _, err = util.ReadJson("testdata/management.json", config)
// Expect(err).NotTo(HaveOccurred())
// config.Datadir = dataDir
//
// s, listener = startServer(config, dataDir, "testdata/store.sql")
// addr = listener.Addr().String()
// client, conn = createRawClient(addr)
//
// // s public key
// resp, err := client.GetServerKey(context.TODO(), &mgmtProto.Empty{})
// Expect(err).NotTo(HaveOccurred())
// serverPubKey, err = wgtypes.ParseKey(resp.Key)
// Expect(err).NotTo(HaveOccurred())
// })
//
// AfterEach(func() {
// s.Stop()
// err := conn.Close()
// Expect(err).NotTo(HaveOccurred())
// os.RemoveAll(dataDir)
// })
//
// Context("when calling IsHealthy endpoint", func() {
// Specify("a non-error result is returned", func() {
// healthy, err := client.IsHealthy(context.TODO(), &mgmtProto.Empty{})
//
// Expect(err).NotTo(HaveOccurred())
// Expect(healthy).ToNot(BeNil())
// })
// })
//
// Context("when calling Sync endpoint", func() {
// Context("when there is a new peer registered", func() {
// Specify("a proper configuration is returned", func() {
// key, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key, client)
//
// syncReq := &mgmtProto.SyncRequest{Meta: &mgmtProto.PeerSystemMeta{}}
// encryptedBytes, err := encryption.EncryptMessage(serverPubKey, key, syncReq)
// Expect(err).NotTo(HaveOccurred())
//
// sync, err := client.Sync(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: encryptedBytes,
// })
// Expect(err).NotTo(HaveOccurred())
//
// encryptedResponse := &mgmtProto.EncryptedMessage{}
// err = sync.RecvMsg(encryptedResponse)
// Expect(err).NotTo(HaveOccurred())
//
// resp := &mgmtProto.SyncResponse{}
// err = encryption.DecryptMessage(serverPubKey, key, encryptedResponse.Body, resp)
// Expect(err).NotTo(HaveOccurred())
//
// expectedSignalConfig := &mgmtProto.HostConfig{
// Uri: "signal.wiretrustee.com:10000",
// Protocol: mgmtProto.HostConfig_HTTP,
// }
// expectedStunsConfig := &mgmtProto.HostConfig{
// Uri: "stun:stun.wiretrustee.com:3468",
// Protocol: mgmtProto.HostConfig_UDP,
// }
// expectedTRUNHost := &mgmtProto.HostConfig{
// Uri: "turn:stun.wiretrustee.com:3468",
// Protocol: mgmtProto.HostConfig_UDP,
// }
//
// Expect(resp.WiretrusteeConfig.Signal).To(BeEquivalentTo(expectedSignalConfig))
// Expect(resp.WiretrusteeConfig.Stuns).To(ConsistOf(expectedStunsConfig))
// // TURN validation is special because credentials are dynamically generated
// Expect(resp.WiretrusteeConfig.Turns).To(HaveLen(1))
// actualTURN := resp.WiretrusteeConfig.Turns[0]
// Expect(len(actualTURN.User) > 0).To(BeTrue())
// Expect(actualTURN.HostConfig).To(BeEquivalentTo(expectedTRUNHost))
// Expect(len(resp.NetworkMap.OfflinePeers) == 0).To(BeTrue())
// })
// })
//
// Context("when there are 3 peers registered under one account", func() {
// Specify("a list containing other 2 peers is returned", func() {
// key, _ := wgtypes.GenerateKey()
// key1, _ := wgtypes.GenerateKey()
// key2, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key, client)
// loginPeerWithValidSetupKey(serverPubKey, key1, client)
// loginPeerWithValidSetupKey(serverPubKey, key2, client)
//
// messageBytes, err := pb.Marshal(&mgmtProto.SyncRequest{Meta: &mgmtProto.PeerSystemMeta{}})
// Expect(err).NotTo(HaveOccurred())
// encryptedBytes, err := encryption.Encrypt(messageBytes, serverPubKey, key)
// Expect(err).NotTo(HaveOccurred())
//
// sync, err := client.Sync(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: encryptedBytes,
// })
// Expect(err).NotTo(HaveOccurred())
//
// encryptedResponse := &mgmtProto.EncryptedMessage{}
// err = sync.RecvMsg(encryptedResponse)
// Expect(err).NotTo(HaveOccurred())
// decryptedBytes, err := encryption.Decrypt(encryptedResponse.Body, serverPubKey, key)
// Expect(err).NotTo(HaveOccurred())
//
// resp := &mgmtProto.SyncResponse{}
// err = pb.Unmarshal(decryptedBytes, resp)
// Expect(err).NotTo(HaveOccurred())
//
// Expect(resp.GetRemotePeers()).To(HaveLen(2))
// peers := []string{resp.GetRemotePeers()[0].WgPubKey, resp.GetRemotePeers()[1].WgPubKey}
// Expect(peers).To(ContainElements(key1.PublicKey().String(), key2.PublicKey().String()))
// })
// })
//
// Context("when there is a new peer registered", func() {
// Specify("an update is returned", func() {
// // register only a single peer
// key, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key, client)
//
// messageBytes, err := pb.Marshal(&mgmtProto.SyncRequest{Meta: &mgmtProto.PeerSystemMeta{}})
// Expect(err).NotTo(HaveOccurred())
// encryptedBytes, err := encryption.Encrypt(messageBytes, serverPubKey, key)
// Expect(err).NotTo(HaveOccurred())
//
// sync, err := client.Sync(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: encryptedBytes,
// })
// Expect(err).NotTo(HaveOccurred())
//
// // after the initial sync call we have 0 peer updates
// encryptedResponse := &mgmtProto.EncryptedMessage{}
// err = sync.RecvMsg(encryptedResponse)
// Expect(err).NotTo(HaveOccurred())
// decryptedBytes, err := encryption.Decrypt(encryptedResponse.Body, serverPubKey, key)
// Expect(err).NotTo(HaveOccurred())
// resp := &mgmtProto.SyncResponse{}
// err = pb.Unmarshal(decryptedBytes, resp)
// Expect(resp.GetRemotePeers()).To(HaveLen(0))
//
// wg := sync2.WaitGroup{}
// wg.Add(1)
//
// // continue listening on updates for a peer
// go func() {
// err = sync.RecvMsg(encryptedResponse)
//
// decryptedBytes, err = encryption.Decrypt(encryptedResponse.Body, serverPubKey, key)
// Expect(err).NotTo(HaveOccurred())
// resp = &mgmtProto.SyncResponse{}
// err = pb.Unmarshal(decryptedBytes, resp)
// wg.Done()
// }()
//
// // register a new peer
// key1, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key1, client)
//
// wg.Wait()
//
// Expect(err).NotTo(HaveOccurred())
// Expect(resp.GetRemotePeers()).To(HaveLen(1))
// Expect(resp.GetRemotePeers()[0].WgPubKey).To(BeEquivalentTo(key1.PublicKey().String()))
// })
// })
// })
//
// Context("when calling GetServerKey endpoint", func() {
// Specify("a public Wireguard key of the service is returned", func() {
// resp, err := client.GetServerKey(context.TODO(), &mgmtProto.Empty{})
//
// Expect(err).NotTo(HaveOccurred())
// Expect(resp).ToNot(BeNil())
// Expect(resp.Key).ToNot(BeNil())
// Expect(resp.ExpiresAt).ToNot(BeNil())
//
// // check if the key is a valid Wireguard key
// key, err := wgtypes.ParseKey(resp.Key)
// Expect(err).NotTo(HaveOccurred())
// Expect(key).ToNot(BeNil())
// })
// })
//
// Context("when calling Login endpoint", func() {
// Context("with an invalid setup key", func() {
// Specify("an error is returned", func() {
// key, _ := wgtypes.GenerateKey()
// message, err := encryption.EncryptMessage(serverPubKey, key, &mgmtProto.LoginRequest{SetupKey: "invalid setup key",
// Meta: &mgmtProto.PeerSystemMeta{}})
// Expect(err).NotTo(HaveOccurred())
//
// resp, err := client.Login(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: message,
// })
//
// Expect(err).To(HaveOccurred())
// Expect(resp).To(BeNil())
// })
// })
//
// Context("with a valid setup key", func() {
// It("a non error result is returned", func() {
// key, _ := wgtypes.GenerateKey()
// resp := loginPeerWithValidSetupKey(serverPubKey, key, client)
//
// Expect(resp).ToNot(BeNil())
// })
// })
//
// Context("with a registered peer", func() {
// It("a non error result is returned", func() {
// key, _ := wgtypes.GenerateKey()
// regResp := loginPeerWithValidSetupKey(serverPubKey, key, client)
// Expect(regResp).NotTo(BeNil())
//
// // just login without registration
// message, err := encryption.EncryptMessage(serverPubKey, key, &mgmtProto.LoginRequest{Meta: &mgmtProto.PeerSystemMeta{}})
// Expect(err).NotTo(HaveOccurred())
// loginResp, err := client.Login(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: message,
// })
//
// Expect(err).NotTo(HaveOccurred())
//
// decryptedResp := &mgmtProto.LoginResponse{}
// err = encryption.DecryptMessage(serverPubKey, key, loginResp.Body, decryptedResp)
// Expect(err).NotTo(HaveOccurred())
//
// expectedSignalConfig := &mgmtProto.HostConfig{
// Uri: "signal.wiretrustee.com:10000",
// Protocol: mgmtProto.HostConfig_HTTP,
// }
// expectedStunsConfig := &mgmtProto.HostConfig{
// Uri: "stun:stun.wiretrustee.com:3468",
// Protocol: mgmtProto.HostConfig_UDP,
// }
// expectedTurnsConfig := &mgmtProto.ProtectedHostConfig{
// HostConfig: &mgmtProto.HostConfig{
// Uri: "turn:stun.wiretrustee.com:3468",
// Protocol: mgmtProto.HostConfig_UDP,
// },
// User: "some_user",
// Password: "some_password",
// }
//
// Expect(decryptedResp.GetWiretrusteeConfig().Signal).To(BeEquivalentTo(expectedSignalConfig))
// Expect(decryptedResp.GetWiretrusteeConfig().Stuns).To(ConsistOf(expectedStunsConfig))
// Expect(decryptedResp.GetWiretrusteeConfig().Turns).To(ConsistOf(expectedTurnsConfig))
// })
// })
// })
//
// Context("when there are 10 peers registered under one account", func() {
// Context("when there are 10 more peers registered under the same account", func() {
// Specify("all of the 10 peers will get updates of 10 newly registered peers", func() {
// initialPeers := 10
// additionalPeers := 10
//
// var peers []wgtypes.Key
// for i := 0; i < initialPeers; i++ {
// key, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key, client)
// peers = append(peers, key)
// }
//
// wg := sync2.WaitGroup{}
// wgCounter := initialPeers + initialPeers*additionalPeers
// wg.Add(wgCounter)
//
// var clients []mgmtProto.ManagementService_SyncClient
// for _, peer := range peers {
// go func() {
// messageBytes, err := pb.Marshal(&mgmtProto.SyncRequest{Meta: &mgmtProto.PeerSystemMeta{}})
// Expect(err).NotTo(HaveOccurred())
// encryptedBytes, err := encryption.Encrypt(messageBytes, serverPubKey, peer)
// Expect(err).NotTo(HaveOccurred())
//
// // open stream
// sync, err := client.Sync(context.Background(), &mgmtProto.EncryptedMessage{
// WgPubKey: peer.PublicKey().String(),
// Body: encryptedBytes,
// })
// Expect(err).NotTo(HaveOccurred())
// clients = append(clients, sync)
//
// time.Sleep(1 * time.Second)
//
// // receive stream
// go func() {
// for {
// encryptedResponse := &mgmtProto.EncryptedMessage{}
// err = sync.RecvMsg(encryptedResponse)
// if err != nil {
// break
// }
// decryptedBytes, err := encryption.Decrypt(encryptedResponse.Body, serverPubKey, peer)
// Expect(err).NotTo(HaveOccurred())
//
// resp := &mgmtProto.SyncResponse{}
// err = pb.Unmarshal(decryptedBytes, resp)
// Expect(err).NotTo(HaveOccurred())
// if len(resp.GetRemotePeers()) > 0 {
// // only consider peer updates
// log.Println("Received peer update response")
// wg.Done()
// }
// }
// }()
// }()
// }
//
// time.Sleep(5 * time.Second)
// for i := 0; i < additionalPeers; i++ {
// key, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key, client)
// r := rand.New(rand.NewSource(time.Now().UnixNano()))
// n := r.Intn(200)
// time.Sleep(time.Duration(n) * time.Millisecond)
// }
//
// wg.Wait()
//
// for _, syncClient := range clients {
// err := syncClient.CloseSend()
// Expect(err).NotTo(HaveOccurred())
// }
// })
// })
// })
//
// Context("when there are peers registered under one account concurrently", func() {
// Specify("then there are no duplicate IPs", func() {
// initialPeers := 30
//
// ipChannel := make(chan string, 20)
// for i := 0; i < initialPeers; i++ {
// go func() {
// defer GinkgoRecover()
// key, _ := wgtypes.GenerateKey()
// loginPeerWithValidSetupKey(serverPubKey, key, client)
// syncReq := &mgmtProto.SyncRequest{Meta: &mgmtProto.PeerSystemMeta{}}
// encryptedBytes, err := encryption.EncryptMessage(serverPubKey, key, syncReq)
// Expect(err).NotTo(HaveOccurred())
//
// // open stream
// sync, err := client.Sync(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: encryptedBytes,
// })
// Expect(err).NotTo(HaveOccurred())
// encryptedResponse := &mgmtProto.EncryptedMessage{}
// err = sync.RecvMsg(encryptedResponse)
// Expect(err).NotTo(HaveOccurred())
//
// resp := &mgmtProto.SyncResponse{}
// err = encryption.DecryptMessage(serverPubKey, key, encryptedResponse.Body, resp)
// Expect(err).NotTo(HaveOccurred())
//
// ipChannel <- resp.GetPeerConfig().Address
// }()
// }
//
// ips := make(map[string]struct{})
// for ip := range ipChannel {
// if _, ok := ips[ip]; ok {
// Fail("found duplicate IP: " + ip)
// }
// ips[ip] = struct{}{}
// if len(ips) == initialPeers {
// break
// }
// }
// close(ipChannel)
// })
// })
//
// Context("after login two peers", func() {
// Specify("then they receive the same network", func() {
// key, _ := wgtypes.GenerateKey()
// firstLogin := loginPeerWithValidSetupKey(serverPubKey, key, client)
// key, _ = wgtypes.GenerateKey()
// secondLogin := loginPeerWithValidSetupKey(serverPubKey, key, client)
//
// _, firstLoginNetwork, err := net.ParseCIDR(firstLogin.GetPeerConfig().GetAddress())
// Expect(err).NotTo(HaveOccurred())
// _, secondLoginNetwork, err := net.ParseCIDR(secondLogin.GetPeerConfig().GetAddress())
// Expect(err).NotTo(HaveOccurred())
//
// Expect(secondLoginNetwork.String()).To(BeEquivalentTo(firstLoginNetwork.String()))
// })
// })
// })
//
// func loginPeerWithValidSetupKey(serverPubKey wgtypes.Key, key wgtypes.Key, client mgmtProto.ManagementServiceClient) *mgmtProto.LoginResponse {
// defer GinkgoRecover()
//
// meta := &mgmtProto.PeerSystemMeta{
// Hostname: key.PublicKey().String(),
// GoOS: runtime.GOOS,
// OS: runtime.GOOS,
// Core: "core",
// Platform: "platform",
// Kernel: "kernel",
// WiretrusteeVersion: "",
// }
// message, err := encryption.EncryptMessage(serverPubKey, key, &mgmtProto.LoginRequest{SetupKey: ValidSetupKey, Meta: meta})
// Expect(err).NotTo(HaveOccurred())
//
// resp, err := client.Login(context.TODO(), &mgmtProto.EncryptedMessage{
// WgPubKey: key.PublicKey().String(),
// Body: message,
// })
//
// Expect(err).NotTo(HaveOccurred())
//
// loginResp := &mgmtProto.LoginResponse{}
// err = encryption.DecryptMessage(serverPubKey, key, resp.Body, loginResp)
// Expect(err).NotTo(HaveOccurred())
// return loginResp
// }
//
// func createRawClient(addr string) (mgmtProto.ManagementServiceClient, *grpc.ClientConn) {
// ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
// defer cancel()
//
// conn, err := grpc.DialContext(ctx, addr,
// grpc.WithTransportCredentials(insecure.NewCredentials()),
// grpc.WithBlock(),
// grpc.WithKeepaliveParams(keepalive.ClientParameters{
// Time: 10 * time.Second,
// Timeout: 2 * time.Second,
// }))
// Expect(err).NotTo(HaveOccurred())
//
// return mgmtProto.NewManagementServiceClient(conn), conn
// }
//
// func startServer(config *server.Config, dataDir string, testFile string) (*grpc.Server, net.Listener) {
// lis, err := net.Listen("tcp", ":0")
// Expect(err).NotTo(HaveOccurred())
// s := grpc.NewServer()
//
// store, _, err := store.NewTestStoreFromSQL(context.Background(), testFile, dataDir)
// if err != nil {
// log.Fatalf("failed creating a store: %s: %v", config.Datadir, err)
// }
//
// peersUpdateManager := server.NewPeersUpdateManager(nil)
// eventStore := &activity.InMemoryEventStore{}
//
// metrics, err := telemetry.NewDefaultAppMetrics(context.Background())
// if err != nil {
// log.Fatalf("failed creating metrics: %v", err)
// }
//
// accountManager, err := server.BuildManager(context.Background(), store, peersUpdateManager, nil, "", "netbird.selfhosted", eventStore, nil, false, server.MocIntegratedValidator{}, metrics)
// if err != nil {
// log.Fatalf("failed creating a manager: %v", err)
// }
//
// secretsManager := server.NewTimeBasedAuthSecretsManager(peersUpdateManager, config.TURNConfig, config.Relay)
// mgmtServer, err := server.NewServer(context.Background(), config, accountManager, settings.NewManager(store), peersUpdateManager, secretsManager, nil, nil)
// Expect(err).NotTo(HaveOccurred())
// mgmtProto.RegisterManagementServiceServer(s, mgmtServer)
// go func() {
// if err := s.Serve(lis); err != nil {
// Expect(err).NotTo(HaveOccurred())
// }
// }()
//
// return s, lis
// }
Reference in New Issue View Git Blame Copy Permalink