load_balance

package
v0.0.0-...-04ef08d Latest Latest
Warning

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

 Go to latest Published: Apr 24, 2024 License: MulanPSL-2.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

View Source 
const ActiveHealthyCheckMethodDefault = "HEAD"
View Source 
const ActiveHealthyCheckStatusCodeRangeDefaultEnd = 300
View Source 
const ActiveHealthyCheckStatusCodeRangeDefaultStart = 200
View Source 
const HealthCheckIntervalMsDefault = 10 * 1000
View Source 
const PassiveUnHealthyCheckStatusCodeRangeDefaultEnd = 600
View Source 
const PassiveUnHealthyCheckStatusCodeRangeDefaultStart = 500
View Source 
const UnHealthyFailMaxCountDefault = 5

Variables

This section is empty.

Functions

func ActiveHealthyCheckDefault 

func ActiveHealthyCheckDefault(RoundTripper http.RoundTripper, url string, method string, statusCodeMin int, statusCodeMax int) (bool, error)

ActiveHealthyCheckDefault 执行一个主动的健康检查，默认使用HEAD请求对给定的URL进行检查。 参数: - RoundTripper: 实现了http.RoundTripper接口的对象，用于发送HTTP请求。如果为空，将使用默认的http.Transport。 - url: 需要进行健康检查的URL地址。 返回值: - bool: 检查结果，如果服务被认为是健康的则返回true，否则返回false。 - error: 执行过程中遇到的任何错误。

func ArrayFilter 

func ArrayFilter[T any](arr []T, callback func(T) bool) []T

ArrayFilter 是一个根据回调函数过滤数组元素的通用函数。 它接受一个类型参数 T 的数组 arr 和一个回调函数 callback，该回调函数对每个数组元素进行测试。 如果回调函数对某个元素返回 true，则该元素被加入到结果数组中。

参数： arr []T - 需要进行过滤的数组。 callback func(T) bool - 用于测试每个元素的回调函数，如果该函数返回 true，则元素被包含在结果数组中。

返回值： []T - 过滤后由满足条件的元素组成的新数组。

func ExtractHostname 

func ExtractHostname(rawURL string) (string, error)

func Get_List_Of_HTTP_Idempotent_Methods 

func Get_List_Of_HTTP_Idempotent_Methods() []string

func HealthyResponseCheckDefault 

func HealthyResponseCheckDefault(response *http.Response, UnHealthyStatusMin int, UnHealthyStatusMax int) (bool, error)

HealthyResponseCheckDefault 检查HTTP响应是否表示服务健康。

参数: 

response *http.Response - 用于检查的HTTP响应对象。

返回值: 

bool - 如果响应表示服务健康，则为true；否则为false。
error - 如果检查过程中遇到错误，则返回错误信息；否则为nil。

func HealthyResponseCheckSuccess 

func HealthyResponseCheckSuccess(response *http.Response, statusCodeMin int, statusCodeMax int) (bool, error)

func IsIdempotentMethodFailoverAttemptStrategy 

func IsIdempotentMethodFailoverAttemptStrategy(req *http.Request) bool

IsIdempotentMethod 判断给定的http.Request的Method是否为HTTP幂等方法，如果是则返回true，否则返回false

func PrintRequest 

func PrintRequest(req *http.Request)

func PrintResponse 

func PrintResponse(resp *http.Response)

func RunHealthCheckOnce 

func RunHealthCheckOnce(h *HTTP3HTTP2LoadBalancer)

Types

type HTTP3HTTP2LoadBalancer 

type HTTP3HTTP2LoadBalancer struct {
	RoundTripper               func(r *http.Request) (*http.Response, error)
	PassiveHealthyCheckEnabled bool
	ActiveHealthyCheckEnabled  bool
	UpStreamsGetter            func() generic.MapInterface[string, LoadBalanceAndUpStream]
	SelectorAvailableServer    func() (LoadBalanceAndUpStream, error)
	//毫秒
	GetHealthyCheckInterval     func() int64
	SetHealthy                  func(healthy bool)
	ActiveHealthyChecker        func() (bool, error)
	HealthCheckIntervalMsTicker *time.Ticker

	Identifier string
	// contains filtered or unexported fields
}

func (*HTTP3HTTP2LoadBalancer) Close 

func (h *HTTP3HTTP2LoadBalancer) Close() error

Close implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) FailoverAttemptStrategy 

func (h *HTTP3HTTP2LoadBalancer) FailoverAttemptStrategy(r *http.Request) bool

FailoverAttemptStrategy implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) GetActiveHealthyCheckEnabled 

func (s *HTTP3HTTP2LoadBalancer) GetActiveHealthyCheckEnabled() bool

GetActiveHealthyCheckEnabled implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) GetIdentifier 

func (h *HTTP3HTTP2LoadBalancer) GetIdentifier() string

GetIdentifier implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) GetPassiveHealthyCheckEnabled 

func (s *HTTP3HTTP2LoadBalancer) GetPassiveHealthyCheckEnabled() bool

GetPassiveHealthyCheckEnabled implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) GetUpStreams 

func (h *HTTP3HTTP2LoadBalancer) GetUpStreams() generic.MapInterface[string, LoadBalanceAndUpStream]

UpStream 是一个上游服务接口，定义了如何与上游服务进行交互以及健康检查的方法。 该接口包括发送HTTP请求、健康检查、标识服务和标记健康状态等方法。

