update: proto file to v1.3.0

go.mod

@@ -3,7 +3,7 @@ module tunnel_pls
 go 1.25.5
 
 require (
-	git.fossy.my.id/bagas/tunnel-please-grpc v1.2.0
+	git.fossy.my.id/bagas/tunnel-please-grpc v1.3.0
 	github.com/caddyserver/certmagic v0.25.0
 	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbletea v1.3.10

go.sum

@@ -1,5 +1,5 @@
-git.fossy.my.id/bagas/tunnel-please-grpc v1.2.0 h1:BS1dJU3wa2ILgTGwkV95Knle0il0OQtErGqyb6xV7SU=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.3.0 h1:RhcBKUG41/om4jgN+iF/vlY/RojTeX1QhBa4p4428ec=
-git.fossy.my.id/bagas/tunnel-please-grpc v1.2.0/go.mod h1:fG+VkArdkceGB0bNA7IFQus9GetLAwdF5Oi4jdMlXtY=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.3.0/go.mod h1:fG+VkArdkceGB0bNA7IFQus9GetLAwdF5Oi4jdMlXtY=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=

internal/grpc/client/client.go

@@ -9,6 +9,7 @@ import (
 	"log"
 	"time"
 	"tunnel_pls/internal/config"
+	"tunnel_pls/types"
 
 	"tunnel_pls/session"
 
@@ -39,9 +40,9 @@ type Client struct {
 	conn                       *grpc.ClientConn
 	config                     *GrpcConfig
 	sessionRegistry            session.Registry
-	slugService                proto.SlugChangeClient
 	eventService               proto.EventServiceClient
 	authorizeConnectionService proto.UserServiceClient
+	closing                    bool
 }
 
 func DefaultConfig() *GrpcConfig {
@@ -113,14 +114,12 @@ func New(config *GrpcConfig, sessionRegistry session.Registry) (*Client, error)
 		return nil, fmt.Errorf("failed to connect to gRPC server at %s: %w", config.Address, err)
 	}
 
-	slugService := proto.NewSlugChangeClient(conn)
 	eventService := proto.NewEventServiceClient(conn)
 	authorizeConnectionService := proto.NewUserServiceClient(conn)
 
 	return &Client{
 		conn:                       conn,
 		config:                     config,
-		slugService:                slugService,
 		sessionRegistry:            sessionRegistry,
 		eventService:               eventService,
 		authorizeConnectionService: authorizeConnectionService,
@@ -155,16 +154,17 @@ func (c *Client) SubscribeEvents(ctx context.Context, identity, authToken string
 	for {
 		subscribe, err := c.eventService.Subscribe(ctx)
 		if err != nil {
-			if !isConnectionError(err) {
+			if errors.Is(err, context.Canceled) || status.Code(err) == codes.Canceled || ctx.Err() != nil {
 				return err
 			}
-			if status.Code(err) == codes.Unauthenticated {
+			if !c.isConnectionError(err) || status.Code(err) == codes.Unauthenticated {
 				return err
 			}
-			if err := wait(); err != nil {
+			if err = wait(); err != nil {
 				return err
 			}
 			growBackoff()
+			log.Printf("Reconnect to controller within %v sec", backoff.Seconds())
 			continue
 		}
 
@@ -180,8 +180,8 @@ func (c *Client) SubscribeEvents(ctx context.Context, identity, authToken string
 
 		if err != nil {
 			log.Println("Authentication failed to send to gRPC server:", err)
-			if isConnectionError(err) {
+			if c.isConnectionError(err) {
-				if err := wait(); err != nil {
+				if err = wait(); err != nil {
 					return err
 				}
 				growBackoff()
@@ -193,9 +193,12 @@ func (c *Client) SubscribeEvents(ctx context.Context, identity, authToken string
 		backoff = baseBackoff
 
 		if err = c.processEventStream(subscribe); err != nil {
-			if isConnectionError(err) {
+			if errors.Is(err, context.Canceled) || status.Code(err) == codes.Canceled || ctx.Err() != nil {
+				return err
+			}
+			if c.isConnectionError(err) {
 				log.Printf("Reconnect to controller within %v sec", backoff.Seconds())
-				if err := wait(); err != nil {
+				if err = wait(); err != nil {
 					return err
 				}
 				growBackoff()
@@ -210,22 +213,17 @@ func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Nod
 	for {
 		recv, err := subscribe.Recv()
 		if err != nil {
-			if isConnectionError(err) {
-				log.Printf("connection error receiving from gRPC server: %v", err)
 			return err
 		}
-			if status.Code(err) == codes.Unauthenticated {
-				log.Printf("Authentication failed: %v", err)
-				return err
-			}
-			log.Printf("non-connection receive error from gRPC server: %v", err)
-			continue
-		}
 		switch recv.GetType() {
 		case proto.EventType_SLUG_CHANGE:
 			oldSlug := recv.GetSlugEvent().GetOld()
 			newSlug := recv.GetSlugEvent().GetNew()
-			sess, err := c.sessionRegistry.Get(oldSlug)
+			var userSession *session.SSHSession
+			userSession, err = c.sessionRegistry.Get(types.SessionKey{
+				Id:   oldSlug,
+				Type: types.HTTP,
+			})
 			if err != nil {
 				errSend := subscribe.Send(&proto.Node{
 					Type: proto.EventType_SLUG_CHANGE_RESPONSE,
@@ -237,15 +235,20 @@ func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Nod
 					},
 				})
 				if errSend != nil {
-					if isConnectionError(errSend) {
+					if c.isConnectionError(errSend) {
-						log.Printf("connection error sending slug change failure: %v", errSend)
 						return errSend
 					}
 					log.Printf("non-connection send error for slug change failure: %v", errSend)
 				}
 				continue
 			}
-			err = c.sessionRegistry.Update(oldSlug, newSlug)
+			err = c.sessionRegistry.Update(types.SessionKey{
+				Id:   oldSlug,
+				Type: types.HTTP,
+			}, types.SessionKey{
+				Id:   newSlug,
+				Type: types.HTTP,
+			})
 			if err != nil {
 				errSend := subscribe.Send(&proto.Node{
 					Type: proto.EventType_SLUG_CHANGE_RESPONSE,
@@ -257,15 +260,14 @@ func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Nod
 					},
 				})
 				if errSend != nil {
-					if isConnectionError(errSend) {
+					if c.isConnectionError(errSend) {
-						log.Printf("connection error sending slug change failure: %v", errSend)
 						return errSend
 					}
 					log.Printf("non-connection send error for slug change failure: %v", errSend)
 				}
 				continue
 			}
-			sess.GetInteraction().Redraw()
+			userSession.GetInteraction().Redraw()
 			err = subscribe.Send(&proto.Node{
 				Type: proto.EventType_SLUG_CHANGE_RESPONSE,
 				Payload: &proto.Node_SlugEventResponse{
@@ -276,7 +278,7 @@ func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Nod
 				},
 			})
 			if err != nil {
-				if isConnectionError(err) {
+				if c.isConnectionError(err) {
 					log.Printf("connection error sending slug change success: %v", err)
 					return err
 				}
@@ -289,7 +291,7 @@ func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Nod
 			for _, ses := range sessions {
 				detail := ses.Detail()
 				details = append(details, &proto.Detail{
-					Node:           config.Getenv("domain", "localhost"),
+					Node:           config.Getenv("DOMAIN", "localhost"),
 					ForwardingType: detail.ForwardingType,
 					Slug:           detail.Slug,
 					UserId:         detail.UserID,
@@ -306,7 +308,7 @@ func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Nod
 				},
 			})
 			if err != nil {
-				if isConnectionError(err) {
+				if c.isConnectionError(err) {
 					log.Printf("connection error sending sessions success: %v", err)
 					return err
 				}
@@ -338,6 +340,7 @@ func (c *Client) AuthorizeConn(ctx context.Context, token string) (authorized bo
 func (c *Client) Close() error {
 	if c.conn != nil {
 		log.Printf("Closing gRPC connection to %s", c.config.Address)
+		c.closing = true
 		return c.conn.Close()
 	}
 	return nil
@@ -361,7 +364,10 @@ func (c *Client) GetConfig() *GrpcConfig {
 	return c.config
 }
 
-func isConnectionError(err error) bool {
+func (c *Client) isConnectionError(err error) bool {
+	if c.closing {
+		return false
+	}
 	if err == nil {
 		return false
 	}

main.go

@@ -7,7 +7,9 @@ import (
 	"net/http"
 	_ "net/http/pprof"
 	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 	"time"
 	"tunnel_pls/internal/config"
 	"tunnel_pls/internal/grpc/client"
@@ -68,10 +70,14 @@ func main() {
 	sshConfig.AddHostKey(private)
 	sessionRegistry := session.NewRegistry()
 
-	var grpcClient *client.Client
+	ctx, cancel := context.WithCancel(context.Background())
-	var cancel context.CancelFunc = func() {}
+	defer cancel()
-	var ctx context.Context = context.Background()
 
+	errChan := make(chan error, 2)
+	shutdownChan := make(chan os.Signal, 1)
+	signal.Notify(shutdownChan, os.Interrupt, syscall.SIGTERM)
+
+	var grpcClient *client.Client
 	if isNodeMode {
 		grpcHost := config.Getenv("GRPC_ADDRESS", "localhost")
 		grpcPort := config.Getenv("GRPC_PORT", "8080")
@@ -79,10 +85,9 @@ func main() {
 		nodeToken := config.Getenv("NODE_TOKEN", "")
 		if nodeToken == "" {
 			log.Fatalf("NODE_TOKEN is required in node mode")
-			return
 		}
 
-		grpcClient, err = client.New(&client.GrpcConfig{
+		c, err := client.New(&client.GrpcConfig{
 			Address:            grpcAddr,
 			UseTLS:             false,
 			InsecureSkipVerify: false,
@@ -91,37 +96,46 @@ func main() {
 			MaxRetries:         3,
 		}, sessionRegistry)
 		if err != nil {
-			return
+			log.Fatalf("failed to create grpc client: %v", err)
 		}
-		defer func(grpcClient *client.Client) {
+		grpcClient = c
-			err := grpcClient.Close()
-			if err != nil {
 
+		healthCtx, healthCancel := context.WithTimeout(ctx, 5*time.Second)
+		if err := grpcClient.CheckServerHealth(healthCtx); err != nil {
+			healthCancel()
+			log.Fatalf("gRPC health check failed: %v", err)
 		}
-		}(grpcClient)
+		healthCancel()
 
-		ctx, cancel = context.WithTimeout(context.Background(), time.Second*5)
-		err = grpcClient.CheckServerHealth(ctx)
-		if err != nil {
-			log.Fatalf("gRPC health check failed: %s", err)
-			return
-		}
-		cancel()
-
-		ctx, cancel = context.WithCancel(context.Background())
 		go func() {
 			identity := config.Getenv("DOMAIN", "localhost")
-			err = grpcClient.SubscribeEvents(ctx, identity, nodeToken)
+			if err := grpcClient.SubscribeEvents(ctx, identity, nodeToken); err != nil {
-			if err != nil {
+				errChan <- fmt.Errorf("failed to subscribe to events: %w", err)
-				return
 			}
 		}()
 	}
 
+	go func() {
 		app, err := server.NewServer(sshConfig, sessionRegistry, grpcClient)
 		if err != nil {
-		log.Fatalf("Failed to start server: %s", err)
+			errChan <- fmt.Errorf("failed to start server: %s", err)
+			return
 		}
 		app.Start()
+	}()
+
+	select {
+	case err := <-errChan:
+		log.Printf("error happen : %s", err)
+	case sig := <-shutdownChan:
+		log.Printf("received signal %s, shutting down", sig)
+	}
+
 	cancel()
+
+	if grpcClient != nil {
+		if err := grpcClient.Close(); err != nil {
+			log.Printf("failed to close grpc conn : %s", err)
+		}
+	}
 }

server/http.go

@@ -13,6 +13,7 @@ import (
 	"time"
 	"tunnel_pls/internal/config"
 	"tunnel_pls/session"
+	"tunnel_pls/types"
 
 	"golang.org/x/crypto/ssh"
 )
@@ -313,7 +314,10 @@ func (hs *httpServer) handler(conn net.Conn) {
 		return
 	}
 
-	sshSession, err := hs.sessionRegistry.Get(slug)
+	sshSession, err := hs.sessionRegistry.Get(types.SessionKey{
+		Id:   slug,
+		Type: types.HTTP,
+	})
 	if err != nil {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
 			fmt.Sprintf("Location: https://tunnl.live/tunnel-not-found?slug=%s\r\n", slug) +

server/https.go

@@ -9,6 +9,7 @@ import (
 	"net"
 	"strings"
 	"tunnel_pls/internal/config"
+	"tunnel_pls/types"
 )
 
 func (hs *httpServer) ListenAndServeTLS() error {
@@ -89,7 +90,10 @@ func (hs *httpServer) handlerTLS(conn net.Conn) {
 		return
 	}
 
-	sshSession, err := hs.sessionRegistry.Get(slug)
+	sshSession, err := hs.sessionRegistry.Get(types.SessionKey{
+		Id:   slug,
+		Type: types.HTTP,
+	})
 	if err != nil {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
 			fmt.Sprintf("Location: https://tunnl.live/tunnel-not-found?slug=%s\r\n", slug) +

server/server.go

@@ -88,7 +88,6 @@ func (s *Server) handleConnection(conn net.Conn) {
 		_, u, _ := s.grpcClient.AuthorizeConn(ctx, sshConn.User())
 		user = u
 	}
-
 	sshSession := session.New(sshConn, forwardingReqs, chans, s.sessionRegistry, user)
 	err = sshSession.Start()
 	if err != nil {

session/handler.go

@@ -164,8 +164,9 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
 
 func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	slug := random.GenerateRandomString(20)
+	key := types.SessionKey{Id: slug, Type: types.HTTP}
 
-	if !s.registry.Register(slug, s) {
+	if !s.registry.Register(key, s) {
 		log.Printf("Failed to register client with slug: %s", slug)
 		err := req.Reply(false, nil)
 		if err != nil {
@@ -178,7 +179,7 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	err := binary.Write(buf, binary.BigEndian, uint32(portToBind))
 	if err != nil {
 		log.Println("Failed to write port to buffer:", err)
-		s.registry.Remove(slug)
+		s.registry.Remove(key)
 		err = req.Reply(false, nil)
 		if err != nil {
 			log.Println("Failed to reply to request:", err)
@@ -190,7 +191,7 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	err = req.Reply(true, buf.Bytes())
 	if err != nil {
 		log.Println("Failed to reply to request:", err)
-		s.registry.Remove(slug)
+		s.registry.Remove(key)
 		err = req.Reply(false, nil)
 		if err != nil {
 			log.Println("Failed to reply to request:", err)
@@ -225,10 +226,29 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 		return
 	}
 
+	key := types.SessionKey{Id: fmt.Sprintf("%d", portToBind), Type: types.TCP}
+
+	if !s.registry.Register(key, s) {
+		log.Printf("Failed to register TCP client with id: %s", key.Id)
+		if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
+			log.Printf("Failed to reset port status: %v", setErr)
+		}
+		if closeErr := listener.Close(); closeErr != nil {
+			log.Printf("Failed to close listener: %s", closeErr)
+		}
+		err = req.Reply(false, nil)
+		if err != nil {
+			log.Println("Failed to reply to request:", err)
+		}
+		_ = s.lifecycle.Close()
+		return
+	}
+
 	buf := new(bytes.Buffer)
 	err = binary.Write(buf, binary.BigEndian, uint32(portToBind))
 	if err != nil {
 		log.Println("Failed to write port to buffer:", err)
+		s.registry.Remove(key)
 		if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
 			log.Printf("Failed to reset port status: %v", setErr)
 		}
@@ -244,6 +264,7 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 	err = req.Reply(true, buf.Bytes())
 	if err != nil {
 		log.Println("Failed to reply to request:", err)
+		s.registry.Remove(key)
 		if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
 			log.Printf("Failed to reset port status: %v", setErr)
 		}
@@ -258,6 +279,7 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 	s.forwarder.SetType(types.TCP)
 	s.forwarder.SetListener(listener)
 	s.forwarder.SetForwardedPort(portToBind)
+	s.slugManager.Set(key.Id)
 	s.lifecycle.SetStatus(types.RUNNING)
 	go s.forwarder.AcceptTCPConnections()
 	s.interaction.Start()

session/lifecycle/lifecycle.go

@@ -25,7 +25,7 @@ type Lifecycle struct {
 	channel          ssh.Channel
 	forwarder        Forwarder
 	slugManager      slug.Manager
-	unregisterClient func(slug string)
+	unregisterClient func(key types.SessionKey)
 	startedAt        time.Time
 }
 
@@ -41,7 +41,7 @@ func NewLifecycle(conn ssh.Conn, forwarder Forwarder, slugManager slug.Manager)
 	}
 }
 
-func (l *Lifecycle) SetUnregisterClient(unregisterClient func(slug string)) {
+func (l *Lifecycle) SetUnregisterClient(unregisterClient func(key types.SessionKey)) {
 	l.unregisterClient = unregisterClient
 }
 
@@ -51,7 +51,7 @@ type SessionLifecycle interface {
 	GetConnection() ssh.Conn
 	GetChannel() ssh.Channel
 	SetChannel(channel ssh.Channel)
-	SetUnregisterClient(unregisterClient func(slug string))
+	SetUnregisterClient(unregisterClient func(key types.SessionKey))
 	IsActive() bool
 	StartedAt() time.Time
 }
@@ -94,8 +94,9 @@ func (l *Lifecycle) Close() error {
 	}
 
 	clientSlug := l.slugManager.Get()
-	if clientSlug != "" {
+	if clientSlug != "" && l.unregisterClient != nil {
-		l.unregisterClient(clientSlug)
+		key := types.SessionKey{Id: clientSlug, Type: l.forwarder.GetTunnelType()}
+		l.unregisterClient(key)
 	}
 
 	if l.forwarder.GetTunnelType() == types.TCP {

session/registry.go

@@ -3,96 +3,109 @@ package session
 import (
 	"fmt"
 	"sync"
+	"tunnel_pls/types"
 )
 
+type Key = types.SessionKey
+
 type Registry interface {
-	Get(slug string) (session *SSHSession, err error)
+	Get(key Key) (session *SSHSession, err error)
-	Update(oldSlug, newSlug string) error
+	Update(oldKey, newKey Key) error
-	Register(slug string, session *SSHSession) (success bool)
+	Register(key Key, session *SSHSession) (success bool)
-	Remove(slug string)
+	Remove(key Key)
 	GetAllSessionFromUser(user string) []*SSHSession
 }
 type registry struct {
 	mu        sync.RWMutex
-	byUser    map[string]map[string]*SSHSession
+	byUser    map[string]map[Key]*SSHSession
-	slugIndex map[string]string
+	slugIndex map[Key]string
 }
 
 func NewRegistry() Registry {
 	return &registry{
-		byUser:    make(map[string]map[string]*SSHSession),
+		byUser:    make(map[string]map[Key]*SSHSession),
-		slugIndex: make(map[string]string),
+		slugIndex: make(map[Key]string),
 	}
 }
 
-func (r *registry) Get(slug string) (session *SSHSession, err error) {
+func (r *registry) Get(key Key) (session *SSHSession, err error) {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 
-	userID, ok := r.slugIndex[slug]
+	userID, ok := r.slugIndex[key]
 	if !ok {
 		return nil, fmt.Errorf("session not found")
 	}
 
-	client, ok := r.byUser[userID][slug]
+	client, ok := r.byUser[userID][key]
 	if !ok {
 		return nil, fmt.Errorf("session not found")
 	}
 	return client, nil
 }
 
-func (r *registry) Update(oldSlug, newSlug string) error {
+func (r *registry) Update(oldKey, newKey Key) error {
-	if isForbiddenSlug(newSlug) {
+	if oldKey.Type != newKey.Type {
+		return fmt.Errorf("tunnel type cannot change")
+	}
+
+	if newKey.Type != types.HTTP {
+		return fmt.Errorf("non http tunnel cannot change slug")
+	}
+
+	if isForbiddenSlug(newKey.Id) {
 		return fmt.Errorf("this subdomain is reserved. Please choose a different one")
-	} else if !isValidSlug(newSlug) {
+	}
+
+	if !isValidSlug(newKey.Id) {
 		return fmt.Errorf("invalid subdomain. Follow the rules")
 	}
 
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	userID, ok := r.slugIndex[oldSlug]
+	userID, ok := r.slugIndex[oldKey]
 	if !ok {
 		return fmt.Errorf("session not found")
 	}
 
-	if _, exists := r.slugIndex[newSlug]; exists && newSlug != oldSlug {
+	if _, exists := r.slugIndex[newKey]; exists && newKey != oldKey {
 		return fmt.Errorf("someone already uses this subdomain")
 	}
 
-	client, ok := r.byUser[userID][oldSlug]
+	client, ok := r.byUser[userID][oldKey]
 	if !ok {
 		return fmt.Errorf("session not found")
 	}
 
-	delete(r.byUser[userID], oldSlug)
+	delete(r.byUser[userID], oldKey)
-	delete(r.slugIndex, oldSlug)
+	delete(r.slugIndex, oldKey)
 
-	client.slugManager.Set(newSlug)
+	client.slugManager.Set(newKey.Id)
-	r.slugIndex[newSlug] = userID
+	r.slugIndex[newKey] = userID
 
 	if r.byUser[userID] == nil {
-		r.byUser[userID] = make(map[string]*SSHSession)
+		r.byUser[userID] = make(map[Key]*SSHSession)
 	}
-	r.byUser[userID][newSlug] = client
+	r.byUser[userID][newKey] = client
 	return nil
 }
 
-func (r *registry) Register(slug string, session *SSHSession) (success bool) {
+func (r *registry) Register(key Key, session *SSHSession) (success bool) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	if _, exists := r.slugIndex[slug]; exists {
+	if _, exists := r.slugIndex[key]; exists {
 		return false
 	}
 
 	userID := session.userID
 	if r.byUser[userID] == nil {
-		r.byUser[userID] = make(map[string]*SSHSession)
+		r.byUser[userID] = make(map[Key]*SSHSession)
 	}
 
-	r.byUser[userID][slug] = session
+	r.byUser[userID][key] = session
-	r.slugIndex[slug] = userID
+	r.slugIndex[key] = userID
 	return true
 }
 
@@ -112,20 +125,20 @@ func (r *registry) GetAllSessionFromUser(user string) []*SSHSession {
 	return sessions
 }
 
-func (r *registry) Remove(slug string) {
+func (r *registry) Remove(key Key) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	userID, ok := r.slugIndex[slug]
+	userID, ok := r.slugIndex[key]
 	if !ok {
 		return
 	}
 
-	delete(r.byUser[userID], slug)
+	delete(r.byUser[userID], key)
 	if len(r.byUser[userID]) == 0 {
 		delete(r.byUser, userID)
 	}
-	delete(r.slugIndex, slug)
+	delete(r.slugIndex, key)
 }
 
 func isValidSlug(slug string) bool {

session/session.go

@@ -9,6 +9,7 @@ import (
 	"tunnel_pls/session/interaction"
 	"tunnel_pls/session/lifecycle"
 	"tunnel_pls/session/slug"
+	"tunnel_pls/types"
 
 	"golang.org/x/crypto/ssh"
 )
@@ -54,9 +55,15 @@ func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan
 	lifecycleManager := lifecycle.NewLifecycle(conn, forwarderManager, slugManager)
 
 	interactionManager.SetLifecycle(lifecycleManager)
-	interactionManager.SetSlugModificator(sessionRegistry.Update)
+	interactionManager.SetSlugModificator(func(oldSlug, newSlug string) error {
+		oldKey := types.SessionKey{Id: oldSlug, Type: forwarderManager.GetTunnelType()}
+		newKey := types.SessionKey{Id: newSlug, Type: forwarderManager.GetTunnelType()}
+		return sessionRegistry.Update(oldKey, newKey)
+	})
 	forwarderManager.SetLifecycle(lifecycleManager)
-	lifecycleManager.SetUnregisterClient(sessionRegistry.Remove)
+	lifecycleManager.SetUnregisterClient(func(key types.SessionKey) {
+		sessionRegistry.Remove(key)
+	})
 
 	return &SSHSession{
 		initialReq:    forwardingReq,

types/types.go

@@ -15,6 +15,11 @@ const (
 	TCP  TunnelType = "TCP"
 )
 
+type SessionKey struct {
+	Id   string
+	Type TunnelType
+}
+
 var BadGatewayResponse = []byte("HTTP/1.1 502 Bad Gateway\r\n" +
 	"Content-Length: 11\r\n" +
 	"Content-Type: text/plain\r\n\r\n" +