forked from ebhomengo/niki
145 lines
2.8 KiB
Go
145 lines
2.8 KiB
Go
package routing
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
type RequestPolicy uint8
|
|
|
|
const (
|
|
ReqDefault RequestPolicy = iota
|
|
|
|
ReqAllNodes
|
|
|
|
ReqAllShards
|
|
|
|
ReqMultiShard
|
|
|
|
ReqSpecial
|
|
)
|
|
|
|
const (
|
|
ReadOnlyCMD string = "readonly"
|
|
)
|
|
|
|
func (p RequestPolicy) String() string {
|
|
switch p {
|
|
case ReqDefault:
|
|
return "default"
|
|
case ReqAllNodes:
|
|
return "all_nodes"
|
|
case ReqAllShards:
|
|
return "all_shards"
|
|
case ReqMultiShard:
|
|
return "multi_shard"
|
|
case ReqSpecial:
|
|
return "special"
|
|
default:
|
|
return fmt.Sprintf("unknown_request_policy(%d)", p)
|
|
}
|
|
}
|
|
|
|
func ParseRequestPolicy(raw string) (RequestPolicy, error) {
|
|
switch strings.ToLower(raw) {
|
|
case "", "default", "none":
|
|
return ReqDefault, nil
|
|
case "all_nodes":
|
|
return ReqAllNodes, nil
|
|
case "all_shards":
|
|
return ReqAllShards, nil
|
|
case "multi_shard":
|
|
return ReqMultiShard, nil
|
|
case "special":
|
|
return ReqSpecial, nil
|
|
default:
|
|
return ReqDefault, fmt.Errorf("routing: unknown request_policy %q", raw)
|
|
}
|
|
}
|
|
|
|
type ResponsePolicy uint8
|
|
|
|
const (
|
|
RespDefaultKeyless ResponsePolicy = iota
|
|
RespDefaultHashSlot
|
|
RespAllSucceeded
|
|
RespOneSucceeded
|
|
RespAggSum
|
|
RespAggMin
|
|
RespAggMax
|
|
RespAggLogicalAnd
|
|
RespAggLogicalOr
|
|
RespSpecial
|
|
)
|
|
|
|
func (p ResponsePolicy) String() string {
|
|
switch p {
|
|
case RespDefaultKeyless:
|
|
return "default(keyless)"
|
|
case RespDefaultHashSlot:
|
|
return "default(hashslot)"
|
|
case RespAllSucceeded:
|
|
return "all_succeeded"
|
|
case RespOneSucceeded:
|
|
return "one_succeeded"
|
|
case RespAggSum:
|
|
return "agg_sum"
|
|
case RespAggMin:
|
|
return "agg_min"
|
|
case RespAggMax:
|
|
return "agg_max"
|
|
case RespAggLogicalAnd:
|
|
return "agg_logical_and"
|
|
case RespAggLogicalOr:
|
|
return "agg_logical_or"
|
|
case RespSpecial:
|
|
return "special"
|
|
default:
|
|
return "all_succeeded"
|
|
}
|
|
}
|
|
|
|
func ParseResponsePolicy(raw string) (ResponsePolicy, error) {
|
|
switch strings.ToLower(raw) {
|
|
case "default(keyless)":
|
|
return RespDefaultKeyless, nil
|
|
case "default(hashslot)":
|
|
return RespDefaultHashSlot, nil
|
|
case "all_succeeded":
|
|
return RespAllSucceeded, nil
|
|
case "one_succeeded":
|
|
return RespOneSucceeded, nil
|
|
case "agg_sum":
|
|
return RespAggSum, nil
|
|
case "agg_min":
|
|
return RespAggMin, nil
|
|
case "agg_max":
|
|
return RespAggMax, nil
|
|
case "agg_logical_and":
|
|
return RespAggLogicalAnd, nil
|
|
case "agg_logical_or":
|
|
return RespAggLogicalOr, nil
|
|
case "special":
|
|
return RespSpecial, nil
|
|
default:
|
|
return RespDefaultKeyless, fmt.Errorf("routing: unknown response_policy %q", raw)
|
|
}
|
|
}
|
|
|
|
type CommandPolicy struct {
|
|
Request RequestPolicy
|
|
Response ResponsePolicy
|
|
// Tips that are not request_policy or response_policy
|
|
// e.g nondeterministic_output, nondeterministic_output_order.
|
|
Tips map[string]string
|
|
}
|
|
|
|
func (p *CommandPolicy) CanBeUsedInPipeline() bool {
|
|
return p.Request != ReqAllNodes && p.Request != ReqAllShards && p.Request != ReqMultiShard
|
|
}
|
|
|
|
func (p *CommandPolicy) IsReadOnly() bool {
|
|
_, readOnly := p.Tips[ReadOnlyCMD]
|
|
return readOnly
|
|
}
|