From 05e758e4fe0a91f5b2d068c3cb1014b9be59edac Mon Sep 17 00:00:00 2001 From: Jin Hai Date: Mon, 22 Jun 2026 17:33:47 +0800 Subject: [PATCH] Go CLI: Fix alter role (#16226) ### What problem does this PR solve? As title. ### Type of change - [x] Bug Fix (non-breaking change which fixes an issue) --------- Signed-off-by: Jin Hai --- internal/admin/enterprise_handler.go | 12 +- internal/admin/enterprise_service.go | 18 +- internal/admin/handler.go | 17 ++ internal/admin/router.go | 5 +- internal/admin/service.go | 29 ++- internal/cli/admin_command.go | 328 +++++++++++++++++++-------- internal/cli/admin_parser.go | 293 +++++++++++------------- internal/cli/cli_http.go | 24 +- internal/cli/parser.go | 31 +-- internal/cli/user_parser.go | 92 +------- 10 files changed, 453 insertions(+), 396 deletions(-) diff --git a/internal/admin/enterprise_handler.go b/internal/admin/enterprise_handler.go index 45c6a21151..a408135709 100644 --- a/internal/admin/enterprise_handler.go +++ b/internal/admin/enterprise_handler.go @@ -125,15 +125,15 @@ func (h *Handler) DropRole(c *gin.Context) { success(c, role, "") } -// GetRolePermission handle get role permission -func (h *Handler) GetRolePermission(c *gin.Context) { +// ShowRolePermission handle get role permission +func (h *Handler) ShowRolePermission(c *gin.Context) { roleName := c.Param("role_name") if roleName == "" { errorResponse(c, "Role name is required", 400) return } - permissions, err := h.service.GetRolePermission(roleName) + permissions, err := h.service.ShowRolePermission(roleName) if err != nil { errorResponse(c, err.Error(), 500) return @@ -1269,8 +1269,8 @@ func (h *Handler) PurgeUsersData(c *gin.Context) { success(c, result, "") } -// CreateUserAPIKey handle create tenant API key -func (h *Handler) CreateUserAPIKey(c *gin.Context) { +// GenerateUserAPIKey handle create tenant API key +func (h *Handler) GenerateUserAPIKey(c *gin.Context) { encodedUsername := c.Param("username") username, err := common.DecodeEmail(encodedUsername) if err != nil { @@ -1278,7 +1278,7 @@ func (h *Handler) CreateUserAPIKey(c *gin.Context) { return } - apiKey, err := h.service.CreateUserAPIKey(username) + apiKey, err := h.service.GenerateUserAPIKey(username) if err != nil { errorResponse(c, err.Error(), 500) return diff --git a/internal/admin/enterprise_service.go b/internal/admin/enterprise_service.go index 5a43e2c7cb..48724fbb1a 100644 --- a/internal/admin/enterprise_service.go +++ b/internal/admin/enterprise_service.go @@ -85,14 +85,12 @@ func (s *Service) DropRole(roleName string) (map[string]interface{}, error) { return result, nil } -// GetRolePermission get role permissions -func (s *Service) GetRolePermission(roleName string) ([]map[string]interface{}, error) { - result := []map[string]interface{}{ - { - "command": "get_role_permission", - "role_name": roleName, - "error": "'get role permissions' is implemented in enterprise edition", - }, +// ShowRolePermission get role permissions +func (s *Service) ShowRolePermission(roleName string) (map[string]interface{}, error) { + result := map[string]interface{}{ + "command": "show_role_permission", + "role_name": roleName, + "error": "'show role permissions' is implemented in enterprise edition", } return result, nil @@ -834,8 +832,8 @@ func (s *Service) PurgeUsersData(preview bool, days int, userPlan *string, userA return result, nil } -// CreateUserAPIKey create tenant API key for tenant -func (s *Service) CreateUserAPIKey(username string) (map[string]interface{}, error) { +// GenerateUserAPIKey create tenant API key for tenant +func (s *Service) GenerateUserAPIKey(username string) (map[string]interface{}, error) { user, err := s.userDAO.GetByEmail(username) if err != nil { diff --git a/internal/admin/handler.go b/internal/admin/handler.go index 923e22a168..6634878f8e 100644 --- a/internal/admin/handler.go +++ b/internal/admin/handler.go @@ -622,6 +622,23 @@ func (h *Handler) ShutdownService(c *gin.Context) { success(c, result, "") } +// StartService handle start service +func (h *Handler) StartService(c *gin.Context) { + serviceID := c.Param("service_id") + if serviceID == "" { + errorResponse(c, "Service ID is required", 400) + return + } + + result, err := h.service.StartService(serviceID) + if err != nil { + errorResponse(c, err.Error(), 500) + return + } + + success(c, result, "") +} + // RestartService handle restart service func (h *Handler) RestartService(c *gin.Context) { serviceID := c.Param("service_id") diff --git a/internal/admin/router.go b/internal/admin/router.go index bbf66f3661..8f5e4ba6bc 100644 --- a/internal/admin/router.go +++ b/internal/admin/router.go @@ -75,6 +75,7 @@ func (r *Router) Setup(engine *gin.Engine) { protected.GET("/services/:service_id", r.handler.GetService) protected.DELETE("/services/:service_id", r.handler.ShutdownService) protected.PUT("/services/:service_id", r.handler.RestartService) + protected.POST("/services/:service_id", r.handler.StartService) // Variables/Settings protected.GET("/variables", r.handler.ListVariables) @@ -156,7 +157,7 @@ func (r *Router) Setup(engine *gin.Engine) { protected.DELETE("/users/data", r.handler.PurgeUsersData) // API Keys - protected.POST("/users/:username/keys", r.handler.CreateUserAPIKey) + protected.POST("/users/:username/keys", r.handler.GenerateUserAPIKey) protected.DELETE("/users/:username/keys/:key", r.handler.DeleteUserAPIKey) protected.GET("/users/:username/keys", r.handler.ListUserAPIKeys) @@ -171,7 +172,7 @@ func (r *Router) Setup(engine *gin.Engine) { protected.GET("/roles/:role_name", r.handler.ShowRole) protected.PUT("/roles/:role_name", r.handler.UpdateRole) protected.DELETE("/roles/:role_name", r.handler.DropRole) - protected.GET("/roles/:role_name/permission", r.handler.GetRolePermission) + protected.GET("/roles/:role_name/permission", r.handler.ShowRolePermission) protected.POST("/roles/:role_name/permission", r.handler.GrantRolePermission) protected.DELETE("/roles/:role_name/permission", r.handler.RevokeRolePermission) protected.GET("/roles/resource", r.handler.ListResources) diff --git a/internal/admin/service.go b/internal/admin/service.go index 831b432744..7c88c46c8a 100644 --- a/internal/admin/service.go +++ b/internal/admin/service.go @@ -534,12 +534,13 @@ func (s *Service) GetUserDetails(username string) (map[string]interface{}, error } return map[string]interface{}{ - "id": user.ID, - "email": user.Email, - "nickname": user.Nickname, - "is_active": user.IsActive, - "create_time": user.CreateTime, - "update_time": user.UpdateTime, + "id": user.ID, + "email": user.Email, + "nickname": user.Nickname, + "is_active": user.IsActive, + "is_superuser": user.IsSuperuser, + "create_time": user.CreateTime, + "update_time": user.UpdateTime, }, nil } @@ -1412,17 +1413,27 @@ func (s *Service) checkTaskExecutorAlive(name string) (map[string]interface{}, e func (s *Service) ShutdownService(serviceID string) (map[string]interface{}, error) { // TODO: Implement with proper service manager return map[string]interface{}{ + "command": "shutdown service", "service_id": serviceID, - "status": "shutdown", + "error": "shutdown service not implemented", + }, nil +} + +// StartService start service +func (s *Service) StartService(serviceID string) (map[string]interface{}, error) { + return map[string]interface{}{ + "command": "start service", + "service_id": serviceID, + "error": "command 'start service' isn't implemented", }, nil } // RestartService restart service func (s *Service) RestartService(serviceID string) (map[string]interface{}, error) { - // TODO: Implement with proper service manager return map[string]interface{}{ + "command": "restart service", "service_id": serviceID, - "status": "restarted", + "error": "command 'restart service' isn't implemented", }, nil } diff --git a/internal/cli/admin_command.go b/internal/cli/admin_command.go index be86f3327a..3415fc6950 100644 --- a/internal/cli/admin_command.go +++ b/internal/cli/admin_command.go @@ -252,7 +252,7 @@ func (c *CLI) AdminAlterRole(cmd *Command) (ResponseIf, error) { return nil, fmt.Errorf("failed to alter role: HTTP %d, body: %s", resp.StatusCode, string(resp.Body)) } - var result SimpleResponse + var result CommonDataResponse if err = json.Unmarshal(resp.Body, &result); err != nil { return nil, fmt.Errorf("alter role failed: invalid JSON (%w)", err) @@ -265,8 +265,8 @@ func (c *CLI) AdminAlterRole(cmd *Command) (ResponseIf, error) { return &result, nil } -// GrantAdmin grants admin privileges to a user (admin mode only) -func (c *CLI) GrantAdmin(cmd *Command) (ResponseIf, error) { +// AdminGrantUserAdminCommand grants admin privileges to a user (admin mode only) +func (c *CLI) AdminGrantUserAdminCommand(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") } @@ -301,8 +301,8 @@ func (c *CLI) GrantAdmin(cmd *Command) (ResponseIf, error) { return &result, nil } -// RevokeAdmin revokes admin privileges from a user (admin mode only) -func (c *CLI) RevokeAdmin(cmd *Command) (ResponseIf, error) { +// AdminRevokeUserAdminCommand revokes admin privileges from a user (admin mode only) +func (c *CLI) AdminRevokeUserAdminCommand(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") } @@ -337,6 +337,140 @@ func (c *CLI) RevokeAdmin(cmd *Command) (ResponseIf, error) { return &result, nil } +// AdminGrantRolePermissionCommand grants permission to role (admin mode only) +func (c *CLI) AdminGrantRolePermissionCommand(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") + } + + actions, ok := cmd.Params["actions"].([]string) + if !ok { + return nil, fmt.Errorf("actions not provided") + } + + resource, ok := cmd.Params["resource"].(string) + if !ok { + return nil, fmt.Errorf("resource not provided") + } + + roleName, ok := cmd.Params["role_name"].(string) + if !ok { + return nil, fmt.Errorf("role_name not provided") + } + + payload := map[string]interface{}{ + "actions": actions, + "resource": resource, + } + + apiURL := fmt.Sprintf("/admin/roles/%s/permission", roleName) + + resp, err := c.AdminServerClient.Request("POST", apiURL, "admin", nil, payload) + if err != nil { + return nil, fmt.Errorf("failed to grant permission to role: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to grant permission to 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("grant permission to role failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + result.Duration = resp.Duration + return &result, nil +} + +// AdminRevokeRolePermissionCommand revokes permission from role (admin mode only) +func (c *CLI) AdminRevokeRolePermissionCommand(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") + } + + actions, ok := cmd.Params["actions"].([]string) + if !ok { + return nil, fmt.Errorf("actions not provided") + } + + resource, ok := cmd.Params["resource"].(string) + if !ok { + return nil, fmt.Errorf("resource not provided") + } + + roleName, ok := cmd.Params["role_name"].(string) + if !ok { + return nil, fmt.Errorf("role_name not provided") + } + + payload := map[string]interface{}{ + "actions": actions, + "resource": resource, + } + + apiURL := fmt.Sprintf("/admin/roles/%s/permission", roleName) + + resp, err := c.AdminServerClient.Request("DELETE", apiURL, "admin", nil, payload) + if err != nil { + return nil, fmt.Errorf("failed to revoke permission from role: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to revoke permission from 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("revoke permission from role failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + result.Duration = resp.Duration + return &result, nil +} + +// AdminShowRolePermissionCommand shows admin privileges from a user (admin mode only) +func (c *CLI) AdminShowRolePermissionCommand(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, ok := cmd.Params["role_name"].(string) + if !ok { + return nil, fmt.Errorf("role_name not provided") + } + + apiURL := fmt.Sprintf("/admin/roles/%s/permission", roleName) + + resp, err := c.AdminServerClient.Request("GET", apiURL, "admin", nil, nil) + if err != nil { + return nil, fmt.Errorf("failed to show role permission: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to show role permission: 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 permission failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + result.Duration = resp.Duration + return &result, nil +} + // AdminCreateUserCommand creates a new user (admin mode only) func (c *CLI) AdminCreateUserCommand(cmd *Command) (ResponseIf, error) { if c.Config.CLIMode != AdminMode || c.AdminServerClient.LoginToken == nil { @@ -563,27 +697,112 @@ func (c *CLI) AdminListServicesCommand(cmd *Command) (ResponseIf, error) { return &result, nil } +// AdminStartServiceCommand starts a service (admin mode only) +func (c *CLI) AdminStartServiceCommand(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") + } + + serviceIndex := cmd.Params["service_index"].(int) + + endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex) + + resp, err := c.AdminServerClient.Request("POST", endPoint, "admin", nil, nil) + if err != nil { + return nil, fmt.Errorf("failed to start service: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to start service: 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("start service failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + + result.Duration = resp.Duration + return &result, nil +} + +// AdminRestartServiceCommand restarts a service (admin mode only) +func (c *CLI) AdminRestartServiceCommand(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") + } + + serviceIndex := cmd.Params["service_index"].(int) + + endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex) + + resp, err := c.AdminServerClient.Request("PUT", endPoint, "admin", nil, nil) + if err != nil { + return nil, fmt.Errorf("failed to restart service: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to restart service: 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("restart service failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + + result.Duration = resp.Duration + return &result, nil +} + +// AdminShutdownServiceCommand shuts down a service (admin mode only) +func (c *CLI) AdminShutdownServiceCommand(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") + } + + serviceIndex := cmd.Params["service_index"].(int) + + endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex) + + resp, err := c.AdminServerClient.Request("DELETE", endPoint, "admin", nil, nil) + if err != nil { + return nil, fmt.Errorf("failed to shutdown service: %w", err) + } + + if resp.StatusCode != 200 { + return nil, fmt.Errorf("failed to shutdown service: 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("shutdown service failed: invalid JSON (%w)", err) + } + + if result.Code != 0 { + return nil, fmt.Errorf("%s", result.Message) + } + + result.Duration = resp.Duration + return &result, nil +} + // 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") } - serviceIndex := cmd.Params["number"].(int) - - // Check for benchmark iterations - iterations := 1 - if val, ok := cmd.Params["iterations"].(int); ok && val > 1 { - iterations = val - } + serviceIndex := cmd.Params["service_index"].(int) endPoint := fmt.Sprintf("/admin/services/%d", serviceIndex) - 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 service: %w", err) @@ -1031,46 +1250,6 @@ func (c *CLI) ShowUserPermission(cmd *Command) (ResponseIf, error) { return &result, nil } -// GenerateAdminToken generates an API token for a user (admin mode only) -func (c *CLI) GenerateAdminToken(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") - } - - encodedUserName := common.EncodeEmail(userName) - apiURL := fmt.Sprintf("/admin/users/%s/keys", encodedUserName) - - resp, err := c.AdminServerClient.Request("POST", apiURL, "admin", nil, nil) - if err != nil { - return nil, fmt.Errorf("failed to generate token: %w", err) - } - - if resp.StatusCode != 200 { - return nil, fmt.Errorf("failed to generate token: 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("generate token failed: invalid JSON (%w)", err) - } - - if result.Code != 0 { - return nil, fmt.Errorf("%s", result.Message) - } - - delete(result.Data, "update_date") - delete(result.Data, "update_time") - delete(result.Data, "create_time") - - result.Duration = resp.Duration - return &result, nil -} - func (c *CLI) ListAdminTasks(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") @@ -1394,41 +1573,6 @@ func (c *CLI) UserShowMessageQueueCommand(cmd *Command) (ResponseIf, error) { return &result, nil } -func (c *CLI) AdminRemoveServiceCommand(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") - } - serviceNumber, ok := cmd.Params["service_number"].(int) - if !ok { - return nil, fmt.Errorf("service_number not provided") - } - - payload := map[string]interface{}{ - "service_number": serviceNumber, - } - - resp, err := c.AdminServerClient.Request("DELETE", "/admin/services", "admin", nil, payload) - if err != nil { - return nil, fmt.Errorf("failed to remove unavailable service: %w", err) - } - - if resp.StatusCode != 200 { - return nil, fmt.Errorf("failed to remove unavailable service: HTTP %d, body: %s", resp.StatusCode, string(resp.Body)) - } - - var result SimpleResponse - if err = json.Unmarshal(resp.Body, &result); err != nil { - return nil, fmt.Errorf("remove unavailable service failed: invalid JSON (%w)", err) - } - - if result.Code != 0 { - return nil, fmt.Errorf("%s", result.Message) - } - - result.Duration = resp.Duration - return &result, nil -} - // AdminCheckLicenseCommand check license command (admin mode only) func (c *CLI) AdminCheckLicenseCommand(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 5fc5b385bd..c7b7bee5fe 100644 --- a/internal/cli/admin_parser.go +++ b/internal/cli/admin_parser.go @@ -50,7 +50,7 @@ func (p *Parser) parseAdminLoginUser() (*Command, error) { p.nextToken() } - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -61,7 +61,7 @@ func (p *Parser) parseAdminLoginUser() (*Command, error) { func (p *Parser) parseAdminLogout() (*Command, error) { cmd := NewCommand("logout") p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -71,7 +71,7 @@ func (p *Parser) parseAdminLogout() (*Command, error) { func (p *Parser) parseAdminPingServer() (*Command, error) { cmd := NewCommand("ping_server") p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -208,7 +208,7 @@ func (p *Parser) parseAdminListFiles() (*Command, error) { cmd.Params["dataset_name"] = datasetName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -232,7 +232,7 @@ func (p *Parser) parseAdminListIngestionTasks() (*Command, error) { cmd := NewCommand("list_admin_ingestion_tasks") - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -321,16 +321,16 @@ func (p *Parser) parseAdminShowCommand() (*Command, error) { func (p *Parser) parseAdminShowService() (*Command, error) { p.nextToken() // consume SERVICE - serviceNum, err := p.parseNumber() + serviceIndex, err := p.parseNumber() if err != nil { return nil, err } cmd := NewCommand("admin_show_service") - cmd.Params["number"] = serviceNum + cmd.Params["service_index"] = serviceIndex p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -538,12 +538,19 @@ func (p *Parser) parseAdminShowRole() (*Command, error) { if err != nil { return nil, err } - - cmd := NewCommand("admin_show_role") - cmd.Params["role_name"] = roleName - p.nextToken() - // Semicolon is optional for UNSET TOKEN + + var cmd *Command + if p.curToken.Type == TokenPermission { + p.nextToken() + cmd = NewCommand("admin_show_role_permission") + cmd.Params["role_name"] = roleName + } else { + cmd = NewCommand("admin_show_role") + cmd.Params["role_name"] = roleName + } + + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -574,7 +581,7 @@ func (p *Parser) parseAdminShowVariable() (*Command, error) { cmd.Params["var_name"] = varName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -694,7 +701,7 @@ func (p *Parser) parseCommonShowPoolModel() (*Command, error) { cmd := NewCommand("show_pool_provider") cmd.Params["provider_name"] = providerName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -718,7 +725,7 @@ func (p *Parser) parseCommonShowPoolModel() (*Command, error) { cmd := NewCommand("show_pool_model") cmd.Params["provider_name"] = providerName cmd.Params["model_name"] = modelName - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -752,6 +759,7 @@ func (p *Parser) parseAdminCheckLicense() (*Command, error) { return cmd, nil } +// STOP INGESTION TASKS 'task_id1 task_id2'; func (p *Parser) parseAdminStopIngestionTasks() (*Command, error) { p.nextToken() // consume STOP @@ -781,7 +789,7 @@ func (p *Parser) parseAdminStopIngestionTasks() (*Command, error) { return nil, fmt.Errorf("expected USER or INGESTION") } - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -790,7 +798,7 @@ func (p *Parser) parseAdminStopIngestionTasks() (*Command, error) { } func (p *Parser) parseAdminRemoveIngestionTasks() (*Command, error) { - p.nextToken() // consume Ingestion + p.nextToken() // consume INGESTION if p.curToken.Type != TokenTasks { return nil, fmt.Errorf("expected TASKS") @@ -808,7 +816,7 @@ func (p *Parser) parseAdminRemoveIngestionTasks() (*Command, error) { cmd := NewCommand("admin_remove_ingestion_tasks") cmd.Params["tasks"] = tasks - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -858,7 +866,7 @@ func (p *Parser) parseAdminCreateUser() (*Command, error) { return nil, fmt.Errorf("expected password or KEY after USER, got %s", p.curToken.Value) } - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -903,7 +911,7 @@ func (p *Parser) parseAdminCreateRole() (*Command, error) { p.nextToken() } - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -982,7 +990,7 @@ func (p *Parser) parseAdminDropRole() (*Command, error) { cmd.Params["role_name"] = roleName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1005,7 +1013,7 @@ func (p *Parser) parseAdminDropModelProvider() (*Command, error) { cmd.Params["provider_name"] = providerName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1023,7 +1031,7 @@ func (p *Parser) parseAdminDropDataset() (*Command, error) { cmd.Params["dataset_name"] = datasetName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1041,7 +1049,7 @@ func (p *Parser) parseAdminDropChat() (*Command, error) { cmd.Params["chat_name"] = chatName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1089,7 +1097,7 @@ func (p *Parser) parseAdminAlterUser() (*Command, error) { cmd.Params["password"] = password p.nextToken() - // Semicolon is optional for SHOW TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1121,7 +1129,34 @@ func (p *Parser) parseAdminAlterUser() (*Command, error) { cmd.Params["role_name"] = roleName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional + if p.curToken.Type == TokenSemicolon { + p.nextToken() + } + return cmd, nil +} + +func (p *Parser) parseAdminActivateUser() (*Command, error) { + p.nextToken() // consume ACTIVE + + userName, err := p.parseQuotedString() + if err != nil { + return nil, err + } + p.nextToken() + + // Accept 'on' or 'off' as identifier + status := p.curToken.Value + if status != "on" && status != "off" { + return nil, fmt.Errorf("expected 'on' or 'off', got %s", p.curToken.Value) + } + p.nextToken() + + cmd := NewCommand("admin_activate_user") + cmd.Params["user_name"] = userName + cmd.Params["activate_status"] = status + + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1130,16 +1165,18 @@ func (p *Parser) parseAdminAlterUser() (*Command, error) { func (p *Parser) parseAdminAlterRole() (*Command, error) { p.nextToken() // consume ROLE - roleName, err := p.parseIdentifier() + + roleName, err := p.parseQuotedString() if err != nil { return nil, err } - p.nextToken() + if p.curToken.Type != TokenSet { return nil, fmt.Errorf("expected SET") } p.nextToken() + if p.curToken.Type != TokenDescription { return nil, fmt.Errorf("expected DESCRIPTION") } @@ -1149,13 +1186,13 @@ func (p *Parser) parseAdminAlterRole() (*Command, error) { if err != nil { return nil, err } + p.nextToken() - cmd := NewCommand("alter_role") + cmd := NewCommand("admin_alter_role") cmd.Params["role_name"] = roleName cmd.Params["description"] = description - p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1163,33 +1200,8 @@ func (p *Parser) parseAdminAlterRole() (*Command, error) { } // endregion ALTER commands -func (p *Parser) parseAdminActivateUser() (*Command, error) { - p.nextToken() // consume ACTIVE - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - p.nextToken() - // Accept 'on' or 'off' as identifier - status := p.curToken.Value - if status != "on" && status != "off" { - return nil, fmt.Errorf("expected 'on' or 'off', got %s", p.curToken.Value) - } - - cmd := NewCommand("admin_activate_user") - cmd.Params["user_name"] = userName - cmd.Params["activate_status"] = status - - p.nextToken() - // Semicolon is optional for UNSET TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil -} - -func (p *Parser) parseAdminGrantCommand() (*Command, error) { +func (p *Parser) parseAdminGrantCommands() (*Command, error) { p.nextToken() // consume GRANT if p.curToken.Type == TokenAdmin { @@ -1206,11 +1218,11 @@ func (p *Parser) parseAdminGrantAdmin() (*Command, error) { return nil, err } - cmd := NewCommand("grant_admin") + cmd := NewCommand("admin_grant_user_admin") cmd.Params["user_name"] = userName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1218,50 +1230,56 @@ func (p *Parser) parseAdminGrantAdmin() (*Command, error) { } func (p *Parser) parseAdminGrantPermission() (*Command, error) { - actions, err := p.parseIdentifierList() + actionListStr, err := p.parseQuotedString() if err != nil { return nil, err } + actions := strings.Split(actionListStr, ",") + p.nextToken() + for idx, _ := range actions { + actions[idx] = strings.TrimSpace(actions[idx]) + } if p.curToken.Type != TokenOn { return nil, fmt.Errorf("expected ON") } p.nextToken() - resource, err := p.parseIdentifier() + resource, err := p.parseQuotedString() if err != nil { return nil, err } - p.nextToken() + if p.curToken.Type != TokenTo { return nil, fmt.Errorf("expected TO") } p.nextToken() + if p.curToken.Type != TokenRole { return nil, fmt.Errorf("expected ROLE") } p.nextToken() - roleName, err := p.parseIdentifier() + roleName, err := p.parseQuotedString() if err != nil { return nil, err } - cmd := NewCommand("grant_permission") + cmd := NewCommand("admin_grant_role_permission") cmd.Params["actions"] = actions cmd.Params["resource"] = resource cmd.Params["role_name"] = roleName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } return cmd, nil } -func (p *Parser) parseAdminRevokeCommand() (*Command, error) { +func (p *Parser) parseAdminRevokeCommands() (*Command, error) { p.nextToken() // consume REVOKE if p.curToken.Type == TokenAdmin { @@ -1278,11 +1296,11 @@ func (p *Parser) parseAdminRevokeAdmin() (*Command, error) { return nil, err } - cmd := NewCommand("revoke_admin") + cmd := NewCommand("admin_revoke_user_admin") cmd.Params["user_name"] = userName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1290,17 +1308,22 @@ func (p *Parser) parseAdminRevokeAdmin() (*Command, error) { } func (p *Parser) parseAdminRevokePermission() (*Command, error) { - actions, err := p.parseIdentifierList() + actionListStr, err := p.parseQuotedString() if err != nil { return nil, err } + actions := strings.Split(actionListStr, ",") + p.nextToken() + for idx, _ := range actions { + actions[idx] = strings.TrimSpace(actions[idx]) + } if p.curToken.Type != TokenOn { return nil, fmt.Errorf("expected ON") } p.nextToken() - resource, err := p.parseIdentifier() + resource, err := p.parseQuotedString() if err != nil { return nil, err } @@ -1315,18 +1338,18 @@ func (p *Parser) parseAdminRevokePermission() (*Command, error) { } p.nextToken() - roleName, err := p.parseIdentifier() + roleName, err := p.parseQuotedString() if err != nil { return nil, err } - cmd := NewCommand("revoke_permission") + cmd := NewCommand("admin_revoke_role_permission") cmd.Params["actions"] = actions cmd.Params["resource"] = resource cmd.Params["role_name"] = roleName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1366,8 +1389,6 @@ func (p *Parser) parseAdminSetCommand() (*Command, error) { return p.parseAdminSetVariable() case TokenDefault: return p.parseAdminSetDefault() - case TokenToken: - return p.parseAdminSetToken() default: return nil, fmt.Errorf("unknown SET target: %s", p.curToken.Value) } @@ -1413,7 +1434,8 @@ func (p *Parser) parseAdminSetLicense() (*Command, error) { func (p *Parser) parseAdminSetVariable() (*Command, error) { p.nextToken() // consume VAR - varName, err := p.parseIdentifier() + + varName, err := p.parseQuotedString() if err != nil { return nil, err } @@ -1429,7 +1451,7 @@ func (p *Parser) parseAdminSetVariable() (*Command, error) { cmd.Params["var_value"] = varValue p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1477,7 +1499,7 @@ func (p *Parser) parseAdminSetDefault() (*Command, error) { } p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1496,7 +1518,7 @@ func (p *Parser) parseAdminSetToken() (*Command, error) { cmd.Params["token"] = tokenValue p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1534,37 +1556,6 @@ func (p *Parser) parseAdminResetCommand() (*Command, error) { cmd := NewCommand("reset_default_model") cmd.Params["model_type"] = modelType - p.nextToken() - // Semicolon is optional for UNSET TOKEN - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil -} - -func (p *Parser) parseAdminGenerateCommand() (*Command, error) { - p.nextToken() // consume GENERATE - if p.curToken.Type != TokenToken { - return nil, fmt.Errorf("expected TOKEN") - } - p.nextToken() - if p.curToken.Type != TokenFor { - return nil, fmt.Errorf("expected FOR") - } - p.nextToken() - if p.curToken.Type != TokenUser { - return nil, fmt.Errorf("expected USER") - } - p.nextToken() - - userName, err := p.parseQuotedString() - if err != nil { - return nil, err - } - - cmd := NewCommand("generate_token") - cmd.Params["user_name"] = userName - p.nextToken() // Semicolon is optional if p.curToken.Type == TokenSemicolon { @@ -1600,7 +1591,7 @@ func (p *Parser) parseAdminImportCommand() (*Command, error) { cmd.Params["dataset_name"] = datasetName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1634,7 +1625,7 @@ func (p *Parser) parseAdminRetrieveCommand() (*Command, error) { cmd.Params["datasets"] = datasets p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1673,7 +1664,7 @@ func (p *Parser) parseAdminParseDataset() (*Command, error) { cmd.Params["method"] = method p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1706,7 +1697,7 @@ func (p *Parser) parseAdminParseDocs() (*Command, error) { cmd.Params["dataset_name"] = datasetName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1770,62 +1761,63 @@ func (p *Parser) parseAdminUserStatement() (*Command, error) { } } -func (p *Parser) parseAdminStartupCommand() (*Command, error) { - p.nextToken() // consume STARTUP +func (p *Parser) parseAdminStartService() (*Command, error) { + p.nextToken() // consume START + if p.curToken.Type != TokenService { return nil, fmt.Errorf("expected SERVICE") } p.nextToken() - serviceNum, err := p.parseNumber() + serviceIndex, err := p.parseNumber() if err != nil { return nil, err } - cmd := NewCommand("startup_service") - cmd.Params["number"] = serviceNum + cmd := NewCommand("admin_start_service") + cmd.Params["service_index"] = serviceIndex p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } return cmd, nil } -func (p *Parser) parseAdminShutdownCommand() (*Command, error) { +func (p *Parser) parseAdminShutdownCommands() (*Command, error) { p.nextToken() // consume SHUTDOWN switch p.curToken.Type { case TokenService: - return p.parseAdminShutdownServiceCommand() + return p.parseAdminShutdownService() case TokenIngestor: - return p.parseAdminShutdownIngestorCommand() + return p.parseAdminShutdownIngestor() default: return nil, fmt.Errorf("expected SERVICE or INGESTOR") } } -func (p *Parser) parseAdminShutdownServiceCommand() (*Command, error) { +func (p *Parser) parseAdminShutdownService() (*Command, error) { p.nextToken() // consume SERVICE - serviceNum, err := p.parseNumber() + serviceIndex, err := p.parseNumber() if err != nil { return nil, err } - cmd := NewCommand("shutdown_service") - cmd.Params["number"] = serviceNum + cmd := NewCommand("admin_shutdown_service") + cmd.Params["service_index"] = serviceIndex p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } return cmd, nil } -func (p *Parser) parseAdminShutdownIngestorCommand() (*Command, error) { +func (p *Parser) parseAdminShutdownIngestor() (*Command, error) { p.nextToken() // consume INGESTOR ingestorName, err := p.parseQuotedString() @@ -1837,30 +1829,30 @@ func (p *Parser) parseAdminShutdownIngestorCommand() (*Command, error) { cmd.Params["ingestor_name"] = ingestorName p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } return cmd, nil } -func (p *Parser) parseAdminRestartCommand() (*Command, error) { +func (p *Parser) parseAdminRestart() (*Command, error) { p.nextToken() // consume RESTART if p.curToken.Type != TokenService { return nil, fmt.Errorf("expected SERVICE") } p.nextToken() - serviceNum, err := p.parseNumber() + serviceIndex, err := p.parseNumber() if err != nil { return nil, err } - cmd := NewCommand("restart_service") - cmd.Params["number"] = serviceNum + cmd := NewCommand("admin_restart_service") + cmd.Params["service_index"] = serviceIndex p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1930,7 +1922,7 @@ func (p *Parser) parseStartIngestion() (*Command, error) { cmd.Params["uri"] = uri p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1954,7 +1946,7 @@ func (p *Parser) parseStopIngestion() (*Command, error) { cmd.Params["task_id"] = taskID p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1973,7 +1965,7 @@ func (p *Parser) parseAdminIngestCommand() (*Command, error) { cmd.Params["uri"] = uri p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -1987,7 +1979,7 @@ func (p *Parser) parseAdminUnsetCommand() (*Command, error) { } p.nextToken() - // Semicolon is optional for UNSET TOKEN + // Semicolon is optional if p.curToken.Type == TokenSemicolon { p.nextToken() } @@ -2059,20 +2051,12 @@ func (p *Parser) parseMessageQueueCommand() (*Command, error) { return cmd, nil } -func (p *Parser) parseAdminRemoveCommand() (*Command, error) { - p.nextToken() // consume MESSAGE_QUEUE +// REMOVE INGESTION TASK 'task_id'; +// REMOVE USER 'user@example.com' INGESTION TASKS 'created'; +func (p *Parser) parseAdminRemoveCommands() (*Command, error) { + p.nextToken() // consume REMOVE - var cmd *Command switch p.curToken.Type { - case TokenService: - p.nextToken() // consume SERVICE - serviceNum, err := p.parseNumber() - if err != nil { - return nil, fmt.Errorf("expected service number after SERVICE") - } - p.nextToken() // consume service number - cmd = NewCommand("admin_remove_service_command") - cmd.Params["service_number"] = serviceNum case TokenIngestion: return p.parseAdminRemoveIngestionTasks() case TokenUser: @@ -2080,11 +2064,6 @@ func (p *Parser) parseAdminRemoveCommand() (*Command, error) { default: return nil, fmt.Errorf("expected SERVICE") } - // Semicolon is optional - if p.curToken.Type == TokenSemicolon { - p.nextToken() - } - return cmd, nil } // SHOW USERS SUMMARY; diff --git a/internal/cli/cli_http.go b/internal/cli/cli_http.go index 0c176d6b7f..5dc1918f45 100644 --- a/internal/cli/cli_http.go +++ b/internal/cli/cli_http.go @@ -47,10 +47,22 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.RunBenchmark(cmd) case "admin_list_services": return c.AdminListServicesCommand(cmd) - case "grant_admin": - return c.GrantAdmin(cmd) - case "revoke_admin": - return c.RevokeAdmin(cmd) + case "admin_start_service": + return c.AdminStartServiceCommand(cmd) + case "admin_restart_service": + return c.AdminRestartServiceCommand(cmd) + case "admin_shutdown_service": + return c.AdminShutdownServiceCommand(cmd) + case "admin_grant_user_admin": + return c.AdminGrantUserAdminCommand(cmd) + case "admin_revoke_user_admin": + return c.AdminRevokeUserAdminCommand(cmd) + case "admin_grant_role_permission": + return c.AdminGrantRolePermissionCommand(cmd) + case "admin_revoke_role_permission": + return c.AdminRevokeRolePermissionCommand(cmd) + case "admin_show_role_permission": + return c.AdminShowRolePermissionCommand(cmd) case "admin_create_user": return c.AdminCreateUserCommand(cmd) case "admin_create_user_api_key": @@ -95,8 +107,6 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.AdminListResourcesCommand(cmd) case "admin_list_roles_command": return c.AdminListRolesCommand(cmd) - case "generate_token": - return c.GenerateAdminToken(cmd) case "admin_list_available_providers": return c.CommonAvailableProvidersCommand(cmd) case "admin_show_provider": @@ -133,8 +143,6 @@ func (c *CLI) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) { return c.UserPullMessageCommand(cmd) case "user_show_message_queue_command": return c.UserShowMessageQueueCommand(cmd) - case "admin_remove_service_command": - return c.AdminRemoveServiceCommand(cmd) case "admin_check_license": return c.AdminCheckLicenseCommand(cmd) case "admin_show_fingerprint": diff --git a/internal/cli/parser.go b/internal/cli/parser.go index 4c6bc911b0..dc40ce87a6 100644 --- a/internal/cli/parser.go +++ b/internal/cli/parser.go @@ -99,36 +99,25 @@ func (p *Parser) parseAdminCommand() (*Command, error) { case TokenAlter: return p.parseAdminAlterCommands() case TokenGrant: - return p.parseAdminGrantCommand() + return p.parseAdminGrantCommands() case TokenRevoke: - return p.parseAdminRevokeCommand() + return p.parseAdminRevokeCommands() case TokenSet: return p.parseAdminSetCommand() - case TokenUnset: - return p.parseAdminUnsetCommand() case TokenReset: return p.parseAdminResetCommand() - case TokenGenerate: - return p.parseAdminGenerateCommand() - case TokenImport: - return p.parseAdminImportCommand() - case TokenRetrieve: - return p.parseAdminRetrieveCommand() - case TokenParse: - return p.parseAdminParseCommand() case TokenBenchmark: return p.parseAdminBenchmarkCommand() - - case TokenStartup: - return p.parseAdminStartupCommand() + case TokenStart: + return p.parseAdminStartService() case TokenShutdown: - return p.parseAdminShutdownCommand() + return p.parseAdminShutdownCommands() case TokenRestart: - return p.parseAdminRestartCommand() + return p.parseAdminRestart() case TokenMQ: return p.parseMessageQueueCommand() case TokenRemove: - return p.parseAdminRemoveCommand() + return p.parseAdminRemoveCommands() case TokenStop: return p.parseAdminStopIngestionTasks() case TokenAdd: @@ -189,12 +178,6 @@ func (p *Parser) parseUserCommand() (*Command, error) { return p.parseBenchmarkCommand() case TokenRegister: return p.parseRegisterCommand() - case TokenStartup: - return p.parseStartupCommand() - case TokenShutdown: - return p.parseShutdownCommand() - case TokenRestart: - return p.parseRestartCommand() case TokenEnable: return p.parseEnableCommand() case TokenDisable: diff --git a/internal/cli/user_parser.go b/internal/cli/user_parser.go index 573965cc13..64f9234680 100644 --- a/internal/cli/user_parser.go +++ b/internal/cli/user_parser.go @@ -1009,15 +1009,10 @@ optionsLoop: return cmd, nil } -// syntax: add admin server host '127.0.0.1:9333' user 'ccc' password 'ppp' +// syntax: add admin host '127.0.0.1:9333' user 'ccc' password 'ppp' func (p *Parser) parseAddAdminServer() (*Command, error) { p.nextToken() // consume ADMIN - if p.curToken.Type != TokenServer { - return nil, fmt.Errorf("expected server name") - } - p.nextToken() // consume SERVER - if p.curToken.Type != TokenHost { return nil, fmt.Errorf("expected HOST") } @@ -1041,15 +1036,10 @@ func (p *Parser) parseAddAdminServer() (*Command, error) { return cmd, nil } -// syntax: add api server 'abc' host '127.0.0.1:9333' token 'xxx' user 'ccc' password 'ppp' +// syntax: add api 'abc' host '127.0.0.1:9333' token 'xxx' user 'ccc' password 'ppp' func (p *Parser) parseAddAPIServer() (*Command, error) { p.nextToken() // consume API - if p.curToken.Type != TokenServer { - return nil, fmt.Errorf("expected server name") - } - p.nextToken() // consume SERVER - serverName, err := p.parseQuotedString() if err != nil { return nil, err @@ -1103,15 +1093,10 @@ optionsLoop: return cmd, nil } -// syntax: delete api server 'abc' +// syntax: delete api 'abc' func (p *Parser) parseDeleteAPIServer() (*Command, error) { p.nextToken() // consume API - if p.curToken.Type != TokenServer { - return nil, fmt.Errorf("expected server name") - } - p.nextToken() // consume SERVER - serverName, err := p.parseQuotedString() if err != nil { return nil, err @@ -1870,7 +1855,7 @@ func (p *Parser) parseIdentifierList() ([]string, error) { for p.curToken.Type == TokenComma { p.nextToken() - ident, err := p.parseIdentifier() + ident, err = p.parseIdentifier() if err != nil { return nil, err } @@ -3716,75 +3701,6 @@ func (p *Parser) parseUserStatement() (*Command, error) { } } -func (p *Parser) parseStartupCommand() (*Command, error) { - p.nextToken() // consume STARTUP - if p.curToken.Type != TokenService { - return nil, fmt.Errorf("expected SERVICE") - } - p.nextToken() - - serviceNum, err := p.parseNumber() - if err != nil { - return nil, err - } - - cmd := NewCommand("startup_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) parseShutdownCommand() (*Command, error) { - p.nextToken() // consume SHUTDOWN - if p.curToken.Type != TokenService { - return nil, fmt.Errorf("expected SERVICE") - } - p.nextToken() - - serviceNum, err := p.parseNumber() - if err != nil { - return nil, err - } - - cmd := NewCommand("shutdown_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) parseRestartCommand() (*Command, error) { - p.nextToken() // consume RESTART - if p.curToken.Type != TokenService { - return nil, fmt.Errorf("expected SERVICE") - } - p.nextToken() - - serviceNum, err := p.parseNumber() - if err != nil { - return nil, err - } - - cmd := NewCommand("restart_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) parseUnsetCommand() (*Command, error) { p.nextToken() // consume UNSET