func (*HTTP3HTTP2LoadBalancer) HealthyCheckRunning 

func (h *HTTP3HTTP2LoadBalancer) HealthyCheckRunning() bool

func (*HTTP3HTTP2LoadBalancer) HealthyCheckStart 

func (h *HTTP3HTTP2LoadBalancer) HealthyCheckStart()

func (*HTTP3HTTP2LoadBalancer) HealthyCheckStop 

func (h *HTTP3HTTP2LoadBalancer) HealthyCheckStop()

func (*HTTP3HTTP2LoadBalancer) LoadBalancePolicySelector 

func (h *HTTP3HTTP2LoadBalancer) LoadBalancePolicySelector() ([]LoadBalanceAndUpStream, error)

LoadBalancePolicySelector implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) RoundTrip 

func (h *HTTP3HTTP2LoadBalancer) RoundTrip(r *http.Request) (*http.Response, error)

RoundTrip implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) SelectAvailableServer 

func (h *HTTP3HTTP2LoadBalancer) SelectAvailableServer() (LoadBalanceAndUpStream, error)

选择一个可用的上游服务器 参数：

func (*HTTP3HTTP2LoadBalancer) SelectAvailableServers 

func (h *HTTP3HTTP2LoadBalancer) SelectAvailableServers() ([]LoadBalanceAndUpStream, error)

SelectAvailableServers implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) SetActiveHealthyCheckEnabled 

func (h *HTTP3HTTP2LoadBalancer) SetActiveHealthyCheckEnabled(e bool)

SetActiveHealthyCheckEnabled implements LoadBalanceService.

func (*HTTP3HTTP2LoadBalancer) SetPassiveHealthyCheckEnabled 

func (h *HTTP3HTTP2LoadBalancer) SetPassiveHealthyCheckEnabled(e bool)

SetPassiveHealthyCheckEnabled implements LoadBalanceService.

type HealthCheckResult 

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

HealthCheckResult 是一个健康检查结果的结构体。 它包含以下字段： key: 用于标识健康检查的唯一键。 healthy: 表示检查是否健康的布尔值。 err: 执行健康检查时遇到的错误信息。 svc: 实现了LoadBalanceAndUpStream接口的服务，用于在健康检查中进行负载均衡和上游服务管理。

type LoadBalanceAndUpStream 

type LoadBalanceAndUpStream interface {
	GetActiveHealthyCheckEnabled() bool
	SetActiveHealthyCheckEnabled(bool)
	GetPassiveHealthyCheckEnabled() bool
	SetPassiveHealthyCheckEnabled(bool)
	Close() error
	// RoundTrip 是一个代理方法，用于发送HTTP请求，并返回响应或错误。
	// 参数：
	//   *http.Request: 待发送的HTTP请求
	// 返回值：
	//   *http.Response: 请求的响应
	//   error: 请求过程中遇到的错误
	RoundTrip(*http.Request) (*http.Response, error)

	GetLoadBalanceService() optional.Option[LoadBalanceService]

	GetServerConfigCommon() ServerConfigCommon
}

LoadBalance 是一个负载均衡接口，它定义了如何对HTTP请求进行负载均衡转发。 其中包含了一个Map，用于映射域名到对应的UpStream。

func NewSingleHostHTTP12ClientOfAddress 

func NewSingleHostHTTP12ClientOfAddress(Identifier string, UpStreamServerURL string, options ...func(*SingleHostHTTP12ClientOfAddress)) (LoadBalanceAndUpStream, error)

NewSingleHostHTTP12ClientOfAddress 创建一个指定地址的单主机HTTP客户端实例。

参数: 

identifier string - 客户端的标识符，用于区分不同的客户端实例。
UpStreamServerURL string - 上游服务器的URL，客户端将向该URL发送请求。
ServerAddress string - 服务端地址，指定客户端连接的服务端主机地址。

返回值: 

LoadBalanceAndUpStream - 实现了负载均衡和上游服务选择的接口。

func NewSingleHostHTTP3ClientOfAddress 

func NewSingleHostHTTP3ClientOfAddress(Identifier string, UpStreamServerURL string, options ...func(*SingleHostHTTP3ClientOfAddress)) (LoadBalanceAndUpStream, error)

NewSingleHostHTTP3ClientOfAddress 创建一个指定地址的单主机HTTP客户端实例。

参数: 

identifier string - 客户端的标识符，用于区分不同的客户端实例。
UpStreamServerURL string - 上游服务器的URL，客户端将向该URL发送请求。
ServerAddress string - 服务端地址，指定客户端连接的服务端主机地址。

返回值: 

LoadBalanceAndUpStream - 实现了负载均衡和上游服务选择的接口。

func NewSingleHostHTTP3HTTP2LoadBalancerOfAddress 

func NewSingleHostHTTP3HTTP2LoadBalancerOfAddress(Identifier string, UpStreamServerURL string, options ...func(*SingleHostHTTP3HTTP2LoadBalancerOfAddress)) (LoadBalanceAndUpStream, error)

NewSingleHostHTTP3HTTP2LoadBalancerOfAddress 创建一个指定地址的单主机HTTP客户端实例。

参数: 

identifier string - 客户端的标识符，用于区分不同的客户端实例。
UpStreamServerURL string - 上游服务器的URL，客户端将向该URL发送请求。
ServerAddress string - 服务端地址，指定客户端连接的服务端主机地址。

