rcmgr

package
v0.0.6 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 22, 2025 License: MIT Imports: 28 Imported by: 1

Documentation

Overview

rcmgr 包是 go-dep2p 的资源管理器。 它允许你跟踪整个 go-dep2p 进程中使用的资源。 同时确保进程不会使用超过你定义的限制的资源。 资源管理器只知道它被告知的内容，因此这个库的使用者(无论是 go-dep2p 还是 go-dep2p 的用户)有责任在实际分配资源之前与资源管理器确认。

Index

Constants

This section is empty.

Variables

View Source 
var DefaultLimits = ScalingLimitConfig{
	SystemBaseLimit: BaseLimit{
		ConnsInbound:    64,
		ConnsOutbound:   128,
		Conns:           128,
		StreamsInbound:  64 * 16,
		StreamsOutbound: 128 * 16,
		Streams:         128 * 16,
		Memory:          128 << 20,
		FD:              256,
	},

	SystemLimitIncrease: BaseLimitIncrease{
		ConnsInbound:    64,
		ConnsOutbound:   128,
		Conns:           128,
		StreamsInbound:  64 * 16,
		StreamsOutbound: 128 * 16,
		Streams:         128 * 16,
		Memory:          1 << 30,
		FDFraction:      1,
	},

	TransientBaseLimit: BaseLimit{
		ConnsInbound:    32,
		ConnsOutbound:   64,
		Conns:           64,
		StreamsInbound:  128,
		StreamsOutbound: 256,
		Streams:         256,
		Memory:          32 << 20,
		FD:              64,
	},

	TransientLimitIncrease: BaseLimitIncrease{
		ConnsInbound:    16,
		ConnsOutbound:   32,
		Conns:           32,
		StreamsInbound:  128,
		StreamsOutbound: 256,
		Streams:         256,
		Memory:          128 << 20,
		FDFraction:      0.25,
	},

	AllowlistedSystemBaseLimit: BaseLimit{
		ConnsInbound:    64,
		ConnsOutbound:   128,
		Conns:           128,
		StreamsInbound:  64 * 16,
		StreamsOutbound: 128 * 16,
		Streams:         128 * 16,
		Memory:          128 << 20,
		FD:              256,
	},

	AllowlistedSystemLimitIncrease: BaseLimitIncrease{
		ConnsInbound:    64,
		ConnsOutbound:   128,
		Conns:           128,
		StreamsInbound:  64 * 16,
		StreamsOutbound: 128 * 16,
		Streams:         128 * 16,
		Memory:          1 << 30,
		FDFraction:      1,
	},

	AllowlistedTransientBaseLimit: BaseLimit{
		ConnsInbound:    32,
		ConnsOutbound:   64,
		Conns:           64,
		StreamsInbound:  128,
		StreamsOutbound: 256,
		Streams:         256,
		Memory:          32 << 20,
		FD:              64,
	},

	AllowlistedTransientLimitIncrease: BaseLimitIncrease{
		ConnsInbound:    16,
		ConnsOutbound:   32,
		Conns:           32,
		StreamsInbound:  128,
		StreamsOutbound: 256,
		Streams:         256,
		Memory:          128 << 20,
		FDFraction:      0.25,
	},

	ServiceBaseLimit: BaseLimit{
		StreamsInbound:  1024,
		StreamsOutbound: 4096,
		Streams:         4096,
		Memory:          64 << 20,
	},

	ServiceLimitIncrease: BaseLimitIncrease{
		StreamsInbound:  512,
		StreamsOutbound: 2048,
		Streams:         2048,
		Memory:          128 << 20,
	},

	ServicePeerBaseLimit: BaseLimit{
		StreamsInbound:  128,
		StreamsOutbound: 256,
		Streams:         256,
		Memory:          16 << 20,
	},

	ServicePeerLimitIncrease: BaseLimitIncrease{
		StreamsInbound:  4,
		StreamsOutbound: 8,
		Streams:         8,
		Memory:          4 << 20,
	},

	ProtocolBaseLimit: BaseLimit{
		StreamsInbound:  512,
		StreamsOutbound: 2048,
		Streams:         2048,
		Memory:          64 << 20,
	},

	ProtocolLimitIncrease: BaseLimitIncrease{
		StreamsInbound:  256,
		StreamsOutbound: 512,
		Streams:         512,
		Memory:          164 << 20,
	},

	ProtocolPeerBaseLimit: BaseLimit{
		StreamsInbound:  64,
		StreamsOutbound: 128,
		Streams:         256,
		Memory:          16 << 20,
	},

	ProtocolPeerLimitIncrease: BaseLimitIncrease{
		StreamsInbound:  4,
		StreamsOutbound: 8,
		Streams:         16,
		Memory:          4,
	},

	PeerBaseLimit: BaseLimit{

		ConnsInbound:    8,
		ConnsOutbound:   8,
		Conns:           8,
		StreamsInbound:  256,
		StreamsOutbound: 512,
		Streams:         512,
		Memory:          64 << 20,
		FD:              4,
	},

	PeerLimitIncrease: BaseLimitIncrease{
		StreamsInbound:  128,
		StreamsOutbound: 256,
		Streams:         256,
		Memory:          128 << 20,
		FDFraction:      1.0 / 64,
	},

	ConnBaseLimit: BaseLimit{
		ConnsInbound:  1,
		ConnsOutbound: 1,
		Conns:         1,
		FD:            1,
		Memory:        32 << 20,
	},

	StreamBaseLimit: BaseLimit{
		StreamsInbound:  1,
		StreamsOutbound: 1,
		Streams:         1,
		Memory:          16 << 20,
	},
}

