core/go-proxy
8
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor(proxy): clarify config parameter names

Browse source 
Co-Authored-By: Virgil <virgil@lethean.io>
This commit is contained in:
Virgil 2026-04-04 22:09:58 +00:00
parent 6422a948bf
commit cfd669e4d2
6 changed files with 63 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
core_impl.go
View file

@ -216,9 +216,9 @@ func (cd *CustomDiff) OnLogin(e Event) {
//
// limiter := proxy.NewRateLimiter(proxy.RateLimit{MaxConnectionsPerMinute: 30, BanDurationSeconds: 300})
// if limiter.Allow("203.0.113.42:3333") { /* accept */ }
func NewRateLimiter(cfg RateLimit) *RateLimiter {
func NewRateLimiter(config RateLimit) *RateLimiter {
return &RateLimiter{
config: cfg,
config: config,
buckets: make(map[string]*tokenBucket),
banned: make(map[string]time.Time),
}
@ -286,13 +286,13 @@ func (rl *RateLimiter) Tick() {
// watcher := proxy.NewConfigWatcher("config.json", func(cfg *proxy.Config) {
// proxyInstance.Reload(cfg)
// })
func NewConfigWatcher(path string, onChange func(*Config)) *ConfigWatcher {
func NewConfigWatcher(configPath string, onChange func(*Config)) *ConfigWatcher {
watcher := &ConfigWatcher{
path: path,
path: configPath,
onChange: onChange,
done: make(chan struct{}),
}
if info, err := os.Stat(path); err == nil {
if info, err := os.Stat(configPath); err == nil {
watcher.lastMod = info.ModTime()
}
return watcher

46
log/impl.go
View file

@ -51,10 +51,10 @@ func (l *ShareLog) OnReject(e proxy.Event) {
l.writeRejectLine(e.Miner.User(), e.Error)
}
func (l *AccessLog) writeLine(kind, ip, user, agent string, rx, tx uint64) {
l.mu.Lock()
defer l.mu.Unlock()
if err := l.ensureFile(); err != nil {
func (accessLog *AccessLog) writeLine(kind, ip, user, agent string, rx, tx uint64) {
accessLog.mu.Lock()
defer accessLog.mu.Unlock()
if err := accessLog.ensureFile(); err != nil {
return
}
var builder strings.Builder
@ -72,13 +72,13 @@ func (l *AccessLog) writeLine(kind, ip, user, agent string, rx, tx uint64) {
builder.WriteString(" tx=")
builder.WriteString(strconv.FormatUint(tx, 10))
builder.WriteByte('\n')
_, _ = l.f.WriteString(builder.String())
_, _ = accessLog.f.WriteString(builder.String())
}
func (l *ShareLog) writeAcceptLine(user string, diff uint64, latency uint64) {
l.mu.Lock()
defer l.mu.Unlock()
if err := l.ensureFile(); err != nil {
func (shareLog *ShareLog) writeAcceptLine(user string, diff uint64, latency uint64) {
shareLog.mu.Lock()
defer shareLog.mu.Unlock()
if err := shareLog.ensureFile(); err != nil {
return
}
var builder strings.Builder
@ -92,13 +92,13 @@ func (l *ShareLog) writeAcceptLine(user string, diff uint64, latency uint64) {
builder.WriteString(strconv.FormatUint(latency, 10))
builder.WriteString("ms")
builder.WriteByte('\n')
_, _ = l.f.WriteString(builder.String())
_, _ = shareLog.f.WriteString(builder.String())
}
func (l *ShareLog) writeRejectLine(user, reason string) {
l.mu.Lock()
defer l.mu.Unlock()
if err := l.ensureFile(); err != nil {
func (shareLog *ShareLog) writeRejectLine(user, reason string) {
shareLog.mu.Lock()
defer shareLog.mu.Unlock()
if err := shareLog.ensureFile(); err != nil {
return
}
var builder strings.Builder
@ -108,29 +108,29 @@ func (l *ShareLog) writeRejectLine(user, reason string) {
builder.WriteString(" reason=\"")
builder.WriteString(reason)
builder.WriteString("\"\n")
_, _ = l.f.WriteString(builder.String())
_, _ = shareLog.f.WriteString(builder.String())
}
func (l *AccessLog) ensureFile() error {
if l.f != nil {
func (accessLog *AccessLog) ensureFile() error {
if accessLog.f != nil {
return nil
}
f, err := os.OpenFile(l.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
f, err := os.OpenFile(accessLog.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
if err != nil {
return err
}
l.f = f
accessLog.f = f
return nil
}
func (l *ShareLog) ensureFile() error {
if l.f != nil {
func (shareLog *ShareLog) ensureFile() error {
if shareLog.f != nil {
return nil
}
f, err := os.OpenFile(l.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
f, err := os.OpenFile(shareLog.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
if err != nil {
return err
}
l.f = f
shareLog.f = f
return nil
}

12
pool/impl.go
View file

@ -18,16 +18,16 @@ import (
)
// NewStrategyFactory creates a StrategyFactory for the supplied config.
func NewStrategyFactory(cfg *proxy.Config) StrategyFactory {
func NewStrategyFactory(config *proxy.Config) StrategyFactory {
return func(listener StratumListener) Strategy {
return NewFailoverStrategy(cfg.Pools, listener, cfg)
return NewFailoverStrategy(config.Pools, listener, config)
}
}
// NewStratumClient constructs a pool client.
func NewStratumClient(cfg proxy.PoolConfig, listener StratumListener) *StratumClient {
func NewStratumClient(poolConfig proxy.PoolConfig, listener StratumListener) *StratumClient {
return &StratumClient{
config: cfg,
config: poolConfig,
listener: listener,
pending: make(map[int64]struct{}),
}
@ -335,11 +335,11 @@ func (c *StratumClient) handleMessage(line []byte) {
}
// NewFailoverStrategy creates the ordered pool failover wrapper.
func NewFailoverStrategy(pools []proxy.PoolConfig, listener StratumListener, cfg *proxy.Config) *FailoverStrategy {
func NewFailoverStrategy(pools []proxy.PoolConfig, listener StratumListener, config *proxy.Config) *FailoverStrategy {
return &FailoverStrategy{
pools: pools,
listener: listener,
config: cfg,
config: config,
}
}

6
splitter/nicehash/impl.go
View file

@ -14,13 +14,13 @@ func init() {
}
// NewNonceSplitter creates a NiceHash splitter.
func NewNonceSplitter(cfg *proxy.Config, events *proxy.EventBus, factory pool.StrategyFactory) *NonceSplitter {
func NewNonceSplitter(config *proxy.Config, events *proxy.EventBus, factory pool.StrategyFactory) *NonceSplitter {
if factory == nil {
factory = pool.NewStrategyFactory(cfg)
factory = pool.NewStrategyFactory(config)
}
return &NonceSplitter{
byID: make(map[int64]*NonceMapper),
config: cfg,
config: config,
events: events,
strategyFactory: factory,
}

6
splitter/simple/impl.go
View file

@ -14,14 +14,14 @@ func init() {
}
// NewSimpleSplitter creates the passthrough splitter.
func NewSimpleSplitter(cfg *proxy.Config, events *proxy.EventBus, factory pool.StrategyFactory) *SimpleSplitter {
func NewSimpleSplitter(config *proxy.Config, events *proxy.EventBus, factory pool.StrategyFactory) *SimpleSplitter {
if factory == nil {
factory = pool.NewStrategyFactory(cfg)
factory = pool.NewStrategyFactory(config)
}
return &SimpleSplitter{
active: make(map[int64]*SimpleMapper),
idle: make(map[int64]*SimpleMapper),
config: cfg,
config: config,
events: events,
factory: factory,
}

46
state_impl.go
View file

@ -37,25 +37,25 @@ type MinerSnapshot struct {
// if !result.OK {
// return
// }
func New(cfg *Config) (*Proxy, Result) {
if cfg == nil {
func New(config *Config) (*Proxy, Result) {
if config == nil {
return nil, errorResult(errors.New("config is nil"))
}
if result := cfg.Validate(); !result.OK {
if result := config.Validate(); !result.OK {
return nil, result
}
p := &Proxy{
config: cfg,
config: config,
events: NewEventBus(),
stats: NewStats(),
workers: NewWorkers(cfg.Workers, nil),
workers: NewWorkers(config.Workers, nil),
miners: make(map[int64]*Miner),
customDiff: NewCustomDiff(cfg.CustomDiff),
customDiffBuckets: NewCustomDiffBuckets(cfg.CustomDiffStats),
rateLimit: NewRateLimiter(cfg.RateLimit),
accessLog: newAccessLogSink(cfg.AccessLogFile),
shareLog: newShareLogSink(cfg.ShareLogFile),
customDiff: NewCustomDiff(config.CustomDiff),
customDiffBuckets: NewCustomDiffBuckets(config.CustomDiffStats),
rateLimit: NewRateLimiter(config.RateLimit),
accessLog: newAccessLogSink(config.AccessLogFile),
shareLog: newShareLogSink(config.ShareLogFile),
done: make(chan struct{}),
}
p.events.Subscribe(EventLogin, p.customDiff.OnLogin)
@ -78,12 +78,12 @@ func New(cfg *Config) (*Proxy, Result) {
}
p.events.Subscribe(EventAccept, p.onShareSettled)
p.events.Subscribe(EventReject, p.onShareSettled)
if cfg.Watch && cfg.configPath != "" {
p.watcher = NewConfigWatcher(cfg.configPath, p.Reload)
if config.Watch && config.configPath != "" {
p.watcher = NewConfigWatcher(config.configPath, p.Reload)
}
if factory, ok := getSplitterFactory(cfg.Mode); ok {
p.splitter = factory(cfg, p.events)
if factory, ok := getSplitterFactory(config.Mode); ok {
p.splitter = factory(config, p.events)
} else {
p.splitter = &noopSplitter{}
}
@ -312,40 +312,40 @@ func (p *Proxy) closeAllMiners() {
// Reload swaps the live configuration and updates dependent state.
//
// p.Reload(updatedCfg)
func (p *Proxy) Reload(cfg *Config) {
if p == nil || cfg == nil {
func (p *Proxy) Reload(config *Config) {
if p == nil || config == nil {
return
}
if p.config == nil {
p.config = cfg
p.config = config
} else {
preservedBind := append([]BindAddr(nil), p.config.Bind...)
preservedMode := p.config.Mode
preservedWorkers := p.config.Workers
preservedConfigPath := p.config.configPath
*p.config = *cfg
*p.config = *config
p.config.Bind = preservedBind
p.config.Mode = preservedMode
p.config.Workers = preservedWorkers
p.config.configPath = preservedConfigPath
}
if p.customDiff != nil {
p.customDiff.globalDiff = cfg.CustomDiff
p.customDiff.globalDiff = config.CustomDiff
}
if p.customDiffBuckets != nil {
p.customDiffBuckets.SetEnabled(cfg.CustomDiffStats)
p.customDiffBuckets.SetEnabled(config.CustomDiffStats)
}
p.rateLimit = NewRateLimiter(cfg.RateLimit)
p.rateLimit = NewRateLimiter(config.RateLimit)
for _, server := range p.servers {
if server != nil {
server.limiter = p.rateLimit
}
}
if p.accessLog != nil {
p.accessLog.SetPath(cfg.AccessLogFile)
p.accessLog.SetPath(config.AccessLogFile)
}
if p.shareLog != nil {
p.shareLog.SetPath(cfg.ShareLogFile)
p.shareLog.SetPath(config.ShareLogFile)
}
}