func read() {
log.Tracef("Reading settings messages!!")
for msg := range service.In {
log.Tracef("Read settings message!! %q", msg)
settings := (msg).(map[string]interface{})
config.Update(func(updated *config.Config) error {
if autoReport, ok := settings["autoReport"].(bool); ok {
// turn on/off analaytics reporting
if autoReport {
analytics.StartService()
} else {
analytics.StopService()
}
baseSettings.AutoReport = autoReport
*updated.AutoReport = autoReport
} else if proxyAll, ok := settings["proxyAll"].(bool); ok {
baseSettings.ProxyAll = proxyAll
updated.Client.ProxyAll = proxyAll
} else if autoLaunch, ok := settings["autoLaunch"].(bool); ok {
launcher.CreateLaunchFile(autoLaunch)
baseSettings.AutoLaunch = autoLaunch
*updated.AutoLaunch = autoLaunch
}
return nil
})
}
}
func Configure(cfg *config.Config, version, revisionDate string, buildDate string) {
cfgMutex.Lock()
defer cfgMutex.Unlock()
if service == nil {
// base settings are always written
baseSettings = &Settings{
Version: version,
BuildDate: buildDate,
RevisionDate: revisionDate,
AutoReport: *cfg.AutoReport,
AutoLaunch: *cfg.AutoLaunch,
ProxyAll: cfg.Client.ProxyAll,
}
err := start(baseSettings)
if err != nil {
log.Errorf("Unable to register settings service: %q", err)
return
}
go read()
} else {
if *cfg.AutoLaunch != baseSettings.AutoLaunch {
// autolaunch setting modified on disk
launcher.CreateLaunchFile(*cfg.AutoLaunch)
}
baseSettings.AutoReport = *cfg.AutoReport
baseSettings.AutoLaunch = *cfg.AutoLaunch
baseSettings.ProxyAll = cfg.Client.ProxyAll
}
}
func read() {
log.Tracef("Reading settings messages!!")
for msg := range service.In {
log.Tracef("Read settings message!! %q", msg)
settings := (msg).(map[string]interface{})
err := config.Update(func(updated *config.Config) error {
if autoReport, ok := settings["autoReport"].(bool); ok {
baseSettings.AutoReport = autoReport
*updated.AutoReport = autoReport
} else if proxyAll, ok := settings["proxyAll"].(bool); ok {
baseSettings.ProxyAll = proxyAll
updated.Client.ProxyAll = proxyAll
} else if autoLaunch, ok := settings["autoLaunch"].(bool); ok {
launcher.CreateLaunchFile(autoLaunch)
baseSettings.AutoLaunch = autoLaunch
*updated.AutoLaunch = autoLaunch
}
return nil
})
if err != nil {
log.Errorf("Unable to update settings: %v", err)
}
}
}
// Load loads the initial settings at startup, either from disk or using defaults.
func LoadSettings(version, revisionDate, buildDate string) *Settings {
log.Debug("Loading settings")
// Create default settings that may or may not be overridden from an existing file
// on disk.
settings = &Settings{
AutoReport: true,
AutoLaunch: true,
ProxyAll: false,
SystemProxy: true,
}
// Use settings from disk if they're available.
if bytes, err := ioutil.ReadFile(path); err != nil {
log.Debugf("Could not read file %v", err)
} else if err := yaml.Unmarshal(bytes, settings); err != nil {
log.Errorf("Could not load yaml %v", err)
// Just keep going with the original settings not from disk.
} else {
log.Debugf("Loaded settings from %v", path)
}
if settings.AutoLaunch {
launcher.CreateLaunchFile(settings.AutoLaunch)
}
// always override below 3 attributes as they are not meant to be persisted across versions
settings.Version = version
settings.BuildDate = buildDate
settings.RevisionDate = revisionDate
// Only configure the UI once. This will typically be the case in the normal
// application flow, but tests might call Load twice, for example, which we
// want to allow.
once.Do(func() {
err := settings.start()
if err != nil {
log.Errorf("Unable to register settings service: %q", err)
return
}
go settings.read()
})
return settings
}
// SetAutoLaunch sets whether or not to auto-launch Lantern on system startup.
func (s *Settings) SetAutoLaunch(auto bool) {
s.Lock()
defer s.unlockAndSave()
s.AutoLaunch = auto
go launcher.CreateLaunchFile(auto)
}
func (cfg *Config) applyClientDefaults() {
// Make sure we always have at least one masquerade set
if cfg.Client.MasqueradeSets == nil {
cfg.Client.MasqueradeSets = make(map[string][]*fronted.Masquerade)
}
if len(cfg.Client.MasqueradeSets) == 0 {
cfg.Client.MasqueradeSets[cloudflare] = cloudflareMasquerades
}
// Make sure we always have at least one server
if cfg.Client.FrontedServers == nil {
cfg.Client.FrontedServers = make([]*client.FrontedServerInfo, 0)
}
if len(cfg.Client.FrontedServers) == 0 && len(cfg.Client.ChainedServers) == 0 {
cfg.Client.FrontedServers = []*client.FrontedServerInfo{
&client.FrontedServerInfo{
Host: "jp.fallbacks.getiantem.org",
Port: 443,
PoolSize: 0,
MasqueradeSet: cloudflare,
MaxMasquerades: 20,
QOS: 10,
Weight: 4000,
Trusted: true,
},
}
cfg.Client.ChainedServers = make(map[string]*client.ChainedServerInfo, len(fallbacks))
for key, fb := range fallbacks {
cfg.Client.ChainedServers[key] = fb
}
}
if cfg.AutoReport == nil {
cfg.AutoReport = new(bool)
*cfg.AutoReport = true
}
if cfg.AutoLaunch == nil {
cfg.AutoLaunch = new(bool)
*cfg.AutoLaunch = true
launcher.CreateLaunchFile(*cfg.AutoLaunch)
}
// Make sure all servers have a QOS and Weight configured
for _, server := range cfg.Client.FrontedServers {
if server.QOS == 0 {
server.QOS = 5
}
if server.Weight == 0 {
server.Weight = 100
}
if server.RedialAttempts == 0 {
server.RedialAttempts = 2
}
}
// Always make sure we have a map of ChainedServers
if cfg.Client.ChainedServers == nil {
cfg.Client.ChainedServers = make(map[string]*client.ChainedServerInfo)
}
// Sort servers so that they're always in a predictable order
cfg.Client.SortServers()
}
