feat(agent): dns based service discovery and volume manager added

Author: tanmoysrt

agent/.gitignore

@@ -0,0 +1,6 @@
+.vscode
+docs
+agent.db
+agent.db-*
+docs.txt
+agent

agent/README.md

@@ -0,0 +1,27 @@
+Container
+ - Create Container
+ - 
+
+Service
+ - Create Service
+ - Get Service
+ - Stop Service
+ - Remove Service
+ - Update Service
+
+DNS
+ - Create Entry
+ - Delete Entry
+ - Get Entry
+
+IPTables
+ - 
+
+
+
+ ----- Important ---------
+ User: root
+ Directories - 
+ - /var/lib/swiftwave > Main directory to store swiftwave persistent files
+ - /var/lib/swiftwave/agent > Directory to store agent related files
+   - Will be kinda work directory for service, no need to specify anywhere

agent/api_server.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+	"github.com/labstack/echo/v4/middleware"
+)
+
+func startHttpServer() {
+	e := echo.New()
+	e.HideBanner = true
+	e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{
+		Format: "method=${method}, uri=${uri}, status=${status}\n",
+	}))
+
+	// Auth middleware
+	// e.Use(func(next echo.HandlerFunc) echo.HandlerFunc {
+	// 	return func(c echo.Context) error {
+	// 		token := c.Request().Header.Get("Authorization")
+	// 		if token != "Token" {
+	// 			return c.JSON(http.StatusUnauthorized, "Unauthorized")
+	// 		}
+	// 		return next(c)
+	// 	}
+	// })
+
+	// Container API
+
+	// Create + Remove + Status + Logs
+	// Container is mutable
+	// For update, swiftwave will remove previous container and create a new one
+
+	/*
+		For zero downtime deployment, we can use the following steps:
+		1. Create a new container with the new image
+		2. Wait for the new container to be ready
+		3. Update the DNS record to point to the new container
+		4. Remove the old DNS records
+		5. Remove the old containers
+	*/
+
+	// Volume API
+	e.GET("/volumes", fetchAllVolumes)
+	e.GET("/volumes/:uuid", fetchVolume)
+	e.POST("/volumes/:uuid/size", fetchVolumeSize)
+	e.POST("/volumes", createVolume)
+	e.DELETE("/volumes/:uuid", deleteVolume)
+
+	// DNS Record API
+	e.GET("/dns", fetchAllDNSRecords)
+	e.GET("/dns/:domain", fetchDNSRecordsByDomain)
+	e.DELETE("/dns", deleteDNSRecord)
+	e.POST("/dns", createDNSRecord)
+
+	// Wireguard Peer API
+
+	if err := e.Start(":8080"); err != nil && !errors.Is(err, http.ErrServerClosed) {
+		e.Logger.Fatal(err)
+	}
+}

