mirrors/hysteria
1
0
Fork 0
mirror of https://github.com/apernet/hysteria.git synced 2025-04-04 13:07:39 +03:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #884 from apernet/fix-lazy

Browse source 
fix: lazy mode should defer config evaluation
This commit is contained in:
Toby 2023-12-29 10:24:41 -08:00 • committed by GitHub
commit f3d675145f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 25 additions and 26 deletions
Download patch file Download diff file Expand all files Collapse all files

8
app/cmd/client.go
View file

@ -398,12 +398,10 @@ func runClient(cmd *cobra.Command, args []string) {
if err := viper.Unmarshal(&config); err != nil { if err := viper.Unmarshal(&config); err != nil {
logger.Fatal("failed to parse client config", zap.Error(err)) logger.Fatal("failed to parse client config", zap.Error(err))
} }
hyConfig, err := config.Config()
if err != nil {
logger.Fatal("failed to load client config", zap.Error(err))
}
c, err := client.NewReconnectableClient(hyConfig, func(c client.Client, info *client.HandshakeInfo, count int) { c, err := client.NewReconnectableClient(
config.Config,
func(c client.Client, info *client.HandshakeInfo, count int) {
connectLog(info, count) connectLog(info, count)
// On the client side, we start checking for updates after we successfully connect // On the client side, we start checking for updates after we successfully connect
// to the server, which, depending on whether lazy mode is enabled, may or may not // to the server, which, depending on whether lazy mode is enabled, may or may not

25
core/client/reconnect.go
View file

@ -10,23 +10,21 @@ import (
// reconnectableClientImpl is a wrapper of Client, which can reconnect when the connection is closed, // reconnectableClientImpl is a wrapper of Client, which can reconnect when the connection is closed,
// except when the caller explicitly calls Close() to permanently close this client. // except when the caller explicitly calls Close() to permanently close this client.
type reconnectableClientImpl struct { type reconnectableClientImpl struct {
config *Config configFunc func() (*Config, error) // called before connecting
connectedFunc func(Client, *HandshakeInfo, int) // called when successfully connected
client Client client Client
count int count int
connectedFunc func(Client, *HandshakeInfo, int) // called when successfully connected
m sync.Mutex m sync.Mutex
closed bool // permanent close closed bool // permanent close
} }
func NewReconnectableClient(config *Config, connectedFunc func(Client, *HandshakeInfo, int), lazy bool) (Client, error) { // NewReconnectableClient creates a reconnectable client.
// Make sure we capture any error in config and return it here, // If lazy is true, the client will not connect until the first call to TCP() or UDP().
// so that the caller doesn't have to wait until the first call // We use a function for config mainly to delay config evaluation
// to TCP() or UDP() to get the error (when lazy is true). // (which involves DNS resolution) until the actual connection attempt.
if err := config.verifyAndFill(); err != nil { func NewReconnectableClient(configFunc func() (*Config, error), connectedFunc func(Client, *HandshakeInfo, int), lazy bool) (Client, error) {
return nil, err
}
rc := &reconnectableClientImpl{ rc := &reconnectableClientImpl{
config: config, configFunc: configFunc,
connectedFunc: connectedFunc, connectedFunc: connectedFunc,
} }
if !lazy { if !lazy {
@ -41,9 +39,12 @@ func (rc *reconnectableClientImpl) reconnect() error {
if rc.client != nil { if rc.client != nil {
_ = rc.client.Close() _ = rc.client.Close()
} }
var err error
var info *HandshakeInfo var info *HandshakeInfo
rc.client, info, err = NewClient(rc.config) config, err := rc.configFunc()
if err != nil {
return err
}
rc.client, info, err = NewClient(config)
if err != nil { if err != nil {
return err return err
} else { } else {