wip(api): disable mongodb dependencies

Author: heiytor

api/server.go

@@ -22,6 +22,17 @@ type env struct {
 	// MongoURI specifies the connection string for MongoDB.
 	MongoURI string `env:"MONGO_URI,default=mongodb://mongo:27017/main"`
 
+	// PostgresHost specifies the host for PostgreSQL.
+	PostgresHost string `env:"POSTGRES_HOST,default=postgres"`
+	// PostgresPort specifies the port for PostgreSQL.
+	PostgresPort string `env:"POSTGRES_PORT,default=5432"`
+	// PostgresUser specifies the username for authenticate PostgreSQL.
+	PostgresUser string `env:"POSTGRES_USER,default=admin"`
+	// PostgresUser specifies the password for authenticate PostgreSQL.
+	PostgresPassword string `env:"POSTGRES_PASSWORD,default=admin"`
+	// PostgresDB especifica o nome do banco de dados PostgreSQL a ser utilizado.
+	PostgresDB string `env:"POSTGRES_DB,default=main"`
+
 	// RedisURI specifies the connection string for Redis.
 	RedisURI string `env:"REDIS_URI,default=redis://redis:6379"`
 	// RedisCachePoolSize defines the maximum number of concurrent connections to Redis cache.

api/services/auth.go

@@ -10,12 +10,10 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"encoding/pem"
-	"net"
 	"slices"
 	"strings"
 	"time"
 
-	"github.com/cnf/structhash"
 	"github.com/shellhub-io/shellhub/pkg/api/authorizer"
 	"github.com/shellhub-io/shellhub/pkg/api/jwttoken"
 	"github.com/shellhub-io/shellhub/pkg/api/requests"
@@ -66,119 +64,7 @@ type AuthService interface {
 }
 
 func (s *service) AuthDevice(ctx context.Context, req requests.DeviceAuth, remoteAddr string) (*models.DeviceAuthResponse, error) {
-	var identity *models.DeviceIdentity
-	if req.Identity != nil {
-		identity = &models.DeviceIdentity{
-			MAC: req.Identity.MAC,
-		}
-	}
-
-	var hostname string
-	if req.Hostname != "" {
-		hostname = req.Hostname
-	}
-
-	if hostname == "" && (identity == nil || identity.MAC == "") {
-		return nil, NewErrAuthDeviceNoIdentityAndHostname()
-	}
-
-	auth := models.DeviceAuth{
-		Hostname:  hostname,
-		Identity:  identity,
-		PublicKey: req.PublicKey,
-		TenantID:  req.TenantID,
-	}
-
-	uid := sha256.Sum256(structhash.Dump(auth, 1))
-	key := hex.EncodeToString(uid[:])
-
-	claims := authorizer.DeviceClaims{
-		UID:      key,
-		TenantID: req.TenantID,
-	}
-
-	token, err := jwttoken.EncodeDeviceClaims(claims, s.privKey)
-	if err != nil {
-		return nil, NewErrTokenSigned(err)
-	}
-
-	type Device struct {
-		Name      string
-		Namespace string
-	}
-
-	var value *Device
-
-	if err := s.cache.Get(ctx, strings.Join([]string{"auth_device", key}, "/"), &value); err == nil && value != nil {
-		return &models.DeviceAuthResponse{
-			UID:       key,
-			Token:     token,
-			Name:      value.Name,
-			Namespace: value.Namespace,
-		}, nil
-	}
-	var info *models.DeviceInfo
-	if req.Info != nil {
-		info = &models.DeviceInfo{
-			ID:         req.Info.ID,
-			PrettyName: req.Info.PrettyName,
-			Version:    req.Info.Version,
-			Arch:       req.Info.Arch,
-			Platform:   req.Info.Platform,
-		}
-	}
-
-	position, err := s.locator.GetPosition(net.ParseIP(remoteAddr))
-	if err != nil {
-		return nil, err
-	}
-
-	device := models.Device{
-		UID:        key,
-		Identity:   identity,
-		Info:       info,
-		PublicKey:  req.PublicKey,
-		TenantID:   req.TenantID,
-		LastSeen:   clock.Now(),
-		RemoteAddr: remoteAddr,
-		Position: &models.DevicePosition{
-			Longitude: position.Longitude,
-			Latitude:  position.Latitude,
-		},
-	}
-
-	// The order here is critical as we don't want to register devices if the tenant id is invalid
-	namespace, err := s.store.NamespaceGet(ctx, device.TenantID)
-	if err != nil {
-		return nil, NewErrNamespaceNotFound(device.TenantID, err)
-	}
-
-	hostname = strings.ToLower(hostname)
-
-	if err := s.store.DeviceCreate(ctx, device, hostname); err != nil {
-		return nil, NewErrDeviceCreate(device, err)
-	}
-
-	for _, uid := range req.Sessions {
-		if err := s.store.SessionSetLastSeen(ctx, models.UID(uid)); err != nil {
-			continue
-		}
-	}
-
-	dev, err := s.store.DeviceGetByUID(ctx, models.UID(device.UID), device.TenantID)
-	if err != nil {
-		return nil, NewErrDeviceNotFound(models.UID(device.UID), err)
-	}
-	if err := s.cache.Set(ctx, strings.Join([]string{"auth_device", key}, "/"), &Device{Name: dev.Name, Namespace: namespace.Name}, time.Second*30); err != nil {
-		return nil, err
-	}
-
-	return &models.DeviceAuthResponse{
-		UID:       key,
-		Token:     token,
-		Name:      dev.Name,
-		Namespace: namespace.Name,
-	}, nil
+	return nil, nil
 }
 
 func (s *service) AuthLocalUser(ctx context.Context, req *requests.AuthLocalUser, sourceIP string) (*models.UserAuthResponse, int64, string, error) {

api/services/task.go

@@ -1,16 +1,9 @@
 package services
 
 import (
-	"bufio"
-	"bytes"
 	"context"
-	"strconv"
-	"strings"
-	"time"
 
-	"github.com/shellhub-io/shellhub/pkg/models"
 	"github.com/shellhub-io/shellhub/pkg/worker"
-	log "github.com/sirupsen/logrus"
 )
 
 const (
@@ -20,59 +13,6 @@ const (
 // Device Heartbeat sets the device status to "online". It processes in batch.
 func (s *service) DevicesHeartbeat() worker.TaskHandler {
 	return func(ctx context.Context, payload []byte) error {
-		log.WithField("task", TaskDevicesHeartbeat.String()).
-			Info("executing heartbeat task")
-
-		scanner := bufio.NewScanner(bytes.NewReader(payload))
-		scanner.Split(bufio.ScanLines)
-
-		devices := make([]models.ConnectedDevice, 0)
-		for scanner.Scan() {
-			parts := strings.Split(scanner.Text(), "=")
-			if len(parts) != 2 {
-				log.WithField("task", TaskDevicesHeartbeat.String()).
-					Warn("failed to parse queue payload due to lack of '='.")
-
-				continue
-			}
-
-			lastSeen, err := strconv.ParseInt(parts[1], 10, 64)
-			if err != nil {
-				log.WithField("task", TaskDevicesHeartbeat.String()).
-					WithError(err).
-					Warn("failed to parse timestamp to integer.")
-
-				continue
-			}
-
-			parts = strings.Split(parts[0], ":")
-			if len(parts) != 2 {
-				log.WithField("task", TaskDevicesHeartbeat.String()).
-					Warn("failed to parse queue payload due to lack of ':'.")
-
-				continue
-			}
-
-			device := models.ConnectedDevice{
-				UID:      parts[1],
-				TenantID: parts[0],
-				LastSeen: time.Unix(lastSeen, 0),
-			}
-
-			devices = append(devices, device)
-		}
-
-		if err := s.store.DeviceSetOnline(ctx, devices); err != nil {
-			log.WithField("task", TaskDevicesHeartbeat.String()).
-				WithError(err).
-				Error("failed to complete the heartbeat task")
-
-			return err
-		}
-
-		log.WithField("task", TaskDevicesHeartbeat.String()).
-			Info("finishing heartbeat task")
-
 		return nil
 	}
 }

api/store/mongo/api-key.go

@@ -3,152 +3,34 @@ package mongo
 import (
 	"context"
 
-	"github.com/shellhub-io/shellhub/api/store"
-	"github.com/shellhub-io/shellhub/api/store/mongo/queries"
 	"github.com/shellhub-io/shellhub/pkg/api/query"
-	"github.com/shellhub-io/shellhub/pkg/clock"
 	"github.com/shellhub-io/shellhub/pkg/models"
-	"go.mongodb.org/mongo-driver/bson"
 )
 
 func (s *Store) APIKeyCreate(ctx context.Context, apiKey *models.APIKey) (string, error) {
-	now := clock.Now()
-	apiKey.CreatedAt = now
-	apiKey.UpdatedAt = now
-
-	res, err := s.db.Collection("api_keys").InsertOne(ctx, apiKey)
-	if err != nil {
-		return "", FromMongoError(err)
-	}
-
-	return res.InsertedID.(string), nil
+	return "", nil
 }
 
 func (s *Store) APIKeyGet(ctx context.Context, id string) (*models.APIKey, error) {
-	apiKey := new(models.APIKey)
-	if err := s.db.Collection("api_keys").FindOne(ctx, bson.M{"_id": id}).Decode(apiKey); err != nil {
-		return nil, FromMongoError(err)
-	}
-
-	return apiKey, nil
+	return nil, nil
 }
 
 func (s *Store) APIKeyGetByName(ctx context.Context, tenantID string, name string) (*models.APIKey, error) {
-	apiKey := new(models.APIKey)
-	if err := s.db.Collection("api_keys").FindOne(ctx, bson.M{"tenant_id": tenantID, "name": name}).Decode(&apiKey); err != nil {
-		return nil, FromMongoError(err)
-	}
-
-	return apiKey, nil
+	return nil, nil
 }
 
 func (s *Store) APIKeyConflicts(ctx context.Context, tenantID string, target *models.APIKeyConflicts) ([]string, bool, error) {
-	pipeline := []bson.M{
-		{
-			"$match": bson.M{
-				"tenant_id": tenantID,
-				"$or": []bson.M{
-					{"_id": target.ID},
-					{"name": target.Name},
-				},
-			},
-		},
-	}
-
-	cursor, err := s.db.Collection("api_keys").Aggregate(ctx, pipeline)
-	if err != nil {
-		return nil, false, FromMongoError(err)
-	}
-	defer cursor.Close(ctx)
-
-	apiKey := new(models.APIKeyConflicts)
-	conflicts := make([]string, 0)
-	for cursor.Next(ctx) {
-		if err := cursor.Decode(&apiKey); err != nil {
-			return nil, false, FromMongoError(err)
-		}
-
-		if apiKey.ID == target.ID {
-			conflicts = append(conflicts, "id")
-		}
-
-		if apiKey.Name == target.Name {
-			conflicts = append(conflicts, "name")
-		}
-	}
-
-	return conflicts, len(conflicts) > 0, nil
+	return nil, false, nil
 }
 
 func (s *Store) APIKeyList(ctx context.Context, tenantID string, paginator query.Paginator, sorter query.Sorter) ([]models.APIKey, int, error) {
-	query := []bson.M{
-		{
-			"$match": bson.M{
-				"tenant_id": tenantID,
-			},
-		},
-	}
-
-	queryCount := append(query, bson.M{"$count": "count"})
-	count, err := AggregateCount(ctx, s.db.Collection("api_keys"), queryCount)
-	if err != nil {
-		return nil, 0, FromMongoError(err)
-	}
-
-	if count == 0 {
-		return []models.APIKey{}, 0, nil
-	}
-
-	query = append(query, queries.FromSorter(&sorter)...)
-	query = append(query, queries.FromPaginator(&paginator)...)
-
-	cursor, err := s.db.Collection("api_keys").Aggregate(ctx, query)
-	if err != nil {
-		return nil, 0, FromMongoError(err)
-	}
-	defer cursor.Close(ctx)
-
-	apiKeys := make([]models.APIKey, 0)
-	for cursor.Next(ctx) {
-		apiKey := new(models.APIKey)
-		if err := cursor.Decode(apiKey); err != nil {
-			return nil, 0, FromMongoError(err)
-		}
-
-		apiKeys = append(apiKeys, *apiKey)
-	}
-
-	return apiKeys, count, nil
+	return nil, 0, nil
 }
 
 func (s *Store) APIKeyUpdate(ctx context.Context, tenantID, name string, changes *models.APIKeyChanges) error {
-	changes.UpdatedAt = clock.Now()
-
-	res, err := s.db.
-		Collection("api_keys").
-		UpdateOne(ctx, bson.M{"tenant_id": tenantID, "name": name}, bson.M{"$set": changes})
-	if err != nil {
-		return FromMongoError(err)
-	}
-
-	if res.ModifiedCount < 1 {
-		return store.ErrNoDocuments
-	}
-
 	return nil
 }
 
 func (s *Store) APIKeyDelete(ctx context.Context, tenantID, name string) error {
-	result, err := s.db.
-		Collection("api_keys").
-		DeleteOne(ctx, bson.M{"tenant_id": tenantID, "name": name})
-	if err != nil {
-		return FromMongoError(err)
-	}
-
-	if result.DeletedCount < 1 {
-		return store.ErrNoDocuments
-	}
-
 	return nil
 }