satoshi
81227cb90f
isOpenSource was matching things like Braiins OS, cgminer, bfgminer,
and a generic "esp32" — software that's open but runs on closed
hardware (Antminer, unknown rigs). public-pool's UI reserves the
star for open-source HARDWARE, with open firmware on top, and that's
the convention to match. New regex covers the family verbatim from
public-pool-ui's user-agent-link switch table:
bitaxe, bitaxeHex, NerdMiner, NerdNOS, NerdAxe, NerdAxeGamma,
NerdOCTAXE, NerdEKO, NerdQAxe+, NerdQAxe++, PiAxe, QAxe, QAxe+,
0xAxe, LeafMiner
Also extend detectHardware so all those user-agents get a recognised
label instead of "esp32" / raw token.
Replace the squished "TLS" pill with an inline-flex badge: 0.78em
text, 5px corners, padlock SVG, generous left/right padding so it
reads at a glance instead of looking like a typo.
Custom block explorer: new optional union under StartOS Advanced
config ("Block Explorer" — defaults to "mempool.space"). Picking
"Custom URL" surfaces the value as MEMPOOL_BASE_URL on the
container env. config.Config picks it up, the aggregator copies
it into every Snapshot (mempool_base_url field), and the UI's
shared explorerBaseFor() helper trusts the custom URL verbatim
when present (no /testnet4 / /signet path appended — a self-hosted
instance is presumably single-network already). Falls back to the
public mempool.space mirrors per chain when unset, which is the
default behaviour.
89 lines
2.4 KiB
Go
89 lines
2.4 KiB
Go
// Package config loads kamado-api configuration from environment variables.
|
|
// Missing required values are a hard error at startup; optional values get
|
|
// documented defaults.
|
|
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
type Config struct {
|
|
// HTTP server
|
|
ListenAddr string
|
|
|
|
// CKPool socket
|
|
CKPoolSockDir string
|
|
|
|
// Bitcoin Core RPC
|
|
BitcoinRPCURL string // full URL e.g. http://bitcoind:8332
|
|
BitcoinRPCUser string
|
|
BitcoinRPCPassword string
|
|
BitcoinRPCTimeout time.Duration
|
|
|
|
// ZMQ (Phase 2b)
|
|
BitcoinZMQBlock string // e.g. tcp://bitcoind:28332, empty to disable
|
|
|
|
// CKPool log file, for block-solve detection (Phase 2b)
|
|
CKPoolLogFile string
|
|
|
|
// SQLite DB path for persistence (Phase 2b)
|
|
DBPath string
|
|
|
|
// Poll interval for refreshing ckpool stats
|
|
PollInterval time.Duration
|
|
|
|
// Optional mempool.space-compatible explorer base URL. Empty means
|
|
// the UI uses the public mempool.space; non-empty means the user
|
|
// has pointed Kamado at their own instance via the StartOS config.
|
|
MempoolBaseURL string
|
|
}
|
|
|
|
func FromEnv() (*Config, error) {
|
|
cfg := &Config{
|
|
ListenAddr: getenv("LISTEN_ADDR", ":8080"),
|
|
CKPoolSockDir: getenv("CKPOOL_SOCKDIR", "/run/ckpool"),
|
|
BitcoinRPCURL: os.Getenv("BITCOIN_RPC_URL"),
|
|
BitcoinRPCUser: os.Getenv("BITCOIN_RPC_USER"),
|
|
BitcoinRPCPassword: os.Getenv("BITCOIN_RPC_PASSWORD"),
|
|
BitcoinRPCTimeout: getenvDuration("BITCOIN_RPC_TIMEOUT", 10*time.Second),
|
|
BitcoinZMQBlock: os.Getenv("BITCOIN_ZMQ_BLOCK"),
|
|
CKPoolLogFile: getenv("CKPOOL_LOGFILE", "/var/log/ckpool/ckpool.log"),
|
|
DBPath: getenv("DB_PATH", "/var/lib/kamado/kamado.db"),
|
|
PollInterval: getenvDuration("POLL_INTERVAL", 5*time.Second),
|
|
MempoolBaseURL: os.Getenv("MEMPOOL_BASE_URL"),
|
|
}
|
|
|
|
if cfg.BitcoinRPCURL == "" {
|
|
return nil, fmt.Errorf("BITCOIN_RPC_URL is required")
|
|
}
|
|
if cfg.BitcoinRPCUser == "" || cfg.BitcoinRPCPassword == "" {
|
|
return nil, fmt.Errorf("BITCOIN_RPC_USER and BITCOIN_RPC_PASSWORD are required")
|
|
}
|
|
return cfg, nil
|
|
}
|
|
|
|
func getenv(key, def string) string {
|
|
if v := os.Getenv(key); v != "" {
|
|
return v
|
|
}
|
|
return def
|
|
}
|
|
|
|
func getenvDuration(key string, def time.Duration) time.Duration {
|
|
v := os.Getenv(key)
|
|
if v == "" {
|
|
return def
|
|
}
|
|
// Accept both Go duration syntax ("5s", "10s") and bare seconds ("10").
|
|
if d, err := time.ParseDuration(v); err == nil {
|
|
return d
|
|
}
|
|
if n, err := strconv.Atoi(v); err == nil {
|
|
return time.Duration(n) * time.Second
|
|
}
|
|
return def
|
|
}
|