agent/db_client.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+	"runtime"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+var (
+	rDB  *gorm.DB // rDB is the read-only database instance
+	rwDB *gorm.DB // rwDB is the read-write database instance
+)
+
+const dbName = "agent.db"
+
+func CreateDatabaseFileIfNotExist() error {
+	if _, err := os.Stat(dbName); os.IsNotExist(err) {
+		file, err := os.Create(dbName)
+		if err != nil {
+			return fmt.Errorf("failed to create database file: %v", err)
+		}
+		file.Close()
+	}
+	return nil
+}
+
+func InitiateDatabaseInstances() error {
+	readDBInstance, err := OpenSqliteDatabase(dbName, true)
+	if err != nil {
+		return fmt.Errorf("failed to open read-only database: %v", err)
+	}
+	rDB = readDBInstance
+	readWriteDBInstance, err := OpenSqliteDatabase(dbName, false)
+	if err != nil {
+		return fmt.Errorf("failed to open read-write database: %v", err)
+	}
+	rwDB = readWriteDBInstance
+	return nil
+}
+
+func MigrateDatabase() error {
+	if rwDB == nil {
+		return fmt.Errorf("read-write database instance is nil or not initialized")
+	}
+	err := rwDB.AutoMigrate(&DNSEntry{}, &Volume{}, &VolumeMount{}, &EnvironmentVariable{}, &Container{})
+	if err != nil {
+		return fmt.Errorf("failed to migrate Agent table: %v", err)
+	}
+	return nil
+}
+
+func OpenSqliteDatabase(file string, readonly bool) (*gorm.DB, error) {
+	dbString := SQLiteDbString(file, readonly)
+	gormDb, err := gorm.Open(sqlite.Open(dbString), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Info),
+	})
+	if err != nil {
+		return nil, err
+	}
+	db, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	pragmasToSet := []string{
+		"temp_store=memory",
+	}
+	for _, pragma := range pragmasToSet {
+		_, err = db.Exec("PRAGMA " + pragma + ";")
+		if err != nil {
+			return nil, err
+		}
+	}
+	if readonly {
+		db.SetMaxOpenConns(max(4, runtime.NumCPU()))
+	} else {
+		db.SetMaxOpenConns(1)
+	}
+
+	return gormDb, nil
+}
+
+func SQLiteDbString(file string, readonly bool) string {
+	connectionParams := make(url.Values)
+	connectionParams.Add("_busy_timeout", "5000")
+	connectionParams.Add("_synchronous", "NORMAL")
+	connectionParams.Add("_cache_size", "-20000")
+	connectionParams.Add("_foreign_keys", "true")
+	if readonly {
+		connectionParams.Add("mode", "ro")
+	} else {
+		connectionParams.Add("_journal_mode", "WAL")
+		connectionParams.Add("_txlock", "IMMEDIATE")
+		connectionParams.Add("mode", "rwc")
+	}
+
+	return "file:" + file + "?" + connectionParams.Encode()
+}

agent/db_schema.go

@@ -0,0 +1,83 @@
+package main
+
+type ContainerStatus string
+
+const (
+	ContainerStatusImagePulling ContainerStatus = "image_pulling"
+	ContainerStatusImagePullErr ContainerStatus = "image_pull_error"
+	ContainerStatusPending      ContainerStatus = "pending"
+	ContainerStatusRunning      ContainerStatus = "running"
+	ContainerStatusStopped      ContainerStatus = "stopped"
+	ContainerStatusExited       ContainerStatus = "exited"
+)
+
+type Container struct {
+	Name              string          `gorm:"column:name;index"`
+	ServiceName       string          `gorm:"column:service_name;index"`
+	Image             string          `gorm:"column:image;index"`
+	IPAddress         string          `gorm:"column:ip_address"`
+	Status            ContainerStatus `gorm:"column:status;default:pending"`
+	IsHealthy         bool            `gorm:"column:is_healthy;default:false"`
+	ExitReason        string          `gorm:"column:exit_reason"`
+	Entrypoint        string          `gorm:"column:entrypoint"`
+	Command           string          `gorm:"column:command;default:[]"`
+	NoNewPrivileges   bool            `gorm:"column:no_new_privileges;default:true"`
+	AddCapabilities   string          `gorm:"column:add_capabilities"`
+	MemorySoftLimitMB int64           `gorm:"column:memory_soft_limit_mb"`
+	MemoryHardLimitMB int64           `gorm:"column:memory_hard_limit_mb"`
+}
+
+type EnvironmentVariable struct {
+	Name          string `gorm:"column:name"`
+	Value         string `gorm:"column:value"`
+	ContainerName string `gorm:"column:container_name;index"`
+}
+
+type VolumeMount struct {
+	MountPath     string `gorm:"column:mount_path"`
+	VolumeUUID    string `gorm:"column:volume_uuid;index"`
+	ContainerName string `gorm:"column:container_name;index"`
+}
+
+type VolumeType string
+
+const (
+	LocalVolume VolumeType = "local"
+	NFSVolume   VolumeType = "nfs"
+	CIFSVolume  VolumeType = "cifs"
+)
+
+type Volume struct {
+	UUID        string            `gorm:"column:uuid;primaryKey"`
+	Type        VolumeType        `gorm:"column:type;index"`
+	LocalConfig LocalVolumeConfig `gorm:"embedded;embeddedPrefix:local_config_"`
+	NFSConfig   NFSVolumeConfig   `gorm:"embedded;embeddedPrefix:nfs_config_"`
+	CIFSConfig  CIFSVolumeConfig  `gorm:"embedded;embeddedPrefix:cifs_config_"`
+}
+
+type LocalVolumeConfig struct {
+	IsCustomPath bool   `gorm:"column:is_custom_path"`
+	CustomPath   string `gorm:"column:custom_path"`
+}
+
+type NFSVolumeConfig struct {
+	Host    string `gorm:"column:host"`
+	Path    string `gorm:"column:path"`
+	Version int    `gorm:"column:version"`
+}
+
+type CIFSVolumeConfig struct {
+	Share    string `gorm:"column:share"`
+	Host     string `gorm:"column:host"`
+	Username string `gorm:"column:username"`
+	Password string `gorm:"column:password"`
+	FileMode string `gorm:"column:file_mode"`
+	DirMode  string `gorm:"column:dir_mode"`
+	Uid      int    `gorm:"column:uid;default:0"`
+	Gid      int    `gorm:"column:gid;default:0"`
+}
+
+type DNSEntry struct {
+	Domain string `gorm:"column:domain;index" json:"domain"`
+	IP     string `gorm:"column:ip;index" json:"ip"`
+}

