// Файл: internal/repl/repl.go // Назначение: REPL (Read-Eval-Print Loop) интерфейс для интерактивной работы с СУБД. // Поддерживает автодополнение, историю команд, цветовой вывод и все операции с данными. package repl import ( "bufio" "fmt" "os" "strings" "futriis/internal/cluster" "futriis/internal/compression" "futriis/internal/config" "futriis/internal/log" "futriis/internal/storage" "futriis/pkg/utils" "github.com/fatih/color" ) // Repl представляет основную структуру REPL type Repl struct { store *storage.Storage coordinator *cluster.RaftCoordinator logger *log.Logger config *config.Config reader *bufio.Reader currentDB string currentUser string currentRole string authenticated bool commands map[string]*Command history []string historyPos int } // Command представляет команду REPL type Command struct { Name string Description string Handler func(args []string) error } // NewRepl создаёт новый экземпляр REPL func NewRepl(store *storage.Storage, coordinator *cluster.RaftCoordinator, logger *log.Logger, cfg *config.Config) *Repl { r := &Repl{ store: store, coordinator: coordinator, logger: logger, config: cfg, reader: bufio.NewReader(os.Stdin), currentDB: "", currentUser: "", currentRole: "anonymous", authenticated: false, commands: make(map[string]*Command), history: make([]string, 0, cfg.Repl.HistorySize), historyPos: -1, } r.registerCommands() return r } // registerCommands регистрирует все команды REPL func (r *Repl) registerCommands() { // Команды управления базами данных r.commands["create database"] = &Command{ Name: "create database", Description: "Create a new database", Handler: r.handleCreateDatabase, } r.commands["drop database"] = &Command{ Name: "drop database", Description: "Drop a database", Handler: r.handleDropDatabase, } r.commands["use"] = &Command{ Name: "use", Description: "Switch to a database", Handler: r.handleUseDatabase, } r.commands["show databases"] = &Command{ Name: "show databases", Description: "List all databases", Handler: r.handleShowDatabases, } // Команды управления коллекциями r.commands["create collection"] = &Command{ Name: "create collection", Description: "Create a new collection in current database", Handler: r.handleCreateCollection, } r.commands["drop collection"] = &Command{ Name: "drop collection", Description: "Drop a collection from current database", Handler: r.handleDropCollection, } r.commands["show collections"] = &Command{ Name: "show collections", Description: "List all collections in current database", Handler: r.handleShowCollections, } // Команды работы с документами r.commands["insert"] = &Command{ Name: "insert", Description: "Insert a document into a collection (JSON format)", Handler: r.handleInsert, } r.commands["find"] = &Command{ Name: "find", Description: "Find a document by ID", Handler: r.handleFind, } r.commands["findbyindex"] = &Command{ Name: "findbyindex", Description: "Find documents by index", Handler: r.handleFindByIndex, } r.commands["update"] = &Command{ Name: "update", Description: "Update a document", Handler: r.handleUpdate, } r.commands["delete"] = &Command{ Name: "delete", Description: "Delete a document", Handler: r.handleDelete, } r.commands["count"] = &Command{ Name: "count", Description: "Count documents in a collection", Handler: r.handleCount, } // Команды управления индексами r.commands["create index"] = &Command{ Name: "create index", Description: "Create an index on a collection", Handler: r.handleCreateIndex, } r.commands["drop index"] = &Command{ Name: "drop index", Description: "Drop an index from a collection", Handler: r.handleDropIndex, } r.commands["show indexes"] = &Command{ Name: "show indexes", Description: "Show all indexes in a collection", Handler: r.handleShowIndexes, } // Команды ограничений r.commands["add required"] = &Command{ Name: "add required", Description: "Add a required field constraint", Handler: r.handleAddRequired, } r.commands["add unique"] = &Command{ Name: "add unique", Description: "Add a unique constraint", Handler: r.handleAddUnique, } r.commands["add min"] = &Command{ Name: "add min", Description: "Add a minimum value constraint", Handler: r.handleAddMin, } r.commands["add max"] = &Command{ Name: "add max", Description: "Add a maximum value constraint", Handler: r.handleAddMax, } r.commands["add enum"] = &Command{ Name: "add enum", Description: "Add an enum constraint (allowed values)", Handler: r.handleAddEnum, } // Команды ACL r.commands["acl login"] = &Command{ Name: "acl login", Description: "Login with username and password", Handler: r.handleACLLogin, } r.commands["acl logout"] = &Command{ Name: "acl logout", Description: "Logout current user", Handler: r.handleACLLogout, } r.commands["acl grant"] = &Command{ Name: "acl grant", Description: "Grant permissions to a role", Handler: r.handleACLGrant, } // Команды сжатия r.commands["compression stats"] = &Command{ Name: "compression stats", Description: "Show compression statistics for the database", Handler: r.handleCompressionStats, } r.commands["compress collection"] = &Command{ Name: "compress collection", Description: "Manually compress all documents in a collection", Handler: r.handleCompressCollection, } r.commands["doc compression"] = &Command{ Name: "doc compression", Description: "Show compression ratio for a document", Handler: r.handleDocCompression, } r.commands["compression config"] = &Command{ Name: "compression config", Description: "Show current compression configuration", Handler: r.handleCompressionConfig, } // Команды кластера r.commands["status"] = &Command{ Name: "status", Description: "Show cluster status", Handler: r.handleStatus, } r.commands["nodes"] = &Command{ Name: "nodes", Description: "List cluster nodes", Handler: r.handleNodes, } // Команды системы r.commands["help"] = &Command{ Name: "help", Description: "Show this help message", Handler: r.handleHelp, } r.commands["clear"] = &Command{ Name: "clear", Description: "Clear the screen", Handler: r.handleClear, } r.commands["quit"] = &Command{ Name: "quit", Description: "Exit the REPL", Handler: r.handleQuit, } r.commands["exit"] = &Command{ Name: "exit", Description: "Exit the REPL", Handler: r.handleQuit, } } // Run запускает основной цикл REPL func (r *Repl) Run() error { utils.Println("") utils.PrintInfo("Type 'help' for available commands") utils.Println("") for { // Формируем приглашение к вводу prompt := r.buildPrompt() // Читаем ввод пользователя fmt.Print(prompt) input, err := r.reader.ReadString('\n') if err != nil { if err.Error() == "EOF" { return nil } return err } input = strings.TrimSpace(input) if input == "" { continue } // Сохраняем в историю r.addToHistory(input) // Обрабатываем команду if err := r.executeCommand(input); err != nil { utils.PrintError(err.Error()) r.logger.Error("REPL command error: " + err.Error()) } } } // buildPrompt формирует строку приглашения func (r *Repl) buildPrompt() string { return color.New(color.FgHiCyan).Sprint("futriiS:~> ") } // executeCommand выполняет введённую команду func (r *Repl) executeCommand(input string) error { parts := strings.Fields(input) if len(parts) == 0 { return nil } // Ищем команду по префиксу for cmdName, cmd := range r.commands { if strings.HasPrefix(input, cmdName) { args := strings.SplitN(input, " ", len(strings.Fields(cmdName))) if len(args) > 0 { args = args[1:] } return cmd.Handler(args) } } return fmt.Errorf("unknown command: %s", parts[0]) } // addToHistory добавляет команду в историю func (r *Repl) addToHistory(cmd string) { if len(r.history) >= r.config.Repl.HistorySize { r.history = r.history[1:] } r.history = append(r.history, cmd) r.historyPos = len(r.history) } // ========== Обработчики команд ========== func (r *Repl) handleCreateDatabase(args []string) error { if len(args) < 1 { return fmt.Errorf("usage: create database ") } name := args[0] if err := r.store.CreateDatabase(name); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Database '%s' created", name)) return nil } func (r *Repl) handleDropDatabase(args []string) error { if len(args) < 1 { return fmt.Errorf("usage: drop database ") } name := args[0] if err := r.store.DropDatabase(name); err != nil { return err } if r.currentDB == name { r.currentDB = "" } utils.PrintSuccess(fmt.Sprintf("Database '%s' dropped", name)) return nil } func (r *Repl) handleUseDatabase(args []string) error { if len(args) < 1 { return fmt.Errorf("usage: use ") } name := args[0] if !r.store.ExistsDatabase(name) { return fmt.Errorf("database '%s' does not exist", name) } r.currentDB = name utils.PrintSuccess(fmt.Sprintf("Switched to database '%s'", name)) return nil } func (r *Repl) handleShowDatabases(args []string) error { databases := r.store.ListDatabases() if len(databases) == 0 { utils.PrintInfo("No databases found") return nil } utils.PrintInfo("Databases:") for _, db := range databases { prefix := " " if db == r.currentDB { prefix = " *" } utils.Println(fmt.Sprintf("%s %s", prefix, db)) } return nil } func (r *Repl) handleCreateCollection(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 1 { return fmt.Errorf("usage: create collection ") } name := args[0] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } if err := db.CreateCollection(name); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Collection '%s' created in database '%s'", name, r.currentDB)) return nil } func (r *Repl) handleDropCollection(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 1 { return fmt.Errorf("usage: drop collection ") } name := args[0] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } if err := db.DropCollection(name); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Collection '%s' dropped from database '%s'", name, r.currentDB)) return nil } func (r *Repl) handleShowCollections(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } collections := db.ListCollections() if len(collections) == 0 { utils.PrintInfo("No collections found") return nil } utils.PrintInfo(fmt.Sprintf("Collections in database '%s':", r.currentDB)) for _, coll := range collections { utils.Println(fmt.Sprintf(" - %s", coll)) } return nil } func (r *Repl) handleInsert(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: insert ") } collName := args[0] jsonStr := strings.Join(args[1:], " ") db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } // Простой парсинг JSON (можно улучшить) // Для примера, создаём документ из map doc := storage.NewDocument() // Упрощённый парсинг: ожидаем формат key=value,key2=value2 pairs := strings.Split(jsonStr, ",") for _, pair := range pairs { kv := strings.SplitN(pair, "=", 2) if len(kv) == 2 { doc.SetField(kv[0], kv[1]) } } if err := coll.Insert(doc); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Document inserted with ID: %s", doc.ID)) return nil } func (r *Repl) handleFind(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: find ") } collName := args[0] docID := args[1] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } doc, err := coll.Find(docID) if err != nil { return err } utils.PrintInfo(fmt.Sprintf("Document found:")) utils.PrintJSON(doc.GetFields()) return nil } func (r *Repl) handleFindByIndex(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 3 { return fmt.Errorf("usage: findbyindex ") } collName := args[0] indexName := args[1] value := args[2] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } docs, err := coll.FindByIndex(indexName, value) if err != nil { return err } utils.PrintInfo(fmt.Sprintf("Found %d document(s):", len(docs))) for i, doc := range docs { utils.PrintInfo(fmt.Sprintf(" [%d] ID: %s", i+1, doc.ID)) utils.PrintJSON(doc.GetFields()) } return nil } func (r *Repl) handleUpdate(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 3 { return fmt.Errorf("usage: update ...") } collName := args[0] docID := args[1] updates := make(map[string]interface{}) for i := 2; i < len(args); i++ { kv := strings.SplitN(args[i], "=", 2) if len(kv) == 2 { updates[kv[0]] = kv[1] } } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } if err := coll.Update(docID, updates); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Document '%s' updated", docID)) return nil } func (r *Repl) handleDelete(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: delete ") } collName := args[0] docID := args[1] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } if err := coll.Delete(docID); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Document '%s' deleted", docID)) return nil } func (r *Repl) handleCount(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 1 { return fmt.Errorf("usage: count ") } collName := args[0] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } count := coll.Count() utils.PrintInfo(fmt.Sprintf("Collection '%s' has %d document(s)", collName, count)) return nil } func (r *Repl) handleCreateIndex(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 3 { return fmt.Errorf("usage: create index [unique]") } collName := args[0] indexName := args[1] fields := strings.Split(args[2], ",") unique := len(args) > 3 && args[3] == "unique" db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } if err := coll.CreateIndex(indexName, fields, unique); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Index '%s' created on collection '%s'", indexName, collName)) return nil } func (r *Repl) handleDropIndex(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: drop index ") } collName := args[0] indexName := args[1] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } if err := coll.DropIndex(indexName); err != nil { return err } utils.PrintSuccess(fmt.Sprintf("Index '%s' dropped from collection '%s'", indexName, collName)) return nil } func (r *Repl) handleShowIndexes(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 1 { return fmt.Errorf("usage: show indexes ") } collName := args[0] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } indexes := coll.GetIndexes() if len(indexes) == 0 { utils.PrintInfo(fmt.Sprintf("No indexes found on collection '%s'", collName)) return nil } utils.PrintInfo(fmt.Sprintf("Indexes on collection '%s':", collName)) for _, idx := range indexes { utils.Println(fmt.Sprintf(" - %s", idx)) } return nil } func (r *Repl) handleAddRequired(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: add required ") } collName := args[0] field := args[1] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } coll.AddRequiredField(field) utils.PrintSuccess(fmt.Sprintf("Required field '%s' added to collection '%s'", field, collName)) return nil } func (r *Repl) handleAddUnique(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: add unique ") } collName := args[0] field := args[1] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } coll.AddUniqueConstraint(field) utils.PrintSuccess(fmt.Sprintf("Unique constraint added for field '%s' on collection '%s'", field, collName)) return nil } func (r *Repl) handleAddMin(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 3 { return fmt.Errorf("usage: add min ") } collName := args[0] field := args[1] var minVal float64 if _, err := fmt.Sscanf(args[2], "%f", &minVal); err != nil { return fmt.Errorf("invalid minimum value: %s", args[2]) } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } coll.AddMinConstraint(field, minVal) utils.PrintSuccess(fmt.Sprintf("Min constraint added for field '%s' on collection '%s' (min: %.2f)", field, collName, minVal)) return nil } func (r *Repl) handleAddMax(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 3 { return fmt.Errorf("usage: add max ") } collName := args[0] field := args[1] var maxVal float64 if _, err := fmt.Sscanf(args[2], "%f", &maxVal); err != nil { return fmt.Errorf("invalid maximum value: %s", args[2]) } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } coll.AddMaxConstraint(field, maxVal) utils.PrintSuccess(fmt.Sprintf("Max constraint added for field '%s' on collection '%s' (max: %.2f)", field, collName, maxVal)) return nil } func (r *Repl) handleAddEnum(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 3 { return fmt.Errorf("usage: add enum ") } collName := args[0] field := args[1] values := make([]interface{}, len(args[2:])) for i, v := range args[2:] { values[i] = v } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } coll.AddEnumConstraint(field, values) utils.PrintSuccess(fmt.Sprintf("Enum constraint added for field '%s' on collection '%s' (allowed: %v)", field, collName, values)) return nil } func (r *Repl) handleACLLogin(args []string) error { if len(args) < 2 { return fmt.Errorf("usage: acl login ") } username := args[0] password := args[1] // Здесь должна быть реальная проверка пароля // Для примера используем заглушку if username == "admin" && password == "admin" { r.authenticated = true r.currentUser = username r.currentRole = "admin" utils.PrintSuccess(fmt.Sprintf("Logged in as '%s' with role '%s'", username, r.currentRole)) } else { return fmt.Errorf("invalid username or password") } return nil } func (r *Repl) handleACLLogout(args []string) error { r.authenticated = false r.currentUser = "" r.currentRole = "anonymous" utils.PrintSuccess("Logged out") return nil } func (r *Repl) handleACLGrant(args []string) error { if !r.authenticated || r.currentRole != "admin" { return fmt.Errorf("permission denied: admin access required") } if len(args) < 3 { return fmt.Errorf("usage: acl grant ") } collName := args[0] role := args[1] perms := args[2] if r.currentDB == "" { return fmt.Errorf("no database selected") } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } canRead := strings.Contains(perms, "r") canWrite := strings.Contains(perms, "w") canDelete := strings.Contains(perms, "d") isAdmin := strings.Contains(perms, "a") coll.SetACL(role, canRead, canWrite, canDelete, isAdmin) utils.PrintSuccess(fmt.Sprintf("Permissions '%s' granted to role '%s' on collection '%s'", perms, role, collName)) return nil } // ========== Обработчики команд сжатия ========== func (r *Repl) handleCompressionStats(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } collections := db.ListCollections() totalDocs := int64(0) compressedDocs := int64(0) totalOriginalSize := int64(0) totalCompressedSize := int64(0) for _, collName := range collections { coll, err := db.GetCollection(collName) if err != nil { continue } docs := coll.GetAllDocuments() for _, doc := range docs { totalDocs++ if doc.Compressed { compressedDocs++ totalOriginalSize += doc.OriginalSize // Оцениваем сжатый размер (для статистики) if data, err := doc.Serialize(); err == nil { totalCompressedSize += int64(len(data)) } } } } utils.PrintHeader("Compression Statistics") utils.PrintInfo(fmt.Sprintf(" Total Documents: %d", totalDocs)) utils.PrintInfo(fmt.Sprintf(" Compressed Documents: %d", compressedDocs)) if totalDocs > 0 { utils.PrintInfo(fmt.Sprintf(" Compression Rate: %.2f%%", float64(compressedDocs)/float64(totalDocs)*100)) } if totalOriginalSize > 0 { ratio := float64(totalCompressedSize) / float64(totalOriginalSize) utils.PrintInfo(fmt.Sprintf(" Size Reduction: %.2f%%", (1-ratio)*100)) utils.PrintInfo(fmt.Sprintf(" Original Size: %s", utils.FormatBytes(totalOriginalSize))) utils.PrintInfo(fmt.Sprintf(" Compressed Size: %s", utils.FormatBytes(totalCompressedSize))) } utils.PrintInfo(fmt.Sprintf(" Algorithm: %s", r.config.Compression.Algorithm)) utils.PrintInfo(fmt.Sprintf(" Compression Level: %d", r.config.Compression.Level)) utils.PrintInfo(fmt.Sprintf(" Min Size Threshold: %s", utils.FormatBytes(int64(r.config.Compression.MinSize)))) return nil } func (r *Repl) handleCompressCollection(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 1 { return fmt.Errorf("usage: compress collection ") } collName := args[0] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } docs := coll.GetAllDocuments() compressed := 0 utils.PrintInfo(fmt.Sprintf("Compressing collection '%s'...", collName)) for _, doc := range docs { if !doc.Compressed { if err := doc.Compress(&compression.Config{ Enabled: r.config.Compression.Enabled, Algorithm: r.config.Compression.Algorithm, Level: r.config.Compression.Level, MinSize: r.config.Compression.MinSize, }); err == nil { compressed++ } } } utils.PrintSuccess(fmt.Sprintf("Compressed %d documents in collection '%s'", compressed, collName)) return nil } func (r *Repl) handleDocCompression(args []string) error { if r.currentDB == "" { return fmt.Errorf("no database selected") } if len(args) < 2 { return fmt.Errorf("usage: doc compression ") } collName := args[0] docID := args[1] db, err := r.store.GetDatabase(r.currentDB) if err != nil { return err } coll, err := db.GetCollection(collName) if err != nil { return err } doc, err := coll.Find(docID) if err != nil { return err } utils.PrintHeader(fmt.Sprintf("Compression Info for Document: %s", docID)) utils.PrintInfo(fmt.Sprintf(" Compressed: %v", doc.Compressed)) if doc.Compressed { ratio := doc.GetCompressionRatio() utils.PrintInfo(fmt.Sprintf(" Ratio: %.2f%%", (1-ratio)*100)) utils.PrintInfo(fmt.Sprintf(" Original Size: %s", utils.FormatBytes(doc.OriginalSize))) // Получаем текущий размер if data, err := doc.Serialize(); err == nil { utils.PrintInfo(fmt.Sprintf(" Current Size: %s", utils.FormatBytes(int64(len(data))))) } } return nil } func (r *Repl) handleCompressionConfig(args []string) error { utils.PrintHeader("Compression Configuration") utils.PrintInfo(fmt.Sprintf(" Enabled: %v", r.config.Compression.Enabled)) utils.PrintInfo(fmt.Sprintf(" Algorithm: %s", r.config.Compression.Algorithm)) utils.PrintInfo(fmt.Sprintf(" Level: %d", r.config.Compression.Level)) utils.PrintInfo(fmt.Sprintf(" Min Size: %s", utils.FormatBytes(int64(r.config.Compression.MinSize)))) // Выводим информацию об алгоритмах utils.PrintInfo("") utils.PrintInfo("Available Algorithms:") utils.PrintInfo(" snappy - Fast compression/decompression, good balance (default)") utils.PrintInfo(" lz4 - Extremely fast, lower compression ratio") utils.PrintInfo(" zstd - High compression ratio, slower") return nil } // ========== Обработчики команд кластера ========== func (r *Repl) handleStatus(args []string) error { utils.PrintHeader("Cluster Status") isLeader := r.coordinator.IsLeader() if isLeader { utils.PrintSuccess(" Role: LEADER") } else { utils.PrintWarning(" Role: FOLLOWER") } utils.PrintInfo(fmt.Sprintf(" Cluster Name: %s", r.config.Cluster.Name)) utils.PrintInfo(fmt.Sprintf(" Node: %s:%d", r.config.Cluster.NodeIP, r.config.Cluster.NodePort)) utils.PrintInfo(fmt.Sprintf(" Raft Port: %d", r.config.Cluster.RaftPort)) return nil } func (r *Repl) handleNodes(args []string) error { utils.PrintHeader("Cluster Nodes") for i, node := range r.config.Cluster.Nodes { prefix := " " if i == 0 { prefix = " *" } utils.Println(fmt.Sprintf("%s %s", prefix, node)) } return nil } // ========== Системные обработчики ========== func (r *Repl) handleHelp(args []string) error { utils.Println("") utils.PrintHeader("Available Commands") // Группировка команд по категориям categories := map[string][]string{ "Database Management": { "create database ", "drop database ", "use ", "show databases", }, "Collection Management": { "create collection ", "drop collection ", "show collections", }, "Document Operations": { "insert ", "find ", "findbyindex ", "update ...", "delete ", "count ", }, "Index Management": { "create index [unique]", "drop index ", "show indexes ", }, "Constraints": { "add required ", "add unique ", "add min ", "add max ", "add enum ", }, "Compression": { "compression stats", "compression config", "compress collection ", "doc compression ", }, "Access Control": { "acl login ", "acl logout", "acl grant ", }, "Transactions": { "db.startSession() - Start a new session", "session.startTransaction() - Begin a transaction", "session.commitTransaction() - Commit current transaction", "session.abortTransaction() - Abort/Rollback current transaction", }, "HTTP API": { "GET /api/db/{db}/{coll}[/{id}] - Get document(s)", "POST /api/db/{db}/{coll} - Insert document", "PUT /api/db/{db}/{coll}/{id} - Update document", "DELETE /api/db/{db}/{coll}/{id} - Delete document", "GET /api/index/{db}/{coll}/list - List indexes", "POST /api/index/{db}/{coll}/create - Create index", "DELETE /api/index/{db}/{coll}/drop - Drop index", "POST /api/acl/user/{username} - Create user", "GET /api/acl/users - List users", "POST /api/acl/grant/{role}/{perm} - Grant permission", "GET /api/cluster/status - Cluster status", }, "Cluster": { "status", "nodes", }, "System": { "help", "clear", "quit", "exit", }, } for category, commands := range categories { utils.PrintInfo(fmt.Sprintf("\n%s:", category)) for _, cmd := range commands { utils.Println(fmt.Sprintf(" %-40s %s", cmd, r.getCommandDescription(cmd))) } } utils.PrintInfo("") utils.PrintInfo("Permission flags for 'acl grant':") utils.PrintInfo(" r - read") utils.PrintInfo(" w - write") utils.PrintInfo(" d - delete") utils.PrintInfo(" a - admin") utils.PrintInfo(" Example: acl grant users admin rwa") utils.PrintInfo("") return nil } func (r *Repl) getCommandDescription(cmd string) string { // Ищем полное имя команды for name, command := range r.commands { if strings.HasPrefix(cmd, name) { return command.Description } } return "" } func (r *Repl) handleClear(args []string) error { // Очистка экрана для разных ОС fmt.Print("\033[2J\033[H") return nil } func (r *Repl) handleQuit(args []string) error { os.Exit(0) return nil } // Close закрывает REPL и сохраняет историю func (r *Repl) Close() error { // Сохраняем историю в файл (опционально) if len(r.history) > 0 { // Здесь можно сохранить историю в файл } return nil }