github.com/kobeld/docker@v1.12.0-rc1/daemon/discovery.go (about) 1 package daemon 2 3 import ( 4 "errors" 5 "fmt" 6 "reflect" 7 "strconv" 8 "time" 9 10 log "github.com/Sirupsen/logrus" 11 "github.com/docker/docker/pkg/discovery" 12 13 // Register the libkv backends for discovery. 14 _ "github.com/docker/docker/pkg/discovery/kv" 15 ) 16 17 const ( 18 // defaultDiscoveryHeartbeat is the default value for discovery heartbeat interval. 19 defaultDiscoveryHeartbeat = 20 * time.Second 20 // defaultDiscoveryTTLFactor is the default TTL factor for discovery 21 defaultDiscoveryTTLFactor = 3 22 ) 23 24 var errDiscoveryDisabled = errors.New("discovery is disabled") 25 26 type discoveryReloader interface { 27 discovery.Watcher 28 Stop() 29 Reload(backend, address string, clusterOpts map[string]string) error 30 ReadyCh() <-chan struct{} 31 } 32 33 type daemonDiscoveryReloader struct { 34 backend discovery.Backend 35 ticker *time.Ticker 36 term chan bool 37 readyCh chan struct{} 38 } 39 40 func (d *daemonDiscoveryReloader) Watch(stopCh <-chan struct{}) (<-chan discovery.Entries, <-chan error) { 41 return d.backend.Watch(stopCh) 42 } 43 44 func (d *daemonDiscoveryReloader) ReadyCh() <-chan struct{} { 45 return d.readyCh 46 } 47 48 func discoveryOpts(clusterOpts map[string]string) (time.Duration, time.Duration, error) { 49 var ( 50 heartbeat = defaultDiscoveryHeartbeat 51 ttl = defaultDiscoveryTTLFactor * defaultDiscoveryHeartbeat 52 ) 53 54 if hb, ok := clusterOpts["discovery.heartbeat"]; ok { 55 h, err := strconv.Atoi(hb) 56 if err != nil { 57 return time.Duration(0), time.Duration(0), err 58 } 59 heartbeat = time.Duration(h) * time.Second 60 ttl = defaultDiscoveryTTLFactor * heartbeat 61 } 62 63 if tstr, ok := clusterOpts["discovery.ttl"]; ok { 64 t, err := strconv.Atoi(tstr) 65 if err != nil { 66 return time.Duration(0), time.Duration(0), err 67 } 68 ttl = time.Duration(t) * time.Second 69 70 if _, ok := clusterOpts["discovery.heartbeat"]; !ok { 71 h := int(t / defaultDiscoveryTTLFactor) 72 heartbeat = time.Duration(h) * time.Second 73 } 74 75 if ttl <= heartbeat { 76 return time.Duration(0), time.Duration(0), 77 fmt.Errorf("discovery.ttl timer must be greater than discovery.heartbeat") 78 } 79 } 80 81 return heartbeat, ttl, nil 82 } 83 84 // initDiscovery initializes the nodes discovery subsystem by connecting to the specified backend 85 // and starts a registration loop to advertise the current node under the specified address. 86 func initDiscovery(backendAddress, advertiseAddress string, clusterOpts map[string]string) (discoveryReloader, error) { 87 heartbeat, backend, err := parseDiscoveryOptions(backendAddress, clusterOpts) 88 if err != nil { 89 return nil, err 90 } 91 92 reloader := &daemonDiscoveryReloader{ 93 backend: backend, 94 ticker: time.NewTicker(heartbeat), 95 term: make(chan bool), 96 readyCh: make(chan struct{}), 97 } 98 // We call Register() on the discovery backend in a loop for the whole lifetime of the daemon, 99 // but we never actually Watch() for nodes appearing and disappearing for the moment. 100 go reloader.advertiseHeartbeat(advertiseAddress) 101 return reloader, nil 102 } 103 104 // advertiseHeartbeat registers the current node against the discovery backend using the specified 105 // address. The function never returns, as registration against the backend comes with a TTL and 106 // requires regular heartbeats. 107 func (d *daemonDiscoveryReloader) advertiseHeartbeat(address string) { 108 var ready bool 109 if err := d.initHeartbeat(address); err == nil { 110 ready = true 111 close(d.readyCh) 112 } 113 114 for { 115 select { 116 case <-d.ticker.C: 117 if err := d.backend.Register(address); err != nil { 118 log.Warnf("Registering as %q in discovery failed: %v", address, err) 119 } else { 120 if !ready { 121 close(d.readyCh) 122 ready = true 123 } 124 } 125 case <-d.term: 126 return 127 } 128 } 129 } 130 131 // initHeartbeat is used to do the first heartbeat. It uses a tight loop until 132 // either the timeout period is reached or the heartbeat is successful and returns. 133 func (d *daemonDiscoveryReloader) initHeartbeat(address string) error { 134 // Setup a short ticker until the first heartbeat has succeeded 135 t := time.NewTicker(500 * time.Millisecond) 136 defer t.Stop() 137 // timeout makes sure that after a period of time we stop being so aggressive trying to reach the discovery service 138 timeout := time.After(60 * time.Second) 139 140 for { 141 select { 142 case <-timeout: 143 return errors.New("timeout waiting for initial discovery") 144 case <-d.term: 145 return errors.New("terminated") 146 case <-t.C: 147 if err := d.backend.Register(address); err == nil { 148 return nil 149 } 150 } 151 } 152 } 153 154 // Reload makes the watcher to stop advertising and reconfigures it to advertise in a new address. 155 func (d *daemonDiscoveryReloader) Reload(backendAddress, advertiseAddress string, clusterOpts map[string]string) error { 156 d.Stop() 157 158 heartbeat, backend, err := parseDiscoveryOptions(backendAddress, clusterOpts) 159 if err != nil { 160 return err 161 } 162 163 d.backend = backend 164 d.ticker = time.NewTicker(heartbeat) 165 d.readyCh = make(chan struct{}) 166 167 go d.advertiseHeartbeat(advertiseAddress) 168 return nil 169 } 170 171 // Stop terminates the discovery advertising. 172 func (d *daemonDiscoveryReloader) Stop() { 173 d.ticker.Stop() 174 d.term <- true 175 } 176 177 func parseDiscoveryOptions(backendAddress string, clusterOpts map[string]string) (time.Duration, discovery.Backend, error) { 178 heartbeat, ttl, err := discoveryOpts(clusterOpts) 179 if err != nil { 180 return 0, nil, err 181 } 182 183 backend, err := discovery.New(backendAddress, heartbeat, ttl, clusterOpts) 184 if err != nil { 185 return 0, nil, err 186 } 187 return heartbeat, backend, nil 188 } 189 190 // modifiedDiscoverySettings returns whether the discovery configuration has been modified or not. 191 func modifiedDiscoverySettings(config *Config, backendType, advertise string, clusterOpts map[string]string) bool { 192 if config.ClusterStore != backendType || config.ClusterAdvertise != advertise { 193 return true 194 } 195 196 if (config.ClusterOpts == nil && clusterOpts == nil) || 197 (config.ClusterOpts == nil && len(clusterOpts) == 0) || 198 (len(config.ClusterOpts) == 0 && clusterOpts == nil) { 199 return false 200 } 201 202 return !reflect.DeepEqual(config.ClusterOpts, clusterOpts) 203 }