Feat add: GUI

.air.toml

@@ -0,0 +1,46 @@
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+  args_bin = []
+  bin = "tmp\\main.exe"
+  cmd = "go build -o ./tmp/main.exe ."
+  delay = 500
+  exclude_dir = ["assets", "tmp", "vendor", "testdata"]
+  exclude_file = []
+  exclude_regex = ["_test.go"]
+  exclude_unchanged = true
+  follow_symlink = true
+  full_bin = ""
+  include_dir = []
+  include_ext = ["go", "tpl", "tmpl", "html"]
+  include_file = []
+  kill_delay = "0s"
+  log = "build-errors.log"
+  poll = false
+  poll_interval = 0
+  post_cmd = []
+  pre_cmd = []
+  rerun = false
+  rerun_delay = 500
+  send_interrupt = false
+  stop_on_error = false
+
+[color]
+  app = ""
+  build = "yellow"
+  main = "magenta"
+  runner = "green"
+  watcher = "cyan"
+
+[log]
+  main_only = false
+  time = false
+
+[misc]
+  clean_on_exit = true
+
+[screen]
+  clear_on_rebuild = false
+  keep_scroll = true

.gitignore

@@ -25,10 +25,4 @@ go.work
 .idea/*
 config.json
 
-queen
-security
-drone
-database
-api
-website
-discord-bot
+.venv

README.md

@@ -5,6 +5,6 @@ This is the core of cubus. It will be a platform to create, configure and manage
 2. Create a fork
 3. Checkout the correct branch / create one
 4. Implement the feature or help by doing todos in the code (marked by `// TODO: `)
-5. Create a PR or a Stacked PR depending if there is already a PR for the feature
+5. Create a PR or a Stacked PR depending on if there is already a PR for the feature
 
 and if you have any ideas how to improve something or have a feature idea, please post it in the discussion tab.

cubes/base.go

@@ -0,0 +1,30 @@
+package cubes
+
+import "CUBUS-core/shared/types"
+
+type Base interface {
+	InitMessageChannel()
+	SendMessage(message types.Message)
+	GetMessageChannel() chan types.Message
+	GetConfig() types.CubeConfig
+}
+
+type BaseStruct struct {
+	messageChannel chan types.Message
+}
+
+func (b *BaseStruct) InitMessageChannel() {
+	b.messageChannel = make(chan types.Message)
+}
+
+func (b *BaseStruct) SendMessage(message types.Message) {
+	b.messageChannel <- message
+}
+
+func (b *BaseStruct) GetMessageChannel() chan types.Message {
+	return b.messageChannel
+}
+
+func (b *BaseStruct) GetConfig() types.CubeConfig {
+	return types.CubeConfig{}
+}

cubes/queen/queen.go

@@ -0,0 +1,156 @@
+package queen
+
+import (
+	"CUBUS-core/cubes"
+	"CUBUS-core/shared/tasks"
+	"CUBUS-core/shared/types"
+	"crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"github.com/hibiken/asynq"
+	"log"
+	"os"
+	"time"
+)
+
+type Queen struct {
+	cubes.BaseStruct
+	config      types.QueenConfig
+	privateKey  crypto.PrivateKey
+	asynqClient *asynq.Client
+	logger      *log.Logger
+}
+
+func New(config types.QueenConfig) *Queen {
+	logger := log.New(os.Stdout, "Cube (type: "+config.CubeType.Value+", id: "+config.Id+"):  ", log.LstdFlags)
+	q := Queen{config: config, logger: logger}
+	q.InitMessageChannel()
+	if q.config.PublicKey == nil || q.config.PublicKey == "" {
+		q.generateKeyPair()
+	} else {
+		q.loadPrivateKey()
+	}
+	go q.start()
+	return &q
+}
+
+func (q *Queen) generateKeyPair() {
+	q.logger.Println("Generating new key pair")
+	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		q.logger.Fatalln("Failed to generate key pair: ", err)
+	}
+	q.logger.Println("Key pair generated")
+	q.privateKey = privateKey
+	q.config.PublicKey = &privateKey.PublicKey
+
+	privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
+	privateKeyPEM := pem.EncodeToMemory(&pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: privateKeyBytes,
+	})
+	err = os.WriteFile(q.config.Id+".pem", privateKeyPEM, 0600)
+	if err != nil {
+		q.logger.Fatalln("Failed to write private key to file: ", err)
+	}
+	go q.SendMessage(types.Message{
+		MessageType: "UPDATE PUBLIC KEY",
+		Message:     q.config.PublicKey,
+	})
+	q.logger.Println("Key pair saved to file")
+}
+
+func (q *Queen) loadPrivateKey() {
+	q.logger.Println("Loading private key")
+	privateKeyPEM, err := os.ReadFile(q.config.Id + ".pem")
+	if err != nil {
+		q.logger.Fatalln("Failed to read private key from file: ", err)
+	}
+
+	block, _ := pem.Decode(privateKeyPEM)
+	if block == nil || block.Type != "RSA PRIVATE KEY" {
+		q.logger.Fatalln("Failed to decode private key")
+	}
+
+	privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
+	if err != nil {
+		q.logger.Fatalln("Failed to parse private key: ", err)
+	}
+	q.privateKey = privateKey
+	q.logger.Println("Private key loaded")
+}
+
+func (q *Queen) startServer() {
+	q.logger.Println("Starting asynq server")
+	srv := asynq.NewServer(
+		asynq.RedisClientOpt{
+			Addr:     q.config.RedisAddress,
+			Password: q.config.RedisPassword,
+			DB:       q.config.RedisDB,
+		},
+		asynq.Config{
+			Concurrency: 1<<31 - 1,
+			Queues: map[string]int{
+				"critical": 6,
+				"default":  3,
+				"low":      1,
+			},
+		},
+	)
+
+	mux := asynq.NewServeMux()
+
+	q.logger.Println("Registering tasks")
+	for _, task := range q.config.Tasks {
+		mux.HandleFunc(task.Type, task.Handler)
+		q.logger.Println("Registered task: ", task.Type)
+	}
+
+	go func() {
+		err := srv.Run(mux)
+		if err != nil {
+
+		}
+	}()
+}
+
+func (q *Queen) startClient() {
+	q.logger.Println("Starting asynq client")
+	client := asynq.NewClient(asynq.RedisClientOpt{Addr: q.config.RedisAddress, Password: q.config.RedisPassword, DB: q.config.RedisDB})
+	defer func(client *asynq.Client) {
+		err := client.Close()
+		if err != nil {
+			q.logger.Println("Failed to close asynq client: ", err)
+		}
+	}(client)
+	q.asynqClient = client
+	q.logger.Println("Asynq client started")
+}
+
+func (q *Queen) start() {
+	q.startServer()
+	time.Sleep(1 * time.Second)
+	q.startClient()
+}
+
+func (q *Queen) Enqueue(task *asynq.Task, options ...asynq.Option) (*asynq.TaskInfo, error) {
+	for q.asynqClient == nil {
+	}
+	return q.asynqClient.Enqueue(task, options...)
+}
+
+func (q *Queen) GetConfig() types.CubeConfig {
+	return q.config.CubeConfig
+}
+
+func (q *Queen) Ping() {
+	task, _ := tasks.NewPingTask(q.config.Id)
+	info, err := q.Enqueue(task)
+	if err != nil {
+		q.logger.Println("Failed to enqueue ping task: ", err)
+		return
+	}
+	q.logger.Println("Ping task enqueued: ", info.ID)
+}

extract_i18n.py

@@ -0,0 +1,60 @@
+import re
+import toml
+import os
+import glob
+import logging
+
+def load_existing_strings(directory):
+    strings = set()
+    for filename in glob.glob(os.path.join(directory, '*.toml')):
+        with open(filename, 'r', encoding='utf-8') as f:
+            data = toml.load(f)
+            strings.update(data.keys())
+    return strings
+
+def extract_strings_from_go_files(directory, existing_strings):
+    strings = set()
+    unfiltered_strings = set()
+    constants = {}
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".go"):
+                logging.info(f"Checking file: {os.path.join(root, file)}")
+                with open(os.path.join(root, file), 'r') as f:
+                    content = f.read()
+                    const_matches = re.findall(r'(\w+)\s+:=\s+"([^"]*)"', content)
+                    for match in const_matches:
+                        constants[match[0]] = match[1]
+                    matches = re.findall(r'T\(([^)]*)\)', content)
+                    for match in matches:
+                        if match.startswith("\"") and match.endswith("\""):
+                            match_string = match[1:-1]
+                        elif match in constants:
+                            match_string = constants[match]
+                        if match_string not in existing_strings:
+                            strings.add(match_string)
+                        unfiltered_strings.add(match_string)
+    warn_unused_translations(existing_strings, unfiltered_strings)
+    return strings
+
+def write_strings_to_toml(strings, directory):
+    if len(strings) == 0:
+        logging.info(f"No new strings to add to {directory}")
+        return
+    for filename in glob.glob(os.path.join(directory, '*.toml')):
+        with open(filename, 'r', encoding='utf-8') as f:
+            data = toml.load(f)
+        data.update({f'{s}': s for s in strings})
+        with open(filename, 'w', encoding='utf-8') as f:
+            toml.dump(data, f)
+    logging.info(f"Added {len(strings)} new strings to {directory} (keys: {strings})")
+
+def warn_unused_translations(existing_strings, extracted_strings):
+    unused_translations = existing_strings - extracted_strings
+    for unused in unused_translations:
+        logging.warning(f"Unused translation: {unused}")
+
+logging.basicConfig(level=logging.INFO)
+existing_strings = load_existing_strings('./shared/translation/locals')
+extracted_strings = extract_strings_from_go_files('./', existing_strings)
+write_strings_to_toml(extracted_strings, './shared/translation/locals')