open-consul/api/watch/plan.go

255 lines
5.8 KiB
Go
Raw Normal View History

2014-08-20 20:45:34 +00:00
package watch
import (
2019-01-08 16:43:14 +00:00
"context"
2014-08-20 20:45:34 +00:00
"fmt"
"io"
2014-08-20 20:45:34 +00:00
"log"
"reflect"
"time"
consulapi "github.com/hashicorp/consul/api"
"github.com/hashicorp/go-hclog"
2014-08-20 20:45:34 +00:00
)
const (
// retryInterval is the base retry value
retryInterval = 5 * time.Second
// maximum back off time, this is to prevent
// exponential runaway
maxBackoffTime = 180 * time.Second
// Name used with hclog Logger. We do not add this to the logging package
// because we do not want to pull in the root consul module.
watchLoggerName = "watch"
2014-08-20 20:45:34 +00:00
)
func (p *Plan) Run(address string) error {
return p.RunWithConfig(address, nil)
}
2014-08-20 20:45:34 +00:00
// Run is used to run a watch plan
func (p *Plan) RunWithConfig(address string, conf *consulapi.Config) error {
logger := p.Logger
if logger == nil {
logger = newWatchLogger(p.LogOutput)
}
2014-08-20 20:45:34 +00:00
// Setup the client
p.address = address
if conf == nil {
conf = consulapi.DefaultConfigWithLogger(logger)
}
2014-08-20 20:45:34 +00:00
conf.Address = address
conf.Datacenter = p.Datacenter
2014-08-20 23:45:37 +00:00
conf.Token = p.Token
2014-08-20 20:45:34 +00:00
client, err := consulapi.NewClient(conf)
if err != nil {
return fmt.Errorf("Failed to connect to agent: %v", err)
}
return p.RunWithClientAndHclog(client, logger)
}
// RunWithClientAndLogger runs a watch plan using an external client and
// hclog.Logger instance. Using this, the plan's Datacenter, Token and LogOutput
// fields are ignored and the passed client is expected to be configured as
// needed.
func (p *Plan) RunWithClientAndHclog(client *consulapi.Client, logger hclog.Logger) error {
var watchLogger hclog.Logger
if logger == nil {
watchLogger = newWatchLogger(nil)
} else {
watchLogger = logger.Named(watchLoggerName)
}
p.client = client
// Loop until we are canceled
failures := 0
OUTER:
for !p.shouldStop() {
// Invoke the handler
blockParamVal, result, err := p.Watcher(p)
// Check if we should terminate since the function
// could have blocked for a while
if p.shouldStop() {
break
}
// Handle an error in the watch function
if err != nil {
// Perform an exponential backoff
failures++
if blockParamVal == nil {
p.lastParamVal = nil
} else {
p.lastParamVal = blockParamVal.Next(p.lastParamVal)
}
retry := retryInterval * time.Duration(failures*failures)
if retry > maxBackoffTime {
retry = maxBackoffTime
}
watchLogger.Error("Watch errored", "type", p.Type, "error", err, "retry", retry)
select {
case <-time.After(retry):
continue OUTER
case <-p.stopCh:
return nil
}
}
// Clear the failures
failures = 0
// If the index is unchanged do nothing
if p.lastParamVal != nil && p.lastParamVal.Equal(blockParamVal) {
continue
}
// Update the index, look for change
oldParamVal := p.lastParamVal
p.lastParamVal = blockParamVal.Next(oldParamVal)
if oldParamVal != nil && reflect.DeepEqual(p.lastResult, result) {
continue
}
// Handle the updated result
p.lastResult = result
// If a hybrid handler exists use that
if p.HybridHandler != nil {
p.HybridHandler(blockParamVal, result)
} else if p.Handler != nil {
idx, ok := blockParamVal.(WaitIndexVal)
if !ok {
watchLogger.Error("Handler only supports index-based " +
" watches but non index-based watch run. Skipping Handler.")
}
p.Handler(uint64(idx), result)
}
}
return nil
}
//Deprecated: Use RunwithClientAndHclog
func (p *Plan) RunWithClientAndLogger(client *consulapi.Client, logger *log.Logger) error {
p.client = client
2014-08-20 20:45:34 +00:00
// Loop until we are canceled
failures := 0
2014-08-20 22:18:08 +00:00
OUTER:
2014-08-20 20:45:34 +00:00
for !p.shouldStop() {
// Invoke the handler
blockParamVal, result, err := p.Watcher(p)
2014-08-20 20:45:34 +00:00
// Check if we should terminate since the function
// could have blocked for a while
if p.shouldStop() {
break
}
// Handle an error in the watch function
if err != nil {
// Perform an exponential backoff
failures++
if blockParamVal == nil {
p.lastParamVal = nil
} else {
p.lastParamVal = blockParamVal.Next(p.lastParamVal)
}
2014-08-20 20:45:34 +00:00
retry := retryInterval * time.Duration(failures*failures)
if retry > maxBackoffTime {
retry = maxBackoffTime
}
2018-03-21 15:56:14 +00:00
logger.Printf("[ERR] consul.watch: Watch (type: %s) errored: %v, retry in %v",
p.Type, err, retry)
2014-08-20 20:45:34 +00:00
select {
case <-time.After(retry):
2014-08-20 22:18:08 +00:00
continue OUTER
2014-08-20 20:45:34 +00:00
case <-p.stopCh:
return nil
}
}
// Clear the failures
failures = 0
// If the index is unchanged do nothing
if p.lastParamVal != nil && p.lastParamVal.Equal(blockParamVal) {
2014-08-20 20:45:34 +00:00
continue
}
// Update the index, look for change
oldParamVal := p.lastParamVal
p.lastParamVal = blockParamVal.Next(oldParamVal)
if oldParamVal != nil && reflect.DeepEqual(p.lastResult, result) {
2014-08-20 20:45:34 +00:00
continue
}
// Handle the updated result
p.lastResult = result
// If a hybrid handler exists use that
if p.HybridHandler != nil {
p.HybridHandler(blockParamVal, result)
} else if p.Handler != nil {
idx, ok := blockParamVal.(WaitIndexVal)
if !ok {
logger.Printf("[ERR] consul.watch: Handler only supports index-based " +
" watches but non index-based watch run. Skipping Handler.")
}
p.Handler(uint64(idx), result)
2014-08-20 22:18:08 +00:00
}
2014-08-20 20:45:34 +00:00
}
return nil
}
// Stop is used to stop running the watch plan
2017-04-21 00:46:29 +00:00
func (p *Plan) Stop() {
2014-08-20 20:45:34 +00:00
p.stopLock.Lock()
defer p.stopLock.Unlock()
if p.stop {
return
}
p.stop = true
if p.cancelFunc != nil {
p.cancelFunc()
}
2014-08-20 20:45:34 +00:00
close(p.stopCh)
}
2017-04-21 00:46:29 +00:00
func (p *Plan) shouldStop() bool {
2014-08-20 20:45:34 +00:00
select {
case <-p.stopCh:
return true
default:
return false
}
}
2019-01-08 16:43:14 +00:00
func (p *Plan) setCancelFunc(cancel context.CancelFunc) {
p.stopLock.Lock()
defer p.stopLock.Unlock()
if p.shouldStop() {
// The watch is stopped and execute the new cancel func to stop watchFactory
cancel()
return
}
p.cancelFunc = cancel
}
func (p *Plan) IsStopped() bool {
p.stopLock.Lock()
defer p.stopLock.Unlock()
return p.stop
}
func newWatchLogger(output io.Writer) hclog.Logger {
return hclog.New(&hclog.LoggerOptions{
Name: watchLoggerName,
Output: output,
})
}