DefaultLimits 是默认限制器构造函数使用的限制。 参数:

  • SystemBaseLimit: 系统基础限制配置
  • SystemLimitIncrease: 系统限制增量配置
  • TransientBaseLimit: 临时基础限制配置
  • TransientLimitIncrease: 临时限制增量配置
  • AllowlistedSystemBaseLimit: 白名单系统基础限制配置
  • AllowlistedSystemLimitIncrease: 白名单系统限制增量配置
  • AllowlistedTransientBaseLimit: 白名单临时基础限制配置
  • AllowlistedTransientLimitIncrease: 白名单临时限制增量配置
  • ServiceBaseLimit: 服务基础限制配置
  • ServiceLimitIncrease: 服务限制增量配置
  • ServicePeerBaseLimit: 服务对等节点基础限制配置
  • ServicePeerLimitIncrease: 服务对等节点限制增量配置
  • ProtocolBaseLimit: 协议基础限制配置
  • ProtocolLimitIncrease: 协议限制增量配置
  • ProtocolPeerBaseLimit: 协议对等节点基础限制配置
  • ProtocolPeerLimitIncrease: 协议对等节点限制增量配置
  • PeerBaseLimit: 对等节点基础限制配置
  • PeerLimitIncrease: 对等节点限制增量配置
  • ConnBaseLimit: 连接基础限制配置
  • StreamBaseLimit: 流基础限制配置

返回值:

  • ScalingLimitConfig: 包含所有限制配置的可扩展限制配置
View Source 
var DefaultNetworkPrefixLimitV4 = sortNetworkPrefixes([]NetworkPrefixLimit{
	{

		Network:   netip.MustParsePrefix("127.0.0.0/8"),
		ConnCount: math.MaxInt,
	},
})

DefaultNetworkPrefixLimitV4 定义了 IPv4 的默认网络前缀限制

View Source 
var DefaultNetworkPrefixLimitV6 = sortNetworkPrefixes([]NetworkPrefixLimit{
	{

		Network:   netip.MustParsePrefix("::1/128"),
		ConnCount: math.MaxInt,
	},
})

DefaultNetworkPrefixLimitV6 定义了 IPv6 的默认网络前缀限制

View Source 
var InfiniteLimits = ConcreteLimitConfig{
	// contains filtered or unexported fields
}

InfiniteLimits 是一个使用无限限制的限制器配置,因此实际上不限制任何内容。 请记住,操作系统会限制应用程序可以使用的文件描述符数量。 参数:

  • system: BaseLimit - 系统级别的无限制配置
  • transient: BaseLimit - 临时的无限制配置
  • allowlistedSystem: BaseLimit - 白名单系统的无限制配置
  • allowlistedTransient: BaseLimit - 白名单临时的无限制配置
  • serviceDefault: BaseLimit - 服务默认的无限制配置
  • servicePeerDefault: BaseLimit - 服务对等节点默认的无限制配置
  • protocolDefault: BaseLimit - 协议默认的无限制配置
  • protocolPeerDefault: BaseLimit - 协议对等节点默认的无限制配置
  • peerDefault: BaseLimit - 对等节点默认的无限制配置
  • conn: BaseLimit - 连接的无限制配置
  • stream: BaseLimit - 流的无限制配置

Functions

func IsConnScope 

func IsConnScope(name string) bool

IsConnScope 检查给定名称是否为连接作用域 参数:

  • name: string - 作用域名称

返回值:

  • bool - 是否为连接作用域

func IsSpan 

func IsSpan(name string) bool

IsSpan 检查给定名称是否为 span 作用域 参数:

  • name: 要检查的名称

返回:

  • bool: 如果是 span 作用域则返回 true

func IsStreamScope 

func IsStreamScope(name string) bool

IsStreamScope 检查给定名称是否为流作用域 参数:

  • name: string - 作用域名称

返回值:

  • bool - 是否为流作用域

func IsSystemScope 

func IsSystemScope(name string) bool

IsSystemScope 检查给定名称是否为系统作用域 参数:

  • name: string - 作用域名称

返回值:

  • bool - 是否为系统作用域

func IsTransientScope 

func IsTransientScope(name string) bool

IsTransientScope 检查给定名称是否为临时作用域 参数:

  • name: string - 作用域名称

返回值:

  • bool - 是否为临时作用域

func MustRegisterWith 

func MustRegisterWith(reg prometheus.Registerer)

MustRegisterWith 注册所有指标收集器到Prometheus @param reg - Prometheus注册器实例

func NewResourceManager 

func NewResourceManager(limits Limiter, opts ...Option) (network.ResourceManager, error)

NewResourceManager 创建一个新的资源管理器 参数:

  • limits: 资源限制器
  • opts: 可选的配置选项

返回:

  • network.ResourceManager: 资源管理器接口实现
  • error: 错误信息

func ParseProtocolScopeName 

func ParseProtocolScopeName(name string) string

ParseProtocolScopeName 从作用域名称中解析协议名称 参数:

  • name: string - 作用域名称

返回值:

  • string - 协议名称，如果不是协议作用域则返回空字符串

func PeerStrInScopeName 

func PeerStrInScopeName(name string) string

PeerStrInScopeName 从作用域名称中提取对等节点ID字符串 参数:

  • name: string - 作用域名称

返回值:

  • string - 对等节点ID字符串，如果不是对等节点作用域则返回空字符串

Types

type Allowlist 

type Allowlist struct {
	// contains filtered or unexported fields
}

Allowlist 白名单结构体

func GetAllowlist 

func GetAllowlist(rcmgr network.ResourceManager) *Allowlist

GetAllowlist 尝试从给定的资源管理器接口获取白名单 参数:

  • rcmgr: 资源管理器接口

返回值:

  • *Allowlist: 白名单对象,如果获取失败则返回nil

func (*Allowlist) Add 

func (al *Allowlist) Add(ma multiaddr.Multiaddr) error

Add 将多地址添加到白名单中 参数:

  • ma: 多地址

返回:

  • error: 错误信息

func (*Allowlist) Allowed 

