2014-07-13 00:45:33 +02:00
|
|
|
// Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
|
|
|
|
// All rights reserved. Use of this source code is governed by an MIT-style
|
|
|
|
// license that can be found in the LICENSE file.
|
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 (
|
|
|
|
"encoding/xml"
|
2014-05-14 12:58:33 +02:00
|
|
|
"fmt"
|
2014-04-22 11:46:08 +02:00
|
|
|
"os"
|
2014-03-02 23:58:14 +01:00
|
|
|
"reflect"
|
|
|
|
"sort"
|
|
|
|
"strconv"
|
2014-04-19 13:33:51 +02:00
|
|
|
|
|
|
|
"code.google.com/p/go.crypto/bcrypt"
|
2014-08-01 16:35:37 +02:00
|
|
|
"github.com/syncthing/syncthing/logger"
|
2014-09-06 14:11:18 +02:00
|
|
|
"github.com/syncthing/syncthing/osutil"
|
2014-08-01 16:35:37 +02:00
|
|
|
"github.com/syncthing/syncthing/protocol"
|
2014-03-02 23:58:14 +01:00
|
|
|
)
|
|
|
|
|
2014-05-15 02:18:09 +02:00
|
|
|
var l = logger.DefaultLogger
|
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
type Configuration struct {
|
2014-09-06 14:11:18 +02:00
|
|
|
Location string `xml:"-" json:"-"`
|
2014-08-01 16:48:06 +02:00
|
|
|
Version int `xml:"version,attr" default:"3"`
|
2014-03-02 23:58:14 +01:00
|
|
|
Repositories []RepositoryConfiguration `xml:"repository"`
|
2014-04-08 13:45:18 +02:00
|
|
|
Nodes []NodeConfiguration `xml:"node"`
|
2014-04-08 15:56:12 +02:00
|
|
|
GUI GUIConfiguration `xml:"gui"`
|
2014-03-02 23:58:14 +01:00
|
|
|
Options OptionsConfiguration `xml:"options"`
|
|
|
|
XMLName xml.Name `xml:"configuration" json:"-"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type RepositoryConfiguration struct {
|
2014-08-18 23:05:47 +02:00
|
|
|
ID string `xml:"id,attr"`
|
|
|
|
Directory string `xml:"directory,attr"`
|
|
|
|
Nodes []RepositoryNodeConfiguration `xml:"node"`
|
|
|
|
ReadOnly bool `xml:"ro,attr"`
|
|
|
|
RescanIntervalS int `xml:"rescanIntervalS,attr" default:"60"`
|
|
|
|
IgnorePerms bool `xml:"ignorePerms,attr"`
|
|
|
|
Invalid string `xml:"-"` // Set at runtime when there is an error, not saved
|
|
|
|
Versioning VersioningConfiguration `xml:"versioning"`
|
2014-05-25 20:49:08 +02:00
|
|
|
|
2014-06-30 01:42:03 +02:00
|
|
|
nodeIDs []protocol.NodeID
|
2014-05-25 20:49:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type VersioningConfiguration struct {
|
|
|
|
Type string `xml:"type,attr"`
|
|
|
|
Params map[string]string
|
|
|
|
}
|
|
|
|
|
|
|
|
type InternalVersioningConfiguration struct {
|
|
|
|
Type string `xml:"type,attr,omitempty"`
|
|
|
|
Params []InternalParam `xml:"param"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type InternalParam struct {
|
|
|
|
Key string `xml:"key,attr"`
|
|
|
|
Val string `xml:"val,attr"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *VersioningConfiguration) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
|
|
|
|
var tmp InternalVersioningConfiguration
|
|
|
|
tmp.Type = c.Type
|
|
|
|
for k, v := range c.Params {
|
|
|
|
tmp.Params = append(tmp.Params, InternalParam{k, v})
|
|
|
|
}
|
|
|
|
|
|
|
|
return e.EncodeElement(tmp, start)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *VersioningConfiguration) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
|
|
|
|
var tmp InternalVersioningConfiguration
|
|
|
|
err := d.DecodeElement(&tmp, &start)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
c.Type = tmp.Type
|
|
|
|
c.Params = make(map[string]string, len(tmp.Params))
|
|
|
|
for _, p := range tmp.Params {
|
|
|
|
c.Params[p.Key] = p.Val
|
|
|
|
}
|
|
|
|
return nil
|
2014-04-08 13:45:18 +02:00
|
|
|
}
|
|
|
|
|
2014-06-30 01:42:03 +02:00
|
|
|
func (r *RepositoryConfiguration) NodeIDs() []protocol.NodeID {
|
2014-04-08 13:45:18 +02:00
|
|
|
if r.nodeIDs == nil {
|
|
|
|
for _, n := range r.Nodes {
|
|
|
|
r.nodeIDs = append(r.nodeIDs, n.NodeID)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return r.nodeIDs
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
type NodeConfiguration struct {
|
2014-07-28 12:44:46 +02:00
|
|
|
NodeID protocol.NodeID `xml:"id,attr"`
|
|
|
|
Name string `xml:"name,attr,omitempty"`
|
|
|
|
Addresses []string `xml:"address,omitempty"`
|
|
|
|
Compression bool `xml:"compression,attr"`
|
2014-07-30 07:59:22 +02:00
|
|
|
CertName string `xml:"certName,attr,omitempty"`
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
type RepositoryNodeConfiguration struct {
|
|
|
|
NodeID protocol.NodeID `xml:"id,attr"`
|
|
|
|
|
|
|
|
Deprecated_Name string `xml:"name,attr,omitempty" json:"-"`
|
|
|
|
Deprecated_Addresses []string `xml:"address,omitempty" json:"-"`
|
|
|
|
}
|
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
type OptionsConfiguration struct {
|
2014-05-14 17:43:23 +02:00
|
|
|
ListenAddress []string `xml:"listenAddress" default:"0.0.0.0:22000"`
|
2014-07-13 09:33:44 +02:00
|
|
|
GlobalAnnServer string `xml:"globalAnnounceServer" default:"announce.syncthing.net:22026"`
|
2014-04-08 13:45:18 +02:00
|
|
|
GlobalAnnEnabled bool `xml:"globalAnnounceEnabled" default:"true"`
|
|
|
|
LocalAnnEnabled bool `xml:"localAnnounceEnabled" default:"true"`
|
2014-05-22 09:35:54 +02:00
|
|
|
LocalAnnPort int `xml:"localAnnouncePort" default:"21025"`
|
2014-08-17 15:01:48 +02:00
|
|
|
LocalAnnMCAddr string `xml:"localAnnounceMCAddr" default:"[ff32::5222]:21026"`
|
2014-04-08 13:45:18 +02:00
|
|
|
ParallelRequests int `xml:"parallelRequests" default:"16"`
|
|
|
|
MaxSendKbps int `xml:"maxSendKbps"`
|
|
|
|
ReconnectIntervalS int `xml:"reconnectionIntervalS" default:"60"`
|
2014-03-08 23:19:33 +01:00
|
|
|
StartBrowser bool `xml:"startBrowser" default:"true"`
|
2014-04-18 13:39:51 +02:00
|
|
|
UPnPEnabled bool `xml:"upnpEnabled" default:"true"`
|
2014-08-11 23:58:32 +02:00
|
|
|
UPnPLease int `xml:"upnpLeaseMinutes" default:"0"`
|
2014-08-13 23:45:44 +02:00
|
|
|
UPnPRenewal int `xml:"upnpRenewalMinutes" default:"30"`
|
2014-06-17 23:22:19 +02:00
|
|
|
URAccepted int `xml:"urAccepted"` // Accepted usage reporting version; 0 for off (undecided), -1 for off (permanently)
|
2014-04-08 15:56:12 +02:00
|
|
|
|
2014-08-18 23:05:47 +02:00
|
|
|
Deprecated_RescanIntervalS int `xml:"rescanIntervalS,omitempty" json:"-"`
|
|
|
|
Deprecated_UREnabled bool `xml:"urEnabled,omitempty" json:"-"`
|
|
|
|
Deprecated_URDeclined bool `xml:"urDeclined,omitempty" json:"-"`
|
|
|
|
Deprecated_ReadOnly bool `xml:"readOnly,omitempty" json:"-"`
|
|
|
|
Deprecated_GUIEnabled bool `xml:"guiEnabled,omitempty" json:"-"`
|
|
|
|
Deprecated_GUIAddress string `xml:"guiAddress,omitempty" json:"-"`
|
2014-04-08 15:56:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type GUIConfiguration struct {
|
|
|
|
Enabled bool `xml:"enabled,attr" default:"true"`
|
|
|
|
Address string `xml:"address" default:"127.0.0.1:8080"`
|
|
|
|
User string `xml:"user,omitempty"`
|
|
|
|
Password string `xml:"password,omitempty"`
|
2014-05-21 14:04:16 +02:00
|
|
|
UseTLS bool `xml:"tls,attr"`
|
2014-06-04 22:00:55 +02:00
|
|
|
APIKey string `xml:"apikey,omitempty"`
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
|
2014-06-30 01:42:03 +02:00
|
|
|
func (cfg *Configuration) NodeMap() map[protocol.NodeID]NodeConfiguration {
|
|
|
|
m := make(map[protocol.NodeID]NodeConfiguration, len(cfg.Nodes))
|
2014-06-07 04:00:46 +02:00
|
|
|
for _, n := range cfg.Nodes {
|
|
|
|
m[n.NodeID] = n
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2014-08-15 00:15:26 +02:00
|
|
|
func (cfg *Configuration) GetNodeConfiguration(nodeid protocol.NodeID) *NodeConfiguration {
|
|
|
|
for i, node := range cfg.Nodes {
|
|
|
|
if node.NodeID == nodeid {
|
|
|
|
return &cfg.Nodes[i]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-06-07 04:00:46 +02:00
|
|
|
func (cfg *Configuration) RepoMap() map[string]RepositoryConfiguration {
|
|
|
|
m := make(map[string]RepositoryConfiguration, len(cfg.Repositories))
|
|
|
|
for _, r := range cfg.Repositories {
|
|
|
|
m[r.ID] = r
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
2014-03-04 22:29:43 +01:00
|
|
|
func setDefaults(data interface{}) error {
|
2014-03-02 23:58:14 +01:00
|
|
|
s := reflect.ValueOf(data).Elem()
|
|
|
|
t := s.Type()
|
|
|
|
|
|
|
|
for i := 0; i < s.NumField(); i++ {
|
|
|
|
f := s.Field(i)
|
|
|
|
tag := t.Field(i).Tag
|
|
|
|
|
|
|
|
v := tag.Get("default")
|
|
|
|
if len(v) > 0 {
|
|
|
|
switch f.Interface().(type) {
|
|
|
|
case string:
|
|
|
|
f.SetString(v)
|
|
|
|
|
|
|
|
case int:
|
|
|
|
i, err := strconv.ParseInt(v, 10, 64)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
f.SetInt(i)
|
|
|
|
|
|
|
|
case bool:
|
|
|
|
f.SetBool(v == "true")
|
|
|
|
|
2014-03-04 22:29:43 +01:00
|
|
|
case []string:
|
|
|
|
// We don't do anything with string slices here. Any default
|
|
|
|
// we set will be appended to by the XML decoder, so we fill
|
|
|
|
// those after decoding.
|
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
default:
|
|
|
|
panic(f.Type())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-03-04 22:29:43 +01:00
|
|
|
// fillNilSlices sets default value on slices that are still nil.
|
|
|
|
func fillNilSlices(data interface{}) error {
|
|
|
|
s := reflect.ValueOf(data).Elem()
|
|
|
|
t := s.Type()
|
|
|
|
|
|
|
|
for i := 0; i < s.NumField(); i++ {
|
|
|
|
f := s.Field(i)
|
|
|
|
tag := t.Field(i).Tag
|
|
|
|
|
|
|
|
v := tag.Get("default")
|
|
|
|
if len(v) > 0 {
|
|
|
|
switch f.Interface().(type) {
|
|
|
|
case []string:
|
|
|
|
if f.IsNil() {
|
|
|
|
rv := reflect.MakeSlice(reflect.TypeOf([]string{}), 1, 1)
|
|
|
|
rv.Index(0).SetString(v)
|
|
|
|
f.Set(rv)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2014-09-06 14:11:18 +02:00
|
|
|
func (cfg *Configuration) Save() error {
|
|
|
|
fd, err := os.Create(cfg.Location + ".tmp")
|
|
|
|
if err != nil {
|
|
|
|
l.Warnln("Saving config:", err)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
e := xml.NewEncoder(fd)
|
2014-03-02 23:58:14 +01:00
|
|
|
e.Indent("", " ")
|
2014-09-06 14:11:18 +02:00
|
|
|
err = e.Encode(cfg)
|
|
|
|
if err != nil {
|
|
|
|
fd.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
_, err = fd.Write([]byte("\n"))
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
l.Warnln("Saving config:", err)
|
|
|
|
fd.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err = fd.Close()
|
2014-03-02 23:58:14 +01:00
|
|
|
if err != nil {
|
2014-09-06 14:11:18 +02:00
|
|
|
l.Warnln("Saving config:", err)
|
2014-03-02 23:58:14 +01:00
|
|
|
return err
|
|
|
|
}
|
2014-09-06 14:11:18 +02:00
|
|
|
|
|
|
|
err = osutil.Rename(cfg.Location+".tmp", cfg.Location)
|
|
|
|
if err != nil {
|
|
|
|
l.Warnln("Saving config:", err)
|
|
|
|
}
|
2014-03-02 23:58:14 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
func uniqueStrings(ss []string) []string {
|
|
|
|
var m = make(map[string]bool, len(ss))
|
|
|
|
for _, s := range ss {
|
|
|
|
m[s] = true
|
|
|
|
}
|
|
|
|
|
|
|
|
var us = make([]string, 0, len(m))
|
|
|
|
for k := range m {
|
|
|
|
us = append(us, k)
|
|
|
|
}
|
|
|
|
|
|
|
|
return us
|
|
|
|
}
|
|
|
|
|
2014-09-06 14:11:18 +02:00
|
|
|
func (cfg *Configuration) prepare(myID protocol.NodeID) {
|
2014-03-04 22:29:43 +01:00
|
|
|
fillNilSlices(&cfg.Options)
|
2014-03-04 11:25:10 +01:00
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
cfg.Options.ListenAddress = uniqueStrings(cfg.Options.ListenAddress)
|
2014-03-29 18:53:48 +01:00
|
|
|
|
2014-05-13 04:57:38 +02:00
|
|
|
// Initialize an empty slice for repositories if the config has none
|
|
|
|
if cfg.Repositories == nil {
|
|
|
|
cfg.Repositories = []RepositoryConfiguration{}
|
|
|
|
}
|
|
|
|
|
2014-05-13 02:30:04 +02:00
|
|
|
// Check for missing, bad or duplicate repository ID:s
|
2014-04-27 21:53:27 +02:00
|
|
|
var seenRepos = map[string]*RepositoryConfiguration{}
|
2014-05-14 12:58:33 +02:00
|
|
|
var uniqueCounter int
|
2014-03-29 18:53:48 +01:00
|
|
|
for i := range cfg.Repositories {
|
2014-04-27 21:53:27 +02:00
|
|
|
repo := &cfg.Repositories[i]
|
|
|
|
|
2014-05-13 02:30:04 +02:00
|
|
|
if len(repo.Directory) == 0 {
|
2014-05-28 12:39:33 +02:00
|
|
|
repo.Invalid = "no directory configured"
|
2014-05-13 02:30:04 +02:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
2014-04-27 21:53:27 +02:00
|
|
|
if repo.ID == "" {
|
|
|
|
repo.ID = "default"
|
2014-03-29 18:53:48 +01:00
|
|
|
}
|
|
|
|
|
2014-04-27 21:53:27 +02:00
|
|
|
if seen, ok := seenRepos[repo.ID]; ok {
|
2014-05-15 02:08:56 +02:00
|
|
|
l.Warnf("Multiple repositories with ID %q; disabling", repo.ID)
|
2014-05-14 12:58:33 +02:00
|
|
|
|
2014-04-27 21:53:27 +02:00
|
|
|
seen.Invalid = "duplicate repository ID"
|
2014-05-14 12:58:33 +02:00
|
|
|
if seen.ID == repo.ID {
|
|
|
|
uniqueCounter++
|
|
|
|
seen.ID = fmt.Sprintf("%s~%d", repo.ID, uniqueCounter)
|
|
|
|
}
|
2014-04-27 21:53:27 +02:00
|
|
|
repo.Invalid = "duplicate repository ID"
|
2014-05-14 12:58:33 +02:00
|
|
|
uniqueCounter++
|
|
|
|
repo.ID = fmt.Sprintf("%s~%d", repo.ID, uniqueCounter)
|
2014-04-27 21:53:27 +02:00
|
|
|
} else {
|
|
|
|
seenRepos[repo.ID] = repo
|
2014-03-29 18:53:48 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-17 23:22:19 +02:00
|
|
|
if cfg.Options.Deprecated_URDeclined {
|
|
|
|
cfg.Options.URAccepted = -1
|
|
|
|
}
|
|
|
|
cfg.Options.Deprecated_URDeclined = false
|
|
|
|
cfg.Options.Deprecated_UREnabled = false
|
|
|
|
|
2014-04-22 11:46:08 +02:00
|
|
|
// Upgrade to v2 configuration if appropriate
|
2014-04-08 13:45:18 +02:00
|
|
|
if cfg.Version == 1 {
|
2014-09-06 14:11:18 +02:00
|
|
|
convertV1V2(cfg)
|
2014-04-08 13:45:18 +02:00
|
|
|
}
|
|
|
|
|
2014-08-01 16:48:06 +02:00
|
|
|
// Upgrade to v3 configuration if appropriate
|
|
|
|
if cfg.Version == 2 {
|
2014-09-06 14:11:18 +02:00
|
|
|
convertV2V3(cfg)
|
2014-08-01 16:48:06 +02:00
|
|
|
}
|
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
// Upgrade to v4 configuration if appropriate
|
|
|
|
if cfg.Version == 3 {
|
2014-09-06 14:11:18 +02:00
|
|
|
convertV3V4(cfg)
|
2014-08-17 00:20:21 +02:00
|
|
|
}
|
|
|
|
|
2014-04-22 11:46:08 +02:00
|
|
|
// Hash old cleartext passwords
|
2014-04-19 13:33:51 +02:00
|
|
|
if len(cfg.GUI.Password) > 0 && cfg.GUI.Password[0] != '$' {
|
|
|
|
hash, err := bcrypt.GenerateFromPassword([]byte(cfg.GUI.Password), 0)
|
|
|
|
if err != nil {
|
2014-08-17 10:28:36 +02:00
|
|
|
l.Warnln("bcrypting password:", err)
|
2014-04-19 13:33:51 +02:00
|
|
|
} else {
|
|
|
|
cfg.GUI.Password = string(hash)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-22 23:27:00 +02:00
|
|
|
// Build a list of available nodes
|
|
|
|
existingNodes := make(map[protocol.NodeID]bool)
|
|
|
|
existingNodes[myID] = true
|
|
|
|
for _, node := range cfg.Nodes {
|
|
|
|
existingNodes[node.NodeID] = true
|
|
|
|
}
|
|
|
|
|
2014-04-22 11:46:08 +02:00
|
|
|
// Ensure this node is present in all relevant places
|
2014-08-17 00:20:21 +02:00
|
|
|
me := cfg.GetNodeConfiguration(myID)
|
|
|
|
if me == nil {
|
|
|
|
myName, _ := os.Hostname()
|
|
|
|
cfg.Nodes = append(cfg.Nodes, NodeConfiguration{
|
|
|
|
NodeID: myID,
|
|
|
|
Name: myName,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
sort.Sort(NodeConfigurationList(cfg.Nodes))
|
2014-07-22 23:27:00 +02:00
|
|
|
// Ensure that any loose nodes are not present in the wrong places
|
2014-07-28 01:15:16 +02:00
|
|
|
// Ensure that there are no duplicate nodes
|
2014-04-22 11:46:08 +02:00
|
|
|
for i := range cfg.Repositories {
|
|
|
|
cfg.Repositories[i].Nodes = ensureNodePresent(cfg.Repositories[i].Nodes, myID)
|
2014-07-22 23:27:00 +02:00
|
|
|
cfg.Repositories[i].Nodes = ensureExistingNodes(cfg.Repositories[i].Nodes, existingNodes)
|
2014-07-28 01:15:16 +02:00
|
|
|
cfg.Repositories[i].Nodes = ensureNoDuplicates(cfg.Repositories[i].Nodes)
|
2014-08-17 00:20:21 +02:00
|
|
|
sort.Sort(RepositoryNodeConfigurationList(cfg.Repositories[i].Nodes))
|
2014-04-22 11:46:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// An empty address list is equivalent to a single "dynamic" entry
|
|
|
|
for i := range cfg.Nodes {
|
|
|
|
n := &cfg.Nodes[i]
|
|
|
|
if len(n.Addresses) == 0 || len(n.Addresses) == 1 && n.Addresses[0] == "" {
|
|
|
|
n.Addresses = []string{"dynamic"}
|
|
|
|
}
|
|
|
|
}
|
2014-09-06 14:11:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func New(location string, myID protocol.NodeID) Configuration {
|
|
|
|
var cfg Configuration
|
|
|
|
|
|
|
|
cfg.Location = location
|
|
|
|
|
|
|
|
setDefaults(&cfg)
|
|
|
|
setDefaults(&cfg.Options)
|
|
|
|
setDefaults(&cfg.GUI)
|
|
|
|
|
|
|
|
cfg.prepare(myID)
|
|
|
|
|
|
|
|
return cfg
|
|
|
|
}
|
|
|
|
|
|
|
|
func Load(location string, myID protocol.NodeID) (Configuration, error) {
|
|
|
|
var cfg Configuration
|
|
|
|
|
|
|
|
cfg.Location = location
|
|
|
|
|
|
|
|
setDefaults(&cfg)
|
|
|
|
setDefaults(&cfg.Options)
|
|
|
|
setDefaults(&cfg.GUI)
|
|
|
|
|
|
|
|
fd, err := os.Open(location)
|
|
|
|
if err != nil {
|
|
|
|
return Configuration{}, err
|
|
|
|
}
|
|
|
|
err = xml.NewDecoder(fd).Decode(&cfg)
|
|
|
|
fd.Close()
|
|
|
|
|
|
|
|
cfg.prepare(myID)
|
2014-04-22 11:46:08 +02:00
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
return cfg, err
|
|
|
|
}
|
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
func convertV3V4(cfg *Configuration) {
|
2014-08-18 23:05:47 +02:00
|
|
|
// In previous versions, rescan interval was common for each repository.
|
|
|
|
// From now, it can be set independently. We have to make sure, that after upgrade
|
|
|
|
// the individual rescan interval will be defined for every existing repository.
|
|
|
|
for i := range cfg.Repositories {
|
|
|
|
cfg.Repositories[i].RescanIntervalS = cfg.Options.Deprecated_RescanIntervalS
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.Options.Deprecated_RescanIntervalS = 0
|
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
// In previous versions, repositories held full node configurations.
|
|
|
|
// Since that's the only place where node configs were in V1, we still have
|
|
|
|
// to define the deprecated fields to be able to upgrade from V1 to V4.
|
|
|
|
for i, repo := range cfg.Repositories {
|
2014-08-18 23:05:47 +02:00
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
for j := range repo.Nodes {
|
|
|
|
rncfg := cfg.Repositories[i].Nodes[j]
|
|
|
|
rncfg.Deprecated_Name = ""
|
|
|
|
rncfg.Deprecated_Addresses = nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.Version = 4
|
|
|
|
}
|
|
|
|
|
2014-08-01 16:48:06 +02:00
|
|
|
func convertV2V3(cfg *Configuration) {
|
|
|
|
// In previous versions, compression was always on. When upgrading, enable
|
|
|
|
// compression on all existing new. New nodes will get compression on by
|
|
|
|
// default by the GUI.
|
|
|
|
for i := range cfg.Nodes {
|
|
|
|
cfg.Nodes[i].Compression = true
|
|
|
|
}
|
2014-08-02 08:37:10 +02:00
|
|
|
|
|
|
|
// 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"
|
|
|
|
}
|
|
|
|
|
2014-08-01 16:48:06 +02:00
|
|
|
cfg.Version = 3
|
|
|
|
}
|
|
|
|
|
2014-04-08 13:45:18 +02:00
|
|
|
func convertV1V2(cfg *Configuration) {
|
|
|
|
// Collect the list of nodes.
|
|
|
|
// Replace node configs inside repositories with only a reference to the nide ID.
|
|
|
|
// Set all repositories to read only if the global read only flag is set.
|
2014-08-17 00:20:21 +02:00
|
|
|
var nodes = map[string]RepositoryNodeConfiguration{}
|
2014-04-08 13:45:18 +02:00
|
|
|
for i, repo := range cfg.Repositories {
|
2014-04-08 15:56:12 +02:00
|
|
|
cfg.Repositories[i].ReadOnly = cfg.Options.Deprecated_ReadOnly
|
2014-04-08 13:45:18 +02:00
|
|
|
for j, node := range repo.Nodes {
|
2014-06-30 01:42:03 +02:00
|
|
|
id := node.NodeID.String()
|
|
|
|
if _, ok := nodes[id]; !ok {
|
|
|
|
nodes[id] = node
|
2014-04-08 13:45:18 +02:00
|
|
|
}
|
2014-08-17 00:20:21 +02:00
|
|
|
cfg.Repositories[i].Nodes[j] = RepositoryNodeConfiguration{NodeID: node.NodeID}
|
2014-04-08 13:45:18 +02:00
|
|
|
}
|
|
|
|
}
|
2014-04-08 15:56:12 +02:00
|
|
|
cfg.Options.Deprecated_ReadOnly = false
|
2014-04-08 13:45:18 +02:00
|
|
|
|
|
|
|
// Set and sort the list of nodes.
|
|
|
|
for _, node := range nodes {
|
2014-08-17 00:20:21 +02:00
|
|
|
cfg.Nodes = append(cfg.Nodes, NodeConfiguration{
|
|
|
|
NodeID: node.NodeID,
|
|
|
|
Name: node.Deprecated_Name,
|
|
|
|
Addresses: node.Deprecated_Addresses,
|
|
|
|
})
|
2014-04-08 13:45:18 +02:00
|
|
|
}
|
|
|
|
sort.Sort(NodeConfigurationList(cfg.Nodes))
|
|
|
|
|
2014-04-08 15:56:12 +02:00
|
|
|
// GUI
|
|
|
|
cfg.GUI.Address = cfg.Options.Deprecated_GUIAddress
|
|
|
|
cfg.GUI.Enabled = cfg.Options.Deprecated_GUIEnabled
|
|
|
|
cfg.Options.Deprecated_GUIEnabled = false
|
|
|
|
cfg.Options.Deprecated_GUIAddress = ""
|
|
|
|
|
2014-04-08 13:45:18 +02:00
|
|
|
cfg.Version = 2
|
|
|
|
}
|
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
type NodeConfigurationList []NodeConfiguration
|
|
|
|
|
|
|
|
func (l NodeConfigurationList) Less(a, b int) bool {
|
2014-06-30 01:42:03 +02:00
|
|
|
return l[a].NodeID.Compare(l[b].NodeID) == -1
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
func (l NodeConfigurationList) Swap(a, b int) {
|
|
|
|
l[a], l[b] = l[b], l[a]
|
|
|
|
}
|
|
|
|
func (l NodeConfigurationList) Len() int {
|
|
|
|
return len(l)
|
|
|
|
}
|
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
type RepositoryNodeConfigurationList []RepositoryNodeConfiguration
|
|
|
|
|
|
|
|
func (l RepositoryNodeConfigurationList) Less(a, b int) bool {
|
|
|
|
return l[a].NodeID.Compare(l[b].NodeID) == -1
|
|
|
|
}
|
|
|
|
func (l RepositoryNodeConfigurationList) Swap(a, b int) {
|
|
|
|
l[a], l[b] = l[b], l[a]
|
|
|
|
}
|
|
|
|
func (l RepositoryNodeConfigurationList) Len() int {
|
|
|
|
return len(l)
|
|
|
|
}
|
|
|
|
|
|
|
|
func ensureNodePresent(nodes []RepositoryNodeConfiguration, myID protocol.NodeID) []RepositoryNodeConfiguration {
|
2014-03-02 23:58:14 +01:00
|
|
|
for _, node := range nodes {
|
2014-06-30 01:42:03 +02:00
|
|
|
if node.NodeID.Equals(myID) {
|
2014-07-28 01:20:36 +02:00
|
|
|
return nodes
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
nodes = append(nodes, RepositoryNodeConfiguration{
|
2014-07-28 01:20:36 +02:00
|
|
|
NodeID: myID,
|
|
|
|
})
|
2014-03-02 23:58:14 +01:00
|
|
|
|
|
|
|
return nodes
|
|
|
|
}
|
2014-07-22 23:27:00 +02:00
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
func ensureExistingNodes(nodes []RepositoryNodeConfiguration, existingNodes map[protocol.NodeID]bool) []RepositoryNodeConfiguration {
|
2014-07-28 01:08:15 +02:00
|
|
|
count := len(nodes)
|
2014-07-22 23:27:00 +02:00
|
|
|
i := 0
|
2014-07-28 01:08:15 +02:00
|
|
|
loop:
|
|
|
|
for i < count {
|
|
|
|
if _, ok := existingNodes[nodes[i].NodeID]; !ok {
|
|
|
|
nodes[i] = nodes[count-1]
|
|
|
|
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-07-28 01:20:36 +02:00
|
|
|
return nodes[0:count]
|
2014-07-22 23:27:00 +02:00
|
|
|
}
|
2014-07-28 01:15:16 +02:00
|
|
|
|
2014-08-17 00:20:21 +02:00
|
|
|
func ensureNoDuplicates(nodes []RepositoryNodeConfiguration) []RepositoryNodeConfiguration {
|
2014-07-28 01:15:16 +02:00
|
|
|
count := len(nodes)
|
|
|
|
i := 0
|
|
|
|
seenNodes := make(map[protocol.NodeID]bool)
|
|
|
|
loop:
|
|
|
|
for i < count {
|
|
|
|
id := nodes[i].NodeID
|
|
|
|
if _, ok := seenNodes[id]; ok {
|
|
|
|
nodes[i] = nodes[count-1]
|
|
|
|
count--
|
|
|
|
continue loop
|
|
|
|
}
|
|
|
|
seenNodes[id] = true
|
|
|
|
i++
|
|
|
|
}
|
2014-07-28 01:20:36 +02:00
|
|
|
return nodes[0:count]
|
2014-07-28 01:15:16 +02:00
|
|
|
}
|