返回值: 

LoadBalanceAndUpStream - 实现了负载均衡和上游服务选择的接口。

type LoadBalanceService 

type LoadBalanceService interface {
	GetUpStreams() generic.MapInterface[string, LoadBalanceAndUpStream]

	//选择一个可用的上游服务器
	// 参数：
	SelectAvailableServers() ([]LoadBalanceAndUpStream, error)

	LoadBalancePolicySelector() ([]LoadBalanceAndUpStream, error)

	GetActiveHealthyCheckEnabled() bool
	SetActiveHealthyCheckEnabled(bool)
	GetPassiveHealthyCheckEnabled() bool
	SetPassiveHealthyCheckEnabled(bool)
	HealthyCheckStart()
	HealthyCheckRunning() bool
	HealthyCheckStop()
	Close() error
	GetIdentifier() string
	RoundTrip(*http.Request) (*http.Response, error)

	FailoverAttemptStrategy(*http.Request) bool
}

type ServerConfigCommon 

type ServerConfigCommon interface {
	GetActiveHealthyCheckEnabled() bool
	SetActiveHealthyCheckEnabled(bool)
	GetPassiveHealthyCheckEnabled() bool
	SetPassiveHealthyCheckEnabled(bool)

	GetPassiveUnHealthyCheckStatusCodeRange() generic.PairInterface[int, int]
	// GetActiveHealthyCheckURL 返回主动健康检查的URL
	GetActiveHealthyCheckURL() string
	// GetActiveHealthyCheckMethod 返回主动健康检查的方法（如GET、POST）
	GetActiveHealthyCheckMethod() string
	// GetActiveHealthyCheckStatusCodeRange 返回主动健康检查接受的状态码范围
	GetActiveHealthyCheckStatusCodeRange() generic.PairInterface[int, int]
	// IncrementUnHealthyFailCount 增加不健康失败计数
	IncrementUnHealthyFailCount()
	// ResetUnHealthyFailCount 重置不健康失败计数
	ResetUnHealthyFailCount()
	// GetUnHealthyFailCount 返回不健康失败计数
	GetUnHealthyFailCount() int64
	// GetUpStreamServerURL 返回上游服务器的URL
	GetUpStreamServerURL() string
	// ActiveHealthyCheck 执行主动健康检查，返回检查是否通过和可能的错误
	ActiveHealthyCheck() (bool, error)

	// Identifier 用于返回上游服务的唯一标识符。
	// 返回值：string - 上游服务的唯一标识符
	GetIdentifier() string

	// IsHealthy 用于判断上游服务是否健康。
	// 返回值：bool - 上游服务的健康状态（true为健康，false为不健康）
	GetHealthy() bool

	// SetHealthy 用于标记上游服务的健康状态。
	// 参数：bool - 上游服务的健康状态（true为健康，false为不健康）
	SetHealthy(bool)

	// PassiveUnHealthyCheck 根据HTTP响应判断上游服务是否健康。
	// 参数：*http.Response - 上游服务返回的HTTP响应
	// 返回值：bool - 上游服务的被动健康状态（true为健康，false为不健康）
	PassiveUnHealthyCheck(*http.Response) (bool, error)

	// SetHealthCheckIntervalMs 设置健康状态的缓存最大年龄。
	// 参数:
	//   int64 - 表示健康状态的缓存的最大年龄（单位：毫秒）。
	SetHealthyCheckInterval(int64)

	// GetHealthCheckIntervalMs 获取健康状态的缓存最大年龄。
	// 返回值:
	//   int64 - 健康状态的缓存的最大年龄（单位：毫秒）。
	GetHealthyCheckInterval() int64
	// 获取逻辑实现
	/*
		SetUnHealthyFailDurationMs 设置不健康状态失败持续时间。

		参数:
		- duration: int64类型，表示不健康状态失败的持续时间。

		返回值:
		- 无

		该函数用于设置一个指定的时间长度，在此时间长度内，如果组件或系统的状态持续不健康，则可能导致操作失败或系统视为异常。
	*/
	SetUnHealthyFailDurationMs(int64)

	// GetHealthCheckIntervalMs 获取健康状态的缓存最大年龄。
	// 返回值:
	//   int64 - 健康状态的缓存的最大年龄（单位：毫秒）。
	GetUnHealthyFailDurationMs() int64

	SetUnHealthyFailMaxCount(int64)

	GetUnHealthyFailMaxCount() int64

	OnUpstreamFailure()
	OnUpstreamHealthy()
}

func ServerConfigImplementConstructor 

func ServerConfigImplementConstructor(Identifier string, UpStreamServerURL string, RoundTripper http.RoundTripper, option ...func(*ServerConfigImplement)) ServerConfigCommon

ServerConfigImplementConstructor 是用于构造ServerConfigImplement对象的函数。 Identifier: 用于标识服务器的唯一字符串。 UpStreamServerURL: 指定上游服务器的URL。 RoundTripper: 实现http.RoundTripper接口的对象，用于进行HTTP请求。 option: 可选参数，一系列函数，可用于修改ServerConfigImplement对象的配置。 返回值为配置好的ServerConfigCommon接口，实现了服务器配置的通用接口。

type ServerConfigImplement 