func (al *Allowlist) Allowed(ma multiaddr.Multiaddr) bool

Allowed 检查多地址是否在白名单中 参数:

  • ma: 多地址

返回:

  • bool: 是否允许

func (*Allowlist) AllowedPeerAndMultiaddr 

func (al *Allowlist) AllowedPeerAndMultiaddr(peerID peer.ID, ma multiaddr.Multiaddr) bool

AllowedPeerAndMultiaddr 检查对等节点和多地址是否在白名单中 参数:

  • peerID: 对等节点ID
  • ma: 多地址

返回:

  • bool: 是否允许

func (*Allowlist) Remove 

func (al *Allowlist) Remove(ma multiaddr.Multiaddr) error

Remove 从白名单中移除多地址 参数:

  • ma: 多地址

返回:

  • error: 错误信息

type BaseLimit 

type BaseLimit struct {
	Streams         int   `json:",omitempty"` // 总流数量限制
	StreamsInbound  int   `json:",omitempty"` // 入站流数量限制
	StreamsOutbound int   `json:",omitempty"` // 出站流数量限制
	Conns           int   `json:",omitempty"` // 总连接数量限制
	ConnsInbound    int   `json:",omitempty"` // 入站连接数量限制
	ConnsOutbound   int   `json:",omitempty"` // 出站连接数量限制
	FD              int   `json:",omitempty"` // 文件描述符数量限制
	Memory          int64 `json:",omitempty"` // 内存大小限制(字节)
}

BaseLimit 是基本资源限制的混入类型。

func (*BaseLimit) Apply 

func (l *BaseLimit) Apply(l2 BaseLimit)

Apply 用 l2 的值覆盖所有零值限制 参数:

  • l2: BaseLimit - 源限制配置

func (BaseLimit) GetConnLimit 

func (l BaseLimit) GetConnLimit(dir network.Direction) int

GetConnLimit 获取指定方向的连接限制 参数:

  • dir: network.Direction - 连接的方向(入站/出站)

返回值:

  • int - 连接数量限制

func (BaseLimit) GetConnTotalLimit 

func (l BaseLimit) GetConnTotalLimit() int

GetConnTotalLimit 获取总连接限制 返回值:

  • int - 总连接数量限制

func (BaseLimit) GetFDLimit 

func (l BaseLimit) GetFDLimit() int

GetFDLimit 获取文件描述符限制 返回值:

  • int - 文件描述符数量限制

func (BaseLimit) GetMemoryLimit 

func (l BaseLimit) GetMemoryLimit() int64

GetMemoryLimit 获取内存限制 返回值:

  • int64 - 内存大小限制(字节)

func (BaseLimit) GetStreamLimit 

func (l BaseLimit) GetStreamLimit(dir network.Direction) int

GetStreamLimit 获取指定方向的流限制 参数:

  • dir: network.Direction - 流的方向(入站/出站)

返回值:

  • int - 流的数量限制

func (BaseLimit) GetStreamTotalLimit 

func (l BaseLimit) GetStreamTotalLimit() int

GetStreamTotalLimit 获取总流限制 返回值:

  • int - 总流数量限制

func (BaseLimit) ToResourceLimits 

func (l BaseLimit) ToResourceLimits() ResourceLimits

ToResourceLimits 将 BaseLimit 转换为 ResourceLimits 返回值:

  • ResourceLimits - 转换后的资源限制

type BaseLimitIncrease 

type BaseLimitIncrease struct {
	Streams         int     `json:",omitempty"` // 每 GiB 内存增加的总流数量
	StreamsInbound  int     `json:",omitempty"` // 每 GiB 内存增加的入站流数量
	StreamsOutbound int     `json:",omitempty"` // 每 GiB 内存增加的出站流数量
	Conns           int     `json:",omitempty"` // 每 GiB 内存增加的总连接数量
	ConnsInbound    int     `json:",omitempty"` // 每 GiB 内存增加的入站连接数量
	ConnsOutbound   int     `json:",omitempty"` // 每 GiB 内存增加的出站连接数量
	Memory          int64   `json:",omitempty"` // 每 GiB 内存增加的内存大小(字节)
	FDFraction      float64 `json:",omitempty"` // 文件描述符增加的比例(0-1)
}

BaseLimitIncrease 是每 GiB 允许内存的增加量。

func (*BaseLimitIncrease) Apply 

func (l *BaseLimitIncrease) Apply(l2 BaseLimitIncrease)

Apply 用 l2 的值覆盖所有零值限制 参数:

  • l2: BaseLimitIncrease - 源限制增量配置

type ConcreteLimitConfig 

type ConcreteLimitConfig struct {
	// contains filtered or unexported fields
}

ConcreteLimitConfig 类似于 PartialLimitConfig,但所有值都已定义。 没有未设置的"默认"值。通常通过调用 PartialLimitConfig.Build(rcmgr.DefaultLimits.AutoScale()) 构建

func (ConcreteLimitConfig) ToPartialLimitConfig 

func (cfg ConcreteLimitConfig) ToPartialLimitConfig() PartialLimitConfig

ToPartialLimitConfig 将 ConcreteLimitConfig 转换为 PartialLimitConfig。 返回的 PartialLimitConfig 不会有默认值。 返回值:

  • PartialLimitConfig - 转换后的部分限制配置

type ConnLimitPerSubnet 

type ConnLimitPerSubnet struct {
	// PrefixLength 定义了子网的大小。例如，/24 子网的 PrefixLength 为 24。
	// 所有共享相同 24 位前缀的 IP 都在同一个子网中,并受相同的限制约束。
	PrefixLength int
	// ConnCount 每个子网允许的最大连接数。
	ConnCount int
}

ConnLimitPerSubnet 定义了每个子网的连接限制

type ErrMemoryLimitExceeded 

type ErrMemoryLimitExceeded struct {
	// contains filtered or unexported fields
}

