2014-03-02 23:58:14 +01:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/xml"
|
|
|
|
"io"
|
|
|
|
"reflect"
|
|
|
|
"sort"
|
|
|
|
"strconv"
|
|
|
|
)
|
|
|
|
|
|
|
|
type Configuration struct {
|
2014-04-08 13:45:18 +02:00
|
|
|
Version int `xml:"version,attr" default:"2"`
|
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-03-29 18:53:48 +01:00
|
|
|
ID string `xml:"id,attr"`
|
2014-03-02 23:58:14 +01:00
|
|
|
Directory string `xml:"directory,attr"`
|
|
|
|
Nodes []NodeConfiguration `xml:"node"`
|
2014-04-08 13:45:18 +02:00
|
|
|
ReadOnly bool `xml:"ro,attr"`
|
|
|
|
nodeIDs []string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (r *RepositoryConfiguration) NodeIDs() []string {
|
|
|
|
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 {
|
|
|
|
NodeID string `xml:"id,attr"`
|
2014-04-08 13:45:18 +02:00
|
|
|
Name string `xml:"name,attr,omitempty"`
|
|
|
|
Addresses []string `xml:"address,omitempty"`
|
2014-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
type OptionsConfiguration struct {
|
2014-04-08 13:45:18 +02:00
|
|
|
ListenAddress []string `xml:"listenAddress" default:":22000"`
|
|
|
|
GlobalAnnServer string `xml:"globalAnnounceServer" default:"announce.syncthing.net:22025"`
|
|
|
|
GlobalAnnEnabled bool `xml:"globalAnnounceEnabled" default:"true"`
|
|
|
|
LocalAnnEnabled bool `xml:"localAnnounceEnabled" default:"true"`
|
|
|
|
ParallelRequests int `xml:"parallelRequests" default:"16"`
|
|
|
|
MaxSendKbps int `xml:"maxSendKbps"`
|
|
|
|
RescanIntervalS int `xml:"rescanIntervalS" default:"60"`
|
|
|
|
ReconnectIntervalS int `xml:"reconnectionIntervalS" default:"60"`
|
|
|
|
MaxChangeKbps int `xml:"maxChangeKbps" default:"1000"`
|
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-04-08 15:56:12 +02:00
|
|
|
|
|
|
|
Deprecated_ReadOnly bool `xml:"readOnly,omitempty"`
|
|
|
|
Deprecated_GUIEnabled bool `xml:"guiEnabled,omitempty"`
|
|
|
|
Deprecated_GUIAddress string `xml:"guiAddress,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
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-03-02 23:58:14 +01:00
|
|
|
}
|
|
|
|
|
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-03-02 23:58:14 +01:00
|
|
|
func writeConfigXML(wr io.Writer, cfg Configuration) error {
|
|
|
|
e := xml.NewEncoder(wr)
|
|
|
|
e.Indent("", " ")
|
|
|
|
err := e.Encode(cfg)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
_, err = wr.Write([]byte("\n"))
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
func readConfigXML(rd io.Reader) (Configuration, error) {
|
|
|
|
var cfg Configuration
|
|
|
|
|
2014-03-04 22:29:43 +01:00
|
|
|
setDefaults(&cfg)
|
|
|
|
setDefaults(&cfg.Options)
|
2014-04-08 15:56:12 +02:00
|
|
|
setDefaults(&cfg.GUI)
|
2014-03-02 23:58:14 +01:00
|
|
|
|
|
|
|
var err error
|
|
|
|
if rd != nil {
|
|
|
|
err = xml.NewDecoder(rd).Decode(&cfg)
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
|
|
var seenRepos = map[string]bool{}
|
|
|
|
for i := range cfg.Repositories {
|
|
|
|
if cfg.Repositories[i].ID == "" {
|
|
|
|
cfg.Repositories[i].ID = "default"
|
|
|
|
}
|
|
|
|
|
|
|
|
id := cfg.Repositories[i].ID
|
|
|
|
if seenRepos[id] {
|
|
|
|
panic("duplicate repository ID " + id)
|
|
|
|
}
|
|
|
|
seenRepos[id] = true
|
|
|
|
}
|
|
|
|
|
2014-04-08 13:45:18 +02:00
|
|
|
if cfg.Version == 1 {
|
|
|
|
convertV1V2(&cfg)
|
|
|
|
}
|
|
|
|
|
2014-03-02 23:58:14 +01:00
|
|
|
return cfg, err
|
|
|
|
}
|
|
|
|
|
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.
|
|
|
|
var nodes = map[string]NodeConfiguration{}
|
|
|
|
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 {
|
|
|
|
if _, ok := nodes[node.NodeID]; !ok {
|
|
|
|
nodes[node.NodeID] = node
|
|
|
|
}
|
|
|
|
cfg.Repositories[i].Nodes[j] = NodeConfiguration{NodeID: node.NodeID}
|
|
|
|
}
|
|
|
|
}
|
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 {
|
|
|
|
cfg.Nodes = append(cfg.Nodes, node)
|
|
|
|
}
|
|
|
|
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 {
|
|
|
|
return l[a].NodeID < l[b].NodeID
|
|
|
|
}
|
|
|
|
func (l NodeConfigurationList) Swap(a, b int) {
|
|
|
|
l[a], l[b] = l[b], l[a]
|
|
|
|
}
|
|
|
|
func (l NodeConfigurationList) Len() int {
|
|
|
|
return len(l)
|
|
|
|
}
|
|
|
|
|
|
|
|
func cleanNodeList(nodes []NodeConfiguration, myID string) []NodeConfiguration {
|
|
|
|
var myIDExists bool
|
|
|
|
for _, node := range nodes {
|
|
|
|
if node.NodeID == myID {
|
|
|
|
myIDExists = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !myIDExists {
|
|
|
|
nodes = append(nodes, NodeConfiguration{
|
|
|
|
NodeID: myID,
|
|
|
|
Addresses: []string{"dynamic"},
|
|
|
|
Name: "",
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
sort.Sort(NodeConfigurationList(nodes))
|
|
|
|
|
|
|
|
return nodes
|
|
|
|
}
|