type ServerConfigImplement struct {
	PassiveHealthyCheckEnabled        bool
	ActiveHealthyCheckEnabled         bool
	ActiveHealthyCheckStatusCodeRange generic.PairInterface[int, int]
	ActiveHealthyCheckMethod          string
	Identifier                        string
	HealthMutex                       sync.Mutex
	FailureMutex                      sync.Mutex
	FailCountMutex                    sync.Mutex
	UpStreamServerURL                 string
	IsHealthy                         bool
	HealthCheckIntervalMs             int64

	ActiveHealthyChecker    func(RoundTripper http.RoundTripper, url string, method string, statusCodeMin int, statusCodeMax int) (bool, error) // 活跃健康检查函数，用于检查给定的传输和URL是否健康。
	RoundTripper            http.RoundTripper
	PassiveUnHealthyChecker func(response *http.Response, UnHealthyStatusMin int, UnHealthyStatusMax int) (bool, error) // 健康响应检查函数，用于基于HTTP响应检查客户端的健康状态。
	UnHealthyFailCount      int64
	ActiveHealthyCheckURL   string

	PassiveUnHealthyCheckStatusCodeRange generic.PairInterface[int, int]
	// contains filtered or unexported fields
}

func (*ServerConfigImplement) ActiveHealthyCheck 

func (l *ServerConfigImplement) ActiveHealthyCheck() (bool, error)

func (*ServerConfigImplement) GetActiveHealthyCheckEnabled 

func (s *ServerConfigImplement) GetActiveHealthyCheckEnabled() bool

GetActiveHealthyCheckEnabled implements ServerConfigCommon.

func (*ServerConfigImplement) GetActiveHealthyCheckMethod 

func (s *ServerConfigImplement) GetActiveHealthyCheckMethod() string

GetActiveHealthyCheckMethod implements ServerConfigCommon.

func (*ServerConfigImplement) GetActiveHealthyCheckStatusCodeRange 

func (s *ServerConfigImplement) GetActiveHealthyCheckStatusCodeRange() generic.PairInterface[int, int]

GetActiveHealthyCheckStatusCodeRange implements ServerConfigCommon.

func (*ServerConfigImplement) GetActiveHealthyCheckURL 

func (s *ServerConfigImplement) GetActiveHealthyCheckURL() string

GetActiveHealthyCheckURL implements ServerConfigCommon.

func (*ServerConfigImplement) GetHealthy 

func (s *ServerConfigImplement) GetHealthy() bool

func (*ServerConfigImplement) GetHealthyCheckInterval 

func (s *ServerConfigImplement) GetHealthyCheckInterval() int64

func (*ServerConfigImplement) GetIdentifier 

func (s *ServerConfigImplement) GetIdentifier() string

func (*ServerConfigImplement) GetPassiveHealthyCheckEnabled 

func (s *ServerConfigImplement) GetPassiveHealthyCheckEnabled() bool

GetPassiveHealthyCheckEnabled implements ServerConfigCommon.

func (*ServerConfigImplement) GetPassiveUnHealthyCheckStatusCodeRange 

func (s *ServerConfigImplement) GetPassiveUnHealthyCheckStatusCodeRange() generic.PairInterface[int, int]

GetPassiveUnHealthyCheckStatusCodeRange implements ServerConfigCommon.

func (*ServerConfigImplement) GetUnHealthyFailCount 

func (s *ServerConfigImplement) GetUnHealthyFailCount() int64

GetUnHealthyFailCount implements ServerConfigCommon.

func (*ServerConfigImplement) GetUnHealthyFailDurationMs 

func (s *ServerConfigImplement) GetUnHealthyFailDurationMs() int64

func (*ServerConfigImplement) GetUnHealthyFailMaxCount 

func (s *ServerConfigImplement) GetUnHealthyFailMaxCount() int64

func (*ServerConfigImplement) GetUpStreamServerURL 

func (s *ServerConfigImplement) GetUpStreamServerURL() string

func (*ServerConfigImplement) IncrementUnHealthyFailCount 

func (s *ServerConfigImplement) IncrementUnHealthyFailCount()

IncrementUnHealthyFailCount implements ServerConfigCommon.

func (*ServerConfigImplement) OnUpstreamFailure 

func (s *ServerConfigImplement) OnUpstreamFailure()

OnUpstreamFailure implements ServerConfigCommon.

func (*ServerConfigImplement) OnUpstreamHealthy 

func (s *ServerConfigImplement) OnUpstreamHealthy()

OnUpstreamHealthy implements ServerConfigCommon.

func (*ServerConfigImplement) PassiveUnHealthyCheck 

func (s *ServerConfigImplement) PassiveUnHealthyCheck(response *http.Response) (bool, error)

func (*ServerConfigImplement) ResetUnHealthyFailCount 

func (s *ServerConfigImplement) ResetUnHealthyFailCount()

ResetUnHealthyFailCount implements ServerConfigCommon.

func (*ServerConfigImplement) SetActiveHealthyCheckEnabled 

func (s *ServerConfigImplement) SetActiveHealthyCheckEnabled(e bool)

SetActiveHealthyCheckEnabled implements ServerConfigCommon.

func (*ServerConfigImplement) SetHealthy 

func (s *ServerConfigImplement) SetHealthy(healthStatus bool)

func (*ServerConfigImplement) SetHealthyCheckInterval 

func (s *ServerConfigImplement) SetHealthyCheckInterval(intervalMs int64)

func (*ServerConfigImplement) SetPassiveHealthyCheckEnabled 

func (s *ServerConfigImplement) SetPassiveHealthyCheckEnabled(e bool)