ErrMemoryLimitExceeded 定义了内存超出限制的错误结构体

func (*ErrMemoryLimitExceeded) Error 

func (e *ErrMemoryLimitExceeded) Error() string

Error 实现 error 接口，返回错误信息 返回值:

  • string: 错误信息字符串

func (*ErrMemoryLimitExceeded) Unwrap 

func (e *ErrMemoryLimitExceeded) Unwrap() error

Unwrap 返回原始错误 返回值:

  • error: 原始错误对象

type ErrStreamOrConnLimitExceeded 

type ErrStreamOrConnLimitExceeded struct {
	// contains filtered or unexported fields
}

ErrStreamOrConnLimitExceeded 定义了流或连接超出限制的错误结构体

func (*ErrStreamOrConnLimitExceeded) Error 

func (e *ErrStreamOrConnLimitExceeded) Error() string

Error 实现 error 接口，返回错误信息 返回值:

  • string: 错误信息字符串

func (*ErrStreamOrConnLimitExceeded) Unwrap 

func (e *ErrStreamOrConnLimitExceeded) Unwrap() error

Unwrap 返回原始错误 返回值:

  • error: 原始错误对象

type Limit 

type Limit interface {
	// GetMemoryLimit 返回(当前的)内存限制。
	// 返回值:
	//   - int64 - 内存限制大小(字节)
	GetMemoryLimit() int64

	// GetStreamLimit 返回入站或出站流的限制。
	// 参数:
	//   - dir: network.Direction - 流的方向(入站/出站)
	// 返回值:
	//   - int - 流的数量限制
	GetStreamLimit(network.Direction) int

	// GetStreamTotalLimit 返回总流限制
	// 返回值:
	//   - int - 总流数量限制
	GetStreamTotalLimit() int

	// GetConnLimit 返回入站或出站连接的限制。
	// 参数:
	//   - dir: network.Direction - 连接的方向(入站/出站)
	// 返回值:
	//   - int - 连接数量限制
	GetConnLimit(network.Direction) int

	// GetConnTotalLimit 返回总连接限制
	// 返回值:
	//   - int - 总连接数量限制
	GetConnTotalLimit() int

	// GetFDLimit 返回文件描述符限制。
	// 返回值:
	//   - int - 文件描述符数量限制
	GetFDLimit() int
}

Limit 是一个指定基本资源限制的接口。

type LimitVal 

type LimitVal int

LimitVal 限制值类型 

const (
	// DefaultLimit 是资源的默认值。具体值取决于上下文,但会从 `DefaultLimits` 获取值。
	DefaultLimit LimitVal = 0
	// Unlimited 是无限资源的值。任意高的数字也可以。
	Unlimited LimitVal = -1
	// BlockAllLimit 是不允许任何资源的 LimitVal。
	BlockAllLimit LimitVal = -2
)

func (LimitVal) Build 

func (l LimitVal) Build(defaultVal int) int

Build 构建限制值 参数:

  • defaultVal: int - 默认限制值

返回值:

  • int - 构建后的实际限制值

func (LimitVal) MarshalJSON 

func (l LimitVal) MarshalJSON() ([]byte, error)

MarshalJSON 实现 JSON 序列化 参数:

  • 无

返回值:

  • []byte - 序列化后的JSON字节数组
  • error 错误信息

func (*LimitVal) UnmarshalJSON 

func (l *LimitVal) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现 JSON 反序列化 参数:

  • b: []byte - 要反序列化的JSON字节数组

返回值:

  • error 错误信息

type LimitVal64 

type LimitVal64 int64

LimitVal64 64位限制值类型 

const (
	// DefaultLimit64 是资源的默认值。
	DefaultLimit64 LimitVal64 = 0
	// Unlimited64 是无限资源的值。
	Unlimited64 LimitVal64 = -1
	// BlockAllLimit64 是不允许任何资源的 LimitVal。
	BlockAllLimit64 LimitVal64 = -2
)

func (LimitVal64) Build 

func (l LimitVal64) Build(defaultVal int64) int64

Build 构建限制值 参数:

  • defaultVal: int64 - 默认限制值

返回值:

  • int64 - 构建后的实际限制值

func (LimitVal64) MarshalJSON 

func (l LimitVal64) MarshalJSON() ([]byte, error)

MarshalJSON 实现 JSON 序列化 返回值:

  • []byte - 序列化后的 JSON 字节数组
  • error 序列化过程中的错误

func (*LimitVal64) UnmarshalJSON 

func (l *LimitVal64) UnmarshalJSON(b []byte) error

UnmarshalJSON 实现 JSON 反序列化 参数:

  • b: []byte - 要反序列化的 JSON 字节数组

返回值:

  • error 反序列化过程中的错误

type Limiter 

