From fd2d2c035e4cff5b1e05a9c93d045879e3d204cf Mon Sep 17 00:00:00 2001 From: Audrius Butkevicius Date: Tue, 18 Nov 2014 22:57:21 +0000 Subject: [PATCH] Add support for multiple announce servers (fixes #677) Somebody owes me a beer. --- cmd/syncthing/main.go | 4 +- gui/index.html | 23 ++- .../core/controllers/syncthingController.js | 18 +- .../core/directives/popoverDirective.js | 9 + internal/auto/gui.files.go | 11 +- internal/config/config.go | 11 +- internal/config/config_test.go | 6 +- internal/discover/discover.go | 156 ++++++++++++------ internal/model/model.go | 4 +- 9 files changed, 162 insertions(+), 80 deletions(-) create mode 100644 gui/scripts/syncthing/core/directives/popoverDirective.js diff --git a/cmd/syncthing/main.go b/cmd/syncthing/main.go index f8485a25c..28919b496 100644 --- a/cmd/syncthing/main.go +++ b/cmd/syncthing/main.go @@ -826,7 +826,7 @@ func renewUPnP(port int) { if forwardedPort != 0 { externalPort = forwardedPort discoverer.StopGlobal() - discoverer.StartGlobal(opts.GlobalAnnServer, uint16(forwardedPort)) + discoverer.StartGlobal(opts.GlobalAnnServers, uint16(forwardedPort)) if debugNet { l.Debugf("Updated UPnP port mapping for external port %d on device %s.", forwardedPort, igd.FriendlyIdentifier()) } @@ -1098,7 +1098,7 @@ func discovery(extPort int) *discover.Discoverer { if opts.GlobalAnnEnabled { l.Infoln("Starting global discovery announcements") - disc.StartGlobal(opts.GlobalAnnServer, uint16(extPort)) + disc.StartGlobal(opts.GlobalAnnServers, uint16(extPort)) } return disc diff --git a/gui/index.html b/gui/index.html index 4cc4bc9b6..f87c7712c 100644 --- a/gui/index.html +++ b/gui/index.html @@ -203,11 +203,17 @@  CPU Utilization {{system.cpuPercent | alwaysNumber | natural:1}}% - -  Global Discovery Server + +  Global Discovery Servers - Online - Offline + + OK + + + + {{announceServersTotal-announceServersFailed.length}}/{{announceServersTotal}} + + @@ -609,8 +615,8 @@
- - + +
@@ -653,8 +659,8 @@
- - + +
@@ -865,6 +871,7 @@ + diff --git a/gui/scripts/syncthing/core/controllers/syncthingController.js b/gui/scripts/syncthing/core/controllers/syncthingController.js index 90d5945a1..4f95bdb82 100644 --- a/gui/scripts/syncthing/core/controllers/syncthingController.js +++ b/gui/scripts/syncthing/core/controllers/syncthingController.js @@ -245,7 +245,8 @@ angular.module('syncthing.core') var hasConfig = !isEmptyObject($scope.config); $scope.config = config; - $scope.config.Options.ListenStr = $scope.config.Options.ListenAddress.join(', '); + $scope.config.Options.ListenAddressStr = $scope.config.Options.ListenAddress.join(', '); + $scope.config.Options.GlobalAnnServersStr = $scope.config.Options.GlobalAnnServers.join(', '); $scope.devices = $scope.config.Devices; $scope.devices.forEach(function (deviceCfg) { @@ -272,6 +273,14 @@ angular.module('syncthing.core') $http.get(urlbase + '/system').success(function (data) { $scope.myID = data.myID; $scope.system = data; + $scope.announceServersTotal = Object.keys(data.extAnnounceOK).length; + var failed = []; + for (var server in data.extAnnounceOK) { + if (!data.extAnnounceOK[server]) { + failed.push(server); + } + } + $scope.announceServersFailed = failed; console.log("refreshSystem", data); }); } @@ -599,8 +608,11 @@ angular.module('syncthing.core') $scope.thisDevice().Name = $scope.tmpOptions.DeviceName; $scope.config.Options = angular.copy($scope.tmpOptions); $scope.config.GUI = angular.copy($scope.tmpGUI); - $scope.config.Options.ListenAddress = $scope.config.Options.ListenStr.split(',').map(function (x) { - return x.trim(); + + ['ListenAddress', 'GlobalAnnServers'].forEach(function (key) { + $scope.config.Options[key] = $scope.config.Options[key + "Str"].split(/[ ,]+/).map(function (x) { + return x.trim(); + }); }); $scope.saveConfig(); diff --git a/gui/scripts/syncthing/core/directives/popoverDirective.js b/gui/scripts/syncthing/core/directives/popoverDirective.js new file mode 100644 index 000000000..8a83e785e --- /dev/null +++ b/gui/scripts/syncthing/core/directives/popoverDirective.js @@ -0,0 +1,9 @@ +angular.module('syncthing.core') + .directive('popover', function () { + return { + restrict: 'A', + link: function (scope, element, attributes) { + $(element).popover(); + } + }; +}); diff --git a/internal/auto/gui.files.go b/internal/auto/gui.files.go index 009a2b345..7c6d24615 100644 --- a/internal/auto/gui.files.go +++ b/internal/auto/gui.files.go @@ -8,7 +8,7 @@ import ( ) func Assets() map[string][]byte { - var assets = make(map[string][]byte, 51) + var assets = make(map[string][]byte, 52) var bs []byte var gr *gzip.Reader @@ -132,7 +132,7 @@ func Assets() map[string][]byte { bs, _ = ioutil.ReadAll(gr) assets["assets/lang/valid-langs.js"] = bs - bs, _ = base64.StdEncoding.DecodeString("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") + bs, _ = base64.StdEncoding.DecodeString("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") gr, _ = gzip.NewReader(bytes.NewBuffer(bs)) bs, _ = ioutil.ReadAll(gr) assets["index.html"] = bs @@ -162,7 +162,7 @@ func Assets() map[string][]byte { bs, _ = ioutil.ReadAll(gr) assets["scripts/syncthing/core/controllers/eventController.js"] = bs - bs, _ = base64.StdEncoding.DecodeString("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") + bs, _ = base64.StdEncoding.DecodeString("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") gr, _ = gzip.NewReader(bytes.NewBuffer(bs)) bs, _ = ioutil.ReadAll(gr) assets["scripts/syncthing/core/controllers/syncthingController.js"] = bs @@ -177,6 +177,11 @@ func Assets() map[string][]byte { bs, _ = ioutil.ReadAll(gr) assets["scripts/syncthing/core/directives/modalDirective.js"] = bs + bs, _ = base64.StdEncoding.DecodeString("H4sIAAAJbogA/1yOQc6DIBCF955iFn8CJIQD6Oo/isWpJcXBDINJ03j3Ymsa7bfjvY+X6WkssWc3paFE1Co/yMst0Oh8YlSmgYobAqOXsFRhTnNakJWFa6lqSATawPPtbTBKYToEnzALBy8tqH9lT1UMdG8PW9mnGS1gxAlJLPRSf16KYDY/oxt/eheN2w/TpjtZ6/e1ds1ayxcAAAD//wEAAP///ZZiOfIAAAA=") + gr, _ = gzip.NewReader(bytes.NewBuffer(bs)) + bs, _ = ioutil.ReadAll(gr) + assets["scripts/syncthing/core/directives/popoverDirective.js"] = bs + bs, _ = base64.StdEncoding.DecodeString("H4sIAAAJbogA/7SSP28CMQzFdz6Fh0oH0insMLdbV5aqQ3TxcVZDArYDRRXfvQmHgPKnrVT1LSfZfu9+tmLDPHnLZhFd8jisZBsa7SjMTRMZq9EAsowjxkZpnQdSoFXCp+gdclVDm/I8xQDDEXzsh4sYNXE4K/TFVco5E6jC/Dk69FX9pe8pvE3OAqWJS6wB/aIGq8pSQ6PsRxexRaVuHpaWBVlMCtJRq8NT1JpwM7M+4S1zEbWH/xl0pHn9x3eS8r1nKBqPYYMgXUzehUphbT05q3jX0GMK6qxMkm6vzqmcGac3A3b5EoJnpO3eJC/H5V5/gNUOoTcBlvUErGe0bvsH4NZmqO+Jf8tEAn34P93vZvXwUo83vPbuLvJOObvpoDQ/AQAA//8BAAD//3zSfX5DAwAA") gr, _ = gzip.NewReader(bytes.NewBuffer(bs)) bs, _ = ioutil.ReadAll(gr) diff --git a/internal/config/config.go b/internal/config/config.go index 9734d0d69..7355be8c0 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -160,7 +160,7 @@ type FolderDeviceConfiguration struct { type OptionsConfiguration struct { ListenAddress []string `xml:"listenAddress" default:"0.0.0.0:22000"` - GlobalAnnServer string `xml:"globalAnnounceServer" default:"announce.syncthing.net:22026"` + GlobalAnnServers []string `xml:"globalAnnounceServer" default:"announce.syncthing.net:22026"` GlobalAnnEnabled bool `xml:"globalAnnounceEnabled" default:"true"` LocalAnnEnabled bool `xml:"localAnnounceEnabled" default:"true"` LocalAnnPort int `xml:"localAnnouncePort" default:"21025"` @@ -239,8 +239,6 @@ func (cfg *Configuration) WriteXML(w io.Writer) error { func (cfg *Configuration) prepare(myID protocol.DeviceID) { fillNilSlices(&cfg.Options) - cfg.Options.ListenAddress = uniqueStrings(cfg.Options.ListenAddress) - // Initialize an empty slice for folders if the config has none if cfg.Folders == nil { cfg.Folders = []FolderConfiguration{} @@ -362,6 +360,9 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) { n.Addresses = []string{"dynamic"} } } + + cfg.Options.ListenAddress = uniqueStrings(cfg.Options.ListenAddress) + cfg.Options.GlobalAnnServers = uniqueStrings(cfg.Options.GlobalAnnServers) } // ChangeRequiresRestart returns true if updating the configuration requires a @@ -469,8 +470,8 @@ func convertV2V3(cfg *Configuration) { // The global discovery format and port number changed in v0.9. Having the // default announce server but old port number is guaranteed to be legacy. - if cfg.Options.GlobalAnnServer == "announce.syncthing.net:22025" { - cfg.Options.GlobalAnnServer = "announce.syncthing.net:22026" + if len(cfg.Options.GlobalAnnServers) == 1 && cfg.Options.GlobalAnnServers[0] == "announce.syncthing.net:22025" { + cfg.Options.GlobalAnnServers = []string{"announce.syncthing.net:22026"} } cfg.Version = 3 diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 426aacfe2..982b8bfd4 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -36,7 +36,7 @@ func init() { func TestDefaultValues(t *testing.T) { expected := OptionsConfiguration{ ListenAddress: []string{"0.0.0.0:22000"}, - GlobalAnnServer: "announce.syncthing.net:22026", + GlobalAnnServers: []string{"announce.syncthing.net:22026"}, GlobalAnnEnabled: true, LocalAnnEnabled: true, LocalAnnPort: 21025, @@ -138,7 +138,7 @@ func TestNoListenAddress(t *testing.T) { func TestOverriddenValues(t *testing.T) { expected := OptionsConfiguration{ ListenAddress: []string{":23000"}, - GlobalAnnServer: "syncthing.nym.se:22026", + GlobalAnnServers: []string{"syncthing.nym.se:22026"}, GlobalAnnEnabled: false, LocalAnnEnabled: false, LocalAnnPort: 42123, @@ -163,7 +163,7 @@ func TestOverriddenValues(t *testing.T) { } if !reflect.DeepEqual(cfg.Options(), expected) { - t.Errorf("Overridden config differs;\n E: %#v\n A: %#v", expected, cfg.Options) + t.Errorf("Overridden config differs;\n E: %#v\n A: %#v", expected, cfg.Options()) } } diff --git a/internal/discover/discover.go b/internal/discover/discover.go index 2e65bbf11..92fd73763 100644 --- a/internal/discover/discover.go +++ b/internal/discover/discover.go @@ -42,13 +42,13 @@ type Discoverer struct { multicastBeacon beacon.Interface registry map[protocol.DeviceID][]CacheEntry registryLock sync.RWMutex - extServer string + extServers []string extPort uint16 localBcastTick <-chan time.Time stopGlobal chan struct{} globalWG sync.WaitGroup forcedBcastTick chan time.Time - extAnnounceOK bool + extAnnounceOK map[string]bool extAnnounceOKmut sync.Mutex } @@ -70,6 +70,7 @@ func NewDiscoverer(id protocol.DeviceID, addresses []string) *Discoverer { errorRetryIntv: 60 * time.Second, cacheLifetime: 5 * time.Minute, registry: make(map[protocol.DeviceID][]CacheEntry), + extAnnounceOK: make(map[string]bool), } } @@ -110,14 +111,26 @@ func (d *Discoverer) StartLocal(localPort int, localMCAddr string) { } } -func (d *Discoverer) StartGlobal(server string, extPort uint16) { +func (d *Discoverer) StartGlobal(servers []string, extPort uint16) { // Wait for any previous announcer to stop before starting a new one. d.globalWG.Wait() - d.extServer = server + d.extServers = servers d.extPort = extPort d.stopGlobal = make(chan struct{}) d.globalWG.Add(1) - go d.sendExternalAnnouncements() + go func() { + defer d.globalWG.Done() + + buf := d.announcementPkt() + + for _, extServer := range d.extServers { + d.globalWG.Add(1) + go func(server string) { + d.sendExternalAnnouncements(server, buf) + d.globalWG.Done() + }(extServer) + } + }() } func (d *Discoverer) StopGlobal() { @@ -127,7 +140,7 @@ func (d *Discoverer) StopGlobal() { } } -func (d *Discoverer) ExtAnnounceOK() bool { +func (d *Discoverer) ExtAnnounceOK() map[string]bool { d.extAnnounceOKmut.Lock() defer d.extAnnounceOKmut.Unlock() return d.extAnnounceOK @@ -144,7 +157,7 @@ func (d *Discoverer) Lookup(device protocol.DeviceID) []string { addrs[i] = cached[i].Address } return addrs - } else if len(d.extServer) != 0 && time.Since(d.localBcastStart) > d.localBcastIntv { + } else if len(d.extServers) != 0 && time.Since(d.localBcastStart) > d.localBcastIntv { // Only perform external lookups if we have at least one external // server and one local announcement interval has passed. This is to // avoid finding local peers on their remote address at startup. @@ -188,20 +201,24 @@ func (d *Discoverer) All() map[protocol.DeviceID][]CacheEntry { func (d *Discoverer) announcementPkt() []byte { var addrs []Address - for _, astr := range d.listenAddrs { - addr, err := net.ResolveTCPAddr("tcp", astr) - if err != nil { - l.Warnln("%v: not announcing %s", err, astr) - continue - } else if debug { - l.Debugf("discover: announcing %s: %#v", astr, addr) - } - if len(addr.IP) == 0 || addr.IP.IsUnspecified() { - addrs = append(addrs, Address{Port: uint16(addr.Port)}) - } else if bs := addr.IP.To4(); bs != nil { - addrs = append(addrs, Address{IP: bs, Port: uint16(addr.Port)}) - } else if bs := addr.IP.To16(); bs != nil { - addrs = append(addrs, Address{IP: bs, Port: uint16(addr.Port)}) + if d.extPort != 0 { + addrs = []Address{{Port: d.extPort}} + } else { + for _, astr := range d.listenAddrs { + addr, err := net.ResolveTCPAddr("tcp", astr) + if err != nil { + l.Warnln("%v: not announcing %s", err, astr) + continue + } else if debug { + l.Debugf("discover: announcing %s: %#v", astr, addr) + } + if len(addr.IP) == 0 || addr.IP.IsUnspecified() { + addrs = append(addrs, Address{Port: uint16(addr.Port)}) + } else if bs := addr.IP.To4(); bs != nil { + addrs = append(addrs, Address{IP: bs, Port: uint16(addr.Port)}) + } else if bs := addr.IP.To16(); bs != nil { + addrs = append(addrs, Address{IP: bs, Port: uint16(addr.Port)}) + } } } var pkt = Announce{ @@ -235,44 +252,43 @@ func (d *Discoverer) sendLocalAnnouncements() { } } -func (d *Discoverer) sendExternalAnnouncements() { - defer d.globalWG.Done() - - remote, err := net.ResolveUDPAddr("udp", d.extServer) - for err != nil { - l.Warnf("Global discovery: %v; trying again in %v", err, d.errorRetryIntv) - time.Sleep(d.errorRetryIntv) - remote, err = net.ResolveUDPAddr("udp", d.extServer) - } +func (d *Discoverer) sendExternalAnnouncements(extServer string, buf []byte) { + timer := time.NewTimer(0) conn, err := net.ListenUDP("udp", nil) for err != nil { + timer.Reset(d.errorRetryIntv) l.Warnf("Global discovery: %v; trying again in %v", err, d.errorRetryIntv) - time.Sleep(d.errorRetryIntv) + select { + case <-d.stopGlobal: + return + case <-timer.C: + } conn, err = net.ListenUDP("udp", nil) } - var buf []byte - if d.extPort != 0 { - var pkt = Announce{ - Magic: AnnouncementMagic, - This: Device{d.myID[:], []Address{{Port: d.extPort}}}, + remote, err := net.ResolveUDPAddr("udp", extServer) + for err != nil { + timer.Reset(d.errorRetryIntv) + l.Warnf("Global discovery: %s: %v; trying again in %v", extServer, err, d.errorRetryIntv) + select { + case <-d.stopGlobal: + return + case <-timer.C: } - buf = pkt.MustMarshalXDR() - } else { - buf = d.announcementPkt() + remote, err = net.ResolveUDPAddr("udp", extServer) } // Delay the first announcement until after a full local announcement // cycle, to increase the chance of other peers finding us locally first. - nextAnnouncement := time.NewTimer(d.localBcastIntv) + timer.Reset(d.localBcastIntv) for { select { case <-d.stopGlobal: return - case <-nextAnnouncement.C: + case <-timer.C: var ok bool if debug { @@ -282,28 +298,29 @@ func (d *Discoverer) sendExternalAnnouncements() { _, err := conn.WriteTo(buf, remote) if err != nil { if debug { - l.Debugln("discover: warning:", err) + l.Debugln("discover: %s: warning:", extServer, err) } ok = false } else { // Verify that the announce server responds positively for our device ID time.Sleep(1 * time.Second) - res := d.externalLookup(d.myID) + res := d.externalLookupOnServer(extServer, d.myID) + if debug { - l.Debugln("discover: external lookup check:", res) + l.Debugln("discover:", extServer, "external lookup check:", res) } ok = len(res) > 0 } d.extAnnounceOKmut.Lock() - d.extAnnounceOK = ok + d.extAnnounceOK[extServer] = ok d.extAnnounceOKmut.Unlock() if ok { - nextAnnouncement.Reset(d.globalBcastIntv) + timer.Reset(d.globalBcastIntv) } else { - nextAnnouncement.Reset(d.errorRetryIntv) + timer.Reset(d.errorRetryIntv) } } } @@ -390,10 +407,39 @@ func (d *Discoverer) registerDevice(addr net.Addr, device Device) bool { } func (d *Discoverer) externalLookup(device protocol.DeviceID) []string { - extIP, err := net.ResolveUDPAddr("udp", d.extServer) + // Buffer up to as many answers as we have servers to query. + results := make(chan []string, len(d.extServers)) + + // Query all servers. + wg := sync.WaitGroup{} + for _, extServer := range d.extServers { + wg.Add(1) + go func(server string) { + result := d.externalLookupOnServer(server, device) + if debug { + l.Debugln("discover:", result, "from", server, "for", device) + } + results <- result + wg.Done() + }(extServer) + } + + wg.Wait() + close(results) + + addrs := []string{} + for result := range results { + addrs = append(addrs, result...) + } + + return addrs +} + +func (d *Discoverer) externalLookupOnServer(extServer string, device protocol.DeviceID) []string { + extIP, err := net.ResolveUDPAddr("udp", extServer) if err != nil { if debug { - l.Debugf("discover: %v; no external lookup", err) + l.Debugf("discover: %s: %v; no external lookup", extServer, err) } return nil } @@ -401,7 +447,7 @@ func (d *Discoverer) externalLookup(device protocol.DeviceID) []string { conn, err := net.DialUDP("udp", nil, extIP) if err != nil { if debug { - l.Debugf("discover: %v; no external lookup", err) + l.Debugf("discover: %s: %v; no external lookup", extServer, err) } return nil } @@ -410,7 +456,7 @@ func (d *Discoverer) externalLookup(device protocol.DeviceID) []string { err = conn.SetDeadline(time.Now().Add(5 * time.Second)) if err != nil { if debug { - l.Debugf("discover: %v; no external lookup", err) + l.Debugf("discover: %s: %v; no external lookup", extServer, err) } return nil } @@ -419,7 +465,7 @@ func (d *Discoverer) externalLookup(device protocol.DeviceID) []string { _, err = conn.Write(buf) if err != nil { if debug { - l.Debugf("discover: %v; no external lookup", err) + l.Debugf("discover: %s: %v; no external lookup", extServer, err) } return nil } @@ -432,20 +478,20 @@ func (d *Discoverer) externalLookup(device protocol.DeviceID) []string { return nil } if debug { - l.Debugf("discover: %v; no external lookup", err) + l.Debugf("discover: %s: %v; no external lookup", extServer, err) } return nil } if debug { - l.Debugf("discover: read external:\n%s", hex.Dump(buf[:n])) + l.Debugf("discover: %s: read external:\n%s", extServer, hex.Dump(buf[:n])) } var pkt Announce err = pkt.UnmarshalXDR(buf[:n]) if err != nil && err != io.EOF { if debug { - l.Debugln("discover:", err) + l.Debugln("discover:", extServer, err) } return nil } diff --git a/internal/model/model.go b/internal/model/model.go index efe16bb86..5bbd7dded 100644 --- a/internal/model/model.go +++ b/internal/model/model.go @@ -1125,7 +1125,9 @@ func (m *Model) ScanFolderSub(folder, sub string) error { if (ignores != nil && ignores.Match(f.Name)) || symlinkInvalid(f.IsSymlink()) { // File has been ignored or an unsupported symlink. Set invalid bit. - l.Debugln("setting invalid bit on ignored", f) + if debug { + l.Debugln("setting invalid bit on ignored", f) + } nf := protocol.FileInfo{ Name: f.Name, Flags: f.Flags | protocol.FlagInvalid,