SetPassiveHealthyCheckEnabled implements ServerConfigCommon.

func (*ServerConfigImplement) SetUnHealthyFailDurationMs 

func (s *ServerConfigImplement) SetUnHealthyFailDurationMs(durationMs int64)

func (*ServerConfigImplement) SetUnHealthyFailMaxCount 

func (s *ServerConfigImplement) SetUnHealthyFailMaxCount(count int64)

type SingleHostHTTP12ClientOfAddress 

type SingleHostHTTP12ClientOfAddress struct {
	ServerConfigCommon ServerConfigCommon

	HealthCheckIntervalMs   int64
	GetServerAddress        func() string                                                                                                       // 服务器地址，指定客户端要连接的HTTP服务器的地址。
	ActiveHealthyChecker    func(RoundTripper http.RoundTripper, url string, method string, statusCodeMin int, statusCodeMax int) (bool, error) // 活跃健康检查函数，用于检查给定的传输和URL是否健康。
	Identifier              string                                                                                                              // 标识符，用于标识此HTTP客户端的唯一字符串。
	HealthMutex             sync.Mutex
	IsHealthy               bool                                                                                        // 健康状态，标识当前客户端是否被视为健康。
	PassiveUnHealthyChecker func(response *http.Response, UnHealthyStatusMin int, UnHealthyStatusMax int) (bool, error) // 健康响应检查函数，用于基于HTTP响应检查客户端的健康状态。
	RoundTripper            http.RoundTripper                                                                           // HTTP传输，用于执行HTTP请求的实际传输。
	UpStreamServerURL       string                                                                                      // 上游服务器URL，指定客户端将请求转发到的上游服务器的地址。
	UnHealthyFailMaxCount   int64
	Closer                  func() error
	// contains filtered or unexported fields
}

SingleHostHTTP12ClientOfAddress 是一个针对单个主机的HTTP客户端结构体，用于管理与特定地址的HTTP通信。

func (*SingleHostHTTP12ClientOfAddress) ActiveHealthyCheck 

func (l *SingleHostHTTP12ClientOfAddress) ActiveHealthyCheck() (bool, error)

ActiveHealthyCheck 执行活跃的健康检查。 实现了 LoadBalanceAndUpStream 接口。 返回值：检查是否成功（bool类型）和可能发生的错误（error类型）。

func (*SingleHostHTTP12ClientOfAddress) Close 

func (l *SingleHostHTTP12ClientOfAddress) Close() error

Close implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetActiveHealthyCheckEnabled 

func (l *SingleHostHTTP12ClientOfAddress) GetActiveHealthyCheckEnabled() bool

GetActiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetHealthCheckIntervalMs 

func (l *SingleHostHTTP12ClientOfAddress) GetHealthCheckIntervalMs() int64

GetHealthCheckIntervalMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetHealthy 

func (l *SingleHostHTTP12ClientOfAddress) GetHealthy() bool

GetHealthy 获取健康状态。 实现了 LoadBalanceAndUpStream 接口。 返回值：当前客户端是否处于健康状态（bool类型）。

func (*SingleHostHTTP12ClientOfAddress) GetHealthyCheckInterval 

func (l *SingleHostHTTP12ClientOfAddress) GetHealthyCheckInterval() int64

GetHealthyCheckInterval implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetIdentifier 

func (l *SingleHostHTTP12ClientOfAddress) GetIdentifier() string

GetIdentifier 获取标识符。 实现了 LoadBalanceAndUpStream 接口。 返回值：此客户端的唯一标识符（string类型）。

func (*SingleHostHTTP12ClientOfAddress) GetLoadBalanceService 

func (l *SingleHostHTTP12ClientOfAddress) GetLoadBalanceService() optional.Option[LoadBalanceService]

GetLoadBalanceService implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetPassiveHealthyCheckEnabled 

func (l *SingleHostHTTP12ClientOfAddress) GetPassiveHealthyCheckEnabled() bool

GetPassiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetServerConfigCommon 

func (l *SingleHostHTTP12ClientOfAddress) GetServerConfigCommon() ServerConfigCommon

GetServerConfigCommon implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetUnHealthyFailDurationMs 

func (l *SingleHostHTTP12ClientOfAddress) GetUnHealthyFailDurationMs() int64

GetUnHealthyFailDurationMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetUnHealthyFailMaxCount 

func (l *SingleHostHTTP12ClientOfAddress) GetUnHealthyFailMaxCount() int64

GetUnHealthyFailMaxCount implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) GetUpStreams 

func (l *SingleHostHTTP12ClientOfAddress) GetUpStreams() optional.Option[generic.MapInterface[string, LoadBalanceAndUpStream]]

UpStreams 实现了LoadBalanceAndUpStream接口的UpStreams方法， 用于获取上游服务的集合。 此处因为是单主机客户端，所以返回空集合。 返回值为上游服务集合的可选类型，此处始终返回None。

func (*SingleHostHTTP12ClientOfAddress) PassiveUnHealthyCheck 

func (l *SingleHostHTTP12ClientOfAddress) PassiveUnHealthyCheck(response *http.Response) (bool, error)

PassiveUnHealthyCheck 对HTTP响应进行健康状态检查。 实现了 LoadBalanceAndUpStream 接口。 参数：HTTP响应（*http.Response类型）。 返回值：检查结果是否健康（bool类型）和可能发生的错误（error类型）。