type Limiter interface {
	// GetSystemLimits 返回系统级别的资源限制
	// 返回值:
	//   - Limit - 系统资源限制
	GetSystemLimits() Limit

	// GetTransientLimits 返回临时资源限制
	// 返回值:
	//   - Limit - 临时资源限制
	GetTransientLimits() Limit

	// GetAllowlistedSystemLimits 返回白名单系统资源限制
	// 返回值:
	//   - Limit - 白名单系统资源限制
	GetAllowlistedSystemLimits() Limit

	// GetAllowlistedTransientLimits 返回白名单临时资源限制
	// 返回值:
	//   - Limit - 白名单临时资源限制
	GetAllowlistedTransientLimits() Limit

	// GetServiceLimits 返回指定服务的资源限制
	// 参数:
	//   - svc: string - 服务名称
	// 返回值:
	//   - Limit - 服务资源限制
	GetServiceLimits(svc string) Limit

	// GetServicePeerLimits 返回指定服务的对等节点资源限制
	// 参数:
	//   - svc: string - 服务名称
	// 返回值:
	//   - Limit - 服务对等节点资源限制
	GetServicePeerLimits(svc string) Limit

	// GetProtocolLimits 返回指定协议的资源限制
	// 参数:
	//   - proto: protocol.ID - 协议ID
	// 返回值:
	//   - Limit - 协议资源限制
	GetProtocolLimits(proto protocol.ID) Limit

	// GetProtocolPeerLimits 返回指定协议的对等节点资源限制
	// 参数:
	//   - proto: protocol.ID - 协议ID
	// 返回值:
	//   - Limit - 协议对等节点资源限制
	GetProtocolPeerLimits(proto protocol.ID) Limit

	// GetPeerLimits 返回指定对等节点的资源限制
	// 参数:
	//   - p: peer.ID - 对等节点ID
	// 返回值:
	//   - Limit - 对等节点资源限制
	GetPeerLimits(p peer.ID) Limit

	// GetStreamLimits 返回指定对等节点的流资源限制
	// 参数:
	//   - p: peer.ID - 对等节点ID
	// 返回值:
	//   - Limit - 流资源限制
	GetStreamLimits(p peer.ID) Limit

	// GetConnLimits 返回连接资源限制
	// 返回值:
	//   - Limit - 连接资源限制
	GetConnLimits() Limit
}

Limiter 是为资源管理器提供限制的接口。

func NewDefaultLimiterFromJSON 

func NewDefaultLimiterFromJSON(in io.Reader) (Limiter, error)

NewDefaultLimiterFromJSON 通过解析 JSON 配置创建一个新的限制器，使用默认限制作为回退。 参数:

  • in: io.Reader - JSON 配置输入流

返回值:

  • Limiter - 创建的限制器
  • error 错误信息

func NewFixedLimiter 

func NewFixedLimiter(conf ConcreteLimitConfig) Limiter

NewFixedLimiter 创建一个新的固定限制器 参数:

  • conf: ConcreteLimitConfig - 具体限制配置

返回值:

  • Limiter - 创建的限制器

func NewLimiterFromJSON 

func NewLimiterFromJSON(in io.Reader, defaults ConcreteLimitConfig) (Limiter, error)

NewLimiterFromJSON 通过解析 JSON 配置创建一个新的限制器。 参数:

  • in: io.Reader - JSON 配置输入流
  • defaults: ConcreteLimitConfig - 默认限制配置

返回值:

  • Limiter - 创建的限制器
  • error 错误信息

type MetricsReporter 

type MetricsReporter interface {
	// AllowConn 当允许打开连接时调用
	// 参数:
	//   - dir: network.Direction - 连接方向(入站/出站)
	//   - usefd: bool - 是否使用文件描述符
	AllowConn(dir network.Direction, usefd bool)

	// BlockConn 当阻止打开连接时调用
	// 参数:
	//   - dir: network.Direction - 连接方向(入站/出站)
	//   - usefd: bool - 是否使用文件描述符
	BlockConn(dir network.Direction, usefd bool)

	// AllowStream 当允许打开流时调用
	// 参数:
	//   - p: peer.ID - 对等节点ID
	//   - dir: network.Direction - 流方向(入站/出站)
	AllowStream(p peer.ID, dir network.Direction)

	// BlockStream 当阻止打开流时调用
	// 参数:
	//   - p: peer.ID - 对等节点ID
	//   - dir: network.Direction - 流方向(入站/出站)
	BlockStream(p peer.ID, dir network.Direction)

	// AllowPeer 当允许将连接附加到对等节点时调用
	// 参数:
	//   - p: peer.ID - 对等节点ID
	AllowPeer(p peer.ID)

	// BlockPeer 当阻止将连接附加到对等节点时调用
	// 参数:
	//   - p: peer.ID - 对等节点ID
	BlockPeer(p peer.ID)

	// AllowProtocol 当允许为流设置协议时调用
	// 参数:
	//   - proto: protocol.ID - 协议ID
	AllowProtocol(proto protocol.ID)

	// BlockProtocol 当阻止为流设置协议时调用
	// 参数:
	//   - proto: protocol.ID - 协议ID
	BlockProtocol(proto protocol.ID)

	// BlockProtocolPeer 当在每个协议对等节点范围内阻止为流设置协议时调用
	// 参数:
	//   - proto: protocol.ID - 协议ID
	//   - p: peer.ID - 对等节点ID
	BlockProtocolPeer(proto protocol.ID, p peer.ID)

	// AllowService 当允许为流设置服务时调用
	// 参数:
	//   - svc: string - 服务名称
	AllowService(svc string)

	// BlockService 当阻止为流设置服务时调用
	// 参数:
	//   - svc: string - 服务名称
	BlockService(svc string)

	// BlockServicePeer 当在每个服务对等节点范围内阻止为流设置服务时调用
	// 参数:
	//   - svc: string - 服务名称
	//   - p: peer.ID - 对等节点ID
	BlockServicePeer(svc string, p peer.ID)

	// AllowMemory 当允许内存预留时调用
	// 参数:
	//   - size: int - 内存大小
	AllowMemory(size int)

	// BlockMemory 当阻止内存预留时调用
	// 参数:
	//   - size: int - 内存大小
	BlockMemory(size int)
}

MetricsReporter 是一个用于收集资源管理器操作指标的接口

type NetworkPrefixLimit 

type NetworkPrefixLimit struct {
	// Network 此限制适用的网络前缀。
	Network netip.Prefix
	// ConnCount 此子网允许的最大连接数。
	ConnCount int
}

NetworkPrefixLimit 定义了特定网络前缀的连接限制

type Option 

type Option func(*resourceManager) error

Option 是一个函数类型,用于配置资源管理器

func WithAllowlistedMultiaddrs 

func WithAllowlistedMultiaddrs(mas []multiaddr.Multiaddr) Option

