TRKJ/EdgeCommon
2
0
Fork 0
mirror of https://github.com/TeaOSLab/EdgeCommon.git synced 2025-11-04 05:00:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

删除不需要的文件

Browse Source
This commit is contained in:
GoEdgeLab
2023-05-24 15:06:22 +08:00
parent b054e74514
commit 0112919468
1 changed files with 0 additions and 432 deletions
Download Patch File Download Diff File Expand all files Collapse all files

432
pkg/nodeconfigs/node_actions.go
View File

@@ -1,432 +0,0 @@
// Copyright 2023 Liuxiangchao iwind.liu@gmail.com. All rights reserved. Official site: https://goedge.cn .
//go:build plus
package nodeconfigs
import (
"github.com/TeaOSLab/EdgeCommon/pkg/serverconfigs/shared"
"github.com/iwind/TeaGo/maps"
"github.com/iwind/TeaGo/types"
)
type NodeActionParam = string
const (
NodeActionParamDailyTrafficOut NodeActionParam = "dailyTrafficOut" // 节点日出口流量
NodeActionParamMonthlyTrafficOut NodeActionParam = "monthlyTrafficOut" // 节点月出口流量
// NodeActionParamTotalTraffic NodeActionParam = "totalTraffic" // 节点总流量 TODO 需要实现
NodeActionParamBandwidthIn NodeActionParam = "bandwidthIn" // 节点入口带宽
NodeActionParamBandwidthOut NodeActionParam = "bandwidthOut" // 节点出口带宽
NodeActionParamCPUUsage NodeActionParam = "cpuUsage" // 节点CPU用量，百分比制，0-100
NodeActionParamMemoryUsage NodeActionParam = "memoryUsage" // 节点内存用量，百分比制，0-100
NodeActionParamLoad NodeActionParam = "load" // 当前节点负载
// NodeActionParamConnectivity NodeActionParam = "connectivity" // 节点连通性 TODO 需要实现
NodeActionParamHealthCheckFailure NodeActionParam = "heathCheckFailure" // 节点健康检查失败
)
type NodeActionParamDefinition struct {
Name string `json:"name"`
Code string `json:"code"`
Description string `json:"description"`
Operators []NodeActionOperator `json:"operators"`
ValueName string `json:"valueName"`
ValueType string `json:"valueType"`
HasDuration bool `json:"hasDuration"`
}
func FindAllNodeActionParamDefinitions() []*NodeActionParamDefinition {
return []*NodeActionParamDefinition{
{
Code: NodeActionParamBandwidthOut,
Name: "节点出口带宽",
Description: "当前节点当前时间点的出口平均带宽（从节点发送到客户端）。",
Operators: allNodeActionNumberOperators,
ValueName: "对比带宽",
ValueType: "bandwidth",
HasDuration: true,
},
{
Code: NodeActionParamBandwidthIn,
Name: "节点入口带宽",
Description: "当前节点当前时间点的入口平均带宽（从客户端发送到节点）。",
Operators: allNodeActionNumberOperators,
ValueName: "对比带宽",
ValueType: "bandwidth",
HasDuration: true,
},
{
Code: NodeActionParamMonthlyTrafficOut,
Name: "节点当月流量",
Description: "当前节点在当月的出口流量。",
Operators: allNodeActionNumberOperators,
ValueName: "对比流量",
ValueType: "traffic",
HasDuration: false,
},
{
Code: NodeActionParamDailyTrafficOut,
Name: "节点当日流量",
Description: "当前节点在当天的出口流量。",
Operators: allNodeActionNumberOperators,
ValueName: "对比流量",
ValueType: "traffic",
HasDuration: false,
},
{
Code: NodeActionParamCPUUsage,
Name: "节点CPU利用率",
Description: "节点当前CPU利用率，取值范围为0-100。",
Operators: allNodeActionNumberOperators,
ValueName: "CPU利用率",
ValueType: "cpu",
HasDuration: true,
},
{
Code: NodeActionParamMemoryUsage,
Name: "节点内存利用率",
Description: "节点当前内存利用率，取值范围为0-100。",
Operators: allNodeActionNumberOperators,
ValueName: "内存利用率",
ValueType: "memory",
HasDuration: true,
},
{
Code: NodeActionParamLoad,
Name: "节点负载",
Description: "节点当前负载，取值范围为0-∞，通常超过10表示系统负载较重。",
Operators: allNodeActionNumberOperators,
ValueName: "系统负载",
ValueType: "load",
HasDuration: true,
},
{
Code: NodeActionParamHealthCheckFailure,
Name: "健康检查失败",
Description: "当前节点任一IP健康检查失败。",
Operators: nil,
HasDuration: true,
},
}
}
type NodeActionOperator = string
const (
NodeActionOperatorGt NodeActionOperator = "gt"
NodeActionOperatorGte NodeActionOperator = "gte"
NodeActionOperatorLt NodeActionOperator = "lt"
NodeActionOperatorLte NodeActionOperator = "lte"
NodeActionOperatorEq NodeActionOperator = "eq"
)
var allNodeActionNumberOperators = []NodeActionOperator{NodeActionOperatorGt, NodeActionOperatorGte, NodeActionOperatorLt, NodeActionOperatorLte, NodeActionOperatorEq}
func FindAllNodeActionOperatorDefinitions() []*shared.Definition {
return []*shared.Definition{
{
Code: NodeActionOperatorGt,
Name: "大于(＞)",
},
{
Code: NodeActionOperatorGte,
Name: "大于等于(≥)",
},
{
Code: NodeActionOperatorLt,
Name: "小于(＜)",
},
{
Code: NodeActionOperatorLte,
Name: "小于等于(≤)",
},
{
Code: NodeActionOperatorEq,
Name: "等于(=)",
},
}
}
// NodeActionCondConnector 条件之间关系
type NodeActionCondConnector = string
const (
NodeActionCondConnectorAnd NodeActionCondConnector = "and"
NodeActionCondConnectorOr NodeActionCondConnector = "or"
)
type NodeActionCond struct {
Param NodeActionParam `json:"param"` // 参数名
Operator NodeActionOperator `json:"operator"` // 操作符
Value any `json:"value"` // 对比值
}
func (this *NodeActionCond) Match(value any) bool {
var paramDef *NodeActionParamDefinition
for _, paramDef2 := range FindAllNodeActionParamDefinitions() {
if paramDef2.Code == this.Param {
paramDef = paramDef2
break
}
}
if paramDef == nil {
return false
}
switch paramDef.ValueType {
case "bandwidth":
if value != nil && !this.isScalar(value) {
var value1Map = maps.NewMap(value)
value = this.toBandwidthBits(value1Map)
}
var value2Map = maps.NewMap(this.Value)
return this.compare(value, this.toBandwidthBits(value2Map))
case "traffic":
if value != nil && !this.isScalar(value) {
var value1Map = maps.NewMap(value)
value = this.toTrafficBytes(value1Map)
}
var value2Map = maps.NewMap(this.Value)
return this.compare(value, this.toTrafficBytes(value2Map))
case "cpu":
return this.compare(value, this.Value)
case "memory":
return this.compare(value, this.Value)
case "load":
return this.compare(value, this.Value)
case "":
return true
}
return false
}
func (this *NodeActionCond) compare(value1, value2 any) bool {
switch this.Operator {
case NodeActionOperatorGt:
return types.Int64(value1) > types.Int64(value2)
case NodeActionOperatorGte:
return types.Int64(value1) >= types.Int64(value2)
case NodeActionOperatorLt:
return types.Int64(value1) < types.Int64(value2)
case NodeActionOperatorLte:
return types.Int64(value1) <= types.Int64(value2)
case NodeActionOperatorEq:
return types.Int64(value1) == types.Int64(value2)
}
return false
}
func (this *NodeActionCond) toBandwidthBits(m maps.Map) int64 {
var count = m.GetInt64("count")
var unit = m.GetString("unit")
if count <= 0 {
return 0
}
switch unit {
case "b":
return count
case "kb":
return count << 10
case "mb":
return count << 20
case "gb":
return count << 30
case "tb":
return count << 40
}
return 0
}
func (this *NodeActionCond) toTrafficBytes(m maps.Map) int64 {
var count = m.GetInt64("count")
var unit = m.GetString("unit")
if count <= 0 {
return 0
}
switch unit {
case "b":
return count
case "kb":
return count << 10
case "mb":
return count << 20
case "gb":
return count << 30
case "tb":
return count << 40
case "pb":
return count << 50
case "eb":
return count << 60
}
return 0
}
func (this *NodeActionCond) isScalar(value any) bool {
if value == nil {
return false
}
switch value.(type) {
case int, int8, int16, int32, int64, uint, uint8, uint16, uint64, float32, float64, string, bool:
return true
}
return false
}
type NodeActionCondsConfig struct {
Conds []*NodeActionCond `json:"conds"`
Connector NodeActionCondConnector `json:"connector"`
}
func NewNodeActionCondsConfig() *NodeActionCondsConfig {
return &NodeActionCondsConfig{
Connector: NodeActionCondConnectorAnd,
}
}
func (this *NodeActionCondsConfig) Match(valueGetter func(param NodeActionParam) (value any, err error)) (bool, error) {
if len(this.Conds) == 0 {
return false, nil
}
for index, cond := range this.Conds {
value, err := valueGetter(cond.Param)
if err != nil {
return false, err
}
var b = cond.Match(value)
if !b {
if this.Connector == NodeActionCondConnectorAnd {
return false, nil
}
// 如果是最后一个OR条件，则直接返回false
if index == len(this.Conds)-1 {
return false, nil
}
} else {
if this.Connector == NodeActionCondConnectorOr {
return true, nil
}
// 如果是最后一个AND条件，则直接返回true
if index == len(this.Conds)-1 {
return true, nil
}
}
}
return true, nil
}
// NodeActionCode 动作代号
type NodeActionCode = string
const (
NodeActionCodeUp NodeActionCode = "up" // 上线
NodeActionCodeDown NodeActionCode = "down" // 下线
NodeActionCodeSwitchToBackupNodesInCluster NodeActionCode = "switchToBackupNodesInCluster" // 切换到集群备用节点
NodeActionCodeSwitchToBackupNodesInGroup NodeActionCode = "switchToBackupNodesInGroup" // 切换到分组备用节点
NodeActionCodeSwitchToBackupIP NodeActionCode = "switchToBackupIP" // 切换到备用IP
NodeActionCodeEnableBackupNodesInCluster NodeActionCode = "enableBackupNodesInCluster" // 启用集群备用节点
NodeActionCodeEnableBackupNodesInGroup NodeActionCode = "enableBackupNodesInGroup" // 启用分组备用节点
NodeActionCodeEnableBackupIP NodeActionCode = "enableBackupIP" // 启用备用IP
NodeActionCodeWebHook NodeActionCode = "webHook" // WebHook
)
func FindAllNodeActionDefinitions() []*shared.Definition {
return []*shared.Definition{
{
Code: NodeActionCodeUp,
Name: "上线当前节点",
Description: "将当前节点状态设置为在线。",
},
{
Code: NodeActionCodeDown,
Name: "下线当前节点",
Description: "将当前节点状态设置为离线。",
},
{
Code: NodeActionCodeSwitchToBackupNodesInCluster,
Name: "切换到集群备用节点",
Description: "下线当前节点并启用节点所在集群备用节点。",
},
{
Code: NodeActionCodeSwitchToBackupNodesInGroup,
Name: "切换到分组备用节点",
Description: "下线当前节点并启用节点所在分组备用节点。",
},
{
Code: NodeActionCodeSwitchToBackupIP,
Name: "切换到备用IP",
Description: "将当前节点的IP切换到当前节点配置的备用IP。",
},
{
Code: NodeActionCodeEnableBackupNodesInCluster,
Name: "启用集群备用节点",
Description: "保持当前节点并启用节点所在集群备用节点。",
},
{
Code: NodeActionCodeEnableBackupNodesInGroup,
Name: "启用分组备用节点",
Description: "保持当前节点并启用节点所在分组备用节点。",
},
{
Code: NodeActionCodeEnableBackupIP,
Name: "启用备用IP",
Description: "保持当前节点的IP并启用当前节点配置的备用IP。",
},
{
Code: NodeActionCodeWebHook,
Name: "WebHook",
Description: "通过WebHook发送通知到URL。",
},
}
}
func FindNodeActionDefinition(code NodeActionCode) *shared.Definition {
for _, def := range FindAllNodeActionDefinitions() {
if def.Code == code {
return def
}
}
return nil
}
func FindNodeActionName(code NodeActionCode) string {
var def = FindNodeActionDefinition(code)
if def != nil {
return def.Name
}
return ""
}
// NodeActionConfig 动作配置
type NodeActionConfig struct {
Code NodeActionCode `json:"code"` // 动作代号
Params any `json:"params"` // 动作参数
}
func NewNodeActionConfig() *NodeActionConfig {
return &NodeActionConfig{}
}
type NodeActionCodeWebHookParams struct {
URL string `json:"url"` // URL路径
}
// NodeActionStatus 动作状态
type NodeActionStatus struct {
ActionId int64 `json:"actionId"` // 动作ID
CreatedAt int64 `json:"createdAt"` // 状态创建时间
Conds *NodeActionCondsConfig `json:"conds"` // 动作条件
Action *NodeActionConfig `json:"action"` // 动作配置
ExpiresAt int64 `json:"expiresAt"` // 过期时间
}