zlei6/ragflow
1
0
Fork 0
mirror of https://github.com/infiniflow/ragflow.git synced 2026-07-31 13:03:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

Go CLI: refactor commands (#16213)

Browse Source 
### What problem does this PR solve?

As title.

### Type of change

- [x] Refactoring

---------

Signed-off-by: Jin Hai <haijin.chn@gmail.com>
This commit is contained in:
Jin Hai
2026-06-21 16:50:02 +08:00
committed by GitHub
parent 1b712be599
commit 5039f46999
10 changed files with 537 additions and 629 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
internal/admin/enterprise_handler.go
View File

@@ -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()

26
internal/admin/enterprise_service.go
View File

@@ -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",

5
internal/admin/router.go
View File

@@ -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)

2
internal/admin/service.go
View File

@@ -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

202
internal/cli/admin_command.go
View File

@@ -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 {

777
internal/cli/admin_parser.go
View File

@@ -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

64
internal/cli/cli_http.go
View File

@@ -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

22
internal/cli/common_command.go
View File

@@ -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)
}

2
internal/cli/parser.go
View File

@@ -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:

25
internal/cli/user_parser.go
View File

@@ -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