2019-06-10 11:33:19 +03:00
|
|
|
package home
|
2018-08-30 17:25:33 +03:00
|
|
|
|
|
|
|
import (
|
|
|
|
"io/ioutil"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"sync"
|
2018-10-30 17:16:20 +03:00
|
|
|
|
2020-10-30 13:32:02 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/dhcpd"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/dnsfilter"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/dnsforward"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/querylog"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/stats"
|
2021-01-13 16:18:51 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/version"
|
2019-03-06 12:20:34 +03:00
|
|
|
"github.com/AdguardTeam/golibs/file"
|
2019-02-25 16:44:22 +03:00
|
|
|
"github.com/AdguardTeam/golibs/log"
|
2019-01-25 16:01:27 +03:00
|
|
|
yaml "gopkg.in/yaml.v2"
|
2018-08-30 17:25:33 +03:00
|
|
|
)
|
|
|
|
|
2018-11-27 20:51:12 +03:00
|
|
|
const (
|
2018-12-05 20:29:00 +03:00
|
|
|
dataDir = "data" // data storage
|
|
|
|
filterDir = "filters" // cache location for downloaded filters, it's under DataDir
|
2018-11-27 20:51:12 +03:00
|
|
|
)
|
2018-10-30 17:16:20 +03:00
|
|
|
|
2019-02-04 13:54:53 +03:00
|
|
|
// logSettings
|
|
|
|
type logSettings struct {
|
2020-06-02 14:20:12 +03:00
|
|
|
LogCompress bool `yaml:"log_compress"` // Compress determines if the rotated log files should be compressed using gzip (default: false)
|
|
|
|
LogLocalTime bool `yaml:"log_localtime"` // If the time used for formatting the timestamps in is the computer's local time (default: false [UTC])
|
|
|
|
LogMaxBackups int `yaml:"log_max_backups"` // Maximum number of old log files to retain (MaxAge may still cause them to get deleted)
|
|
|
|
LogMaxSize int `yaml:"log_max_size"` // Maximum size in megabytes of the log file before it gets rotated (default 100 MB)
|
|
|
|
LogMaxAge int `yaml:"log_max_age"` // MaxAge is the maximum number of days to retain old log files
|
|
|
|
LogFile string `yaml:"log_file"` // Path to the log file. If empty, write to stdout. If "syslog", writes to syslog
|
|
|
|
Verbose bool `yaml:"verbose"` // If true, verbose logging is enabled
|
2019-02-04 13:54:53 +03:00
|
|
|
}
|
|
|
|
|
2018-08-30 17:25:33 +03:00
|
|
|
// configuration is loaded from YAML
|
2018-11-27 20:51:12 +03:00
|
|
|
// field ordering is important -- yaml fields will mirror ordering from here
|
2018-08-30 17:25:33 +03:00
|
|
|
type configuration struct {
|
2019-04-30 14:38:24 +03:00
|
|
|
// Raw file data to avoid re-reading of configuration file
|
|
|
|
// It's reset after config is parsed
|
|
|
|
fileData []byte
|
|
|
|
|
2020-12-29 19:53:56 +03:00
|
|
|
BindHost string `yaml:"bind_host"` // BindHost is the IP address of the HTTP server to bind to
|
|
|
|
BindPort int `yaml:"bind_port"` // BindPort is the port the HTTP server
|
|
|
|
BetaBindPort int `yaml:"beta_bind_port"` // BetaBindPort is the port for new client
|
|
|
|
Users []User `yaml:"users"` // Users that can access HTTP server
|
|
|
|
ProxyURL string `yaml:"http_proxy"` // Proxy address for our HTTP client
|
|
|
|
Language string `yaml:"language"` // two-letter ISO 639-1 language code
|
|
|
|
RlimitNoFile uint `yaml:"rlimit_nofile"` // Maximum number of opened fd's per process (0: default)
|
|
|
|
DebugPProf bool `yaml:"debug_pprof"` // Enable pprof HTTP server on port 6060
|
2019-03-27 17:09:48 +03:00
|
|
|
|
2019-11-12 14:23:00 +03:00
|
|
|
// TTL for a web session (in hours)
|
|
|
|
// An active session is automatically refreshed once a day.
|
|
|
|
WebSessionTTLHours uint32 `yaml:"web_session_ttl"`
|
|
|
|
|
2020-02-19 15:28:06 +03:00
|
|
|
DNS dnsConfig `yaml:"dns"`
|
|
|
|
TLS tlsConfigSettings `yaml:"tls"`
|
2020-02-26 19:58:25 +03:00
|
|
|
|
|
|
|
Filters []filter `yaml:"filters"`
|
|
|
|
WhitelistFilters []filter `yaml:"whitelist_filters"`
|
|
|
|
UserRules []string `yaml:"user_rules"`
|
|
|
|
|
|
|
|
DHCP dhcpd.ServerConfig `yaml:"dhcp"`
|
2018-08-30 17:25:33 +03:00
|
|
|
|
2019-04-26 16:04:22 +03:00
|
|
|
// Note: this array is filled only before file read/write and then it's cleared
|
|
|
|
Clients []clientObject `yaml:"clients"`
|
|
|
|
|
2019-02-04 13:54:53 +03:00
|
|
|
logSettings `yaml:",inline"`
|
|
|
|
|
2018-10-07 00:58:59 +03:00
|
|
|
sync.RWMutex `yaml:"-"`
|
2018-11-27 20:51:12 +03:00
|
|
|
|
|
|
|
SchemaVersion int `yaml:"schema_version"` // keeping last so that users will be less tempted to change it -- used when upgrading between versions
|
2018-08-30 17:25:33 +03:00
|
|
|
}
|
|
|
|
|
2018-11-27 20:51:12 +03:00
|
|
|
// field ordering is important -- yaml fields will mirror ordering from here
|
2018-12-05 20:29:00 +03:00
|
|
|
type dnsConfig struct {
|
2019-01-24 20:11:01 +03:00
|
|
|
BindHost string `yaml:"bind_host"`
|
|
|
|
Port int `yaml:"port"`
|
2018-11-28 18:24:04 +03:00
|
|
|
|
2019-08-08 12:41:00 +03:00
|
|
|
// time interval for statistics (in days)
|
2019-09-10 17:59:10 +03:00
|
|
|
StatsInterval uint32 `yaml:"statistics_interval"`
|
2019-08-08 12:41:00 +03:00
|
|
|
|
2020-05-28 15:29:36 +03:00
|
|
|
QueryLogEnabled bool `yaml:"querylog_enabled"` // if true, query log is enabled
|
|
|
|
QueryLogFileEnabled bool `yaml:"querylog_file_enabled"` // if true, query log will be written to a file
|
|
|
|
QueryLogInterval uint32 `yaml:"querylog_interval"` // time interval for query log (in days)
|
|
|
|
QueryLogMemSize uint32 `yaml:"querylog_size_memory"` // number of entries kept in memory before they are flushed to disk
|
|
|
|
AnonymizeClientIP bool `yaml:"anonymize_client_ip"` // anonymize clients' IP addresses in logs and stats
|
2019-10-30 11:52:58 +03:00
|
|
|
|
2018-11-28 18:24:04 +03:00
|
|
|
dnsforward.FilteringConfig `yaml:",inline"`
|
|
|
|
|
2019-10-30 11:52:58 +03:00
|
|
|
FilteringEnabled bool `yaml:"filtering_enabled"` // whether or not use filter lists
|
|
|
|
FiltersUpdateIntervalHours uint32 `yaml:"filters_update_interval"` // time period to update filters (in hours)
|
|
|
|
DnsfilterConf dnsfilter.Config `yaml:",inline"`
|
2018-08-30 17:25:33 +03:00
|
|
|
}
|
|
|
|
|
2019-02-13 11:08:07 +03:00
|
|
|
type tlsConfigSettings struct {
|
2020-08-27 15:03:07 +03:00
|
|
|
Enabled bool `yaml:"enabled" json:"enabled"` // Enabled is the encryption (DOT/DOH/HTTPS) status
|
|
|
|
ServerName string `yaml:"server_name" json:"server_name,omitempty"` // ServerName is the hostname of your HTTPS/TLS server
|
|
|
|
ForceHTTPS bool `yaml:"force_https" json:"force_https,omitempty"` // ForceHTTPS: if true, forces HTTP->HTTPS redirect
|
|
|
|
PortHTTPS int `yaml:"port_https" json:"port_https,omitempty"` // HTTPS port. If 0, HTTPS will be disabled
|
|
|
|
PortDNSOverTLS int `yaml:"port_dns_over_tls" json:"port_dns_over_tls,omitempty"` // DNS-over-TLS port. If 0, DOT will be disabled
|
|
|
|
PortDNSOverQUIC uint16 `yaml:"port_dns_over_quic" json:"port_dns_over_quic,omitempty"` // DNS-over-QUIC port. If 0, DoQ will be disabled
|
2019-02-12 17:23:38 +03:00
|
|
|
|
2020-12-07 17:58:33 +03:00
|
|
|
// PortDNSCrypt is the port for DNSCrypt requests. If it's zero,
|
|
|
|
// DNSCrypt is disabled.
|
|
|
|
PortDNSCrypt int `yaml:"port_dnscrypt" json:"port_dnscrypt"`
|
|
|
|
// DNSCryptConfigFile is the path to the DNSCrypt config file. Must be
|
|
|
|
// set if PortDNSCrypt is not zero.
|
|
|
|
//
|
|
|
|
// See https://github.com/AdguardTeam/dnsproxy and
|
|
|
|
// https://github.com/ameshkov/dnscrypt.
|
|
|
|
DNSCryptConfigFile string `yaml:"dnscrypt_config_file" json:"dnscrypt_config_file"`
|
|
|
|
|
2019-12-13 15:59:36 +03:00
|
|
|
// Allow DOH queries via unencrypted HTTP (e.g. for reverse proxying)
|
|
|
|
AllowUnencryptedDOH bool `yaml:"allow_unencrypted_doh" json:"allow_unencrypted_doh"`
|
|
|
|
|
2019-02-12 17:23:38 +03:00
|
|
|
dnsforward.TLSConfig `yaml:",inline" json:",inline"`
|
2019-02-13 11:08:07 +03:00
|
|
|
}
|
|
|
|
|
2018-08-30 17:25:33 +03:00
|
|
|
// initialize to default values, will be changed later when reading config or parsing command line
|
|
|
|
var config = configuration{
|
2020-12-29 19:53:56 +03:00
|
|
|
BindPort: 3000,
|
|
|
|
BetaBindPort: 0,
|
|
|
|
BindHost: "0.0.0.0",
|
2018-12-05 20:29:00 +03:00
|
|
|
DNS: dnsConfig{
|
2019-11-08 12:31:50 +03:00
|
|
|
BindHost: "0.0.0.0",
|
|
|
|
Port: 53,
|
|
|
|
StatsInterval: 1,
|
2018-11-28 18:24:04 +03:00
|
|
|
FilteringConfig: dnsforward.FilteringConfig{
|
2019-12-11 17:54:34 +03:00
|
|
|
ProtectionEnabled: true, // whether or not use any of dnsfilter features
|
2020-01-17 15:24:33 +03:00
|
|
|
BlockingMode: "default", // mode how to answer filtered requests
|
2019-12-11 17:54:34 +03:00
|
|
|
BlockedResponseTTL: 10, // in seconds
|
2019-10-30 11:52:58 +03:00
|
|
|
Ratelimit: 20,
|
|
|
|
RefuseAny: true,
|
|
|
|
AllServers: false,
|
2020-11-05 13:26:13 +03:00
|
|
|
|
|
|
|
// set default maximum concurrent queries to 300
|
|
|
|
// we introduced a default limit due to this:
|
|
|
|
// https://github.com/AdguardTeam/AdGuardHome/issues/2015#issuecomment-674041912
|
|
|
|
// was later increased to 300 due to https://github.com/AdguardTeam/AdGuardHome/issues/2257
|
|
|
|
MaxGoroutines: 300,
|
2018-11-28 18:24:04 +03:00
|
|
|
},
|
2019-10-30 11:52:58 +03:00
|
|
|
FilteringEnabled: true, // whether or not use filter lists
|
|
|
|
FiltersUpdateIntervalHours: 24,
|
2018-08-30 17:25:33 +03:00
|
|
|
},
|
2020-02-19 15:28:06 +03:00
|
|
|
TLS: tlsConfigSettings{
|
2020-08-27 15:03:07 +03:00
|
|
|
PortHTTPS: 443,
|
|
|
|
PortDNSOverTLS: 853, // needs to be passed through to dnsproxy
|
|
|
|
PortDNSOverQUIC: 784,
|
2019-02-11 21:52:39 +03:00
|
|
|
},
|
2020-06-02 14:20:12 +03:00
|
|
|
logSettings: logSettings{
|
|
|
|
LogCompress: false,
|
|
|
|
LogLocalTime: false,
|
|
|
|
LogMaxBackups: 0,
|
|
|
|
LogMaxSize: 100,
|
2020-06-05 17:58:42 +03:00
|
|
|
LogMaxAge: 3,
|
2020-06-02 14:20:12 +03:00
|
|
|
},
|
2018-12-06 00:29:38 +03:00
|
|
|
SchemaVersion: currentSchemaVersion,
|
2018-08-30 17:25:33 +03:00
|
|
|
}
|
|
|
|
|
2019-07-09 18:37:24 +03:00
|
|
|
// initConfig initializes default configuration for the current OS&ARCH
|
|
|
|
func initConfig() {
|
2019-11-12 14:23:00 +03:00
|
|
|
config.WebSessionTTLHours = 30 * 24
|
|
|
|
|
2019-11-08 12:31:50 +03:00
|
|
|
config.DNS.QueryLogEnabled = true
|
2020-05-28 15:29:36 +03:00
|
|
|
config.DNS.QueryLogFileEnabled = true
|
2019-11-08 12:31:50 +03:00
|
|
|
config.DNS.QueryLogInterval = 90
|
|
|
|
config.DNS.QueryLogMemSize = 1000
|
|
|
|
|
2019-08-22 15:09:43 +03:00
|
|
|
config.DNS.CacheSize = 4 * 1024 * 1024
|
2019-10-09 19:51:26 +03:00
|
|
|
config.DNS.DnsfilterConf.SafeBrowsingCacheSize = 1 * 1024 * 1024
|
|
|
|
config.DNS.DnsfilterConf.SafeSearchCacheSize = 1 * 1024 * 1024
|
|
|
|
config.DNS.DnsfilterConf.ParentalCacheSize = 1 * 1024 * 1024
|
|
|
|
config.DNS.DnsfilterConf.CacheTime = 30
|
2019-09-04 14:12:00 +03:00
|
|
|
config.Filters = defaultFilters()
|
2020-07-03 18:20:01 +03:00
|
|
|
|
|
|
|
config.DHCP.Conf4.LeaseDuration = 86400
|
|
|
|
config.DHCP.Conf4.ICMPTimeout = 1000
|
|
|
|
config.DHCP.Conf6.LeaseDuration = 86400
|
2020-12-29 19:53:56 +03:00
|
|
|
|
2021-01-13 16:18:51 +03:00
|
|
|
if ch := version.Channel(); ch == "edge" || ch == "development" {
|
2020-12-29 19:53:56 +03:00
|
|
|
config.BetaBindPort = 3001
|
|
|
|
}
|
2019-02-27 12:41:37 +03:00
|
|
|
}
|
|
|
|
|
2019-02-05 20:35:48 +03:00
|
|
|
// getConfigFilename returns path to the current config file
|
|
|
|
func (c *configuration) getConfigFilename() string {
|
2020-02-13 18:42:07 +03:00
|
|
|
configFile, err := filepath.EvalSymlinks(Context.configFilename)
|
2019-03-14 18:06:53 +03:00
|
|
|
if err != nil {
|
|
|
|
if !os.IsNotExist(err) {
|
|
|
|
log.Error("unexpected error while config file path evaluation: %s", err)
|
|
|
|
}
|
2020-02-13 18:42:07 +03:00
|
|
|
configFile = Context.configFilename
|
2019-03-14 18:06:53 +03:00
|
|
|
}
|
2019-02-05 20:35:48 +03:00
|
|
|
if !filepath.IsAbs(configFile) {
|
2020-02-13 18:42:07 +03:00
|
|
|
configFile = filepath.Join(Context.workDir, configFile)
|
2019-02-05 20:35:48 +03:00
|
|
|
}
|
|
|
|
return configFile
|
|
|
|
}
|
|
|
|
|
2019-02-04 13:54:53 +03:00
|
|
|
// getLogSettings reads logging settings from the config file.
|
|
|
|
// we do it in a separate method in order to configure logger before the actual configuration is parsed and applied.
|
|
|
|
func getLogSettings() logSettings {
|
|
|
|
l := logSettings{}
|
|
|
|
yamlFile, err := readConfigFile()
|
2019-04-30 14:38:24 +03:00
|
|
|
if err != nil {
|
2019-02-04 13:54:53 +03:00
|
|
|
return l
|
|
|
|
}
|
|
|
|
err = yaml.Unmarshal(yamlFile, &l)
|
|
|
|
if err != nil {
|
2019-02-25 16:44:22 +03:00
|
|
|
log.Error("Couldn't get logging settings from the configuration: %s", err)
|
2019-02-04 13:54:53 +03:00
|
|
|
}
|
|
|
|
return l
|
|
|
|
}
|
|
|
|
|
|
|
|
// parseConfig loads configuration from the YAML file
|
2018-08-30 17:25:33 +03:00
|
|
|
func parseConfig() error {
|
2019-02-05 20:35:48 +03:00
|
|
|
configFile := config.getConfigFilename()
|
2019-02-25 16:44:22 +03:00
|
|
|
log.Debug("Reading config file: %s", configFile)
|
2019-02-04 13:54:53 +03:00
|
|
|
yamlFile, err := readConfigFile()
|
2018-08-30 17:25:33 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-04-30 14:38:24 +03:00
|
|
|
config.fileData = nil
|
2018-08-30 17:25:33 +03:00
|
|
|
err = yaml.Unmarshal(yamlFile, &config)
|
|
|
|
if err != nil {
|
2019-02-25 16:44:22 +03:00
|
|
|
log.Error("Couldn't parse config file: %s", err)
|
2018-08-30 17:25:33 +03:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-09-04 14:12:00 +03:00
|
|
|
if !checkFiltersUpdateIntervalHours(config.DNS.FiltersUpdateIntervalHours) {
|
|
|
|
config.DNS.FiltersUpdateIntervalHours = 24
|
|
|
|
}
|
2019-08-08 12:41:00 +03:00
|
|
|
|
2018-08-30 17:25:33 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-02-04 13:54:53 +03:00
|
|
|
// readConfigFile reads config file contents if it exists
|
|
|
|
func readConfigFile() ([]byte, error) {
|
2019-04-30 14:38:24 +03:00
|
|
|
if len(config.fileData) != 0 {
|
|
|
|
return config.fileData, nil
|
|
|
|
}
|
|
|
|
|
2019-02-05 20:35:48 +03:00
|
|
|
configFile := config.getConfigFilename()
|
2019-04-30 14:38:24 +03:00
|
|
|
d, err := ioutil.ReadFile(configFile)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("Couldn't read config file %s: %s", configFile, err)
|
|
|
|
return nil, err
|
2019-02-04 13:54:53 +03:00
|
|
|
}
|
2019-04-30 14:38:24 +03:00
|
|
|
return d, nil
|
2019-02-04 13:54:53 +03:00
|
|
|
}
|
|
|
|
|
2018-10-30 12:24:59 +03:00
|
|
|
// Saves configuration to the YAML file and also saves the user filter contents to a file
|
2018-11-29 14:56:56 +03:00
|
|
|
func (c *configuration) write() error {
|
2018-11-29 13:31:50 +03:00
|
|
|
c.Lock()
|
|
|
|
defer c.Unlock()
|
2019-04-26 16:04:22 +03:00
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.clients.WriteDiskConfig(&config.Clients)
|
2019-04-26 16:04:22 +03:00
|
|
|
|
2020-02-13 18:42:07 +03:00
|
|
|
if Context.auth != nil {
|
|
|
|
config.Users = Context.auth.GetUsers()
|
2019-08-29 12:34:07 +03:00
|
|
|
}
|
2020-02-19 15:28:06 +03:00
|
|
|
if Context.tls != nil {
|
|
|
|
tlsConf := tlsConfigSettings{}
|
|
|
|
Context.tls.WriteDiskConfig(&tlsConf)
|
|
|
|
config.TLS = tlsConf
|
|
|
|
}
|
2019-08-29 12:34:07 +03:00
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
if Context.stats != nil {
|
2019-09-25 15:36:09 +03:00
|
|
|
sdc := stats.DiskConfig{}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.stats.WriteDiskConfig(&sdc)
|
2019-09-25 15:36:09 +03:00
|
|
|
config.DNS.StatsInterval = sdc.Interval
|
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
if Context.queryLog != nil {
|
2020-05-28 15:29:36 +03:00
|
|
|
dc := querylog.Config{}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.queryLog.WriteDiskConfig(&dc)
|
2019-09-27 18:58:57 +03:00
|
|
|
config.DNS.QueryLogEnabled = dc.Enabled
|
2020-05-28 15:29:36 +03:00
|
|
|
config.DNS.QueryLogFileEnabled = dc.FileEnabled
|
2019-09-27 18:58:57 +03:00
|
|
|
config.DNS.QueryLogInterval = dc.Interval
|
2019-11-08 12:31:50 +03:00
|
|
|
config.DNS.QueryLogMemSize = dc.MemSize
|
2020-03-03 20:21:53 +03:00
|
|
|
config.DNS.AnonymizeClientIP = dc.AnonymizeClientIP
|
2019-09-27 18:58:57 +03:00
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
if Context.dnsFilter != nil {
|
2019-10-09 19:51:26 +03:00
|
|
|
c := dnsfilter.Config{}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.dnsFilter.WriteDiskConfig(&c)
|
2019-10-09 19:51:26 +03:00
|
|
|
config.DNS.DnsfilterConf = c
|
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
if Context.dnsServer != nil {
|
2019-10-30 11:52:58 +03:00
|
|
|
c := dnsforward.FilteringConfig{}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.dnsServer.WriteDiskConfig(&c)
|
2019-10-30 11:52:58 +03:00
|
|
|
config.DNS.FilteringConfig = c
|
|
|
|
}
|
|
|
|
|
2019-12-11 12:38:58 +03:00
|
|
|
if Context.dhcpServer != nil {
|
2019-11-22 14:21:08 +03:00
|
|
|
c := dhcpd.ServerConfig{}
|
2019-12-11 12:38:58 +03:00
|
|
|
Context.dhcpServer.WriteDiskConfig(&c)
|
2019-11-22 14:21:08 +03:00
|
|
|
config.DHCP = c
|
|
|
|
}
|
|
|
|
|
2019-02-05 20:35:48 +03:00
|
|
|
configFile := config.getConfigFilename()
|
2019-02-25 16:44:22 +03:00
|
|
|
log.Debug("Writing YAML file: %s", configFile)
|
2018-08-30 17:25:33 +03:00
|
|
|
yamlText, err := yaml.Marshal(&config)
|
2019-04-26 16:04:22 +03:00
|
|
|
config.Clients = nil
|
2018-08-30 17:25:33 +03:00
|
|
|
if err != nil {
|
2019-02-25 16:44:22 +03:00
|
|
|
log.Error("Couldn't generate YAML file: %s", err)
|
2018-08-30 17:25:33 +03:00
|
|
|
return err
|
|
|
|
}
|
2019-03-06 12:20:34 +03:00
|
|
|
err = file.SafeWrite(configFile, yamlText)
|
2018-08-30 17:25:33 +03:00
|
|
|
if err != nil {
|
2019-02-25 16:44:22 +03:00
|
|
|
log.Error("Couldn't save YAML config: %s", err)
|
2018-08-30 17:25:33 +03:00
|
|
|
return err
|
|
|
|
}
|
2018-10-30 02:17:24 +03:00
|
|
|
|
2018-11-28 20:15:32 +03:00
|
|
|
return nil
|
|
|
|
}
|