agent/dns_api.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/labstack/echo/v4"
+)
+
+func createDNSRecord(c echo.Context) error {
+	var dnsEntry DNSEntry
+	if err := c.Bind(&dnsEntry); err != nil {
+		return c.JSON(http.StatusBadRequest, Response{
+			Message: "Invalid request",
+			Error:   err.Error(),
+		})
+	}
+	if err := dnsEntry.Create(); err != nil {
+		return c.JSON(http.StatusInternalServerError, Response{
+			Message: "Failed to create DNS record",
+			Error:   err.Error(),
+		})
+	}
+	return c.JSON(http.StatusOK, Response{
+		Message: "DNS record created successfully",
+		Data:    dnsEntry,
+	})
+}
+
+func deleteDNSRecord(c echo.Context) error {
+	var dnsEntry DNSEntry
+	if err := c.Bind(&dnsEntry); err != nil {
+		return c.JSON(http.StatusBadRequest, Response{
+			Message: "Invalid request",
+			Error:   err.Error(),
+		})
+	}
+	if err := dnsEntry.Delete(); err != nil {
+		return c.JSON(http.StatusInternalServerError, Response{
+			Message: "Failed to delete DNS record",
+			Error:   err.Error(),
+		})
+	}
+	return c.JSON(http.StatusOK, Response{
+		Message: "DNS record deleted successfully",
+		Data:    dnsEntry,
+	})
+}
+
+func fetchAllDNSRecords(c echo.Context) error {
+	dnsEntries, err := FetchAllDNSRecords()
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, Response{
+			Message: "Failed to fetch DNS records",
+			Error:   err.Error(),
+		})
+	}
+	return c.JSON(http.StatusOK, Response{
+		Message: "DNS records fetched successfully",
+		Data:    dnsEntries,
+	})
+}
+
+func fetchDNSRecordsByDomain(c echo.Context) error {
+	domain := c.Param("domain")
+	dnsEntries, err := FetchDNSRecordsByDomain(domain)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, Response{
+			Message: "Failed to fetch DNS records",
+			Error:   err.Error(),
+		})
+	}
+	return c.JSON(http.StatusOK, Response{
+		Message: "DNS records fetched successfully",
+		Data:    dnsEntries,
+	})
+}