// Receive accepts a Dependency and data for that dep. This data is
// cached on the Runner. This data is then used to determine if a Template
// is "renderable" (i.e. all its Dependencies have been downloaded at least
// once).
func (r *Runner) Receive(d dep.Dependency, data interface{}) {
// Just because we received data, it does not mean that we are actually
// watching for that data. How is that possible you may ask? Well, this
// Runner's data channel is pooled, meaning it accepts multiple data views
// before actually blocking. Whilest this runner is performing a Run() and
// executing diffs, it may be possible that more data was pushed onto the
// data channel pool for a dependency that we no longer care about.
//
// Accepting this dependency would introduce stale data into the brain, and
// that is simply unacceptable. In fact, it is a fun little bug:
//
// https://github.com/hashicorp/consul-template/issues/198
//
// and by "little" bug, I mean really big bug.
if _, ok := r.dependencies[d.HashCode()]; ok {
log.Printf("[DEBUG] (runner) receiving dependency %s", d.Display())
r.brain.Remember(d, data)
}
}
// Remove removes the given dependency from the list and stops the
// associated View. If a View for the given dependency does not exist, this
// function will return false. If the View does exist, this function will return
// true upon successful deletion.
func (w *Watcher) Remove(d dep.Dependency) bool {
w.Lock()
defer w.Unlock()
log.Printf("[INFO] (watcher) removing %s", d.Display())
if view, ok := w.depViewMap[d.HashCode()]; ok {
log.Printf("[DEBUG] (watcher) actually removing %s", d.Display())
view.stop()
delete(w.depViewMap, d.HashCode())
return true
}
log.Printf("[DEBUG] (watcher) %s did not exist, skipping", d.Display())
return false
}
// Add adds the given dependency to the list of monitored depedencies
// and start the associated view. If the dependency already exists, no action is
// taken.
//
// If the Dependency already existed, it this function will return false. If the
// view was successfully created, it will return true. If an error occurs while
// creating the view, it will be returned here (but future errors returned by
// the view will happen on the channel).
func (w *Watcher) Add(d dep.Dependency) (bool, error) {
w.Lock()
defer w.Unlock()
log.Printf("[INFO] (watcher) adding %s", d.Display())
if _, ok := w.depViewMap[d.HashCode()]; ok {
log.Printf("[DEBUG] (watcher) %s already exists, skipping", d.Display())
return false, nil
}
v, err := NewView(w.config, d)
if err != nil {
return false, err
}
log.Printf("[DEBUG] (watcher) %s starting", d.Display())
w.depViewMap[d.HashCode()] = v
go v.poll(w.DataCh, w.ErrCh)
return true, nil
}