func (*SingleHostHTTP12ClientOfAddress) RoundTrip 

func (l *SingleHostHTTP12ClientOfAddress) RoundTrip(request *http.Request) (*http.Response, error)

RoundTrip 实现了LoadBalanceAndUpStream接口的RoundTrip方法， 用于执行HTTP请求。 参数request为待发送的HTTP请求。 返回值为执行请求后的HTTP响应及可能发生的错误。

func (*SingleHostHTTP12ClientOfAddress) SelectAvailableServer 

func (l *SingleHostHTTP12ClientOfAddress) SelectAvailableServer() (LoadBalanceAndUpStream, error)

SelectAvailableServer 实现了LoadBalanceAndUpStream接口的SelectAvailableServer方法， 用于选择可用的服务实例。 返回值为可用的服务实例（此处始终为自身）及可能发生的错误。

func (*SingleHostHTTP12ClientOfAddress) SetActiveHealthyCheckEnabled 

func (l *SingleHostHTTP12ClientOfAddress) SetActiveHealthyCheckEnabled(e bool)

SetActiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) SetHealthCheckIntervalMs 

func (l *SingleHostHTTP12ClientOfAddress) SetHealthCheckIntervalMs(maxAge int64)

SetHealthCheckIntervalMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) SetHealthy 

func (l *SingleHostHTTP12ClientOfAddress) SetHealthy(healthy bool)

SetHealthy 实现了LoadBalanceAndUpStream接口的SetHealthy方法， 用于设置客户端的健康状态。 参数healthy为true表示客户端健康，为false表示客户端不健康。

func (*SingleHostHTTP12ClientOfAddress) SetHealthyCheckInterval 

func (l *SingleHostHTTP12ClientOfAddress) SetHealthyCheckInterval(interval int64)

SetHealthyCheckInterval implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) SetPassiveHealthyCheckEnabled 

func (l *SingleHostHTTP12ClientOfAddress) SetPassiveHealthyCheckEnabled(e bool)

SetPassiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) SetUnHealthyFailDurationMs 

func (l *SingleHostHTTP12ClientOfAddress) SetUnHealthyFailDurationMs(Duration int64)

SetUnHealthyFailDurationMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP12ClientOfAddress) SetUnHealthyFailMaxCount 

func (l *SingleHostHTTP12ClientOfAddress) SetUnHealthyFailMaxCount(count int64)

SetUnHealthyFailMaxCount implements LoadBalanceAndUpStream.

type SingleHostHTTP3ClientOfAddress 

type SingleHostHTTP3ClientOfAddress struct {
	Closer                func() error
	RoundTripper          http.RoundTripper
	ServerConfigCommon    ServerConfigCommon
	UnHealthyFailMaxCount int64
	HealthMutex           sync.Mutex

	HealthCheckIntervalMs   int64
	GetServerAddress        func() string                                                                                                       // 服务器地址，指定客户端要连接的HTTP服务器的地址。
	ActiveHealthyChecker    func(RoundTripper http.RoundTripper, url string, method string, statusCodeMin int, statusCodeMax int) (bool, error) // 活跃健康检查函数，用于检查给定的传输和URL是否健康。
	Identifier              string                                                                                                              // 标识符，用于标识此HTTP客户端的唯一字符串。
	IsHealthy               bool                                                                                                                // 健康状态，标识当前客户端是否被视为健康。
	PassiveUnHealthyChecker func(response *http.Response, UnHealthyStatusMin int, UnHealthyStatusMax int) (bool, error)                         // 健康响应检查函数，用于基于HTTP响应检查客户端的健康状态。
	// RoundTripper           http.RoundTripper                                              // HTTP传输，用于执行HTTP请求的实际传输。
	UpStreamServerURL string // 上游服务器URL，指定客户端将请求转发到的上游服务器的地址。
	// contains filtered or unexported fields
}

SingleHostHTTPClientOfAddress 是一个针对单个主机的HTTP客户端结构体，用于管理与特定地址的HTTP通信。

func (*SingleHostHTTP3ClientOfAddress) ActiveHealthyCheck 

func (l *SingleHostHTTP3ClientOfAddress) ActiveHealthyCheck() (bool, error)

ActiveHealthyCheck 执行活跃的健康检查。 实现了 LoadBalanceAndUpStream 接口。 返回值：检查是否成功（bool类型）和可能发生的错误（error类型）。

func (*SingleHostHTTP3ClientOfAddress) Close 

func (l *SingleHostHTTP3ClientOfAddress) Close() error

Close implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetActiveHealthyCheckEnabled 

func (l *SingleHostHTTP3ClientOfAddress) GetActiveHealthyCheckEnabled() bool

GetActiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetHealthCheckIntervalMs 

func (l *SingleHostHTTP3ClientOfAddress) GetHealthCheckIntervalMs() int64

GetHealthCheckIntervalMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetHealthy 

func (l *SingleHostHTTP3ClientOfAddress) GetHealthy() bool

GetHealthy 获取健康状态。 实现了 LoadBalanceAndUpStream 接口。 返回值：当前客户端是否处于健康状态（bool类型）。

func (*SingleHostHTTP3ClientOfAddress) GetHealthyCheckInterval 

func (l *SingleHostHTTP3ClientOfAddress) GetHealthyCheckInterval() int64

GetHealthyCheckInterval implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetIdentifier 