WithAllowlistedMultiaddrs 设置要加入白名单的多地址 参数:

  • mas: 多地址切片

返回:

  • Option: 配置选项函数

func WithLimitPerSubnet 

func WithLimitPerSubnet(ipv4 []ConnLimitPerSubnet, ipv6 []ConnLimitPerSubnet) Option

WithLimitPerSubnet 设置每个子网允许的连接数限制。 如果该子网未在 NetworkPrefixLimit 选项中定义,这将限制每个子网的连接数。 可以将其视为任何给定子网的默认限制。

参数:

  • ipv4: []ConnLimitPerSubnet - IPv4 的子网限制列表
  • ipv6: []ConnLimitPerSubnet - IPv6 的子网限制列表

返回值:

  • Option - 返回一个资源管理器选项函数

func WithMetrics 

func WithMetrics(reporter MetricsReporter) Option

WithMetrics 是一个资源管理器选项,用于启用指标收集 参数:

  • reporter: MetricsReporter - 指标报告器

返回值:

  • Option - 资源管理器选项

func WithMetricsDisabled 

func WithMetricsDisabled() Option

WithMetricsDisabled 返回一个禁用指标收集的选项函数 @return Option - 资源管理器配置选项

func WithNetworkPrefixLimit 

func WithNetworkPrefixLimit(ipv4 []NetworkPrefixLimit, ipv6 []NetworkPrefixLimit) Option

WithNetworkPrefixLimit 设置特定网络前缀允许的连接数限制。 当你想为特定子网设置比默认子网限制更高的限制时使用此选项。

参数:

  • ipv4: []NetworkPrefixLimit - IPv4 的网络前缀限制列表
  • ipv6: []NetworkPrefixLimit - IPv6 的网络前缀限制列表

返回值:

  • Option - 返回一个资源管理器选项函数

func WithTrace 

func WithTrace(path string) Option

WithTrace 创建一个带跟踪功能的选项 参数:

  • path string 跟踪文件路径

返回值:

  • Option 资源管理器选项

func WithTraceReporter 

func WithTraceReporter(reporter TraceReporter) Option

WithTraceReporter 创建一个带事件报告器的选项 参数:

  • reporter TraceReporter 事件报告器

返回值:

  • Option 资源管理器选项

type PartialLimitConfig 

type PartialLimitConfig struct {
	System    ResourceLimits `json:",omitempty"` // 系统级别的资源限制
	Transient ResourceLimits `json:",omitempty"` // 临时资源限制

	// 应用于具有白名单多地址的资源的限制。
	// 这些限制仅在达到正常的系统和临时限制时使用。
	AllowlistedSystem    ResourceLimits `json:",omitempty"` // 白名单系统资源限制
	AllowlistedTransient ResourceLimits `json:",omitempty"` // 白名单临时资源限制

	ServiceDefault ResourceLimits            `json:",omitempty"` // 服务默认资源限制
	Service        map[string]ResourceLimits `json:",omitempty"` // 特定服务的资源限制映射

	ServicePeerDefault ResourceLimits            `json:",omitempty"` // 服务对等节点默认资源限制
	ServicePeer        map[string]ResourceLimits `json:",omitempty"` // 特定服务对等节点的资源限制映射

	ProtocolDefault ResourceLimits                 `json:",omitempty"` // 协议默认资源限制
	Protocol        map[protocol.ID]ResourceLimits `json:",omitempty"` // 特定协议的资源限制映射

	ProtocolPeerDefault ResourceLimits                 `json:",omitempty"` // 协议对等节点默认资源限制
	ProtocolPeer        map[protocol.ID]ResourceLimits `json:",omitempty"` // 特定协议对等节点的资源限制映射

	PeerDefault ResourceLimits             `json:",omitempty"` // 对等节点默认资源限制
	Peer        map[peer.ID]ResourceLimits `json:",omitempty"` // 特定对等节点的资源限制映射

	Conn   ResourceLimits `json:",omitempty"` // 连接资源限制
	Stream ResourceLimits `json:",omitempty"` // 流资源限制
}

PartialLimitConfig 定义部分限制配置

func (*PartialLimitConfig) Apply 

func (cfg *PartialLimitConfig) Apply(c PartialLimitConfig)

Apply 应用另一个配置 参数:

  • c: PartialLimitConfig - 要应用的配置

func (PartialLimitConfig) Build 

func (cfg PartialLimitConfig) Build(defaults ConcreteLimitConfig) ConcreteLimitConfig

Build 根据默认值构建具体限制配置 参数:

  • defaults: ConcreteLimitConfig - 默认的具体限制配置

返回值:

  • ConcreteLimitConfig - 构建后的具体限制配置

func (*PartialLimitConfig) MarshalJSON 

func (cfg *PartialLimitConfig) MarshalJSON() ([]byte, error)

MarshalJSON 实现 JSON 序列化 返回值:

  • []byte - 序列化后的 JSON 字节数组
  • error 序列化过程中的错误

type ResourceLimits 

type ResourceLimits struct {
	Streams         LimitVal   `json:",omitempty"` // 流限制
	StreamsInbound  LimitVal   `json:",omitempty"` // 入站流限制
	StreamsOutbound LimitVal   `json:",omitempty"` // 出站流限制
	Conns           LimitVal   `json:",omitempty"` // 连接限制
	ConnsInbound    LimitVal   `json:",omitempty"` // 入站连接限制
	ConnsOutbound   LimitVal   `json:",omitempty"` // 出站连接限制
	FD              LimitVal   `json:",omitempty"` // 文件描述符限制
	Memory          LimitVal64 `json:",omitempty"` // 内存限制
}

ResourceLimits 是基本资源限制的类型。

func (*ResourceLimits) Apply 

func (l *ResourceLimits) Apply(l2 ResourceLimits)

Apply 用另一个资源限制对象的值覆盖当前对象中的默认限制 参数:

  • l2: ResourceLimits - 用于覆盖的资源限制对象

