// Refresh updates the current state of the CoreOSMachine.
func (m *CoreOSMachine) Refresh() {
m.RLock()
defer m.RUnlock()
cs := m.currentState()
if cs == nil {
log.Warning("Unable to refresh machine state")
} else {
m.dynamicState = cs
}
}
func (e *Engine) Run(stop chan bool) {
ticker := time.Tick(reconcileInterval)
machID := e.machine.State().ID
reconcile := func() {
done := make(chan struct{})
defer func() { close(done) }()
// While the reconciliation is running, flush the trigger channel in the background
go func() {
for {
select {
case <-done:
return
default:
select {
case <-e.trigger:
case <-done:
return
}
}
}
}()
e.lease = ensureLeader(e.lease, e.registry, machID)
if e.lease == nil {
return
}
start := time.Now()
e.rec.Reconcile(e)
elapsed := time.Now().Sub(start)
msg := fmt.Sprintf("Engine completed reconciliation in %s", elapsed)
if elapsed > reconcileInterval {
log.Warning(msg)
} else {
log.V(1).Info(msg)
}
}
for {
select {
case <-stop:
log.V(1).Info("Engine exiting due to stop signal")
return
case <-ticker:
log.V(1).Info("Engine tick")
reconcile()
case <-e.trigger:
log.V(1).Info("Engine reconcilation triggered by job state change")
reconcile()
}
}
}
func getConfig(flagset *flag.FlagSet, userCfgFile string) (*config.Config, error) {
opts := globalconf.Options{EnvPrefix: "FLEET_"}
if userCfgFile != "" {
// Fail hard if a user-provided config is not usable
fi, err := os.Stat(userCfgFile)
if err != nil {
log.Fatalf("Unable to use config file %s: %v", userCfgFile, err)
}
if fi.IsDir() {
log.Fatalf("Provided config %s is a directory, not a file", userCfgFile)
}
log.Infof("Using provided config file %s", userCfgFile)
opts.Filename = userCfgFile
} else if _, err := os.Stat(DefaultConfigFile); err == nil {
log.Infof("Using default config file %s", DefaultConfigFile)
opts.Filename = DefaultConfigFile
} else {
log.Infof("No provided or default config file found - proceeding without")
}
gconf, err := globalconf.NewWithOptions(&opts)
if err != nil {
return nil, err
}
gconf.ParseSet("", flagset)
cfg := config.Config{
Verbosity: (*flagset.Lookup("verbosity")).Value.(flag.Getter).Get().(int),
EtcdServers: (*flagset.Lookup("etcd_servers")).Value.(flag.Getter).Get().(stringSlice),
EtcdKeyPrefix: (*flagset.Lookup("etcd_key_prefix")).Value.(flag.Getter).Get().(string),
EtcdKeyFile: (*flagset.Lookup("etcd_keyfile")).Value.(flag.Getter).Get().(string),
EtcdCertFile: (*flagset.Lookup("etcd_certfile")).Value.(flag.Getter).Get().(string),
EtcdCAFile: (*flagset.Lookup("etcd_cafile")).Value.(flag.Getter).Get().(string),
PublicIP: (*flagset.Lookup("public_ip")).Value.(flag.Getter).Get().(string),
RawMetadata: (*flagset.Lookup("metadata")).Value.(flag.Getter).Get().(string),
AgentTTL: (*flagset.Lookup("agent_ttl")).Value.(flag.Getter).Get().(string),
VerifyUnits: (*flagset.Lookup("verify_units")).Value.(flag.Getter).Get().(bool),
AuthorizedKeysFile: (*flagset.Lookup("authorized_keys_file")).Value.(flag.Getter).Get().(string),
}
if cfg.VerifyUnits {
log.Warning("WARNING: The signed/verified units feature is DEPRECATED and should not be used. It will be completely removed from fleet and fleetctl.")
}
config.UpdateLoggingFlagsFromConfig(flag.CommandLine, &cfg)
return &cfg, nil
}
// Run periodically attempts to reconcile the provided Agent until the stop
// channel is closed. Run will also reconcile in reaction to calls to Trigger.
// While a reconciliation is being attempted, calls to Trigger are ignored.
func (ar *AgentReconciler) Run(a *Agent, stop chan bool) {
ticker := time.Tick(reconcileInterval)
reconcile := func() {
done := make(chan struct{})
defer close(done)
// While the reconciliation is running, flush the trigger channel in the background
go func() {
for {
select {
case <-done:
return
default:
select {
case <-ar.rTrigger:
case <-done:
return
}
}
}
}()
start := time.Now()
ar.Reconcile(a)
elapsed := time.Now().Sub(start)
msg := fmt.Sprintf("AgentReconciler completed reconciliation in %s", elapsed)
if elapsed > reconcileInterval {
log.Warning(msg)
} else {
log.V(1).Info(msg)
}
}
for {
select {
case <-stop:
log.V(1).Info("AgentReconciler exiting due to stop signal")
return
case <-ticker:
reconcile()
case <-ar.rTrigger:
reconcile()
}
}
}
// Run periodically attempts to reconcile the provided Agent until the stop
// channel is closed. Run will also reconcile in reaction to calls to Trigger.
// While a reconciliation is being attempted, calls to Trigger are ignored.
func (ar *AgentReconciler) Run(a *Agent, stop chan bool) {
ticker := time.Tick(reconcileInterval)
reconcile := func() {
start := time.Now()
ar.Reconcile(a)
elapsed := time.Now().Sub(start)
msg := fmt.Sprintf("AgentReconciler completed reconciliation in %s", elapsed)
if elapsed > reconcileInterval {
log.Warning(msg)
} else {
log.V(1).Info(msg)
}
}
trigger := make(chan struct{})
go func() {
abort := make(chan struct{})
select {
case <-stop:
close(abort)
case <-ar.rStream.Next(abort):
trigger <- struct{}{}
}
}()
for {
select {
case <-stop:
log.V(1).Info("AgentReconciler exiting due to stop signal")
return
case <-ticker:
reconcile()
case <-trigger:
reconcile()
}
}
}