Merge pull request #305 from Warp-net/develop

Develop

Author: filinvadim

cmd/node/business/handlers/bridge.go

@@ -45,12 +45,6 @@ const pathIsFirstRun = "is-first-run"
 // burst of dashboard calls) can spawn, so one connection can't exhaust memory.
 const maxInflightDispatches = 32
 
-// logoutGracePeriod is how long the node waits after the last dashboard
-// connection drops before logging the owner out. A page reload reconnects well
-// within this window (cancelling the logout); closing the browser tab never
-// reconnects, so the logout fires and the database is sealed.
-const logoutGracePeriod = 5 * time.Second
-
 var upgrader = websocket.Upgrader{
 	ReadBufferSize:  4096,
 	WriteBufferSize: 4096,
@@ -60,7 +54,7 @@ var upgrader = websocket.Upgrader{
 // sameOrigin permits only the dashboard served from this node: a request whose
 // Origin host matches the Host it connects to. A missing Origin (non-browser
 // clients, e.g. health probes) is allowed; any other origin is rejected so a
-// malicious page can't open a /ws connection and pin the auto-logout open.
+// malicious page can't open a /ws connection to this node.
 func sameOrigin(r *http.Request) bool {
 	origin := r.Header.Get("Origin")
 	if origin == "" {
@@ -88,7 +82,6 @@ type Authenticator interface {
 	AuthLogin(message event.LoginEvent, psk security.PSK) (event.LoginResponse, error)
 	AuthLogout()
 	Reset()
-	IsAuthenticated() bool
 	PrivateKey() ed25519.PrivateKey
 }
 
@@ -100,10 +93,6 @@ type BridgeHandler struct {
 
 	mx   sync.RWMutex
 	node Node
-
-	connMx      sync.Mutex
-	activeConns int
-	logoutTimer *time.Timer
 }
 
 func NewBridgeHandler(
@@ -128,13 +117,6 @@ func (b *BridgeHandler) Handle() http.HandlerFunc {
 			return
 		}
 
-		// Track the dashboard connection so closing the last browser tab logs
-		// the owner out (a reload reconnects within the grace period). The
-		// conn.Close defer is registered last so it runs first on return:
-		// the socket is fully torn down before the disconnect accounting arms
-		// the auto-logout timer.
-		b.connConnected()
-		defer b.connDisconnected()
 		defer func() { _ = conn.Close() }()
 
 		// Dispatch each message in its own goroutine so a slow libp2p self-stream
@@ -201,53 +183,6 @@ func (b *BridgeHandler) AttachNode(n Node) {
 	b.mx.Unlock()
 }
 
-// connConnected records a new dashboard connection and cancels any pending
-// auto-logout (e.g. a page reload reconnecting within the grace period).
-func (b *BridgeHandler) connConnected() {
-	b.connMx.Lock()
-	defer b.connMx.Unlock()
-	b.activeConns++
-	if b.logoutTimer != nil {
-		b.logoutTimer.Stop()
-		b.logoutTimer = nil
-	}
-}
-
-// connDisconnected records a dropped dashboard connection. When the last one
-// goes away it arms a grace timer that logs the owner out unless a new
-// connection arrives first, so closing the browser tab seals the node while a
-// reload keeps the session.
-func (b *BridgeHandler) connDisconnected() {
-	b.connMx.Lock()
-	defer b.connMx.Unlock()
-	if b.activeConns > 0 {
-		b.activeConns--
-	}
-	if b.activeConns > 0 {
-		return
-	}
-	if b.logoutTimer != nil {
-		b.logoutTimer.Stop()
-	}
-	b.logoutTimer = time.AfterFunc(logoutGracePeriod, b.autoLogout)
-}
-
-// autoLogout fires when the dashboard has been gone for the whole grace period.
-// It holds connMx across the decision and the logout so a reconnect can't slip
-// in between (which would leave an active connection on a logged-out node); the
-// reconnect either precedes it (activeConns > 0, bail) or follows it cleanly.
-func (b *BridgeHandler) autoLogout() {
-	b.connMx.Lock()
-	defer b.connMx.Unlock()
-	b.logoutTimer = nil
-	if b.activeConns > 0 || !b.auth.IsAuthenticated() {
-		return
-	}
-	log.Infoln("business: dashboard closed, logging out")
-	b.auth.AuthLogout() // closes the database; the node keeps running
-	b.auth.Reset()      // clear the auth guard so the next login can re-authenticate
-}
-
 func (b *BridgeHandler) dispatch(req event.Message) event.Message {
 	defer func() {
 		if r := recover(); r != nil {

core/dht/options.go

@@ -29,7 +29,7 @@ import "github.com/Warp-net/warpnet/core/warpnet"
 type dhtConfig struct {
 	store                         RoutingStorer
 	addCallbacks, removeCallbacks []func(info warpnet.WarpPeerID)
-	bootstrapNodes                 []warpnet.WarpAddrInfo
+	bootstrapNodes                []warpnet.WarpAddrInfo
 	network                       string
 }
 type Option func(*dhtConfig)

core/handler/filter_test.go

@@ -10,14 +10,14 @@ import (
 )
 
 type stubFilterRepo struct {
-	createFn        func(userId string, f domain.Filter) (domain.Filter, error)
-	getFn           func(userId, filterId string) (domain.Filter, error)
-	updateFn        func(userId string, f domain.Filter) (domain.Filter, error)
-	deleteFn        func(userId, filterId string) error
-	listFn          func(userId string, limit *uint64, cursor *string) ([]domain.Filter, string, error)
-	addKwFn         func(userId, filterId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
-	updateKwFn      func(userId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
-	deleteKwFn      func(userId, keywordId string) error
+	createFn   func(userId string, f domain.Filter) (domain.Filter, error)
+	getFn      func(userId, filterId string) (domain.Filter, error)
+	updateFn   func(userId string, f domain.Filter) (domain.Filter, error)
+	deleteFn   func(userId, filterId string) error
+	listFn     func(userId string, limit *uint64, cursor *string) ([]domain.Filter, string, error)
+	addKwFn    func(userId, filterId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
+	updateKwFn func(userId string, kw domain.FilterKeyword) (domain.FilterKeyword, error)
+	deleteKwFn func(userId, keywordId string) error
 }
 
 func (s stubFilterRepo) Create(u string, f domain.Filter) (domain.Filter, error) {

core/handler/like.go

@@ -193,7 +193,7 @@ func StreamUnlikeHandler(repo LikesStorer, userRepo LikedUserFetcher, streamer L
 		if err != nil {
 			return nil, err
 		}
-		
+
 		if unlikedUser.NodeId == ownNodeInfo.ID.String() {
 			return event.LikesCountResponse{Count: num}, nil
 		}

core/handler/subscription_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 type stubSubsRepo struct {
-	subscribeFn    func(ownerId, targetId string) error
+	subscribeFn   func(ownerId, targetId string) error
 	unsubscribeFn func(ownerId, targetId string) error
 }
 

core/handler/user.go

@@ -33,7 +33,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/Warp-net/warpnet/core/mastodon"
 	"github.com/Warp-net/warpnet/core/stream"
 	"github.com/Warp-net/warpnet/core/warpnet"
 	"github.com/Warp-net/warpnet/database"
@@ -296,89 +295,6 @@ func refreshUsers(
 	}
 }
 
-func StreamGetWhoToFollowHandler(
-	authRepo UserAuthStorer,
-	userRepo UserFetcher,
-	followRepo UserFollowsCounter,
-) warpnet.WarpHandlerFunc {
-	return func(buf []byte, s warpnet.WarpStream) (any, error) {
-		var ev event.GetAllUsersEvent
-		err := json.Unmarshal(buf, &ev)
-		if err != nil {
-			return nil, err
-		}
-
-		if ev.UserId == "" {
-			return nil, errEmptyUserId
-		}
-
-		users, cursor, err := userRepo.WhoToFollow(ev.Limit, ev.Cursor)
-		if err != nil {
-			return nil, err
-		}
-
-		followingsLimit := uint64(80) //nolint:mnd    // TODO limit?
-		followings, _, err := followRepo.GetFollowings(authRepo.GetOwner().UserId, &followingsLimit, nil)
-		if err != nil {
-			log.Errorf("get who to follow handler: get followers %v", err)
-		}
-
-		followedUsers := map[string]struct{}{}
-		for _, followingId := range followings {
-			followedUsers[followingId] = struct{}{}
-		}
-
-		owner := authRepo.GetOwner()
-
-		profile, err := userRepo.Get(ev.UserId)
-		if err != nil {
-			log.Errorf("get who to follow handler: get user %v", err)
-			profile = domain.User{
-				Id:       owner.UserId,
-				Username: owner.Username,
-				Network:  warpnet.WarpnetName,
-				NodeId:   owner.NodeId,
-			}
-		}
-
-		whotofollow := make([]domain.User, 0, len(users))
-		latestByNode := make(map[string]int, len(users))
-		for _, user := range users {
-			if user.IsOffline {
-				continue
-			}
-			if user.Id == owner.UserId || user.NodeId == owner.NodeId {
-				continue
-			}
-			// if profile from Warpnet - don't show other network recommendations
-			if profile.Id != owner.UserId && profile.Network != user.Network {
-				continue
-			}
-			if _, ok := followedUsers[user.Id]; ok {
-				continue
-			}
-
-			if user.NodeId != "" && user.Network != mastodon.Network {
-				if idx, ok := latestByNode[user.NodeId]; ok {
-					if user.CreatedAt.After(whotofollow[idx].CreatedAt) {
-						whotofollow[idx] = user
-					}
-					continue
-				}
-			}
-
-			latestByNode[user.NodeId] = len(whotofollow)
-
-			whotofollow = append(whotofollow, user)
-		}
-
-		return event.UsersResponse{
-			Cursor: cursor,
-			Users:  whotofollow,
-		}, nil
-	}
-}
-
 func StreamUpdateProfileHandler(authRepo UserAuthStorer, userRepo UserFetcher) warpnet.WarpHandlerFunc {
 	return func(buf []byte, s warpnet.WarpStream) (any, error) {
 		var ev event.NewUserEvent

core/handler/user_test.go

@@ -310,78 +310,6 @@ func TestStreamGetUsersHandler(t *testing.T) {
 	})
 }
 
-func TestStreamGetWhoToFollowHandler(t *testing.T) {
-	owner := "owner-1"
-
-	t.Run("invalid payload", func(t *testing.T) {
-		h := StreamGetWhoToFollowHandler(stubAuth{owner: domain.Owner{UserId: owner}}, stubUserFetcher{}, stubUserFollowsCounter{})
-		_, err := h([]byte("{"), nil)
-		if err == nil {
-			t.Fatal("expected error")
-		}
-	})
-
-	t.Run("empty user id", func(t *testing.T) {
-		h := StreamGetWhoToFollowHandler(stubAuth{owner: domain.Owner{UserId: owner}}, stubUserFetcher{}, stubUserFollowsCounter{})
-		_, err := h(marshal(t, event.GetAllUsersEvent{}), nil)
-		if err == nil || err.Error() != "empty user id" {
-			t.Fatalf("unexpected err: %v", err)
-		}
-	})
-
-	t.Run("filters out self and already followed", func(t *testing.T) {
-		h := StreamGetWhoToFollowHandler(
-			stubAuth{owner: domain.Owner{UserId: owner, NodeId: "node-1", Username: "test"}},
-			stubUserFetcher{
-				whoToFollowFn: func(limit *uint64, cursor *string) ([]domain.User, string, error) {
-					return []domain.User{
-						{Id: owner, Network: warpnet.WarpnetName},
-						{Id: "already-followed", Network: warpnet.WarpnetName},
-						{Id: "new-user", Network: warpnet.WarpnetName},
-					}, "end", nil
-				},
-				getFn: func(userId string) (domain.User, error) {
-					return domain.User{Id: owner, Network: warpnet.WarpnetName}, nil
-				},
-			},
-			stubUserFollowsCounter{getFollowingsFn: func(userId string, limit *uint64, cursor *string) ([]string, string, error) {
-				return []string{"already-followed"}, "", nil
-			}},
-		)
-		resp, err := h(marshal(t, event.GetAllUsersEvent{UserId: owner}), nil)
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		r := resp.(event.UsersResponse)
-		if len(r.Users) != 1 || r.Users[0].Id != "new-user" {
-			t.Fatalf("expected only new-user, got: %v", r.Users)
-		}
-	})
-
-	t.Run("repo error", func(t *testing.T) {
-		repoErr := errors.New("db error")
-		h := StreamGetWhoToFollowHandler(stubAuth{owner: domain.Owner{UserId: owner}}, stubUserFetcher{whoToFollowFn: func(limit *uint64, cursor *string) ([]domain.User, string, error) {
-			return nil, "", repoErr
-		}}, stubUserFollowsCounter{})
-		_, err := h(marshal(t, event.GetAllUsersEvent{UserId: owner}), nil)
-		if !errors.Is(err, repoErr) {
-			t.Fatalf("expected repo error: %v", err)
-		}
-	})
-
-	t.Run("empty results", func(t *testing.T) {
-		h := StreamGetWhoToFollowHandler(stubAuth{owner: domain.Owner{UserId: owner}}, stubUserFetcher{}, stubUserFollowsCounter{})
-		resp, err := h(marshal(t, event.GetAllUsersEvent{UserId: owner}), nil)
-		if err != nil {
-			t.Fatalf("unexpected err: %v", err)
-		}
-		r := resp.(event.UsersResponse)
-		if len(r.Users) != 0 {
-			t.Fatalf("expected empty users: %v", r.Users)
-		}
-	})
-}
-
 func TestStreamUpdateProfileHandler(t *testing.T) {
 	owner := "owner-1"