func (*ResourceLimits) Build 

func (l *ResourceLimits) Build(defaults Limit) BaseLimit

Build 根据默认值构建基础限制 参数:

  • defaults: Limit - 默认限制值,用于提供默认的资源限制配置

返回值:

  • BaseLimit - 构建的基础限制对象,包含所有资源限制的具体值

func (*ResourceLimits) IsDefault 

func (l *ResourceLimits) IsDefault() bool

IsDefault 检查资源限制是否为默认值 返回值:

  • bool - 如果所有限制都是默认值则返回 true,否则返回 false

func (*ResourceLimits) ToMaybeNilPtr 

func (l *ResourceLimits) ToMaybeNilPtr() *ResourceLimits

ToMaybeNilPtr 将资源限制转换为可能为 nil 的指针 返回值:

  • *ResourceLimits - 如果是默认值则返回 nil,否则返回当前对象的指针

type ResourceManagerStat 

type ResourceManagerStat struct {
	System    network.ScopeStat                 // 系统级别统计
	Transient network.ScopeStat                 // 临时作用域统计
	Services  map[string]network.ScopeStat      // 服务级别统计
	Protocols map[protocol.ID]network.ScopeStat // 协议级别统计
	Peers     map[peer.ID]network.ScopeStat     // 对等节点级别统计
}

ResourceManagerStat 定义了资源管理器的统计信息结构

type ResourceManagerState 

type ResourceManagerState interface {
	// ListServices 列出所有服务名称
	// 返回值:
	//   - []string: 服务名称列表
	ListServices() []string

	// ListProtocols 列出所有协议ID
	// 返回值:
	//   - []protocol.ID: 协议ID列表
	ListProtocols() []protocol.ID

	// ListPeers 列出所有对等节点ID
	// 返回值:
	//   - []peer.ID: 对等节点ID列表
	ListPeers() []peer.ID

	// Stat 获取资源管理器统计信息
	// 返回值:
	//   - ResourceManagerStat: 资源管理器统计信息
	Stat() ResourceManagerStat
}

ResourceManagerState 是一个允许访问资源管理器状态的接口

type ResourceScopeLimiter 

type ResourceScopeLimiter interface {
	// Limit 获取当前限制
	// 返回值:
	//   - Limit: 当前限制
	Limit() Limit

	// SetLimit 设置新的限制
	// 参数:
	//   - Limit: 要设置的新限制
	SetLimit(Limit)
}

ResourceScopeLimiter 是一个允许访问作用域限制的接口

type ScalingLimitConfig 

type ScalingLimitConfig struct {
	SystemBaseLimit     BaseLimit         // 系统基础限制
	SystemLimitIncrease BaseLimitIncrease // 系统限制增量

	TransientBaseLimit     BaseLimit         // 临时基础限制
	TransientLimitIncrease BaseLimitIncrease // 临时限制增量

	AllowlistedSystemBaseLimit     BaseLimit         // 白名单系统基础限制
	AllowlistedSystemLimitIncrease BaseLimitIncrease // 白名单系统限制增量

	AllowlistedTransientBaseLimit     BaseLimit         // 白名单临时基础限制
	AllowlistedTransientLimitIncrease BaseLimitIncrease // 白名单临时限制增量

	ServiceBaseLimit     BaseLimit                  // 服务基础限制
	ServiceLimitIncrease BaseLimitIncrease          // 服务限制增量
	ServiceLimits        map[string]baseLimitConfig // 使用 AddServiceLimit 修改

	ServicePeerBaseLimit     BaseLimit                  // 服务对等节点基础限制
	ServicePeerLimitIncrease BaseLimitIncrease          // 服务对等节点限制增量
	ServicePeerLimits        map[string]baseLimitConfig // 使用 AddServicePeerLimit 修改

	ProtocolBaseLimit     BaseLimit                       // 协议基础限制
	ProtocolLimitIncrease BaseLimitIncrease               // 协议限制增量
	ProtocolLimits        map[protocol.ID]baseLimitConfig // 使用 AddProtocolLimit 修改

	ProtocolPeerBaseLimit     BaseLimit                       // 协议对等节点基础限制
	ProtocolPeerLimitIncrease BaseLimitIncrease               // 协议对等节点限制增量
	ProtocolPeerLimits        map[protocol.ID]baseLimitConfig // 使用 AddProtocolPeerLimit 修改

	PeerBaseLimit     BaseLimit                   // 对等节点基础限制
	PeerLimitIncrease BaseLimitIncrease           // 对等节点限制增量
	PeerLimits        map[peer.ID]baseLimitConfig // 使用 AddPeerLimit 修改

	ConnBaseLimit     BaseLimit         // 连接基础限制
	ConnLimitIncrease BaseLimitIncrease // 连接限制增量

	StreamBaseLimit     BaseLimit         // 流基础限制
	StreamLimitIncrease BaseLimitIncrease // 流限制增量
}

ScalingLimitConfig 是用于配置默认限制的结构体。 {}BaseLimit 是适用于最小节点的限制(dep2p 使用 128MB 内存)和 256 个文件描述符。 {}LimitIncrease 是每增加 1GB RAM 时额外授予的限制。

func (*ScalingLimitConfig) AddPeerLimit 

func (cfg *ScalingLimitConfig) AddPeerLimit(p peer.ID, base BaseLimit, inc BaseLimitIncrease)

AddPeerLimit 添加对等节点限制 参数:

  • p: peer.ID - 对等节点ID
  • base: BaseLimit - 基础限制
  • inc: BaseLimitIncrease - 限制增量

func (*ScalingLimitConfig) AddProtocolLimit 

func (cfg *ScalingLimitConfig) AddProtocolLimit(proto protocol.ID, base BaseLimit, inc BaseLimitIncrease)

