refactor(ssh): change device lookup params to modern naming

Previously, the device lookup API accepted `domain` and `name`
parameters to represent the namespace and device name, respectively.
This outdated naming caused confusion when reading and modifying the
code.

To simplify the implementation and improve readability, we’ve renamed
them to match the modern naming for these values,`namespace` and
`device`, clarifying intent throughout the codebase and avoiding
misunderstanding.

This change only affects the internal API.

Author: henrybarreto

api/routes/device.go

@@ -17,7 +17,7 @@ const (
 	DeleteDeviceURL       = "/devices/:uid"
 	RenameDeviceURL       = "/devices/:uid"
 	OfflineDeviceURL      = "/devices/:uid/offline"
-	LookupDeviceURL       = "/lookup"
+	LookupDeviceURL       = "/device/lookup"
 	UpdateDeviceStatusURL = "/devices/:uid/:status"
 	CreateTagURL          = "/devices/:uid/tags"      // Add a tag to a device.
 	UpdateTagURL          = "/devices/:uid/tags"      // Update device's tags with a new set.
@@ -206,7 +206,7 @@ func (h *Handler) LookupDevice(c gateway.Context) error {
 		return err
 	}
 
-	device, err := h.service.LookupDevice(c.Ctx(), req.Domain, req.Name)
+	device, err := h.service.LookupDevice(c.Ctx(), req.TenantID, req.Name)
 	if err != nil {
 		return err
 	}

api/routes/device_test.go

@@ -446,11 +446,8 @@ func TestLookupDevice(t *testing.T) {
 		expected      Expected
 	}{
 		{
-			title: "fails when bind fails to validate uid",
-			request: requests.DeviceLookup{
-				Username:  "user1",
-				IPAddress: "192.168.1.100",
-			},
+			title:         "fails when bind fails to validate uid",
+			request:       requests.DeviceLookup{},
 			requiredMocks: func(_ requests.DeviceLookup) {},
 			expected: Expected{
 				expectedSession: nil,
@@ -460,13 +457,11 @@ func TestLookupDevice(t *testing.T) {
 		{
 			title: "fails when try to look up of a existing device",
 			request: requests.DeviceLookup{
-				Domain:    "example.com",
-				Name:      "device1",
-				Username:  "user1",
-				IPAddress: "192.168.1.100",
+				TenantID: "example.com",
+				Name:     "device1",
 			},
 			requiredMocks: func(req requests.DeviceLookup) {
-				mock.On("LookupDevice", gomock.Anything, req.Domain, req.Name).Return(nil, svc.ErrDeviceNotFound).Once()
+				mock.On("LookupDevice", gomock.Anything, req.TenantID, req.Name).Return(nil, svc.ErrDeviceNotFound).Once()
 			},
 			expected: Expected{
 				expectedSession: nil,
@@ -476,13 +471,11 @@ func TestLookupDevice(t *testing.T) {
 		{
 			title: "success when try to look up of a existing device",
 			request: requests.DeviceLookup{
-				Domain:    "example.com",
-				Name:      "device1",
-				Username:  "user1",
-				IPAddress: "192.168.1.100",
+				TenantID: "example.com",
+				Name:     "device1",
 			},
 			requiredMocks: func(req requests.DeviceLookup) {
-				mock.On("LookupDevice", gomock.Anything, req.Domain, req.Name).Return(&models.Device{}, nil)
+				mock.On("LookupDevice", gomock.Anything, req.TenantID, req.Name).Return(&models.Device{}, nil)
 			},
 			expected: Expected{
 				expectedSession: &models.Device{},
@@ -500,7 +493,7 @@ func TestLookupDevice(t *testing.T) {
 				assert.NoError(t, err)
 			}
 
-			req := httptest.NewRequest(http.MethodGet, "/internal/lookup", strings.NewReader(string(jsonData)))
+			req := httptest.NewRequest(http.MethodGet, "/internal/device/lookup", strings.NewReader(string(jsonData)))
 			req.Header.Set("Content-Type", "application/json")
 			req.Header.Set("X-Role", authorizer.RoleOwner.String())
 			rec := httptest.NewRecorder()

api/services/mocks/services.go

@@ -28,7 +28,7 @@ type deviceAPI interface {
 	Lookup(lookup map[string]string) (string, []error)
 
 	// DeviceLookup performs a lookup operation based on the provided parameters.
-	DeviceLookup(lookup map[string]string) (*models.Device, []error)
+	DeviceLookup(tenantID, name string) (*models.Device, error)
 
 	// LookupTunnel gets a tunnel from its addrss.
 	// TODO: Create a API interface for Tunnel routes.
@@ -68,23 +68,28 @@ func (c *client) Lookup(lookup map[string]string) (string, []error) {
 	return device.UID, nil
 }
 
-func (c *client) DeviceLookup(lookup map[string]string) (*models.Device, []error) {
+func (c *client) DeviceLookup(tenantID, name string) (*models.Device, error) {
 	device := new(models.Device)
-
 	resp, err := c.http.
 		R().
-		SetQueryParams(lookup).
+		SetQueryParam("tenant_id", tenantID).
+		SetQueryParam("name", name).
 		SetResult(&device).
-		Get("/internal/lookup")
+		Get("/internal/device/lookup")
 	if err != nil {
-		return nil, []error{err}
+		return nil, ErrConnectionFailed
 	}
 
-	if resp.StatusCode() != http.StatusOK {
-		return nil, []error{errors.New("fail to get the device from the API")}
+	switch resp.StatusCode() {
+	case http.StatusOK:
+		return device, nil
+	case http.StatusNotFound:
+		return nil, ErrNotFound
+	case http.StatusForbidden:
+		return nil, ErrForbidden
+	default:
+		return nil, ErrUnknown
 	}
-
-	return device, nil
 }
 
 func (c *client) ListDevices() ([]models.Device, error) {

api/store/mocks/store.go

@@ -53,10 +53,8 @@ type DeviceOffline struct {
 
 // DeviceLookup is the structure to represent the request data for lookup device endpoint.
 type DeviceLookup struct {
-	Domain    string `query:"domain" validate:"required"`
-	Name      string `query:"name" validate:"required"`
-	Username  string `query:"username" validate:""`
-	IPAddress string `query:"ip_address" validate:""`
+	TenantID string `query:"tenant_id" validate:"required"`
+	Name     string `query:"name" validate:"required"`
 }
 
 // DeviceStatus is the structure to represent the request data for update device status to pending endpoint.

pkg/api/internalclient/device.go

@@ -38,8 +38,6 @@ type Data struct {
 	Type string
 	// Term is the terminal used for the client.
 	Term string
-	// TODO:
-	Lookup map[string]string
 	// Handled check if the session is already handling a "shell", "exec" or a "subsystem".
 	Handled bool
 }
@@ -260,9 +258,9 @@ func NewSession(ctx gliderssh.Context, tunnel *httptunnel.Tunnel, cache cache.Ca
 		return nil, err
 	}
 
-	var domain, hostname string
+	var namespaceName, deviceName string
 	if target.IsSSHID() {
-		domain, hostname, err = target.SplitSSHID()
+		namespaceName, deviceName, err = target.SplitSSHID()
 		if err != nil {
 			return nil, err
 		}
@@ -294,21 +292,16 @@ func NewSession(ctx gliderssh.Context, tunnel *httptunnel.Tunnel, cache cache.Ca
 			return nil, err
 		}
 
-		domain = device.Namespace
-		hostname = device.Name
+		namespaceName = device.Namespace
+		deviceName = device.Name
 	}
 
-	lookup := map[string]string{
-		"domain": domain,
-		"name":   hostname,
-	}
-
-	device, errs := api.DeviceLookup(lookup)
-	if len(errs) > 0 {
-		return nil, errs[0]
+	lookupDevice, err := api.DeviceLookup(namespaceName, deviceName)
+	if err != nil {
+		return nil, err
 	}
 
-	namespace, errs := api.NamespaceLookup(device.TenantID)
+	namespace, errs := api.NamespaceLookup(lookupDevice.TenantID)
 	if len(errs) > 1 {
 		return nil, errs[0]
 	}
@@ -331,10 +324,9 @@ func NewSession(ctx gliderssh.Context, tunnel *httptunnel.Tunnel, cache cache.Ca
 		Data: Data{
 			IPAddress: hos.Host,
 			Target:    target,
-			Device:    device,
+			Device:    lookupDevice,
 			Namespace: namespace,
-			Lookup:    lookup,
-			SSHID:     fmt.Sprintf("%s@%s.%s", target.Username, domain, hostname),
+			SSHID:     fmt.Sprintf("%s@%s.%s", target.Username, namespaceName, deviceName),
 		},
 		once:  new(sync.Once),
 		Seats: NewSeats(),
@@ -346,9 +338,6 @@ func NewSession(ctx gliderssh.Context, tunnel *httptunnel.Tunnel, cache cache.Ca
 		},
 	}
 
-	session.Data.Lookup["username"] = target.Username
-	session.Data.Lookup["ip_address"] = hos.Host
-
 	snap.save(session, StateCreated)
 
 	return session, nil
@@ -397,7 +386,13 @@ func (s *Session) NewAgentChannel(name string, seat int) (*AgentChannel, error)
 }
 
 func (s *Session) checkFirewall() (bool, error) {
-	if err := s.api.FirewallEvaluate(s.Data.Lookup); err != nil {
+	// TODO: Refactor firewall evaluation to remove the map requirement.
+	if err := s.api.FirewallEvaluate(map[string]string{
+		"domain":     s.Namespace.Name,
+		"name":       s.Device.Name,
+		"username":   s.Target.Username,
+		"ip_address": s.IPAddress,
+	}); err != nil {
 		defer log.WithError(err).WithFields(log.Fields{
 			"uid":   s.UID,
 			"sshid": s.SSHID,