2014-11-16 21:13:20 +01:00
|
|
|
// Copyright (C) 2014 The Syncthing Authors.
|
2014-09-29 21:43:32 +02:00
|
|
|
//
|
2015-03-07 21:36:35 +01:00
|
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
|
|
// You can obtain one at http://mozilla.org/MPL/2.0/.
|
2014-06-01 22:50:14 +02:00
|
|
|
|
2014-05-15 05:40:17 +02:00
|
|
|
// Package config implements reading and writing of the syncthing configuration file.
|
2014-05-15 02:18:09 +02:00
|
|
|
package config
|
2014-03-02 23:58:14 +01:00
|
|
|
|
|
|
|
import (
|
2015-11-04 21:30:47 +01:00
|
|
|
"encoding/json"
|
2014-03-02 23:58:14 +01:00
|
|
|
"encoding/xml"
|
2014-10-06 09:25:45 +02:00
|
|
|
"io"
|
2014-04-22 11:46:08 +02:00
|
|
|
"os"
|
2014-03-02 23:58:14 +01:00
|
|
|
"sort"
|
2015-03-07 20:48:53 +01:00
|
|
|
"strings"
|
2014-04-19 13:33:51 +02:00
|
|
|
|
2015-09-22 19:38:46 +02:00
|
|
|
"github.com/syncthing/syncthing/lib/protocol"
|
2016-03-25 21:22:29 +01:00
|
|
|
"github.com/syncthing/syncthing/lib/util"
|
2014-03-02 23:58:14 +01:00
|
|
|
)
|
|
|
|
|
2015-04-04 21:49:15 +02:00
|
|
|
const (
|
2015-10-27 11:46:33 +01:00
|
|
|
OldestHandledVersion = 10
|
2016-04-03 21:18:16 +02:00
|
|
|
CurrentVersion = 13
|
2015-06-20 20:21:05 +02:00
|
|
|
MaxRescanIntervalS = 365 * 24 * 60 * 60
|
2015-04-04 21:49:15 +02:00
|
|
|
)
|
2014-10-08 13:52:05 +02:00
|
|
|
|
2015-09-20 15:30:25 +02:00
|
|
|
var (
|
2015-11-09 15:35:14 +01:00
|
|
|
// DefaultDiscoveryServersV4 should be substituted when the configuration
|
|
|
|
// contains <globalAnnounceServer>default-v4</globalAnnounceServer>. This is
|
2015-09-20 15:30:25 +02:00
|
|
|
// done by the "consumer" of the configuration, as we don't want these
|
|
|
|
// saved to the config.
|
2015-11-09 15:35:14 +01:00
|
|
|
DefaultDiscoveryServersV4 = []string{
|
2015-09-20 22:30:31 +02:00
|
|
|
"https://discovery-v4-1.syncthing.net/?id=SR7AARM-TCBUZ5O-VFAXY4D-CECGSDE-3Q6IZ4G-XG7AH75-OBIXJQV-QJ6NLQA", // 194.126.249.5, Sweden
|
2015-11-09 13:58:44 +01:00
|
|
|
"https://discovery-v4-2.syncthing.net/?id=DVU36WY-H3LVZHW-E6LLFRE-YAFN5EL-HILWRYP-OC2M47J-Z4PE62Y-ADIBDQC", // 45.55.230.38, USA
|
2015-12-01 11:14:54 +01:00
|
|
|
"https://discovery-v4-3.syncthing.net/?id=VK6HNJ3-VVMM66S-HRVWSCR-IXEHL2H-U4AQ4MW-UCPQBWX-J2L2UBK-NVZRDQZ", // 128.199.95.124, Singapore
|
2015-11-09 15:35:14 +01:00
|
|
|
}
|
|
|
|
// DefaultDiscoveryServersV6 should be substituted when the configuration
|
|
|
|
// contains <globalAnnounceServer>default-v6</globalAnnounceServer>.
|
|
|
|
DefaultDiscoveryServersV6 = []string{
|
2015-09-20 22:30:31 +02:00
|
|
|
"https://discovery-v6-1.syncthing.net/?id=SR7AARM-TCBUZ5O-VFAXY4D-CECGSDE-3Q6IZ4G-XG7AH75-OBIXJQV-QJ6NLQA", // 2001:470:28:4d6::5, Sweden
|
2015-11-09 13:58:44 +01:00
|
|
|
"https://discovery-v6-2.syncthing.net/?id=DVU36WY-H3LVZHW-E6LLFRE-YAFN5EL-HILWRYP-OC2M47J-Z4PE62Y-ADIBDQC", // 2604:a880:800:10::182:a001, USA
|
2015-12-01 11:14:54 +01:00
|
|
|
"https://discovery-v6-3.syncthing.net/?id=VK6HNJ3-VVMM66S-HRVWSCR-IXEHL2H-U4AQ4MW-UCPQBWX-J2L2UBK-NVZRDQZ", // 2400:6180:0:d0::d9:d001, Singapore
|
2015-09-20 15:30:25 +02:00
|
|
|
}
|
2015-11-09 15:35:14 +01:00
|
|
|
// DefaultDiscoveryServers should be substituted when the configuration
|
|
|
|
// contains <globalAnnounceServer>default</globalAnnounceServer>.
|
|
|
|
DefaultDiscoveryServers = append(DefaultDiscoveryServersV4, DefaultDiscoveryServersV6...)
|
2016-01-10 16:37:31 +01:00
|
|
|
|
|
|
|
// DefaultTheme is the default and fallback theme for the web UI.
|
|
|
|
DefaultTheme = "default"
|
2015-09-20 15:30:25 +02:00
|
|
|
)
|
|
|
|
|
2015-10-27 12:04:51 +01:00
|
|
|
func New(myID protocol.DeviceID) Configuration {
|
|
|
|
var cfg Configuration
|
|
|
|
cfg.Version = CurrentVersion
|
|
|
|
cfg.OriginalVersion = CurrentVersion
|
|
|
|
|
2016-03-25 21:22:29 +01:00
|
|
|
util.SetDefaults(&cfg)
|
|
|
|
util.SetDefaults(&cfg.Options)
|
|
|
|
util.SetDefaults(&cfg.GUI)
|
2015-10-27 12:04:51 +01:00
|
|
|
|
|
|
|
cfg.prepare(myID)
|
|
|
|
|
|
|
|
return cfg
|
|
|
|
}
|
|
|
|
|
|
|
|
func ReadXML(r io.Reader, myID protocol.DeviceID) (Configuration, error) {
|
|
|
|
var cfg Configuration
|
|
|
|
|
2016-03-25 21:22:29 +01:00
|
|
|
util.SetDefaults(&cfg)
|
|
|
|
util.SetDefaults(&cfg.Options)
|
|
|
|
util.SetDefaults(&cfg.GUI)
|
2015-10-27 12:04:51 +01:00
|
|
|
|
|
|
|
err := xml.NewDecoder(r).Decode(&cfg)
|
|
|
|
cfg.OriginalVersion = cfg.Version
|
|
|
|
|
|
|
|
cfg.prepare(myID)
|
|
|
|
return cfg, err
|
|
|
|
}
|
|
|
|
|
2015-11-04 21:30:47 +01:00
|
|
|
func ReadJSON(r io.Reader, myID protocol.DeviceID) (Configuration, error) {
|
|
|
|
var cfg Configuration
|
|
|
|
|
2016-03-25 21:22:29 +01:00
|
|
|
util.SetDefaults(&cfg)
|
|
|
|
util.SetDefaults(&cfg.Options)
|
|
|
|
util.SetDefaults(&cfg.GUI)
|
2015-11-04 21:30:47 +01:00
|
|
|
|
|
|
|
err := json.NewDecoder(r).Decode(&cfg)
|
|
|
|
cfg.OriginalVersion = cfg.Version
|
|
|
|
|
|
|
|
cfg.prepare(myID)
|
|
|
|
return cfg, err
|
|
|
|
}
|
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
type Configuration struct {
|
2015-03-10 23:45:43 +01:00
|
|
|
Version int `xml:"version,attr" json:"version"`
|
|
|
|
Folders []FolderConfiguration `xml:"folder" json:"folders"`
|
|
|
|
Devices []DeviceConfiguration `xml:"device" json:"devices"`
|
|
|
|
GUI GUIConfiguration `xml:"gui" json:"gui"`
|
|
|
|
Options OptionsConfiguration `xml:"options" json:"options"`
|
|
|
|
IgnoredDevices []protocol.DeviceID `xml:"ignoredDevice" json:"ignoredDevices"`
|
2014-12-28 00:12:12 +01:00
|
|
|
XMLName xml.Name `xml:"configuration" json:"-"`
|
2014-09-28 14:22:39 +02:00
|
|
|
|
2015-04-04 21:49:15 +02:00
|
|
|
OriginalVersion int `xml:"-" json:"-"` // The version we read from disk, before any conversion
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
|
2015-04-28 22:32:10 +02:00
|
|
|
func (cfg Configuration) Copy() Configuration {
|
|
|
|
newCfg := cfg
|
2015-04-05 17:36:52 +02:00
|
|
|
|
|
|
|
// Deep copy FolderConfigurations
|
2015-04-28 22:32:10 +02:00
|
|
|
newCfg.Folders = make([]FolderConfiguration, len(cfg.Folders))
|
|
|
|
for i := range newCfg.Folders {
|
|
|
|
newCfg.Folders[i] = cfg.Folders[i].Copy()
|
2015-04-05 17:36:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Deep copy DeviceConfigurations
|
2015-04-28 22:32:10 +02:00
|
|
|
newCfg.Devices = make([]DeviceConfiguration, len(cfg.Devices))
|
|
|
|
for i := range newCfg.Devices {
|
|
|
|
newCfg.Devices[i] = cfg.Devices[i].Copy()
|
2015-04-05 17:36:52 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 22:32:10 +02:00
|
|
|
newCfg.Options = cfg.Options.Copy()
|
2015-04-05 17:36:52 +02:00
|
|
|
|
|
|
|
// DeviceIDs are values
|
2015-04-28 22:32:10 +02:00
|
|
|
newCfg.IgnoredDevices = make([]protocol.DeviceID, len(cfg.IgnoredDevices))
|
|
|
|
copy(newCfg.IgnoredDevices, cfg.IgnoredDevices)
|
2015-04-05 17:36:52 +02:00
|
|
|
|
2015-04-28 22:32:10 +02:00
|
|
|
return newCfg
|
2015-04-05 17:36:52 +02:00
|
|
|
}
|
|
|
|
|
2014-10-06 09:25:45 +02:00
|
|
|
func (cfg *Configuration) WriteXML(w io.Writer) error {
|
|
|
|
e := xml.NewEncoder(w)
|
|
|
|
e.Indent("", " ")
|
|
|
|
err := e.Encode(cfg)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
_, err = w.Write([]byte("\n"))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
func (cfg *Configuration) prepare(myID protocol.DeviceID) {
|
2016-03-25 21:22:29 +01:00
|
|
|
util.FillNilSlices(&cfg.Options)
|
2014-03-04 11:25:10 +01:00
|
|
|
|
2015-11-04 21:30:47 +01:00
|
|
|
// Initialize any empty slices
|
2014-09-28 13:00:38 +02:00
|
|
|
if cfg.Folders == nil {
|
|
|
|
cfg.Folders = []FolderConfiguration{}
|
2014-05-13 04:57:38 +02:00
|
|
|
}
|
2014-12-28 00:12:12 +01:00
|
|
|
if cfg.IgnoredDevices == nil {
|
|
|
|
cfg.IgnoredDevices = []protocol.DeviceID{}
|
|
|
|
}
|
2015-10-27 12:04:51 +01:00
|
|
|
if cfg.Options.AlwaysLocalNets == nil {
|
|
|
|
cfg.Options.AlwaysLocalNets = []string{}
|
|
|
|
}
|
2014-05-13 04:57:38 +02:00
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
// Check for missing, bad or duplicate folder ID:s
|
|
|
|
var seenFolders = map[string]*FolderConfiguration{}
|
|
|
|
for i := range cfg.Folders {
|
|
|
|
folder := &cfg.Folders[i]
|
2015-11-05 09:01:47 +01:00
|
|
|
folder.prepare()
|
2015-06-20 20:21:05 +02:00
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
if seen, ok := seenFolders[folder.ID]; ok {
|
|
|
|
l.Warnf("Multiple folders with ID %q; disabling", folder.ID)
|
|
|
|
seen.Invalid = "duplicate folder ID"
|
|
|
|
folder.Invalid = "duplicate folder ID"
|
2014-04-27 21:53:27 +02:00
|
|
|
} else {
|
2014-09-28 13:00:38 +02:00
|
|
|
seenFolders[folder.ID] = folder
|
2014-03-29 18:53:48 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-25 21:22:29 +01:00
|
|
|
cfg.Options.ListenAddress = util.UniqueStrings(cfg.Options.ListenAddress)
|
|
|
|
cfg.Options.GlobalAnnServers = util.UniqueStrings(cfg.Options.GlobalAnnServers)
|
2015-06-23 14:55:30 +02:00
|
|
|
|
2015-11-05 09:31:36 +01:00
|
|
|
if cfg.Version > 0 && cfg.Version < OldestHandledVersion {
|
2015-04-04 21:49:15 +02:00
|
|
|
l.Warnf("Configuration version %d is deprecated. Attempting best effort conversion, but please verify manually.", cfg.Version)
|
2014-06-17 23:22:19 +02:00
|
|
|
}
|
|
|
|
|
2015-03-07 20:48:53 +01:00
|
|
|
// Upgrade configuration versions as appropriate
|
2015-10-27 11:46:33 +01:00
|
|
|
if cfg.Version <= 10 {
|
2015-07-16 12:52:36 +02:00
|
|
|
convertV10V11(cfg)
|
|
|
|
}
|
2015-06-23 14:55:30 +02:00
|
|
|
if cfg.Version == 11 {
|
|
|
|
convertV11V12(cfg)
|
|
|
|
}
|
2016-04-03 21:18:16 +02:00
|
|
|
if cfg.Version == 12 {
|
|
|
|
convertV12V13(cfg)
|
|
|
|
}
|
2014-11-20 22:24:11 +01:00
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
// Build a list of available devices
|
|
|
|
existingDevices := make(map[protocol.DeviceID]bool)
|
|
|
|
for _, device := range cfg.Devices {
|
|
|
|
existingDevices[device.DeviceID] = true
|
2014-07-22 23:27:00 +02:00
|
|
|
}
|
|
|
|
|
2014-10-06 21:43:38 +02:00
|
|
|
// Ensure this device is present in the config
|
|
|
|
if !existingDevices[myID] {
|
2014-08-17 00:20:21 +02:00
|
|
|
myName, _ := os.Hostname()
|
2014-09-28 13:00:38 +02:00
|
|
|
cfg.Devices = append(cfg.Devices, DeviceConfiguration{
|
|
|
|
DeviceID: myID,
|
2014-09-28 13:05:25 +02:00
|
|
|
Name: myName,
|
2014-08-17 00:20:21 +02:00
|
|
|
})
|
2014-10-06 21:43:38 +02:00
|
|
|
existingDevices[myID] = true
|
2014-08-17 00:20:21 +02:00
|
|
|
}
|
2014-10-06 21:28:16 +02:00
|
|
|
|
2015-12-31 09:17:17 +01:00
|
|
|
// Ensure that the device list is free from duplicates
|
|
|
|
cfg.Devices = ensureNoDuplicateDevices(cfg.Devices)
|
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
sort.Sort(DeviceConfigurationList(cfg.Devices))
|
|
|
|
// Ensure that any loose devices are not present in the wrong places
|
|
|
|
// Ensure that there are no duplicate devices
|
2014-11-23 19:43:49 +01:00
|
|
|
// Ensure that puller settings are sane
|
2016-03-16 12:16:38 +01:00
|
|
|
// Ensure that the versioning configuration parameter map is not nil
|
2014-09-28 13:00:38 +02:00
|
|
|
for i := range cfg.Folders {
|
|
|
|
cfg.Folders[i].Devices = ensureDevicePresent(cfg.Folders[i].Devices, myID)
|
|
|
|
cfg.Folders[i].Devices = ensureExistingDevices(cfg.Folders[i].Devices, existingDevices)
|
2015-12-31 09:17:17 +01:00
|
|
|
cfg.Folders[i].Devices = ensureNoDuplicateFolderDevices(cfg.Folders[i].Devices)
|
2016-03-16 12:16:38 +01:00
|
|
|
if cfg.Folders[i].Versioning.Params == nil {
|
|
|
|
cfg.Folders[i].Versioning.Params = map[string]string{}
|
|
|
|
}
|
2014-09-28 13:00:38 +02:00
|
|
|
sort.Sort(FolderDeviceConfigurationList(cfg.Folders[i].Devices))
|
2014-04-22 11:46:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// An empty address list is equivalent to a single "dynamic" entry
|
2014-09-28 13:00:38 +02:00
|
|
|
for i := range cfg.Devices {
|
|
|
|
n := &cfg.Devices[i]
|
2014-04-22 11:46:08 +02:00
|
|
|
if len(n.Addresses) == 0 || len(n.Addresses) == 1 && n.Addresses[0] == "" {
|
|
|
|
n.Addresses = []string{"dynamic"}
|
|
|
|
}
|
|
|
|
}
|
2014-11-18 23:57:21 +01:00
|
|
|
|
2015-03-26 13:57:27 +01:00
|
|
|
// Very short reconnection intervals are annoying
|
|
|
|
if cfg.Options.ReconnectIntervalS < 5 {
|
|
|
|
cfg.Options.ReconnectIntervalS = 5
|
|
|
|
}
|
|
|
|
|
2016-02-02 11:12:25 +01:00
|
|
|
if cfg.GUI.APIKey == "" {
|
2016-03-25 21:22:29 +01:00
|
|
|
cfg.GUI.APIKey = util.RandomString(32)
|
2014-12-29 13:48:26 +01:00
|
|
|
}
|
2014-09-06 14:11:18 +02:00
|
|
|
}
|
|
|
|
|
2016-04-03 21:18:16 +02:00
|
|
|
func convertV12V13(cfg *Configuration) {
|
|
|
|
// Not using the ignore cache is the new default. Disable it on existing
|
|
|
|
// configurations.
|
|
|
|
cfg.Options.CacheIgnoredFiles = false
|
|
|
|
cfg.Version = 13
|
|
|
|
}
|
|
|
|
|
2015-06-23 14:55:30 +02:00
|
|
|
func convertV11V12(cfg *Configuration) {
|
|
|
|
// Change listen address schema
|
|
|
|
for i, addr := range cfg.Options.ListenAddress {
|
|
|
|
if len(addr) > 0 && !strings.HasPrefix(addr, "tcp://") {
|
2016-03-25 21:22:29 +01:00
|
|
|
cfg.Options.ListenAddress[i] = util.Address("tcp", addr)
|
2015-06-23 14:55:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, device := range cfg.Devices {
|
|
|
|
for j, addr := range device.Addresses {
|
|
|
|
if addr != "dynamic" && addr != "" {
|
2016-03-25 21:22:29 +01:00
|
|
|
cfg.Devices[i].Addresses[j] = util.Address("tcp", addr)
|
2015-06-23 14:55:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use new discovery server
|
2015-09-20 15:30:25 +02:00
|
|
|
var newDiscoServers []string
|
|
|
|
var useDefault bool
|
|
|
|
for _, addr := range cfg.Options.GlobalAnnServers {
|
2015-06-23 14:55:30 +02:00
|
|
|
if addr == "udp4://announce.syncthing.net:22026" {
|
2015-09-20 15:30:25 +02:00
|
|
|
useDefault = true
|
2015-06-23 14:55:30 +02:00
|
|
|
} else if addr == "udp6://announce-v6.syncthing.net:22026" {
|
2015-09-20 15:30:25 +02:00
|
|
|
useDefault = true
|
|
|
|
} else {
|
|
|
|
newDiscoServers = append(newDiscoServers, addr)
|
2015-06-23 14:55:30 +02:00
|
|
|
}
|
|
|
|
}
|
2015-09-20 15:30:25 +02:00
|
|
|
if useDefault {
|
|
|
|
newDiscoServers = append(newDiscoServers, "default")
|
|
|
|
}
|
|
|
|
cfg.Options.GlobalAnnServers = newDiscoServers
|
2015-06-23 14:55:30 +02:00
|
|
|
|
2015-08-23 14:59:38 +02:00
|
|
|
// Use new multicast group
|
|
|
|
if cfg.Options.LocalAnnMCAddr == "[ff32::5222]:21026" {
|
|
|
|
cfg.Options.LocalAnnMCAddr = "[ff12::8384]:21027"
|
|
|
|
}
|
|
|
|
|
2015-08-27 16:04:13 +02:00
|
|
|
// Use new local discovery port
|
|
|
|
if cfg.Options.LocalAnnPort == 21025 {
|
|
|
|
cfg.Options.LocalAnnPort = 21027
|
|
|
|
}
|
|
|
|
|
2015-10-13 21:50:58 +02:00
|
|
|
// Set MaxConflicts to unlimited
|
|
|
|
for i := range cfg.Folders {
|
|
|
|
cfg.Folders[i].MaxConflicts = -1
|
|
|
|
}
|
|
|
|
|
2015-06-23 14:55:30 +02:00
|
|
|
cfg.Version = 12
|
|
|
|
}
|
|
|
|
|
2015-10-13 21:50:58 +02:00
|
|
|
func convertV10V11(cfg *Configuration) {
|
|
|
|
// Set minimum disk free of existing folders to 1%
|
|
|
|
for i := range cfg.Folders {
|
|
|
|
cfg.Folders[i].MinDiskFreePct = 1
|
|
|
|
}
|
|
|
|
cfg.Version = 11
|
|
|
|
}
|
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
func ensureDevicePresent(devices []FolderDeviceConfiguration, myID protocol.DeviceID) []FolderDeviceConfiguration {
|
|
|
|
for _, device := range devices {
|
|
|
|
if device.DeviceID.Equals(myID) {
|
|
|
|
return devices
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
devices = append(devices, FolderDeviceConfiguration{
|
|
|
|
DeviceID: myID,
|
2014-07-28 01:20:36 +02:00
|
|
|
})
|
2014-03-02 23:58:14 +01:00
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
return devices
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
2014-07-22 23:27:00 +02:00
|
|
|
|
2014-09-28 13:00:38 +02:00
|
|
|
func ensureExistingDevices(devices []FolderDeviceConfiguration, existingDevices map[protocol.DeviceID]bool) []FolderDeviceConfiguration {
|
|
|
|
count := len(devices)
|
2014-07-22 23:27:00 +02:00
|
|
|
i := 0
|
2014-07-28 01:08:15 +02:00
|
|
|
loop:
|
|
|
|
for i < count {
|
2014-09-28 13:00:38 +02:00
|
|
|
if _, ok := existingDevices[devices[i].DeviceID]; !ok {
|
|
|
|
devices[i] = devices[count-1]
|
2014-07-28 01:08:15 +02:00
|
|
|
count--
|
|
|
|
continue loop
|
2014-07-22 23:27:00 +02:00
|
|
|
}
|
2014-07-28 01:08:15 +02:00
|
|
|
i++
|
2014-07-22 23:27:00 +02:00
|
|
|
}
|
2014-09-28 13:00:38 +02:00
|
|
|
return devices[0:count]
|
2014-07-22 23:27:00 +02:00
|
|
|
}
|
2014-07-28 01:15:16 +02:00
|
|
|
|
2015-12-31 09:17:17 +01:00
|
|
|
func ensureNoDuplicateFolderDevices(devices []FolderDeviceConfiguration) []FolderDeviceConfiguration {
|
|
|
|
count := len(devices)
|
|
|
|
i := 0
|
|
|
|
seenDevices := make(map[protocol.DeviceID]bool)
|
|
|
|
loop:
|
|
|
|
for i < count {
|
|
|
|
id := devices[i].DeviceID
|
|
|
|
if _, ok := seenDevices[id]; ok {
|
|
|
|
devices[i] = devices[count-1]
|
|
|
|
count--
|
|
|
|
continue loop
|
|
|
|
}
|
|
|
|
seenDevices[id] = true
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
return devices[0:count]
|
|
|
|
}
|
|
|
|
|
|
|
|
func ensureNoDuplicateDevices(devices []DeviceConfiguration) []DeviceConfiguration {
|
2014-09-28 13:00:38 +02:00
|
|
|
count := len(devices)
|
2014-07-28 01:15:16 +02:00
|
|
|
i := 0
|
2014-09-28 13:00:38 +02:00
|
|
|
seenDevices := make(map[protocol.DeviceID]bool)
|
2014-07-28 01:15:16 +02:00
|
|
|
loop:
|
|
|
|
for i < count {
|
2014-09-28 13:00:38 +02:00
|
|
|
id := devices[i].DeviceID
|
|
|
|
if _, ok := seenDevices[id]; ok {
|
|
|
|
devices[i] = devices[count-1]
|
2014-07-28 01:15:16 +02:00
|
|
|
count--
|
|
|
|
continue loop
|
|
|
|
}
|
2014-09-28 13:00:38 +02:00
|
|
|
seenDevices[id] = true
|
2014-07-28 01:15:16 +02:00
|
|
|
i++
|
|
|
|
}
|
2014-09-28 13:00:38 +02:00
|
|
|
return devices[0:count]
|
2014-07-28 01:15:16 +02:00
|
|
|
}
|