612 lines
19 KiB
Go
612 lines
19 KiB
Go
package controllers
|
|
|
|
import (
|
|
"apiserver/backend"
|
|
"apiserver/common"
|
|
"apiserver/models"
|
|
"apiserver/services"
|
|
"apiserver/store"
|
|
"apiserver/utils"
|
|
logger "apiserver/utils"
|
|
"errors"
|
|
"strings"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type QueueController struct{}
|
|
|
|
func (q QueueController) GetQueuesInfo(ctx *gin.Context) {
|
|
// Get all queues
|
|
logger.Debug("Enter GetQueuesInfo() function from ", zap.String("client_ip", ctx.ClientIP()))
|
|
|
|
// get logon user
|
|
token := ctx.GetHeader("Authorization")
|
|
logonUser, err := GetUsernameFromToken(token)
|
|
if err != nil {
|
|
ReturnError(ctx, common.ERROR_CODE, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
var fields []string
|
|
filters := make([]utils.FilterCondition, 0)
|
|
sortOrders := make([]utils.SortOrder, 0)
|
|
|
|
// ---- check parameters ----
|
|
for param := range ctx.Request.URL.Query() {
|
|
if !utils.ContainsField(utils.SupportedQueryParams, param) {
|
|
err := errors.New("invalid queues info query parameters of : " + param)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
}
|
|
|
|
// Get query parameters
|
|
filterStr := ctx.Query("filter")
|
|
fieldsStr := ctx.Query("fields")
|
|
sortStr := ctx.Query("sort") // sort=queue_name:asc,submit_time:desc
|
|
pagetokenStr := ctx.Query("page_token") // page_token=Aafjakjf0023A
|
|
limitStr := ctx.Query("limit") // eg: limit=100
|
|
|
|
logger.Debug("Queues query values are:",
|
|
zap.String("fieldsStr", fieldsStr),
|
|
zap.String("filterStr", filterStr),
|
|
zap.String("sortStr", sortStr),
|
|
zap.String("limitStr", limitStr),
|
|
zap.String("pagetokenStr", pagetokenStr))
|
|
|
|
// ---- check limit value ----
|
|
limit, err := utils.ParseLimit(limitStr)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
// ---- check filter ----
|
|
if filterStr != "" {
|
|
filters = utils.ParseFilters(filterStr)
|
|
if filters == nil {
|
|
err := errors.New("filter " + filterStr + " has syntax error")
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
}
|
|
|
|
//filtercds := make([]utils.Condition, len(filters))
|
|
for _, filter := range filters {
|
|
// check the filter is supported.
|
|
if !utils.ContainsField(models.QUEUE_SUPPORT_FILTERS, filter.Field) {
|
|
err := errors.New("unsupported filter: " + filter.Field)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
}
|
|
var queues models.QueueInfo
|
|
filtercds, err := utils.ConvertToNewFilter(filters, &queues)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
// ---- check fields ----
|
|
// get fields and do check, if not set, use default display columns
|
|
if fieldsStr != "" {
|
|
fields = utils.ParseFields(fieldsStr)
|
|
found := false
|
|
// verify the fields is in supported list
|
|
supportedFields := utils.GetSupportedFields(models.QueueInfo{})
|
|
logger.Debug("queue supportedFields: %v", zap.Any("supportedFields", supportedFields))
|
|
for _, field := range fields {
|
|
if !utils.ContainsField(supportedFields, field) {
|
|
err := errors.New("unsupported query field: " + field)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
// if user not specify queue_name in fields, add queue_name as default field.
|
|
if field == "queue_name" {
|
|
found = true
|
|
}
|
|
}
|
|
if !found {
|
|
logger.Debug("user doesn't specify queue name in query fields, add it.")
|
|
fields = append(fields, "queue_name")
|
|
}
|
|
} else {
|
|
fields = models.QUEUE_DEFAULT_COLUMN
|
|
}
|
|
|
|
// ---- check sort ----
|
|
// handle sort, when no sortStr specified, need add the primary key of queue_info
|
|
// table into sortStr as default value
|
|
if sortStr == "" {
|
|
logger.Debug("sort is not specified, set sort=queue_name:asc as default")
|
|
sortStr = "queue_name:asc"
|
|
}
|
|
// parse sortStr
|
|
sorts, err := utils.ParseSortParam(sortStr, models.QUEUE_SUPPORT_SORT)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
// ---- check paging ---
|
|
if pagetokenStr != "" {
|
|
pagetokenStr, err = utils.ParsePageToken(pagetokenStr)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
}
|
|
|
|
//the primary key of queue_info table queue_name should always be added into sortStr if user doesn't specify.
|
|
found := false
|
|
for _, sortent := range sorts {
|
|
if sortent.Column == "queue_name" {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
// user not specify the queue_name, only append queue_name at the end.
|
|
if !found {
|
|
sorts = append(sorts, utils.SortOrder{
|
|
Column: "queue_name",
|
|
Ascending: true,
|
|
})
|
|
}
|
|
|
|
//check all sort column is in fields
|
|
err = utils.CheckAllMapKeyInList(sorts, fields)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
sortOrders = sorts
|
|
/*
|
|
//fill QueryOptions
|
|
qqueryNew := utils.QueryOptions{
|
|
Conditions: filtercds,
|
|
Orders: sortOrders,
|
|
Limits: limit,
|
|
Bookmark: pagetokenStr,
|
|
}
|
|
*/
|
|
|
|
queryOpts, err := utils.BuildQueryOptions(filtercds, nil, sortOrders, limit, pagetokenStr)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.ERROR_CODE, common.ERROR_QUERY_QUEUEINFO_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
qqueryReply, pagetoken, err := services.QueryData(services.TableQueueInfo, queryOpts, fields)
|
|
if err != nil {
|
|
logger.Error("Failed to query queue info.", zap.Error(err))
|
|
ReturnError(ctx, common.ERROR_CODE, common.ERROR_QUERY_QUEUEINFO_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
// check rbac
|
|
accessRow := make([]utils.OrderMap, 0)
|
|
for _, row := range qqueryReply {
|
|
if queue_name, exist := row.Data["queue_name"]; exist {
|
|
queueStr, ok := queue_name.(string)
|
|
if !ok {
|
|
logger.Error("queue_name is not a string", zap.Any("queue_name", queue_name))
|
|
ReturnError(ctx, common.ERROR_CODE, "queue_name is not a string", nil)
|
|
return
|
|
}
|
|
|
|
queuePermission, err := GetRequireResourcePermission(logonUser, "queue:view")
|
|
if err != nil {
|
|
ReturnError(ctx, common.ERROR_CODE, common.ERROR_ACCESS_FORBIDDEN_MSG, nil)
|
|
return
|
|
}
|
|
if queuePermission.DomainType == models.DomainTypeQueue {
|
|
queueDomainValues := queuePermission.DomainValues
|
|
if utils.ContainsField(queueDomainValues, queueStr) {
|
|
accessRow = append(accessRow, row)
|
|
}
|
|
} else if queuePermission.DomainType == models.DomainTypeAll {
|
|
accessRow = append(accessRow, row)
|
|
}
|
|
}
|
|
}
|
|
logger.Debug("After call GetRequireResourcePermission for all queues info", zap.Error(err), zap.Any("accessRow", accessRow))
|
|
|
|
if err != nil && len(accessRow) == 0 {
|
|
ReturnError(ctx, common.ERROR_CODE, common.ERROR_ACCESS_FORBIDDEN_MSG, nil)
|
|
return
|
|
}
|
|
|
|
logger.Debug("the queue info query reply:", zap.Any("qqueryReply", qqueryReply), zap.String("pagetoken", pagetoken))
|
|
//convert to readable string.
|
|
queryResult := processQueueData(accessRow, pagetoken)
|
|
|
|
ReturnSuccess(ctx, common.SUCCESS_CODE, common.SUCCESS_MSG, queryResult)
|
|
}
|
|
|
|
func processQueueData(rows []utils.OrderMap, page_token string) utils.QueryResult {
|
|
for _, row := range rows {
|
|
if v, exist := row.Data["queue_status"]; exist && v != nil {
|
|
stateVal, ok := utils.IntOrInt64(v)
|
|
if !ok {
|
|
stateVal = -1
|
|
}
|
|
if stateVal >= 0 {
|
|
row.Data["queue_status"] = formatQueueStatus(int64(stateVal))
|
|
} else {
|
|
row.Data["queue_status"] = "UNKNOWN"
|
|
}
|
|
}
|
|
|
|
// Process JSONB fields based on predefined list
|
|
for _, jsonbField := range models.JSONBQFields {
|
|
if v, exist := row.Data[jsonbField]; exist {
|
|
if strValue, ok := v.(string); ok {
|
|
if jsonbData, err := utils.ParseJSONB(strValue); err == nil {
|
|
row.Data[jsonbField] = jsonbData
|
|
} else {
|
|
logger.Error("Failed to parse queue info JSONB field.", zap.Error(err))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//utils.FormatRowsOutput(row.Data)
|
|
}
|
|
return utils.QueryResult{
|
|
Rows: rows,
|
|
Count: len(rows),
|
|
Pagetoken: page_token,
|
|
}
|
|
}
|
|
|
|
func (q QueueController) GetQueueByName(ctx *gin.Context) {
|
|
logger.Debug("Enter GetQueueByName() function from ", zap.String("client_ip", ctx.ClientIP()))
|
|
|
|
// get logon user
|
|
token := ctx.GetHeader("Authorization")
|
|
logonUser, err := GetUsernameFromToken(token)
|
|
if err != nil {
|
|
ReturnError(ctx, common.ERROR_CODE, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
// ---- check parameters ----
|
|
for param := range ctx.Request.URL.Query() {
|
|
if !utils.ContainsField(utils.SupportedQueryParams, param) {
|
|
err := errors.New("invalid specific queue info query parameters of : " + param)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
}
|
|
queueNamesStr := ctx.Param("queuename")
|
|
fieldsStr := ctx.Query("fields")
|
|
|
|
logger.Debug("origin query string queuename, fieldsStr values are:",
|
|
zap.String("queuename", queueNamesStr),
|
|
zap.String("fields", fieldsStr))
|
|
|
|
//add jobid list as filter.
|
|
queueNames := strings.Split(queueNamesStr, ",") // queue_name: q1,q2,q3
|
|
mergeQqueryReply := make([]utils.OrderMap, 0)
|
|
var page_token = ""
|
|
|
|
for _, queuename := range queueNames {
|
|
queuename = strings.TrimSpace(queuename)
|
|
// check rbac
|
|
queuePermission, rbacErr := GetRequireResourcePermission(logonUser, "queue:view")
|
|
|
|
if rbacErr != nil {
|
|
ReturnError(ctx, common.ERROR_AUTH_CODE, common.ERROR_ACCESS_FORBIDDEN_MSG, nil)
|
|
return
|
|
}
|
|
if queuePermission.DomainType == models.DomainTypeQueue {
|
|
queueDomainValues := queuePermission.DomainValues
|
|
if !utils.ContainsField(queueDomainValues, queuename) {
|
|
err := errors.New("access forbidden for queue: " + queuename)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.ERROR_AUTH_CODE, common.ERROR_ACCESS_FORBIDDEN_MSG, nil)
|
|
return
|
|
}
|
|
}
|
|
|
|
filters := make([]utils.FilterCondition, 0)
|
|
sortOrders := make([]utils.SortOrder, 0)
|
|
filters = append(filters, utils.FilterCondition{
|
|
Field: "queue_name",
|
|
Operator: "eq",
|
|
Value: queuename,
|
|
})
|
|
|
|
//filtercds := make([]utils.Condition, len(filters))
|
|
for _, filter := range filters {
|
|
// check the filter is supported.
|
|
if !utils.ContainsField(models.QUEUE_SUPPORT_FILTERS, filter.Field) {
|
|
err := errors.New("unsupported filter: " + filter.Field)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
}
|
|
var queue models.QueueInfo
|
|
var err error
|
|
filtercds, err := utils.ConvertToNewFilter(filters, &queue)
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
var fields []string
|
|
if fieldsStr != "" {
|
|
fields = utils.ParseFields(fieldsStr)
|
|
|
|
found := false
|
|
// verify the fields is in supported list
|
|
supportedFields := utils.GetSupportedFields(models.QueueInfo{})
|
|
logger.Debug("queue supportedFields: %v", zap.Any("supportedFields", supportedFields))
|
|
|
|
for _, field := range fields {
|
|
if !utils.ContainsField(supportedFields, field) {
|
|
err := errors.New("unsupported query field: " + field)
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, common.INVALID_PARAMS_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
// if user not specify queue_name in fields, add queue_name as default field.
|
|
if field == "queue_name" {
|
|
found = true
|
|
}
|
|
}
|
|
|
|
if !found {
|
|
logger.Debug("user doesn't specify queue_name in query fields, add it.")
|
|
fields = append(fields, "queue_name")
|
|
}
|
|
} else { // default display columns
|
|
fields = models.QUEUE_DEFAULT_COLUMN
|
|
}
|
|
|
|
// add a default order: sort=queue_name:asc
|
|
sortOrders = append(sortOrders, utils.SortOrder{
|
|
Column: "queue_name",
|
|
Ascending: true,
|
|
})
|
|
/*
|
|
qqueryNew := utils.QueryOptions{
|
|
Conditions: filtercds,
|
|
Orders: sortOrders,
|
|
Limits: utils.PER_PAGE_LIMIT,
|
|
Bookmark: "", // for one queue, no need page_token
|
|
}
|
|
*/
|
|
queryOpts, err := utils.BuildQueryOptions(filtercds, nil, sortOrders, utils.PER_PAGE_LIMIT, "")
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.ERROR_CODE, common.ERROR_QUERY_JOBINFO_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
qqueryReply, page_token, err := services.QueryData(services.TableQueueInfo, queryOpts, fields)
|
|
if err != nil {
|
|
logger.Error("Failed to query the specific queue info.", zap.Error(err))
|
|
ReturnError(ctx, common.ERROR_CODE, common.ERROR_QUERY_JOBINFO_MSG+": "+err.Error(), nil)
|
|
return
|
|
}
|
|
logger.Debug("the specific queue query reply:", zap.Any("qqueryReply", qqueryReply), zap.String("pagetoken", page_token))
|
|
mergeQqueryReply = append(mergeQqueryReply, qqueryReply...)
|
|
} // end for queue_name
|
|
logger.Debug("the specific queue query reply:", zap.Any("qqueryReply", mergeQqueryReply))
|
|
|
|
//convert job_status to readable string.
|
|
queryResult := processQueueData(mergeQqueryReply, page_token)
|
|
|
|
ReturnSuccess(ctx, common.SUCCESS_CODE, common.SUCCESS_MSG, queryResult)
|
|
}
|
|
|
|
func (q *QueueController) ControlQueue(ctx *gin.Context) {
|
|
logger.Debug("Enter ControlQueue() function")
|
|
|
|
// get the logon user
|
|
token := ctx.GetHeader("Authorization")
|
|
submitUser, err := GetUsernameFromToken(token)
|
|
if err != nil {
|
|
ReturnError(ctx, common.ERROR_CODE, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
var req models.QueueControlRequest
|
|
|
|
// use strict json format check
|
|
if err := utils.BindJSONStrict(ctx, &req); err != nil {
|
|
logger.Error("Invalid request parameters", zap.Error(err))
|
|
ReturnError(ctx, common.ERROR_CODE, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
allFlag, err := preCheckQueueControlRequest(&req)
|
|
if err != nil {
|
|
logger.Error("Failed to send queue control request", zap.Error(err))
|
|
ReturnError(ctx, common.ERROR_CODE, err.Error(), nil)
|
|
return
|
|
}
|
|
|
|
baseAction := req.ControlAction
|
|
logger.Debug("ControlQueue baseAction is ", zap.Any("baseAction", baseAction))
|
|
|
|
var actionType int
|
|
actionType, exists := models.ActionMap[baseAction]
|
|
if !exists {
|
|
logger.Error("Unsupported action type", zap.String("baseAction", baseAction))
|
|
ReturnError(ctx, common.INVALID_PARAMS_CODE, "Unsupported action type: "+baseAction, nil)
|
|
return
|
|
}
|
|
|
|
logger.Debug("ControlQueue actionType is ", zap.Any("actionType", actionType))
|
|
|
|
successQueues := []map[string]interface{}{}
|
|
failedQueues := []map[string]interface{}{}
|
|
|
|
validatedSuccessQueues, validatedFailedQueues := validateQueue(actionType, req.QueueName)
|
|
|
|
if allFlag {
|
|
queueNames := store.GetAllQueueNames()
|
|
validatedSuccessQueues, validatedFailedQueues = validateQueue(actionType, queueNames)
|
|
}
|
|
logger.Debug("validatedSuccessQueues:", zap.Any("validatedSuccessQueues", validatedSuccessQueues))
|
|
for _, queuename := range validatedSuccessQueues {
|
|
// check rbac
|
|
queuePermission, err := GetRequireResourcePermission(submitUser, "queue:control")
|
|
if err != nil {
|
|
logger.Error(err.Error())
|
|
ReturnError(ctx, common.ERROR_AUTH_CODE, common.ERROR_ACCESS_FORBIDDEN_MSG, nil)
|
|
return
|
|
}
|
|
if queuePermission.DomainType == models.DomainTypeQueue {
|
|
queueDomainValues := queuePermission.DomainValues
|
|
if !utils.ContainsField(queueDomainValues, queuename) {
|
|
failedQueues = append(failedQueues, map[string]interface{}{
|
|
"queue_name": queuename,
|
|
"msg": "queue is not allowed to be controlled",
|
|
})
|
|
continue
|
|
}
|
|
}
|
|
successQueues = append(successQueues, map[string]interface{}{
|
|
"queue_name": queuename,
|
|
"msg": "queue is being controlled",
|
|
})
|
|
}
|
|
for queuename, reason := range validatedFailedQueues {
|
|
failedQueues = append(failedQueues, map[string]interface{}{
|
|
"queue_name": queuename,
|
|
"msg": reason,
|
|
})
|
|
}
|
|
|
|
for _, queue := range successQueues {
|
|
queuename := queue["queue_name"].(string)
|
|
err = backend.ControlQueue(queuename, actionType)
|
|
if err != nil {
|
|
logger.Error("Failed to send queue control", zap.Error(err))
|
|
failedQueues = append(failedQueues, map[string]interface{}{
|
|
"queue_name": queuename,
|
|
"msg": "failed to control queue: " + err.Error(),
|
|
})
|
|
}
|
|
}
|
|
response, successMsg := BuildBatchOperationResponse(baseAction, "Queue", successQueues, failedQueues)
|
|
|
|
overallStatus := response["status"].(string)
|
|
logger.Info("Finished processing queue control request",
|
|
zap.String("action", baseAction),
|
|
zap.String("overallStatus", overallStatus),
|
|
zap.Int("succeededCount", len(successQueues)),
|
|
zap.Int("failedCount", len(failedQueues)),
|
|
zap.String("client_ip", ctx.ClientIP()))
|
|
|
|
ReturnSuccess(ctx, common.ACCEPTED, successMsg, response)
|
|
return
|
|
|
|
}
|
|
|
|
func preCheckQueueControlRequest(req *models.QueueControlRequest) (bool, error) {
|
|
logger.Debug("Enter preCheckQueueControlRequest")
|
|
|
|
if err := utils.ValidateControlAction(req.ControlAction, models.SupportedQueueActions); err != nil {
|
|
return false, err
|
|
}
|
|
req.ControlAction = strings.ToLower(strings.TrimSpace(req.ControlAction))
|
|
|
|
isAll := req.QueueName != nil && len(req.QueueName) == 1 && req.QueueName[0] == "all"
|
|
|
|
if req.Comment != "" {
|
|
if len(req.Comment) > 512 {
|
|
return false, errors.New("comment length exceeds the limit of 512 characters")
|
|
}
|
|
}
|
|
return isAll, nil
|
|
}
|
|
|
|
func validateQueue(control int, queuenames []string) (successQueues []string, failedQueues map[string]string) {
|
|
logger.Debug("Validating queuenames: %v", zap.Any("queuenames", queuenames))
|
|
|
|
successQueues = []string{}
|
|
failedQueues = make(map[string]string)
|
|
|
|
if len(queuenames) == 0 {
|
|
logger.Error("queuenames cannot be empty")
|
|
return
|
|
}
|
|
|
|
for _, queuename := range queuenames {
|
|
queuename = strings.TrimSpace(queuename)
|
|
|
|
if queuename == "" {
|
|
logger.Error("queuenames cannot be empty")
|
|
continue
|
|
}
|
|
|
|
if store.Queues.Has(queuename) {
|
|
logger.Debug("Found queuename in store", zap.String("queuename", queuename))
|
|
successQueues = append(successQueues, queuename)
|
|
} else {
|
|
logger.Error("Invalid queuename", zap.String("queuename", queuename))
|
|
failedQueues[queuename] = common.ERROR_QUEUE_NOT_FOUND_MSG
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func isQueueControlAllowed(controlType int, queueStateStr string) bool {
|
|
parts := strings.Split(queueStateStr, ":")
|
|
mainState := parts[0]
|
|
secondState := parts[1]
|
|
|
|
switch controlType {
|
|
case models.QUEUE_CLOSE:
|
|
return mainState == "open"
|
|
case models.QUEUE_OPEN:
|
|
return mainState == "closed"
|
|
case models.QUEUE_ACT:
|
|
return secondState == "inactive_adm"
|
|
case models.QUEUE_INACT:
|
|
return secondState != "inactive_adm"
|
|
default:
|
|
logger.Error("Unsupported control type", zap.Int("controlType", controlType))
|
|
return false
|
|
}
|
|
}
|
|
|
|
func formatQueueStatus(state int64) string {
|
|
var status string
|
|
|
|
if state&(int64(models.QUEUESTAT["CLOSED"])) != 0 { // CLOSED
|
|
status = "closed"
|
|
} else {
|
|
status = "open"
|
|
}
|
|
|
|
if state&int64(models.QUEUESTAT["INACTIVE_ADM"]) != 0 { // INACT_ADMIN
|
|
status += ":inactive_adm"
|
|
} else if state&int64(models.QUEUESTAT["INACTIVE_WIN"]) != 0 { // INACT_WINDOW
|
|
status += ":inactive_win"
|
|
} else {
|
|
status += ":active"
|
|
}
|
|
|
|
return status
|
|
}
|