From 5039f46999093b14fff31bf93ad7e54624ee6355 Mon Sep 17 00:00:00 2001 From: Jin Hai Date: Sun, 21 Jun 2026 16:50:02 +0800 Subject: [PATCH] Go CLI: refactor commands (#16213) ### What problem does this PR solve? As title. ### Type of change - [x] Refactoring --------- Signed-off-by: Jin Hai --- internal/admin/enterprise_handler.go | 41 +- internal/admin/enterprise_service.go | 26 +- internal/admin/router.go | 5 +- internal/admin/service.go | 2 - internal/cli/admin_command.go | 202 ++----- internal/cli/admin_parser.go | 777 +++++++++++++-------------- internal/cli/cli_http.go | 64 +-- internal/cli/common_command.go | 22 +- internal/cli/parser.go | 2 - internal/cli/user_parser.go | 25 +- 10 files changed, 537 insertions(+), 629 deletions(-) diff --git a/internal/admin/enterprise_handler.go b/internal/admin/enterprise_handler.go index 004d1acc97..a398355484 100644 --- a/internal/admin/enterprise_handler.go +++ b/internal/admin/enterprise_handler.go @@ -63,15 +63,15 @@ func (h *Handler) CreateRole(c *gin.Context) { success(c, role, "") } -// GetRole handle get role -func (h *Handler) GetRole(c *gin.Context) { +// ShowRole handle show role +func (h *Handler) ShowRole(c *gin.Context) { roleName := c.Param("role_name") if roleName == "" { errorResponse(c, "Role name is required", 400) return } - role, err := h.service.GetRole(roleName) + role, err := h.service.ShowRole(roleName) if err != nil { errorResponse(c, err.Error(), 500) return @@ -215,6 +215,41 @@ func (h *Handler) ListResources(c *gin.Context) { success(c, resources, "") } +type ListModelsOrShowModelRequest struct { + ModelName string `json:"model_name"` +} + +func (h *Handler) ListModelsOrShowModel(c *gin.Context) { + var req ListModelsOrShowModelRequest + if err := c.ShouldBindJSON(&req); err != nil { + c.JSON(http.StatusBadRequest, gin.H{ + "code": 400, + "message": "Invalid request body", + }) + return + } + + if req.ModelName == "" { + // List models + models, err := h.service.ListAllModels() + if err != nil { + errorResponse(c, err.Error(), 500) + return + } + + success(c, models, "") + } else { + // Get model + model, err := h.service.GetModelByModelName(req.ModelName) + if err != nil { + errorResponse(c, err.Error(), 500) + return + } + + success(c, model, "") + } +} + // GetSystemFingerprint handle get system fingerprint func (h *Handler) GetSystemFingerprint(c *gin.Context) { fingerprint, err := h.service.GetSystemFingerprint() diff --git a/internal/admin/enterprise_service.go b/internal/admin/enterprise_service.go index ff1d9a9344..a46b1a78bb 100644 --- a/internal/admin/enterprise_service.go +++ b/internal/admin/enterprise_service.go @@ -50,12 +50,12 @@ func (s *Service) CreateRole(roleName, description string) (map[string]interface return result, nil } -// GetRole get role details -func (s *Service) GetRole(roleName string) (map[string]interface{}, error) { +// ShowRole show role details +func (s *Service) ShowRole(roleName string) (map[string]interface{}, error) { result := map[string]interface{}{ - "command": "get_role", + "command": "show_role", "role_name": roleName, - "error": "'get role' is implemented in enterprise edition", + "error": "'show role' is implemented in enterprise edition", } return result, nil @@ -134,6 +134,24 @@ func (s *Service) ListResources() (map[string]interface{}, error) { return result, nil } +// ListAllModels list all models +func (s *Service) ListAllModels() ([]map[string]interface{}, error) { + return []map[string]interface{}{ + { + "command": "list_all_models", + "error": "'list all models' is implemented in enterprise edition", + }, + }, nil +} + +func (s *Service) GetModelByModelName(modelName string) (map[string]interface{}, error) { + return map[string]interface{}{ + "command": "get_model_by_model_name", + "model_name": modelName, + "error": "'get model by model name' is implemented in enterprise edition", + }, nil +} + func (s *Service) GetSystemFingerprint() (map[string]interface{}, error) { result := map[string]interface{}{ "command": "get_system_fingerprint", diff --git a/internal/admin/router.go b/internal/admin/router.go index f44c32401c..0e262bee02 100644 --- a/internal/admin/router.go +++ b/internal/admin/router.go @@ -164,7 +164,7 @@ func (r *Router) Setup(engine *gin.Engine) { // Role management protected.GET("/roles", r.handler.ListRoles) protected.POST("/roles", r.handler.CreateRole) - protected.GET("/roles/:role_name", r.handler.GetRole) + protected.GET("/roles/:role_name", r.handler.ShowRole) protected.PUT("/roles/:role_name", r.handler.UpdateRole) protected.DELETE("/roles/:role_name", r.handler.DeleteRole) protected.GET("/roles/:role_name/permission", r.handler.GetRolePermission) @@ -172,6 +172,9 @@ func (r *Router) Setup(engine *gin.Engine) { protected.DELETE("/roles/:role_name/permission", r.handler.RevokeRolePermission) protected.GET("/roles/resource", r.handler.ListResources) + // Models + protected.GET("/all-models", r.handler.ListModelsOrShowModel) + // License protected.GET("/system/fingerprint", r.handler.GetSystemFingerprint) protected.POST("/system/license", r.handler.SetSystemLicense) diff --git a/internal/admin/service.go b/internal/admin/service.go index 1889ba4660..c80c591cfc 100644 --- a/internal/admin/service.go +++ b/internal/admin/service.go @@ -1426,8 +1426,6 @@ func (s *Service) RestartService(serviceID string) (map[string]interface{}, erro }, nil } -// Variable/Settings methods - // AdminException admin exception error type AdminException struct { Message string diff --git a/internal/cli/admin_command.go b/internal/cli/admin_command.go index 8f33154adb..09f0f1865a 100644 --- a/internal/cli/admin_command.go +++ b/internal/cli/admin_command.go @@ -56,21 +56,8 @@ func (c *CLI) PingAdmin(cmd *Command) (ResponseIf, error) { return &result, nil } -// Show admin version to show RAGFlow admin version -// Returns benchmark result map if iterations > 1, otherwise prints status +// AdminShowVersionCommand show RAGFlow admin version func (c *CLI) AdminShowVersionCommand(cmd *Command) (ResponseIf, error) { - // Get iterations from command params (for benchmark) - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } - - if iterations > 1 { - // Benchmark mode: multiple iterations - return c.AdminServerClient.RequestWithIterations("GET", "/admin/version", "web", nil, nil, iterations) - } - - // Single mode resp, err := c.AdminServerClient.Request("GET", "/admin/version", "web", nil, nil) if err != nil { return nil, fmt.Errorf("failed to show admin version: %w", err) @@ -163,49 +150,6 @@ func (c *CLI) AdminListRolesCommand(cmd *Command) (ResponseIf, error) { return &result, nil } -// ShowRole to show role (admin mode only) -func (c *CLI) ShowRole(cmd *Command) (ResponseIf, error) { - if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { - return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") - } - - roleName := cmd.Params["role_name"].(string) - - // Check for benchmark iterations - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } - - endPoint := fmt.Sprintf("/admin/roles/%s/", roleName) - - if iterations > 1 { - // Benchmark mode - return raw result for benchmark stats - return c.AdminServerClient.RequestWithIterations("GET", endPoint, "admin", nil, nil, iterations) - } - - resp, err := c.AdminServerClient.Request("GET", endPoint, "admin", nil, nil) - if err != nil { - return nil, fmt.Errorf("failed to show role: %w", err) - } - - if resp.StatusCode != 200 { - return nil, fmt.Errorf("failed to show role: HTTP %d, body: %s", resp.StatusCode, string(resp.Body)) - } - - var result CommonDataResponse - if err = json.Unmarshal(resp.Body, &result); err != nil { - return nil, fmt.Errorf("show role failed: invalid JSON (%w)", err) - } - - if result.Code != 0 { - return nil, fmt.Errorf("%s", result.Message) - } - - result.Duration = resp.Duration - return &result, nil -} - // AdminCreateRoleCommand creates a new role (admin mode only) func (c *CLI) AdminCreateRoleCommand(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { @@ -591,23 +535,12 @@ type listServicesResponse struct { Message string `json:"message"` } -// ListServices lists all services (admin mode only) -func (c *CLI) ListServices(cmd *Command) (ResponseIf, error) { +// AdminListServicesCommand lists all services (admin mode only) +func (c *CLI) AdminListServicesCommand(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") } - // Check for benchmark iterations - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } - - if iterations > 1 { - // Benchmark mode - return raw result for benchmark stats - return c.AdminServerClient.RequestWithIterations("GET", "/admin/services", "admin", nil, nil, iterations) - } - resp, err := c.AdminServerClient.Request("GET", "/admin/services", "admin", nil, nil) if err != nil { return nil, fmt.Errorf("failed to list services: %w", err) @@ -619,23 +552,19 @@ func (c *CLI) ListServices(cmd *Command) (ResponseIf, error) { var result CommonResponse if err = json.Unmarshal(resp.Body, &result); err != nil { - return nil, fmt.Errorf("list users failed: invalid JSON (%w)", err) + return nil, fmt.Errorf("list services failed: invalid JSON (%w)", err) } if result.Code != 0 { return nil, fmt.Errorf("%s", result.Message) } - for _, user := range result.Data { - delete(user, "extra") - } - result.Duration = resp.Duration return &result, nil } -// Show service show service (admin mode only) -func (c *CLI) ShowService(cmd *Command) (ResponseIf, error) { +// AdminShowService show service (admin mode only) +func (c *CLI) AdminShowService(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") } @@ -690,21 +619,12 @@ func normalizeVariableRows(rows []map[string]interface{}) { } } -// ListVariables lists all system variables (admin mode only). -func (c *CLI) ListVariables(cmd *Command) (ResponseIf, error) { +// AdminListVariables lists all system variables (admin mode only). +func (c *CLI) AdminListVariables(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") } - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } - - if iterations > 1 { - return c.AdminServerClient.RequestWithIterations("GET", "/admin/variables", "admin", nil, nil, iterations) - } - resp, err := c.AdminServerClient.Request("GET", "/admin/variables", "admin", nil, nil) if err != nil { return nil, fmt.Errorf("failed to list variables: %w", err) @@ -728,8 +648,8 @@ func (c *CLI) ListVariables(cmd *Command) (ResponseIf, error) { return &result, nil } -// ShowVariable shows system variables by exact name or name prefix (admin mode only). -func (c *CLI) ShowVariable(cmd *Command) (ResponseIf, error) { +// AdminShowVariable shows system variables by exact name or name prefix (admin mode only). +func (c *CLI) AdminShowVariable(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") } @@ -739,15 +659,7 @@ func (c *CLI) ShowVariable(cmd *Command) (ResponseIf, error) { return nil, fmt.Errorf("var_name not provided") } - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } - payload := map[string]interface{}{"var_name": varName} - if iterations > 1 { - return c.AdminServerClient.RequestWithIterations("GET", "/admin/variables", "admin", nil, payload, iterations) - } resp, err := c.AdminServerClient.Request("GET", "/admin/variables", "admin", nil, payload) if err != nil { @@ -1021,64 +933,6 @@ func (c *CLI) ListUserDatasets(cmd *Command) (ResponseIf, error) { return nil, nil } -// ListAgents lists agents for a specific user (admin mode) -// Returns (result_map, error) - result_map is non-nil for benchmark mode -func (c *CLI) ListAgents(cmd *Command) (ResponseIf, error) { - if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { - return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") - } - - userName, ok := cmd.Params["user_name"].(string) - if !ok { - return nil, fmt.Errorf("user_name not provided") - } - - // Check for benchmark iterations - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } - - encodedUserName := common.EncodeEmail(userName) - apiURL := fmt.Sprintf("/admin/users/%s/agents", encodedUserName) - - if iterations > 1 { - // Benchmark mode - return raw result for benchmark stats - return c.AdminServerClient.RequestWithIterations("GET", apiURL, "admin", nil, nil, iterations) - } - - resp, err := c.AdminServerClient.Request("GET", apiURL, "admin", nil, nil) - if err != nil { - return nil, fmt.Errorf("failed to list agents: %w", err) - } - - if resp.StatusCode != 200 { - return nil, fmt.Errorf("failed to list agents: HTTP %d, body: %s", resp.StatusCode, string(resp.Body)) - } - - resJSON, err := resp.JSON() - if err != nil { - return nil, fmt.Errorf("invalid JSON response: %w", err) - } - - data, ok := resJSON["data"].([]interface{}) - if !ok { - return nil, fmt.Errorf("invalid response format") - } - - // Convert to slice of maps and remove avatar - tableData := make([]map[string]interface{}, 0, len(data)) - for _, item := range data { - if itemMap, ok := item.(map[string]interface{}); ok { - delete(itemMap, "avatar") - tableData = append(tableData, itemMap) - } - } - - PrintTableSimple(tableData) - return nil, nil -} - // GrantPermission grants permission to a role (admin mode only) func (c *CLI) GrantPermission(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { @@ -1804,8 +1658,8 @@ func (c *CLI) AdminShowLicenseCommand(cmd *Command) (ResponseIf, error) { return &result, nil } -// AdminShowUserInfoCommand show user info command (admin mode only) -func (c *CLI) AdminShowUserInfoCommand(cmd *Command) (ResponseIf, error) { +// AdminShowUserCommand show user command (admin mode only) +func (c *CLI) AdminShowUserCommand(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") } @@ -1840,6 +1694,38 @@ func (c *CLI) AdminShowUserInfoCommand(cmd *Command) (ResponseIf, error) { return &result, nil } +// AdminShowRoleCommand show role command (admin mode only) +func (c *CLI) AdminShowRoleCommand(cmd *Command) (ResponseIf, error) { + if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { + return nil, fmt.Errorf("this command is only allowed in ADMIN mode or already login") + } + + roleName := cmd.Params["role_name"].(string) + + endPoint := fmt.Sprintf("/admin/roles/%s/", roleName) + + resp, err := c.AdminServerClient.Request("GET", endPoint, "admin", nil, nil) + if err != nil { + return nil, fmt.Errorf("failed to show role: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to show role: HTTP %d, body: %s", resp.StatusCode, string(resp.Body)) + } + + var result CommonDataResponse + if err = json.Unmarshal(resp.Body, &result); err != nil { + return nil, fmt.Errorf("show role failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + + result.Duration = resp.Duration + return &result, nil +} + func (c *CLI) AdminShowUserActivityCommand(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { diff --git a/internal/cli/admin_parser.go b/internal/cli/admin_parser.go index a3e758cf8a..15b84806f2 100644 --- a/internal/cli/admin_parser.go +++ b/internal/cli/admin_parser.go @@ -69,7 +69,7 @@ func (p *Parser) parseAdminLogout() (*Command, error) { } func (p *Parser) parseAdminPingServer() (*Command, error) { - cmd := NewCommand("ping") + cmd := NewCommand("ping_server") p.nextToken() // Semicolon is optional for UNSET TOKEN if p.curToken.Type == TokenSemicolon { @@ -78,53 +78,6 @@ func (p *Parser) parseAdminPingServer() (*Command, error) { return cmd, nil } -func (p *Parser) parseAdminRegisterCommand() (*Command, error) { - cmd := NewCommand("register_user") - - if err := p.expectPeek(TokenUser); err != nil { - return nil, err - } - p.nextToken() - - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - cmd.Params["user_name"] = userName - - p.nextToken() - if p.curToken.Type != TokenAs { - return nil, fmt.Errorf("expected AS") - } - - p.nextToken() - nickname, err := p.parseQuotedString() - if err != nil { - return nil, err - } - cmd.Params["nickname"] = nickname - - p.nextToken() - if p.curToken.Type != TokenPassword { - return nil, fmt.Errorf("expected PASSWORD") - } - - p.nextToken() - password, err := p.parseQuotedString() - if err != nil { - return nil, err - } - cmd.Params["password"] = password - - p.nextToken() - // Semicolon is optional for UNSET TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return cmd, nil -} - // endregion // region LIST commands @@ -133,29 +86,15 @@ func (p *Parser) parseAdminListCommand() (*Command, error) { switch p.curToken.Type { case TokenServices: - p.nextToken() - // Semicolon is optional for SHOW TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return NewCommand("list_services"), nil + return p.parseAdminListServices() case TokenUsers: return p.parseAdminListUsersCommand() - case TokenDatasets: - return p.parseAdminListDatasets() - case TokenAgents: - return p.parseAdminListAgents() case TokenRoles: return p.parseAdminListRoles() case TokenResources: return p.parseAdminListResources() case TokenVars: - p.nextToken() - // Semicolon is optional for SHOW TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return NewCommand("list_variables"), nil + return p.parseAdminListVariables() case TokenConfigs: p.nextToken() // Semicolon is optional for SHOW TOKEN @@ -172,8 +111,10 @@ func (p *Parser) parseAdminListCommand() (*Command, error) { return NewCommand("list_environments"), nil case TokenAvailable: return p.parseCommonListProviders() + case TokenProvider: + return p.parseAdminListProvider() case TokenModels: - return p.parseListModelsOfProvider() + return p.parseAdminListModels() case TokenUser: return p.parseAdminListUserCommand() case TokenTokens: @@ -202,58 +143,14 @@ func (p *Parser) parseAdminListCommand() (*Command, error) { } } -func (p *Parser) parseAdminListDatasets() (*Command, error) { - cmd := NewCommand("list_user_datasets") - p.nextToken() // consume DATASETS +func (p *Parser) parseAdminListServices() (*Command, error) { + p.nextToken() // consume SERVICES if p.curToken.Type == TokenSemicolon { - return cmd, nil - } - - if p.curToken.Type == TokenOf { - p.nextToken() - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - cmd = NewCommand("list_datasets") - cmd.Params["user_name"] = userName p.nextToken() } - // Semicolon is optional for UNSET TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil -} - -func (p *Parser) parseAdminListAgents() (*Command, error) { - p.nextToken() // consume AGENTS - - if p.curToken.Type == TokenSemicolon { - return NewCommand("list_user_agents"), nil - } - - if p.curToken.Type != TokenOf { - return nil, fmt.Errorf("expected OF") - } - p.nextToken() - - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - - cmd := NewCommand("list_agents") - cmd.Params["user_name"] = userName - - p.nextToken() - // Semicolon is optional for UNSET TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil + return NewCommand("admin_list_services"), nil } func (p *Parser) parseAdminListRoles() (*Command, error) { @@ -276,6 +173,16 @@ func (p *Parser) parseAdminListResources() (*Command, error) { return NewCommand("admin_list_resources_command"), nil } +func (p *Parser) parseAdminListVariables() (*Command, error) { + p.nextToken() // consume VARIABLES + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + return NewCommand("admin_list_variables"), nil +} + func (p *Parser) parseAdminListTokens() (*Command, error) { p.nextToken() // consume TOKENS cmd := NewCommand("list_tokens") @@ -375,6 +282,40 @@ func (p *Parser) parseAdminListIngestionTasks() (*Command, error) { return cmd, nil } +// LIST PROVIDER 'provider_name' MODELS; +func (p *Parser) parseAdminListProvider() (*Command, error) { + p.nextToken() // consume PROVIDER + + providerName, err := p.parseQuotedString() + if err != nil { + return nil, err + } + p.nextToken() + + if p.curToken.Type != TokenModels { + return nil, fmt.Errorf("expected MODELS") + } + p.nextToken() // consume MODELS + cmd := NewCommand("admin_list_provider_models") + cmd.Params["provider_name"] = providerName + + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + return cmd, nil +} + +func (p *Parser) parseAdminListModels() (*Command, error) { + p.nextToken() // consume MODELS + cmd := NewCommand("admin_list_all_models") + + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return cmd, nil +} + // endregion LIST commands // region SHOW commands @@ -384,25 +325,25 @@ func (p *Parser) parseAdminShowCommand() (*Command, error) { switch p.curToken.Type { case TokenService: - return p.parseShowService() + return p.parseAdminShowService() case TokenUser: - return p.parseAdminShowUserCommand() + return p.parseAdminShowUserCommands() case TokenRole: - return p.parseAdminShowRoleCommand() + return p.parseAdminShowRole() case TokenVersion: - return p.parseAdminShowVersionCommand() + return p.parseAdminShowVersion() case TokenVar: - return p.parseShowVariable() + return p.parseAdminShowVariable() case TokenCurrent: - return p.parseAdminShowCurrentCommand() + return p.parseAdminShowCurrent() case TokenFingerprint: - return p.parseAdminShowFingerprintCommand() + return p.parseAdminShowFingerprint() case TokenLicense: - return p.parseAdminShowLicenseCommand() + return p.parseAdminShowLicense() case TokenProvider: - return p.parseShowProvider() + return p.parseAdminShowProvider() case TokenModel: - return p.parseShowModel() + return p.parseAdminShowModel() case TokenAdmin: return p.parseUserShowAdmin() case TokenAPI: @@ -414,39 +355,21 @@ func (p *Parser) parseAdminShowCommand() (*Command, error) { case TokenQuota: return p.parseAdminShowQuotaCommand() case TokenTasks: - return p.parseAdminShowQuotaCommand() + return p.parseAdminShowTasksCommand() default: return nil, fmt.Errorf("unknown SHOW target: %s", p.curToken.Value) } } -func (p *Parser) parseAdminShowUser() (*Command, error) { - p.nextToken() // consume USER - - // Check for PERMISSION - if p.curToken.Type == TokenPermission { - p.nextToken() - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - cmd := NewCommand("show_user_permission") - cmd.Params["user_name"] = userName - p.nextToken() - // Semicolon is optional for SHOW TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil - } - - userName, err := p.parseQuotedString() +func (p *Parser) parseAdminShowService() (*Command, error) { + p.nextToken() // consume SERVICE + serviceNum, err := p.parseNumber() if err != nil { return nil, err } - cmd := NewCommand("show_user") - cmd.Params["user_name"] = userName + cmd := NewCommand("admin_show_service") + cmd.Params["number"] = serviceNum p.nextToken() // Semicolon is optional for UNSET TOKEN @@ -456,14 +379,209 @@ func (p *Parser) parseAdminShowUser() (*Command, error) { return cmd, nil } -func (p *Parser) parseAdminShowRoleCommand() (*Command, error) { +// SHOW USER 'user@example.com'; +// SHOW USER 'user@example.com' ACTIVITY; +// SHOW USER 'user@example.com' SUMMARY; +// SHOW USER 'user@example.com' DATASET 'dataset_name'; +// SHOW USER 'user@example.com' STORAGE; +// SHOW USER 'user@example.com' QUOTA; +// SHOW USER 'user@example.com' INDEX; +// SHOW USER 'user@example.com' PERMISSION; +func (p *Parser) parseAdminShowUserCommands() (*Command, error) { + p.nextToken() // consume USER + + userName, err := p.parseQuotedString() + if err != nil { + return nil, err + } + p.nextToken() + + switch p.curToken.Type { + case TokenActivity: + return p.parseAdminShowActivityCommand(userName) + case TokenSummary: + return p.parseAdminShowUserSummaryCommand(userName) + case TokenDataset: + return p.parseAdminShowUserDataSetCommand(userName) + case TokenStorage: + return p.parseAdminShowUserStorageCommand(userName) + case TokenQuota: + return p.parseAdminShowUserQuotaCommand(userName) + case TokenIndex: + return p.parseAdminShowUserIndexCommand(userName) + case TokenPermission: + return p.parseAdminShowUserPermissionCommand(userName) + default: + return p.parseAdminShowUser(userName) + } +} + +// SHOW USER 'user@example.com'; +func (p *Parser) parseAdminShowUser(userName string) (*Command, error) { + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + cmd := NewCommand("admin_show_user") + cmd.Params["user_name"] = userName + + return cmd, nil +} + +// SHOW USER 'user@example.com' ACTIVITY DAYS 30; +func (p *Parser) parseAdminShowActivityCommand(userName string) (*Command, error) { + p.nextToken() // consume ACTIVITY + + var days int + var err error + + if p.curToken.Type == TokenDays { + p.nextToken() // consume DAYS + days, err = p.parseNumber() + if err != nil { + return nil, err + } + if days < 1 { + return nil, fmt.Errorf("invalid number of DAYS") + } + p.nextToken() + } else { + days = 7 + } + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + cmd := NewCommand("admin_show_user_activity_command") + cmd.Params["user_name"] = userName + cmd.Params["days"] = days + + return cmd, nil +} + +// SHOW USER 'user@example.com' SUMMARY; +func (p *Parser) parseAdminShowUserSummaryCommand(userName string) (*Command, error) { + p.nextToken() // consume SUMMARY + + cmd := NewCommand("admin_show_user_summary_command") + cmd.Params["user_name"] = userName + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return cmd, nil +} + +// SHOW USER 'user@example.com' DATASET 'dataset_name'; +func (p *Parser) parseAdminShowUserDataSetCommand(userName string) (*Command, error) { + p.nextToken() // consume DATASET + + var tree = false + var datasetName string + var err error + datasetName, err = p.parseQuotedString() + if err != nil { + return nil, err + } + p.nextToken() + + if p.curToken.Type == TokenTree { + tree = true + p.nextToken() + } + + cmd := NewCommand("admin_show_user_dataset_command") + cmd.Params["user_name"] = userName + if datasetName != "" { + cmd.Params["dataset_name"] = datasetName + } + if tree { + cmd.Params["tree"] = true + } + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return cmd, nil +} + +// SHOW USER 'user@example.com' STORAGE; +func (p *Parser) parseAdminShowUserStorageCommand(userName string) (*Command, error) { + p.nextToken() // consume STORAGE + + cmd := NewCommand("admin_show_user_storage_command") + cmd.Params["user_name"] = userName + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return cmd, nil +} + +// SHOW USER 'user@example.com' QUOTA; +func (p *Parser) parseAdminShowUserQuotaCommand(userName string) (*Command, error) { + p.nextToken() // consume QUOTA + + cmd := NewCommand("admin_show_user_quota_command") + cmd.Params["user_name"] = userName + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return cmd, nil +} + +// SHOW USER 'user@example.com' INDEX; +func (p *Parser) parseAdminShowUserIndexCommand(userName string) (*Command, error) { + p.nextToken() // consume INDEX + + cmd := NewCommand("admin_show_user_index_command") + cmd.Params["user_name"] = userName + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return cmd, nil +} + +// SHOW USER 'user@example.com' PERMISSION; +func (p *Parser) parseAdminShowUserPermissionCommand(userName string) (*Command, error) { + p.nextToken() // consume PERMISSION + + cmd := NewCommand("admin_show_user_permission_command") + cmd.Params["user_name"] = userName + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + return cmd, nil +} + +// SHOW ROLE 'role_name'; +func (p *Parser) parseAdminShowRole() (*Command, error) { p.nextToken() // consume ROLE - roleName, err := p.parseIdentifier() + + roleName, err := p.parseQuotedString() if err != nil { return nil, err } - cmd := NewCommand("show_role") + cmd := NewCommand("admin_show_role") cmd.Params["role_name"] = roleName p.nextToken() @@ -474,14 +592,27 @@ func (p *Parser) parseAdminShowRoleCommand() (*Command, error) { return cmd, nil } +// SHOW VERSION; +func (p *Parser) parseAdminShowVersion() (*Command, error) { + p.nextToken() // consume VERSION + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return NewCommand("admin_show_version_command"), nil +} + +// SHOW VAR 'var_name'; func (p *Parser) parseAdminShowVariable() (*Command, error) { p.nextToken() // consume VAR - varName, err := p.parseIdentifier() + varName, err := p.parseQuotedString() if err != nil { return nil, err } - cmd := NewCommand("show_variable") + cmd := NewCommand("admin_show_variable") cmd.Params["var_name"] = varName p.nextToken() @@ -492,21 +623,105 @@ func (p *Parser) parseAdminShowVariable() (*Command, error) { return cmd, nil } -func (p *Parser) parseAdminShowService() (*Command, error) { - p.nextToken() // consume SERVICE - serviceNum, err := p.parseNumber() - if err != nil { - return nil, err - } +// SHOW CURRENT; +func (p *Parser) parseAdminShowCurrent() (*Command, error) { + p.nextToken() // consume CURRENT - cmd := NewCommand("show_service") - cmd.Params["number"] = serviceNum - - p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } + + return NewCommand("admin_show_current"), nil +} + +// SHOW FINGERPRINT; +func (p *Parser) parseAdminShowFingerprint() (*Command, error) { + p.nextToken() // consume FINGERPRINT + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return NewCommand("admin_show_fingerprint"), nil +} + +// SHOW LICENSE; +func (p *Parser) parseAdminShowLicense() (*Command, error) { + p.nextToken() // consume LICENSE + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + return NewCommand("admin_show_license"), nil +} + +// SHOW PROVIDER 'provider_name'; +func (p *Parser) parseAdminShowProvider() (*Command, error) { + p.nextToken() // consume PROVIDER + + providerName, err := p.parseQuotedString() + if err != nil { + return nil, fmt.Errorf("expected provider name: %w", err) + } + p.nextToken() + + if p.curToken.Type == TokenModel { + // SHOW PROVIDER 'provider_name' MODEL 'model_name' + return p.parseAdminShowProviderModel(providerName) + } + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + cmd := NewCommand("admin_show_provider") + cmd.Params["provider_name"] = providerName + return cmd, nil +} + +// SHOW PROVIDER 'provider_name' MODEL 'model_name'; +func (p *Parser) parseAdminShowProviderModel(providerName string) (*Command, error) { + p.nextToken() // consume MODEL + + modelName, err := p.parseQuotedString() + if err != nil { + return nil, fmt.Errorf("expected model name: %w", err) + } + p.nextToken() // consume model_name + + cmd := NewCommand("admin_show_provider_model") + cmd.Params["model_name"] = modelName + cmd.Params["provider_name"] = providerName + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + return cmd, nil +} + +// SHOW MODEL 'model_name'; +func (p *Parser) parseAdminShowModel() (*Command, error) { + p.nextToken() // consume MODEL + + modelName, err := p.parseQuotedString() + if err != nil { + return nil, fmt.Errorf("expected model name: %w", err) + } + p.nextToken() + + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + + cmd := NewCommand("admin_show_model") + cmd.Params["model_name"] = modelName return cmd, nil } @@ -2024,243 +2239,6 @@ func (p *Parser) parseAdminRemoveCommand() (*Command, error) { return cmd, nil } -// SHOW VERSION; -func (p *Parser) parseAdminShowVersionCommand() (*Command, error) { - p.nextToken() // consume VERSION - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return NewCommand("admin_show_version_command"), nil -} - -// SHOW CURRENT; -func (p *Parser) parseAdminShowCurrentCommand() (*Command, error) { - p.nextToken() // consume CURRENT - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return NewCommand("show_current"), nil -} - -func (p *Parser) parseAdminShowFingerprintCommand() (*Command, error) { - p.nextToken() // consume FINGERPRINT - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return NewCommand("admin_show_fingerprint_command"), nil -} - -func (p *Parser) parseAdminShowLicenseCommand() (*Command, error) { - p.nextToken() // consume LICENSE - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return NewCommand("admin_show_license_command"), nil -} - -// SHOW USER 'user@example.com'; -// SHOW USER 'user@example.com' DATASET 'dataset_name'; -// SHOW USER 'user@example.com' SUMMARY; -// SHOW USER 'user@example.com' STORAGE; -// SHOW USER 'user@example.com' QUOTA; -// SHOW USER 'user@example.com' INDEX; -func (p *Parser) parseAdminShowUserCommand() (*Command, error) { - p.nextToken() // consume USER - - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - p.nextToken() - - switch p.curToken.Type { - case TokenActivity: - return p.parseAdminShowActivityCommand(userName) - case TokenSummary: - return p.parseAdminShowUserSummaryCommand(userName) - case TokenDataset: - return p.parseAdminShowUserDataSetCommand(userName) - case TokenStorage: - return p.parseAdminShowUserStorageCommand(userName) - case TokenQuota: - return p.parseAdminShowUserQuotaCommand(userName) - case TokenIndex: - return p.parseAdminShowUserIndexCommand(userName) - case TokenPermission: - return p.parseAdminShowUserPermissionCommand(userName) - default: - return p.parseAdminShowUserInfoCommand(userName) - } -} - -// SHOW USER 'user@example.com'; -func (p *Parser) parseAdminShowUserInfoCommand(userName string) (*Command, error) { - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - cmd := NewCommand("admin_show_user_info_command") - cmd.Params["user_name"] = userName - - return cmd, nil -} - -// SHOW USER 'user@example.com' ACTIVITY DAYS 30; -func (p *Parser) parseAdminShowActivityCommand(userName string) (*Command, error) { - p.nextToken() // consume ACTIVITY - - var days int - var err error - - if p.curToken.Type == TokenDays { - p.nextToken() // consume DAYS - days, err = p.parseNumber() - if err != nil { - return nil, err - } - if days < 1 { - return nil, fmt.Errorf("invalid number of DAYS") - } - p.nextToken() - } else { - days = 7 - } - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - cmd := NewCommand("admin_show_user_activity_command") - cmd.Params["user_name"] = userName - cmd.Params["days"] = days - - return cmd, nil -} - -// SHOW USER 'user@example.com' SUMMARY; -func (p *Parser) parseAdminShowUserSummaryCommand(userName string) (*Command, error) { - p.nextToken() // consume SUMMARY - - cmd := NewCommand("admin_show_user_summary_command") - cmd.Params["user_name"] = userName - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return cmd, nil -} - -// SHOW USER 'user@example.com' DATASET 'dataset_name'; -func (p *Parser) parseAdminShowUserDataSetCommand(userName string) (*Command, error) { - p.nextToken() // consume DATASET - - var tree = false - var datasetName string - var err error - datasetName, err = p.parseQuotedString() - if err != nil { - return nil, err - } - p.nextToken() - - if p.curToken.Type == TokenTree { - tree = true - p.nextToken() - } - - cmd := NewCommand("admin_show_user_dataset_command") - cmd.Params["user_name"] = userName - if datasetName != "" { - cmd.Params["dataset_name"] = datasetName - } - if tree { - cmd.Params["tree"] = true - } - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return cmd, nil -} - -// SHOW USER 'user@example.com' STORAGE; -func (p *Parser) parseAdminShowUserStorageCommand(userName string) (*Command, error) { - p.nextToken() // consume STORAGE - - cmd := NewCommand("admin_show_user_storage_command") - cmd.Params["user_name"] = userName - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return cmd, nil -} - -// SHOW USER 'user@example.com' QUOTA; -func (p *Parser) parseAdminShowUserQuotaCommand(userName string) (*Command, error) { - p.nextToken() // consume QUOTA - - cmd := NewCommand("admin_show_user_quota_command") - cmd.Params["user_name"] = userName - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return cmd, nil -} - -// SHOW USER 'user@example.com' INDEX; -func (p *Parser) parseAdminShowUserIndexCommand(userName string) (*Command, error) { - p.nextToken() // consume INDEX - - cmd := NewCommand("admin_show_user_index_command") - cmd.Params["user_name"] = userName - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - - return cmd, nil -} - -// SHOW USER 'user@example.com' PERMISSION; -func (p *Parser) parseAdminShowUserPermissionCommand(userName string) (*Command, error) { - p.nextToken() // consume PERMISSION - - cmd := NewCommand("admin_show_user_permission_command") - cmd.Params["user_name"] = userName - - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil -} - // SHOW USERS SUMMARY; // SHOW USERS ACTIVITY; func (p *Parser) parseAdminShowUsersCommand() (*Command, error) { @@ -2654,6 +2632,7 @@ commandLoop: } // LIST USER 'user@example.com' INGESTION TASKS; +// LIST USER 'user_name' PROVIDER 'provider_name' INSTANCE 'instance_name' MODELS; func (p *Parser) parseAdminListUserCommand() (*Command, error) { p.nextToken() // consume USER diff --git a/internal/cli/cli_http.go b/internal/cli/cli_http.go index c12b1f3228..ea875047f0 100644 --- a/internal/cli/cli_http.go +++ b/internal/cli/cli_http.go @@ -41,12 +41,12 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.LoginUserByCommand(cmd) case "logout": return c.Logout() - case "ping": + case "ping_server": return c.PingByCommand(cmd) case "benchmark": return c.RunBenchmark(cmd) - case "list_services": - return c.ListServices(cmd) + case "admin_list_services": + return c.AdminListServicesCommand(cmd) case "grant_admin": return c.GrantAdmin(cmd) case "revoke_admin": @@ -65,16 +65,16 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.AdminDropUserCommand(cmd) case "admin_drop_user_api_key_command": return c.AdminDropUserAPIKeyCommand(cmd) - case "show_service": - return c.ShowService(cmd) + case "admin_show_service": + return c.AdminShowService(cmd) case "admin_show_version_command": return c.AdminShowVersionCommand(cmd) - case "show_current": - return c.ShowCommonCurrent(cmd) - case "list_variables": - return c.ListVariables(cmd) - case "show_variable": - return c.ShowVariable(cmd) + case "admin_show_current": + return c.CommonShowCurrent(cmd) + case "admin_list_variables": + return c.AdminListVariables(cmd) + case "admin_show_variable": + return c.AdminShowVariable(cmd) case "admin_set_license_command": return c.AdminSetLicenseCommand(cmd) case "admin_set_license_config_command": @@ -83,8 +83,6 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.SetVariable(cmd) case "list_user_datasets": return c.ListUserDatasets(cmd) - case "list_agents": - return c.ListAgents(cmd) case "admin_list_resources_command": return c.AdminListResourcesCommand(cmd) case "admin_list_roles_command": @@ -95,19 +93,19 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.ListAdminTokens(cmd) case "list_available_providers": return c.ListAvailableProviders(cmd) - case "show_provider": - return c.ShowProvider(cmd) - case "list_provider_models": - return c.ListModels(cmd) + case "admin_show_provider": + return c.CommonShowProviderCommand(cmd) + case "admin_show_provider_model": + return c.CommonShowProviderModelCommand(cmd) + case "admin_list_provider_models": + return c.CommonListModelsCommand(cmd) case "list_supported_models": return c.ListSupportedModels(cmd) case "list_instance_models": return c.ListInstanceModels(cmd) - case "show_provider_model": - return c.ShowProviderModel(cmd) - case "show_model": - return c.ShowModel(cmd) - case "list_all_models": + case "admin_show_model": + return c.CommonShowModel(cmd) + case "admin_list_all_models": return c.ListAllModels(cmd) case "list_admin_tasks": return c.ListAdminTasks(cmd) @@ -133,12 +131,14 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.AdminRemoveServiceCommand(cmd) case "admin_check_license_command": return c.AdminCheckLicenseCommand(cmd) - case "admin_show_fingerprint_command": + case "admin_show_fingerprint": return c.AdminShowFingerprintCommand(cmd) - case "admin_show_license_command": + case "admin_show_license": return c.AdminShowLicenseCommand(cmd) - case "admin_show_user_info_command": - return c.AdminShowUserInfoCommand(cmd) + case "admin_show_user": + return c.AdminShowUserCommand(cmd) + case "admin_show_role": + return c.AdminShowRoleCommand(cmd) case "admin_show_user_activity_command": return c.AdminShowUserActivityCommand(cmd) case "admin_show_user_summary_command": @@ -232,7 +232,7 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) { return c.LoginUserByCommand(cmd) case "logout": return c.Logout() - case "ping": + case "ping_server": return c.PingByCommand(cmd) // Configuration commands case "list_configs": @@ -265,21 +265,21 @@ func (c *CLI) ExecuteUserCommand(cmd *Command) (ResponseIf, error) { case "show_version": return c.ShowServerVersion(cmd) case "show_current": - return c.ShowCommonCurrent(cmd) + return c.CommonShowCurrent(cmd) case "list_available_providers": return c.ListAvailableProviders(cmd) case "show_provider": - return c.ShowProvider(cmd) + return c.CommonShowProviderCommand(cmd) case "list_provider_models": - return c.ListModels(cmd) + return c.CommonListModelsCommand(cmd) case "list_supported_models": return c.ListSupportedModels(cmd) case "list_instance_models": return c.ListInstanceModels(cmd) case "show_provider_model": - return c.ShowProviderModel(cmd) + return c.CommonShowProviderModelCommand(cmd) case "show_model": - return c.ShowModel(cmd) + return c.CommonShowModel(cmd) case "list_all_models": return c.ListAllModels(cmd) // Provider commands diff --git a/internal/cli/common_command.go b/internal/cli/common_command.go index f523913098..097da23eb3 100644 --- a/internal/cli/common_command.go +++ b/internal/cli/common_command.go @@ -283,7 +283,7 @@ func (c *CLI) ListAvailableProviders(cmd *Command) (ResponseIf, error) { return &result, nil } -func (c *CLI) ShowProvider(cmd *Command) (ResponseIf, error) { +func (c *CLI) CommonShowProviderCommand(cmd *Command) (ResponseIf, error) { providerName, ok := cmd.Params["provider_name"].(string) if !ok { return nil, fmt.Errorf("provider_name not provided") @@ -323,7 +323,7 @@ func (c *CLI) ShowProvider(cmd *Command) (ResponseIf, error) { return &result, nil } -func (c *CLI) ListModels(cmd *Command) (ResponseIf, error) { +func (c *CLI) CommonListModelsCommand(cmd *Command) (ResponseIf, error) { providerName, ok := cmd.Params["provider_name"].(string) if !ok { @@ -409,7 +409,7 @@ func (c *CLI) ListSupportedModels(cmd *Command) (ResponseIf, error) { return &result, nil } -func (c *CLI) ShowProviderModel(cmd *Command) (ResponseIf, error) { +func (c *CLI) CommonShowProviderModelCommand(cmd *Command) (ResponseIf, error) { providerName, ok := cmd.Params["provider_name"].(string) if !ok { return nil, fmt.Errorf("provider_name not provided") @@ -583,7 +583,7 @@ func (c *CLI) ListDefaultModels(cmd *Command) (ResponseIf, error) { return &result, nil } -func (c *CLI) ShowCommonCurrent(cmd *Command) (ResponseIf, error) { +func (c *CLI) CommonShowCurrent(cmd *Command) (ResponseIf, error) { var result *CommonDataResponse switch c.Config.CLIMode { @@ -918,17 +918,22 @@ func (c *CLI) ListAllModels(cmd *Command) (ResponseIf, error) { "page_size": pageSize, } + var resp *Response + var err error var httpClient *HTTPClient switch c.Config.CLIMode { case AdminMode: httpClient = c.AdminServerClient + apiURL := "/admin/all-models" + resp, err = httpClient.Request("GET", apiURL, "web", nil, payload) case APIMode: httpClient = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer] + apiURL := "/all-models" + resp, err = httpClient.Request("GET", apiURL, "web", nil, payload) default: return nil, fmt.Errorf("invalid server type") } - resp, err := httpClient.Request("GET", "/all-models", "web", nil, payload) if err != nil { return nil, fmt.Errorf("failed to list all models: %w", err) } @@ -949,7 +954,7 @@ func (c *CLI) ListAllModels(cmd *Command) (ResponseIf, error) { return &result, nil } -func (c *CLI) ShowModel(cmd *Command) (ResponseIf, error) { +func (c *CLI) CommonShowModel(cmd *Command) (ResponseIf, error) { modelName, ok := cmd.Params["model_name"].(string) if !ok { @@ -960,17 +965,20 @@ func (c *CLI) ShowModel(cmd *Command) (ResponseIf, error) { "model_name": modelName, } + var resp *Response + var err error var httpClient *HTTPClient switch c.Config.CLIMode { case AdminMode: httpClient = c.AdminServerClient + resp, err = httpClient.Request("GET", "/admin/all-models", "web", nil, payload) case APIMode: httpClient = c.APIServerClientMap[c.Config.APIClientConfig.CurrentAPIServer] + resp, err = httpClient.Request("GET", "/all-models", "web", nil, payload) default: return nil, fmt.Errorf("invalid server type") } - resp, err := httpClient.Request("GET", "/all-models", "web", nil, payload) if err != nil { return nil, fmt.Errorf("failed to show model: %w", err) } diff --git a/internal/cli/parser.go b/internal/cli/parser.go index b910f244da..0ddfb7711e 100644 --- a/internal/cli/parser.go +++ b/internal/cli/parser.go @@ -86,8 +86,6 @@ func (p *Parser) parseAdminCommand() (*Command, error) { return p.parseAdminLogout() case TokenPing: return p.parseAdminPingServer() - case TokenRegister: - return p.parseAdminRegisterCommand() case TokenList: return p.parseAdminListCommand() case TokenShow: diff --git a/internal/cli/user_parser.go b/internal/cli/user_parser.go index 9b7e55ab13..63ca079a30 100644 --- a/internal/cli/user_parser.go +++ b/internal/cli/user_parser.go @@ -63,7 +63,7 @@ func (p *Parser) parseLoginUser() (*Command, error) { } func (p *Parser) parsePingServer() (*Command, error) { - cmd := NewCommand("ping") + cmd := NewCommand("ping_server") p.nextToken() // Semicolon is optional for UNSET TOKEN if p.curToken.Type == TokenSemicolon { @@ -119,6 +119,9 @@ func (p *Parser) parseRegisterCommand() (*Command, error) { return cmd, nil } +// LIST PROVIDER 'provider_name' MODELS; +// LIST PROVIDER 'provider_name' INSTANCE 'instance_name' MODELS +// LIST MODELS; func (p *Parser) parseListCommand() (*Command, error) { p.nextToken() // consume LIST @@ -447,8 +450,6 @@ func (p *Parser) parseShowCommand() (*Command, error) { return NewCommand("show_current"), nil case TokenVar: return p.parseShowVariable() - case TokenService: - return p.parseShowService() case TokenProvider: return p.parseShowProvider() case TokenModel: @@ -488,24 +489,6 @@ func (p *Parser) parseShowVariable() (*Command, error) { return cmd, nil } -func (p *Parser) parseShowService() (*Command, error) { - p.nextToken() // consume SERVICE - serviceNum, err := p.parseNumber() - if err != nil { - return nil, err - } - - cmd := NewCommand("show_service") - cmd.Params["number"] = serviceNum - - p.nextToken() - // Semicolon is optional for UNSET TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil -} - func (p *Parser) parseShowModel() (*Command, error) { p.nextToken() // consume model