func (l *SingleHostHTTP3ClientOfAddress) GetIdentifier() string

GetIdentifier 获取标识符。 实现了 LoadBalanceAndUpStream 接口。 返回值：此客户端的唯一标识符（string类型）。

func (*SingleHostHTTP3ClientOfAddress) GetLoadBalanceService 

func (l *SingleHostHTTP3ClientOfAddress) GetLoadBalanceService() optional.Option[LoadBalanceService]

GetLoadBalanceService implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetPassiveHealthyCheckEnabled 

func (l *SingleHostHTTP3ClientOfAddress) GetPassiveHealthyCheckEnabled() bool

GetPassiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetServerConfigCommon 

func (l *SingleHostHTTP3ClientOfAddress) GetServerConfigCommon() ServerConfigCommon

GetServerConfigCommon implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetUnHealthyFailDurationMs 

func (l *SingleHostHTTP3ClientOfAddress) GetUnHealthyFailDurationMs() int64

GetUnHealthyFailDurationMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetUnHealthyFailMaxCount 

func (l *SingleHostHTTP3ClientOfAddress) GetUnHealthyFailMaxCount() int64

GetUnHealthyFailMaxCount implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) GetUpStreams 

func (l *SingleHostHTTP3ClientOfAddress) GetUpStreams() optional.Option[generic.MapInterface[string, LoadBalanceAndUpStream]]

UpStreams 实现了LoadBalanceAndUpStream接口的UpStreams方法， 用于获取上游服务的集合。 此处因为是单主机客户端，所以返回空集合。 返回值为上游服务集合的可选类型，此处始终返回None。

func (*SingleHostHTTP3ClientOfAddress) PassiveUnHealthyCheck 

func (l *SingleHostHTTP3ClientOfAddress) PassiveUnHealthyCheck(response *http.Response) (bool, error)

PassiveUnHealthyCheck 对HTTP响应进行健康状态检查。 实现了 LoadBalanceAndUpStream 接口。 参数：HTTP响应（*http.Response类型）。 返回值：检查结果是否健康（bool类型）和可能发生的错误（error类型）。

func (*SingleHostHTTP3ClientOfAddress) RoundTrip 

func (l *SingleHostHTTP3ClientOfAddress) RoundTrip(req *http.Request) (*http.Response, error)

RoundTrip 实现了LoadBalanceAndUpStream接口的RoundTrip方法， 用于执行HTTP请求。 参数request为待发送的HTTP请求。 返回值为执行请求后的HTTP响应及可能发生的错误。

func (*SingleHostHTTP3ClientOfAddress) SelectAvailableServer 

func (l *SingleHostHTTP3ClientOfAddress) SelectAvailableServer() (LoadBalanceAndUpStream, error)

SelectAvailableServer 实现了LoadBalanceAndUpStream接口的SelectAvailableServer方法， 用于选择可用的服务实例。 返回值为可用的服务实例（此处始终为自身）及可能发生的错误。

func (*SingleHostHTTP3ClientOfAddress) SetActiveHealthyCheckEnabled 

func (l *SingleHostHTTP3ClientOfAddress) SetActiveHealthyCheckEnabled(e bool)

SetActiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) SetHealthCheckIntervalMs 

func (l *SingleHostHTTP3ClientOfAddress) SetHealthCheckIntervalMs(maxAge int64)

SetHealthCheckIntervalMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) SetHealthy 

func (l *SingleHostHTTP3ClientOfAddress) SetHealthy(healthy bool)

SetHealthy 实现了LoadBalanceAndUpStream接口的SetHealthy方法， 用于设置客户端的健康状态。 参数healthy为true表示客户端健康，为false表示客户端不健康。

func (*SingleHostHTTP3ClientOfAddress) SetHealthyCheckInterval 

func (l *SingleHostHTTP3ClientOfAddress) SetHealthyCheckInterval(interval int64)

SetHealthyCheckInterval implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) SetPassiveHealthyCheckEnabled 

func (l *SingleHostHTTP3ClientOfAddress) SetPassiveHealthyCheckEnabled(e bool)

SetPassiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) SetUnHealthyFailDurationMs 

func (l *SingleHostHTTP3ClientOfAddress) SetUnHealthyFailDurationMs(Duration int64)

SetUnHealthyFailDurationMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3ClientOfAddress) SetUnHealthyFailMaxCount 

func (l *SingleHostHTTP3ClientOfAddress) SetUnHealthyFailMaxCount(count int64)

SetUnHealthyFailMaxCount implements LoadBalanceAndUpStream.

type SingleHostHTTP3HTTP2LoadBalancerOfAddress 

type SingleHostHTTP3HTTP2LoadBalancerOfAddress struct {
	UnHealthyFailMaxCount int64
	//毫秒
	HealthCheckIntervalMs int64

	GetServerAddress        func() string                                                                                                       // 服务器地址，指定客户端要连接的HTTP服务器的地址。
	ActiveHealthyChecker    func(RoundTripper http.RoundTripper, url string, method string, statusCodeMin int, statusCodeMax int) (bool, error) // 活跃健康检查函数，用于检查给定的传输和URL是否健康。
	HealthMutex             sync.Mutex
	Identifier              string                                                                                      // 标识符，用于标识此HTTP客户端的唯一字符串。
	IsHealthy               bool                                                                                        // 健康状态，标识当前客户端是否被视为健康。
	PassiveUnHealthyChecker func(response *http.Response, UnHealthyStatusMin int, UnHealthyStatusMax int) (bool, error) // 健康响应检查函数，用于基于HTTP响应检查客户端的健康状态。
	// RoundTripper           func() http.RoundTripper                                       // HTTP传输，用于执行HTTP请求的实际传输。
	UpStreamServerURL string // 上游服务器URL，指定客户端将请求转发到的上游服务器的地址。

	UpStreams generic.MapInterface[string, LoadBalanceAndUpStream]

	LoadBalanceService *HTTP3HTTP2LoadBalancer

	ServerConfigCommon ServerConfigCommon
	// contains filtered or unexported fields
}