AddProtocolLimit 添加协议限制 参数:

  • proto: protocol.ID - 协议ID
  • base: BaseLimit - 基础限制
  • inc: BaseLimitIncrease - 限制增量

func (*ScalingLimitConfig) AddProtocolPeerLimit 

func (cfg *ScalingLimitConfig) AddProtocolPeerLimit(proto protocol.ID, base BaseLimit, inc BaseLimitIncrease)

AddProtocolPeerLimit 添加协议对等节点限制 参数:

  • proto: protocol.ID - 协议ID
  • base: BaseLimit - 基础限制
  • inc: BaseLimitIncrease - 限制增量

func (*ScalingLimitConfig) AddServiceLimit 

func (cfg *ScalingLimitConfig) AddServiceLimit(svc string, base BaseLimit, inc BaseLimitIncrease)

AddServiceLimit 添加服务限制 参数:

  • svc: string - 服务名称
  • base: BaseLimit - 基础限制
  • inc: BaseLimitIncrease - 限制增量

func (*ScalingLimitConfig) AddServicePeerLimit 

func (cfg *ScalingLimitConfig) AddServicePeerLimit(svc string, base BaseLimit, inc BaseLimitIncrease)

AddServicePeerLimit 添加服务对等节点限制 参数:

  • svc: string - 服务名称
  • base: BaseLimit - 基础限制
  • inc: BaseLimitIncrease - 限制增量

func (*ScalingLimitConfig) AutoScale 

func (cfg *ScalingLimitConfig) AutoScale() ConcreteLimitConfig

AutoScale 自动扩展限制配置 返回值:

  • ConcreteLimitConfig - 自动扩展后的具体限制配置

func (*ScalingLimitConfig) Scale 

func (cfg *ScalingLimitConfig) Scale(memory int64, numFD int) ConcreteLimitConfig

Scale 扩展限制配置。 参数:

  • memory: int64 - 允许堆栈消耗的内存量,对于专用节点建议使用系统内存的 1/8。如果内存小于 128 MB,将使用基本配置。
  • numFD: int - 文件描述符数量

返回值:

  • ConcreteLimitConfig - 扩展后的具体限制配置

type StatsTraceReporter 

type StatsTraceReporter struct{}

StatsTraceReporter 使用跟踪信息报告资源管理器的统计数据

func NewStatsTraceReporter 

func NewStatsTraceReporter() (StatsTraceReporter, error)

NewStatsTraceReporter 创建一个新的统计跟踪报告器 返回值:

  • StatsTraceReporter: 统计跟踪报告器实例
  • error: 错误信息

func (StatsTraceReporter) ConsumeEvent 

func (r StatsTraceReporter) ConsumeEvent(evt TraceEvt)

ConsumeEvent 消费跟踪事件 参数:

  • evt: TraceEvt - 跟踪事件

type TraceEvt 

type TraceEvt struct {
	Time string      // 事件发生的时间
	Type TraceEvtTyp // 事件类型

	Scope *scopeClass `json:",omitempty"` // 作用域类别,可选
	Name  string      `json:",omitempty"` // 作用域名称,可选

	Limit interface{} `json:",omitempty"` // 限制条件,可选

	Priority uint8 `json:",omitempty"` // 优先级,可选

	Delta    int64 `json:",omitempty"` // 变化量,可选
	DeltaIn  int   `json:",omitempty"` // 入站变化量,可选
	DeltaOut int   `json:",omitempty"` // 出站变化量,可选

	Memory int64 `json:",omitempty"` // 内存使用量,可选

	StreamsIn  int `json:",omitempty"` // 入站流数量,可选
	StreamsOut int `json:",omitempty"` // 出站流数量,可选

	ConnsIn  int `json:",omitempty"` // 入站连接数,可选
	ConnsOut int `json:",omitempty"` // 出站连接数,可选

	FD int `json:",omitempty"` // 文件描述符数量,可选
}

TraceEvt 定义了跟踪事件的结构体

type TraceEvtTyp 

type TraceEvtTyp string

TraceEvtTyp 定义跟踪事件类型 

const (
	TraceStartEvt              TraceEvtTyp = "start"                // 开始事件
	TraceCreateScopeEvt        TraceEvtTyp = "create_scope"         // 创建作用域事件
	TraceDestroyScopeEvt       TraceEvtTyp = "destroy_scope"        // 销毁作用域事件
	TraceReserveMemoryEvt      TraceEvtTyp = "reserve_memory"       // 预留内存事件
	TraceBlockReserveMemoryEvt TraceEvtTyp = "block_reserve_memory" // 阻塞预留内存事件
	TraceReleaseMemoryEvt      TraceEvtTyp = "release_memory"       // 释放内存事件
	TraceAddStreamEvt          TraceEvtTyp = "add_stream"           // 添加流事件
	TraceBlockAddStreamEvt     TraceEvtTyp = "block_add_stream"     // 阻塞添加流事件
	TraceRemoveStreamEvt       TraceEvtTyp = "remove_stream"        // 移除流事件
	TraceAddConnEvt            TraceEvtTyp = "add_conn"             // 添加连接事件
	TraceBlockAddConnEvt       TraceEvtTyp = "block_add_conn"       // 阻塞添加连接事件
	TraceRemoveConnEvt         TraceEvtTyp = "remove_conn"          // 移除连接事件
)

定义所有跟踪事件类型常量

type TraceReporter 

type TraceReporter interface {
	// ConsumeEvent 消费一个跟踪事件
	// 参数:
	//   - evt TraceEvt 要消费的事件
	// 注意:此方法会同步调用,实现时应快速处理事件
	ConsumeEvent(evt TraceEvt)
}

TraceReporter 定义事件报告器接口

Source Files

View all Source files

Directories

Path Synopsis
Package obs 实现资源管理器的指标跟踪
 Package obs 实现资源管理器的指标跟踪

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.