// New returns a Resolver with the given version and configuration.
func New(version string, config records.Config) *Resolver {
generatorOptions := []records.Option{
records.WithConfig(config),
}
recordGenerator := records.NewRecordGenerator(generatorOptions...)
r := &Resolver{
version: version,
config: config,
rs: recordGenerator,
// rand.Sources aren't safe for concurrent use, except the global one.
// See: https://github.com/golang/go/issues/3611
rng: rand.New(&lockedSource{src: rand.NewSource(time.Now().UnixNano())}),
masters: append([]string{""}, config.Masters...),
generatorOptions: generatorOptions,
}
timeout := 5 * time.Second
if config.Timeout != 0 {
timeout = time.Duration(config.Timeout) * time.Second
}
rs := config.Resolvers
if !config.ExternalOn {
rs = rs[:0]
}
r.fwd = exchanger.NewForwarder(rs, exchangers(timeout, "udp", "tcp"))
return r
}
func (provider *Mesos) loadMesosConfig() *types.Configuration {
var mesosFuncMap = template.FuncMap{
"getBackend": provider.getBackend,
"getPort": provider.getPort,
"getHost": provider.getHost,
"getWeight": provider.getWeight,
"getDomain": provider.getDomain,
"getProtocol": provider.getProtocol,
"getPassHostHeader": provider.getPassHostHeader,
"getPriority": provider.getPriority,
"getEntryPoints": provider.getEntryPoints,
"getFrontendRule": provider.getFrontendRule,
"getFrontendBackend": provider.getFrontendBackend,
"getID": provider.getID,
"getFrontEndName": provider.getFrontEndName,
"replace": replace,
}
t := records.NewRecordGenerator(time.Duration(provider.StateTimeoutSecond) * time.Second)
sj, err := t.FindMaster(provider.Masters...)
if err != nil {
log.Errorf("Failed to create a client for mesos, error: %s", err)
return nil
}
tasks := provider.taskRecords(sj)
//filter tasks
filteredTasks := fun.Filter(func(task state.Task) bool {
return mesosTaskFilter(task, provider.ExposedByDefault)
}, tasks).([]state.Task)
filteredApps := []state.Task{}
for _, value := range filteredTasks {
if !taskInSlice(value, filteredApps) {
filteredApps = append(filteredApps, value)
}
}
templateObjects := struct {
Applications []state.Task
Tasks []state.Task
Domain string
}{
filteredApps,
filteredTasks,
provider.Domain,
}
configuration, err := provider.getConfiguration("templates/mesos.tmpl", mesosFuncMap, templateObjects)
if err != nil {
log.Error(err)
}
return configuration
}
// Reload triggers a new state load from the configured mesos masters.
// This method is not goroutine-safe.
func (res *Resolver) Reload() {
t := records.NewRecordGenerator(res.generatorOptions...)
err := t.ParseState(res.config, res.masters...)
if err == nil {
timestamp := uint32(time.Now().Unix())
// may need to refactor for fairness
res.rsLock.Lock()
defer res.rsLock.Unlock()
atomic.StoreUint32(&res.config.SOASerial, timestamp)
res.rs = t
} else {
logging.Error.Printf("Warning: Error generating records: %v; keeping old DNS state", err)
}
logging.PrintCurLog()
}