SingleHostHTTPClientOfAddress 是一个针对单个主机的HTTP客户端结构体，用于管理与特定地址的HTTP通信。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) ActiveHealthyCheck 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) ActiveHealthyCheck() (bool, error)

ActiveHealthyCheck 执行活跃的健康检查。 实现了 LoadBalanceAndUpStream 接口。 返回值：检查是否成功（bool类型）和可能发生的错误（error类型）。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) Close 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) Close() error

Close implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetActiveHealthyCheckEnabled 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetActiveHealthyCheckEnabled() bool

GetActiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetHealthCheckIntervalMs 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetHealthCheckIntervalMs() int64

GetHealthCheckIntervalMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetHealthy 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetHealthy() bool

GetHealthy 获取健康状态。 实现了 LoadBalanceAndUpStream 接口。 返回值：当前客户端是否处于健康状态（bool类型）。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetHealthyCheckInterval 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetHealthyCheckInterval() int64

GetHealthyCheckInterval implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetIdentifier 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetIdentifier() string

GetIdentifier 获取标识符。 实现了 LoadBalanceAndUpStream 接口。 返回值：此客户端的唯一标识符（string类型）。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetLoadBalanceService 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetLoadBalanceService() optional.Option[LoadBalanceService]

GetLoadBalanceService implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetPassiveHealthyCheckEnabled 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetPassiveHealthyCheckEnabled() bool

GetPassiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetServerConfigCommon 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetServerConfigCommon() ServerConfigCommon

GetServerConfigCommon implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetUnHealthyFailDurationMs 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetUnHealthyFailDurationMs() int64

GetUnHealthyFailDurationMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetUnHealthyFailMaxCount 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetUnHealthyFailMaxCount() int64

GetUnHealthyFailMaxCount implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetUpStreams 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) GetUpStreams() generic.MapInterface[string, LoadBalanceAndUpStream]

UpStreams 实现了LoadBalanceAndUpStream接口的UpStreams方法， 用于获取上游服务的集合。 此处因为是单主机客户端，所以返回空集合。 返回值为上游服务集合的可选类型，此处始终返回None。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) OnUpstreamFailure 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) OnUpstreamFailure(loadBalanceAndUpStream LoadBalanceAndUpStream)

OnUpstreamFailure 处理上游服务失败的逻辑。 当检测到上游服务失败时，根据配置的不健康服务失败时长和次数，来判断是否标记该上游服务为不健康。 参数: - loadBalanceAndUpStream: 包含负载均衡和上游服务信息的对象。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) PassiveUnHealthyCheck 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) PassiveUnHealthyCheck(response *http.Response) (bool, error)

PassiveUnHealthyCheck 对HTTP响应进行健康状态检查。 实现了 LoadBalanceAndUpStream 接口。 参数：HTTP响应（*http.Response类型）。 返回值：检查结果是否健康（bool类型）和可能发生的错误（error类型）。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) RoundTrip 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) RoundTrip(request *http.Request) (*http.Response, error)

RoundTrip 实现了LoadBalanceAndUpStream接口的RoundTrip方法， 用于执行HTTP请求。 参数request为待发送的HTTP请求。 返回值为执行请求后的HTTP响应及可能发生的错误。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SelectAvailableServer 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SelectAvailableServer() (LoadBalanceAndUpStream, error)

SelectAvailableServer 实现了LoadBalanceAndUpStream接口的SelectAvailableServer方法， 用于选择可用的服务实例。 返回值为可用的服务实例（此处始终为自身）及可能发生的错误。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetActiveHealthyCheckEnabled 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetActiveHealthyCheckEnabled(e bool)

SetActiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetHealthCheckIntervalMs 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetHealthCheckIntervalMs(maxAge int64)

SetHealthCheckIntervalMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetHealthy 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetHealthy(healthy bool)

SetHealthy 实现了LoadBalanceAndUpStream接口的SetHealthy方法， 用于设置客户端的健康状态。 参数healthy为true表示客户端健康，为false表示客户端不健康。

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetHealthyCheckInterval 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetHealthyCheckInterval(interval int64)

SetHealthyCheckInterval implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetPassiveHealthyCheckEnabled 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetPassiveHealthyCheckEnabled(e bool)

SetPassiveHealthyCheckEnabled implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetUnHealthyFailDurationMs 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetUnHealthyFailDurationMs(Duration int64)

SetUnHealthyFailDurationMs implements LoadBalanceAndUpStream.

func (*SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetUnHealthyFailMaxCount 

func (l *SingleHostHTTP3HTTP2LoadBalancerOfAddress) SetUnHealthyFailMaxCount(count int64)

SetUnHealthyFailMaxCount implements LoadBalanceAndUpStream.

Source Files

View all Source files

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.