Fix broken upgrades (fixes #1175)

Hash blocks after receipt, try multiple peers (fixes #1166)

.gitignore

@@ -12,3 +12,6 @@ bin
 perfstats*.csv
 coverage.xml
 !gui/scripts/syncthing
+.DS_Store
+syncthing.md5
+syncthing.exe.md5

.mailmap

@@ -0,0 +1 @@
+NICKS

AUTHORS

@@ -5,12 +5,15 @@ Alexander Graf <register-github@alex-graf.de>
 Andrew Dunham <andrew@du.nham.ca>
 Audrius Butkevicius <audrius.butkevicius@gmail.com>
 Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
+Ben Schulz <ueomkail@gmail.com> <uok@users.noreply.github.com>
 Ben Sidhom <bsidhom@gmail.com>
 Brandon Philips <brandon@ifup.org>
 Caleb Callaway <enlightened.despot@gmail.com>
+Cathryne Linenweaver <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
 Chris Joel <chris@scriptolo.gy>
 Daniel Martí <mvdan@mvdan.cc>
 Dennis Wilson <dw@risu.io>
+Dominik Heidler <dominik@heidler.eu>
 Emil Hessman <emil@hessman.se>
 Felix Ableitner <me@nutomic.com>
 Felix Unterpaintner <bigbear2nd@gmail.com>

CONDUCT.md

@@ -0,0 +1,92 @@
+## Conduct
+
+* We are committed to providing a friendly, safe and welcoming
+  environment for all, regardless of gender, sexual orientation,
+  disability, ethnicity, religion, or similar personal characteristic.
+
+* On IRC, please avoid using overtly sexual nicknames or other nicknames
+  that might detract from a friendly, safe and welcoming environment for
+  all.
+
+* Please be kind and courteous. There's no need to be mean or rude.
+
+* Respect that people have differences of opinion and that every design
+  or implementation choice carries a trade-off and numerous costs. There
+  is seldom a right answer.
+
+* Please keep unstructured critique to a minimum. If you have solid
+  ideas you want to experiment with, make a fork and see how it works.
+
+* We will exclude you from interaction if you insult, demean or harass
+  anyone. That is not welcome behaviour. We interpret the term
+  "harassment" as including the definition in the <a
+  href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>;
+  if you have any lack of clarity about what might be included in that
+  concept, please read their definition. In particular, we don't
+  tolerate behavior that excludes people in socially marginalized
+  groups.
+
+* Private harassment is also unacceptable. No matter who you are, if you
+  feel you have been or are being harassed or made uncomfortable by a
+  community member, please contact one of the channel ops or any of the
+  Syncthing core team immediately. Whether you're a regular  contributor
+  or a newcomer, we care about making this community a safe place for
+  you and we've got your back.
+
+* Likewise any spamming, trolling, flaming, baiting or other
+  attention-stealing behaviour is not welcome.
+
+## Moderation
+
+These are the policies for upholding our community's standards of
+conduct in our communication channels, most notably in Syncthing-related
+IRC channels and on the web forum.
+
+1. Remarks that violate the Syncthing standards of conduct, including
+   hateful, hurtful, oppressive, or exclusionary remarks, are not
+   allowed. (Cursing is allowed, but never targeting another user, and
+   never in a hateful manner.)
+
+2. Remarks that moderators find inappropriate, whether listed in the
+   code of conduct or not, are also not allowed.
+
+3. Moderators will first respond to such remarks with a warning.
+
+4. If the warning is unheeded, the user will be "kicked," i.e., kicked
+   out of the communication channel to cool off.
+
+5. If the user comes back and continues to make trouble, they will be
+   banned, i.e., indefinitely excluded.
+
+6. Moderators may choose at their discretion to un-ban the user if it
+   was a first offense and they offer the offended party a genuine
+   apology.
+
+7. If a moderator bans someone and you think it was unjustified, please
+   take it up with that moderator, or with a different moderator, **in
+   private**. Complaints about bans in-channel are not allowed.
+
+8. Moderators are held to a higher standard than other community
+   members. If a moderator creates an inappropriate situation, they
+   should expect less leeway than others.
+
+In the Syncthing community we strive to go the extra step to look out
+for each other. Don't just aim to be technically unimpeachable, try to
+be your best self. In particular, avoid flirting with offensive or
+sensitive issues, particularly if they're off-topic; this all too
+often leads to unnecessary fights, hurt feelings, and damaged trust;
+worse, it can drive people away from the community entirely.
+
+And if someone takes issue with something you said or did, resist the
+urge to be defensive. Just stop doing what it was they complained about
+and apologize. Even if you feel you were misinterpreted or unfairly
+accused, chances are good there was something you could've communicated
+better — remember that it's your responsibility to make your fellow
+community members comfortable. Everyone wants to get along and we are
+all here first and foremost because we want to talk about cool
+technology. You will find that people will be eager to assume good
+intent and forgive as long as you earn their trust.
+
+*Adapted from the [Rust Code of Conduct](https://github.com/rust-lang/rust/wiki/Note-development-policy#conduct)*
+
+*Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)*

CONTRIBUTING.md

@@ -37,6 +37,36 @@ where to start, any open issues are fair game! Be prepared for a
 all in the name of quality. :) Following the points below will make this
 a smoother process.
 
+Individuals making significant and valuable contributions are given
+commit-access to the project. If you make a significant contribution and
+are not considered for commit-access, please contact any of the
+Syncthing core team members.
+
+All nontrivial contributions should go through the pull request
+mechanism for internal review. Determining what is "nontrivial" is left
+at the discretion of the contributor.
+
+### Authorship
+
+All code authors are listed in the AUTHORS file. Commits must be made
+with the same name and email as listed in the AUTHORS file. To
+accomplish this, ensure that your git configuration is set correctly
+prior to making your first commit;
+
+    $ git config --global user.name "Jane Doe"
+    $ git config --global user.email janedoe@example.com
+
+You must be reachable on the given email address. If you do not wish to
+use your real name for whatever reason, using a nickname or pseudonym is
+perfectly acceptable.
+
+### Core Team
+
+The Syncthing core team currently consists of the following members;
+
+ - Jakob Borg (@calmh)
+ - Audrius Butkevicius (@AudriusButkevicius)
+
 ## Coding Style
 
 - Follow the conventions laid out in [Effective Go](https://golang.org/doc/effective_go.html)
@@ -59,7 +89,7 @@ a smoother process.
   feature should probably be a single commit based on the current
   `master` branch. You may be asked to "rebase" or "squash" your pull
   request to make sure this is the case, especially if there have been
-  amendments during review. 
+  amendments during review.
 
 ## Licensing
 

Godeps/Godeps.json

@@ -1,6 +1,6 @@
 {
 	"ImportPath": "github.com/syncthing/syncthing",
-	"GoVersion": "go1.4rc1",
+	"GoVersion": "go1.4",
 	"Packages": [
 		"./cmd/..."
 	],
@@ -23,7 +23,7 @@
 		},
 		{
 			"ImportPath": "github.com/calmh/xdr",
-			"Rev": "ec3d404f43731551258977b38dd72cf557d00398"
+			"Rev": "45c46b7db7ff83b8b9ee09bbd95f36ab50043ece"
 		},
 		{
 			"ImportPath": "github.com/juju/ratelimit",
@@ -31,7 +31,7 @@
 		},
 		{
 			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "97e257099d2ab9578151ba85e2641e2cd14d3ca8"
+			"Rev": "63c9e642efad852f49e20a6f90194cae112fd2ac"
 		},
 		{
 			"ImportPath": "github.com/syndtr/gosnappy/snappy",
@@ -51,23 +51,19 @@
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/bcrypt",
-			"Comment": "null-236",
-			"Rev": "69e2a90ed92d03812364aeb947b7068dc42e561e"
+			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
 		},
 		{
 			"ImportPath": "golang.org/x/crypto/blowfish",
-			"Comment": "null-236",
-			"Rev": "69e2a90ed92d03812364aeb947b7068dc42e561e"
+			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
 		},
 		{
 			"ImportPath": "golang.org/x/text/transform",
-			"Comment": "null-112",
-			"Rev": "2f707e0ad64637ca1318279be7201f5ed19c4050"
+			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
 		},
 		{
 			"ImportPath": "golang.org/x/text/unicode/norm",
-			"Comment": "null-112",
-			"Rev": "2f707e0ad64637ca1318279be7201f5ed19c4050"
+			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
 		}
 	]
 }

Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go

@@ -11,6 +11,8 @@ import (
 	"go/format"
 	"go/parser"
 	"go/token"
+	"io"
+	"log"
 	"os"
 	"regexp"
 	"strconv"
@@ -269,7 +271,7 @@ func handleStruct(t *ast.StructType) []fieldInfo {
 	return fs
 }
 
-func generateCode(s structInfo) {
+func generateCode(output io.Writer, s structInfo) {
 	name := s.Name
 	fs := s.Fields
 
@@ -286,7 +288,7 @@ func generateCode(s structInfo) {
 	if err != nil {
 		panic(err)
 	}
-	fmt.Println(string(bs))
+	fmt.Fprintln(output, string(bs))
 }
 
 func uncamelize(s string) string {
@@ -295,16 +297,16 @@ func uncamelize(s string) string {
 	})
 }
 
-func generateDiagram(s structInfo) {
+func generateDiagram(output io.Writer, s structInfo) {
 	sn := s.Name
 	fs := s.Fields
 
-	fmt.Println(sn + " Structure:")
-	fmt.Println()
-	fmt.Println(" 0                   1                   2                   3")
-	fmt.Println(" 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1")
+	fmt.Fprintln(output, sn+" Structure:")
+	fmt.Fprintln(output)
+	fmt.Fprintln(output, " 0                   1                   2                   3")
+	fmt.Fprintln(output, " 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1")
 	line := "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-	fmt.Println(line)
+	fmt.Fprintln(output, line)
 
 	for _, f := range fs {
 		tn := f.FieldType
@@ -312,52 +314,52 @@ func generateDiagram(s structInfo) {
 		name := uncamelize(f.Name)
 
 		if sl {
-			fmt.Printf("| %s |\n", center("Number of "+name, 61))
-			fmt.Println(line)
+			fmt.Fprintf(output, "| %s |\n", center("Number of "+name, 61))
+			fmt.Fprintln(output, line)
 		}
 		switch tn {
 		case "bool":
-			fmt.Printf("| %s |V|\n", center(name+" (V=0 or 1)", 59))
-			fmt.Println(line)
+			fmt.Fprintf(output, "| %s |V|\n", center(name+" (V=0 or 1)", 59))
+			fmt.Fprintln(output, line)
 		case "uint16":
-			fmt.Printf("| %s | %s |\n", center("0x0000", 29), center(name, 29))
-			fmt.Println(line)
+			fmt.Fprintf(output, "| %s | %s |\n", center("0x0000", 29), center(name, 29))
+			fmt.Fprintln(output, line)
 		case "uint32":
-			fmt.Printf("| %s |\n", center(name, 61))
-			fmt.Println(line)
+			fmt.Fprintf(output, "| %s |\n", center(name, 61))
+			fmt.Fprintln(output, line)
 		case "int64", "uint64":
-			fmt.Printf("| %-61s |\n", "")
-			fmt.Printf("+ %s +\n", center(name+" (64 bits)", 61))
-			fmt.Printf("| %-61s |\n", "")
-			fmt.Println(line)
+			fmt.Fprintf(output, "| %-61s |\n", "")
+			fmt.Fprintf(output, "+ %s +\n", center(name+" (64 bits)", 61))
+			fmt.Fprintf(output, "| %-61s |\n", "")
+			fmt.Fprintln(output, line)
 		case "string", "byte": // XXX We assume slice of byte!
-			fmt.Printf("| %s |\n", center("Length of "+name, 61))
-			fmt.Println(line)
-			fmt.Printf("/ %61s /\n", "")
-			fmt.Printf("\\ %s \\\n", center(name+" (variable length)", 61))
-			fmt.Printf("/ %61s /\n", "")
-			fmt.Println(line)
+			fmt.Fprintf(output, "| %s |\n", center("Length of "+name, 61))
+			fmt.Fprintln(output, line)
+			fmt.Fprintf(output, "/ %61s /\n", "")
+			fmt.Fprintf(output, "\\ %s \\\n", center(name+" (variable length)", 61))
+			fmt.Fprintf(output, "/ %61s /\n", "")
+			fmt.Fprintln(output, line)
 		default:
 			if sl {
 				tn = "Zero or more " + tn + " Structures"
-				fmt.Printf("/ %s /\n", center("", 61))
-				fmt.Printf("\\ %s \\\n", center(tn, 61))
-				fmt.Printf("/ %s /\n", center("", 61))
+				fmt.Fprintf(output, "/ %s /\n", center("", 61))
+				fmt.Fprintf(output, "\\ %s \\\n", center(tn, 61))
+				fmt.Fprintf(output, "/ %s /\n", center("", 61))
 			} else {
-				fmt.Printf("| %s |\n", center(tn, 61))
+				fmt.Fprintf(output, "| %s |\n", center(tn, 61))
 			}
-			fmt.Println(line)
+			fmt.Fprintln(output, line)
 		}
 	}
-	fmt.Println()
-	fmt.Println()
+	fmt.Fprintln(output)
+	fmt.Fprintln(output)
 }
 
-func generateXdr(s structInfo) {
+func generateXdr(output io.Writer, s structInfo) {
 	sn := s.Name
 	fs := s.Fields
 
-	fmt.Printf("struct %s {\n", sn)
+	fmt.Fprintf(output, "struct %s {\n", sn)
 
 	for _, f := range fs {
 		tn := f.FieldType
@@ -373,21 +375,21 @@ func generateXdr(s structInfo) {
 
 		switch tn {
 		case "uint16", "uint32":
-			fmt.Printf("\tunsigned int %s%s;\n", fn, suf)
+			fmt.Fprintf(output, "\tunsigned int %s%s;\n", fn, suf)
 		case "int64":
-			fmt.Printf("\thyper %s%s;\n", fn, suf)
+			fmt.Fprintf(output, "\thyper %s%s;\n", fn, suf)
 		case "uint64":
-			fmt.Printf("\tunsigned hyper %s%s;\n", fn, suf)
+			fmt.Fprintf(output, "\tunsigned hyper %s%s;\n", fn, suf)
 		case "string":
-			fmt.Printf("\tstring %s<%s>;\n", fn, l)
+			fmt.Fprintf(output, "\tstring %s<%s>;\n", fn, l)
 		case "byte":
-			fmt.Printf("\topaque %s<%s>;\n", fn, l)
+			fmt.Fprintf(output, "\topaque %s<%s>;\n", fn, l)
 		default:
-			fmt.Printf("\t%s %s%s;\n", tn, fn, suf)
+			fmt.Fprintf(output, "\t%s %s%s;\n", tn, fn, suf)
 		}
 	}
-	fmt.Println("}")
-	fmt.Println()
+	fmt.Fprintln(output, "}")
+	fmt.Fprintln(output)
 }
 
 func center(s string, w int) string {
@@ -418,25 +420,35 @@ func inspector(structs *[]structInfo) func(ast.Node) bool {
 }
 
 func main() {
+	outputFile := flag.String("o", "", "Output file, blank for stdout")
 	flag.Parse()
 	fname := flag.Arg(0)
 
 	fset := token.NewFileSet()
 	f, err := parser.ParseFile(fset, fname, nil, parser.ParseComments)
 	if err != nil {
-		panic(err)
+		log.Fatal(err)
 	}
 
 	var structs []structInfo
 	i := inspector(&structs)
 	ast.Inspect(f, i)
 
-	headerTpl.Execute(os.Stdout, map[string]string{"Package": f.Name.Name})
+	var output io.Writer = os.Stdout
+	if *outputFile != "" {
+		fd, err := os.Create(*outputFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		output = fd
+	}
+
+	headerTpl.Execute(output, map[string]string{"Package": f.Name.Name})
 	for _, s := range structs {
-		fmt.Printf("\n/*\n\n")
-		generateDiagram(s)
-		generateXdr(s)
-		fmt.Printf("*/\n")
-		generateCode(s)
+		fmt.Fprintf(output, "\n/*\n\n")
+		generateDiagram(output, s)
+		generateXdr(output, s)
+		fmt.Fprintf(output, "*/\n")
+		generateCode(output, s)
 	}
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go

@@ -8,152 +8,669 @@
 package cache
 
 import (
+	"sync"
 	"sync/atomic"
+	"unsafe"
+
+	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
-// SetFunc is the function that will be called by Namespace.Get to create
-// a cache object, if charge is less than one than the cache object will
-// not be registered to cache tree, if value is nil then the cache object
-// will not be created.
-type SetFunc func() (charge int, value interface{})
-
-// DelFin is the function that will be called as the result of a delete operation.
-// Exist == true is indication that the object is exist, and pending == true is
-// indication of deletion already happen but haven't done yet (wait for all handles
-// to be released). And exist == false means the object doesn't exist.
-type DelFin func(exist, pending bool)
-
-// PurgeFin is the function that will be called as the result of a purge operation.
-type PurgeFin func(ns, key uint64)
-
-// Cache is a cache tree. A cache instance must be goroutine-safe.
-type Cache interface {
-	// SetCapacity sets cache tree capacity.
-	SetCapacity(capacity int)
-
-	// Capacity returns cache tree capacity.
+// Cacher provides interface to implements a caching functionality.
+// An implementation must be goroutine-safe.
+type Cacher interface {
+	// Capacity returns cache capacity.
 	Capacity() int
 
-	// Used returns used cache tree capacity.
-	Used() int
+	// SetCapacity sets cache capacity.
+	SetCapacity(capacity int)
 
-	// Size returns entire alive cache objects size.
-	Size() int
+	// Promote promotes the 'cache node'.
+	Promote(n *Node)
 
-	// NumObjects returns number of alive objects.
-	NumObjects() int
+	// Ban evicts the 'cache node' and prevent subsequent 'promote'.
+	Ban(n *Node)
 
-	// GetNamespace gets cache namespace with the given id.
-	// GetNamespace is never return nil.
-	GetNamespace(id uint64) Namespace
+	// Evict evicts the 'cache node'.
+	Evict(n *Node)
 
-	// PurgeNamespace purges cache namespace with the given id from this cache tree.
-	// Also read Namespace.Purge.
-	PurgeNamespace(id uint64, fin PurgeFin)
+	// EvictNS evicts 'cache node' with the given namespace.
+	EvictNS(ns uint64)
 
-	// ZapNamespace detaches cache namespace with the given id from this cache tree.
-	// Also read Namespace.Zap.
-	ZapNamespace(id uint64)
+	// EvictAll evicts all 'cache node'.
+	EvictAll()
 
-	// Purge purges all cache namespace from this cache tree.
-	// This is behave the same as calling Namespace.Purge method on all cache namespace.
-	Purge(fin PurgeFin)
-
-	// Zap detaches all cache namespace from this cache tree.
-	// This is behave the same as calling Namespace.Zap method on all cache namespace.
-	Zap()
+	// Close closes the 'cache tree'
+	Close() error
 }
 
-// Namespace is a cache namespace. A namespace instance must be goroutine-safe.
-type Namespace interface {
-	// Get gets cache object with the given key.
-	// If cache object is not found and setf is not nil, Get will atomically creates
-	// the cache object by calling setf. Otherwise Get will returns nil.
-	//
-	// The returned cache handle should be released after use by calling Release
-	// method.
-	Get(key uint64, setf SetFunc) Handle
+// Value is a 'cacheable object'. It may implements util.Releaser, if
+// so the the Release method will be called once object is released.
+type Value interface{}
 
-	// Delete removes cache object with the given key from cache tree.
-	// A deleted cache object will be released as soon as all of its handles have
-	// been released.
-	// Delete only happen once, subsequent delete will consider cache object doesn't
-	// exist, even if the cache object ins't released yet.
-	//
-	// If not nil, fin will be called if the cache object doesn't exist or when
-	// finally be released.
-	//
-	// Delete returns true if such cache object exist and never been deleted.
-	Delete(key uint64, fin DelFin) bool
-
-	// Purge removes all cache objects within this namespace from cache tree.
-	// This is the same as doing delete on all cache objects.
-	//
-	// If not nil, fin will be called on all cache objects when its finally be
-	// released.
-	Purge(fin PurgeFin)
-
-	// Zap detaches namespace from cache tree and release all its cache objects.
-	// A zapped namespace can never be filled again.
-	// Calling Get on zapped namespace will always return nil.
-	Zap()
+type CacheGetter struct {
+	Cache *Cache
+	NS    uint64
 }
 
-// Handle is a cache handle.
-type Handle interface {
-	// Release releases this cache handle. This method can be safely called mutiple
-	// times.
-	Release()
-
-	// Value returns value of this cache handle.
-	// Value will returns nil after this cache handle have be released.
-	Value() interface{}
+func (g *CacheGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle {
+	return g.Cache.Get(g.NS, key, setFunc)
 }
 
+// The hash tables implementation is based on:
+// "Dynamic-Sized Nonblocking Hash Tables", by Yujie Liu, Kunlong Zhang, and Michael Spear. ACM Symposium on Principles of Distributed Computing, Jul 2014.
+
 const (
-	DelNotExist = iota
-	DelExist
-	DelPendig
+	mInitialSize           = 1 << 4
+	mOverflowThreshold     = 1 << 5
+	mOverflowGrowThreshold = 1 << 7
 )
 
-// Namespace state.
-type nsState int
-
-const (
-	nsEffective nsState = iota
-	nsZapped
-)
-
-// Node state.
-type nodeState int
-
-const (
-	nodeZero nodeState = iota
-	nodeEffective
-	nodeEvicted
-	nodeDeleted
-)
-
-// Fake handle.
-type fakeHandle struct {
-	value interface{}
-	fin   func()
-	once  uint32
+type mBucket struct {
+	mu     sync.Mutex
+	node   []*Node
+	frozen bool
 }
 
-func (h *fakeHandle) Value() interface{} {
-	if atomic.LoadUint32(&h.once) == 0 {
-		return h.value
+func (b *mBucket) freeze() []*Node {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if !b.frozen {
+		b.frozen = true
+	}
+	return b.node
+}
+
+func (b *mBucket) get(r *Cache, h *mNode, hash uint32, ns, key uint64, noset bool) (done, added bool, n *Node) {
+	b.mu.Lock()
+
+	if b.frozen {
+		b.mu.Unlock()
+		return
+	}
+
+	// Scan the node.
+	for _, n := range b.node {
+		if n.hash == hash && n.ns == ns && n.key == key {
+			atomic.AddInt32(&n.ref, 1)
+			b.mu.Unlock()
+			return true, false, n
+		}
+	}
+
+	// Get only.
+	if noset {
+		b.mu.Unlock()
+		return true, false, nil
+	}
+
+	// Create node.
+	n = &Node{
+		r:    r,
+		hash: hash,
+		ns:   ns,
+		key:  key,
+		ref:  1,
+	}
+	// Add node to bucket.
+	b.node = append(b.node, n)
+	bLen := len(b.node)
+	b.mu.Unlock()
+
+	// Update counter.
+	grow := atomic.AddInt32(&r.nodes, 1) >= h.growThreshold
+	if bLen > mOverflowThreshold {
+		grow = grow || atomic.AddInt32(&h.overflow, 1) >= mOverflowGrowThreshold
+	}
+
+	// Grow.
+	if grow && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+		nhLen := len(h.buckets) << 1
+		nh := &mNode{
+			buckets:         make([]unsafe.Pointer, nhLen),
+			mask:            uint32(nhLen) - 1,
+			pred:            unsafe.Pointer(h),
+			growThreshold:   int32(nhLen * mOverflowThreshold),
+			shrinkThreshold: int32(nhLen >> 1),
+		}
+		ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+		if !ok {
+			panic("BUG: failed swapping head")
+		}
+		go nh.initBuckets()
+	}
+
+	return true, true, n
+}
+
+func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
+	b.mu.Lock()
+
+	if b.frozen {
+		b.mu.Unlock()
+		return
+	}
+
+	// Scan the node.
+	var (
+		n    *Node
+		bLen int
+	)
+	for i := range b.node {
+		n = b.node[i]
+		if n.ns == ns && n.key == key {
+			if atomic.LoadInt32(&n.ref) == 0 {
+				deleted = true
+
+				// Call releaser.
+				if n.value != nil {
+					if r, ok := n.value.(util.Releaser); ok {
+						r.Release()
+					}
+					n.value = nil
+				}
+
+				// Remove node from bucket.
+				b.node = append(b.node[:i], b.node[i+1:]...)
+				bLen = len(b.node)
+			}
+			break
+		}
+	}
+	b.mu.Unlock()
+
+	if deleted {
+		// Call OnDel.
+		for _, f := range n.onDel {
+			f()
+		}
+
+		// Update counter.
+		atomic.AddInt32(&r.size, int32(n.size)*-1)
+		shrink := atomic.AddInt32(&r.nodes, -1) < h.shrinkThreshold
+		if bLen >= mOverflowThreshold {
+			atomic.AddInt32(&h.overflow, -1)
+		}
+
+		// Shrink.
+		if shrink && len(h.buckets) > mInitialSize && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
+			nhLen := len(h.buckets) >> 1
+			nh := &mNode{
+				buckets:         make([]unsafe.Pointer, nhLen),
+				mask:            uint32(nhLen) - 1,
+				pred:            unsafe.Pointer(h),
+				growThreshold:   int32(nhLen * mOverflowThreshold),
+				shrinkThreshold: int32(nhLen >> 1),
+			}
+			ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
+			if !ok {
+				panic("BUG: failed swapping head")
+			}
+			go nh.initBuckets()
+		}
+	}
+
+	return true, deleted
+}
+
+type mNode struct {
+	buckets         []unsafe.Pointer // []*mBucket
+	mask            uint32
+	pred            unsafe.Pointer // *mNode
+	resizeInProgess int32
+
+	overflow        int32
+	growThreshold   int32
+	shrinkThreshold int32
+}
+
+func (n *mNode) initBucket(i uint32) *mBucket {
+	if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
+		return b
+	}
+
+	p := (*mNode)(atomic.LoadPointer(&n.pred))
+	if p != nil {
+		var node []*Node
+		if n.mask > p.mask {
+			// Grow.
+			pb := (*mBucket)(atomic.LoadPointer(&p.buckets[i&p.mask]))
+			if pb == nil {
+				pb = p.initBucket(i & p.mask)
+			}
+			m := pb.freeze()
+			// Split nodes.
+			for _, x := range m {
+				if x.hash&n.mask == i {
+					node = append(node, x)
+				}
+			}
+		} else {
+			// Shrink.
+			pb0 := (*mBucket)(atomic.LoadPointer(&p.buckets[i]))
+			if pb0 == nil {
+				pb0 = p.initBucket(i)
+			}
+			pb1 := (*mBucket)(atomic.LoadPointer(&p.buckets[i+uint32(len(n.buckets))]))
+			if pb1 == nil {
+				pb1 = p.initBucket(i + uint32(len(n.buckets)))
+			}
+			m0 := pb0.freeze()
+			m1 := pb1.freeze()
+			// Merge nodes.
+			node = make([]*Node, 0, len(m0)+len(m1))
+			node = append(node, m0...)
+			node = append(node, m1...)
+		}
+		b := &mBucket{node: node}
+		if atomic.CompareAndSwapPointer(&n.buckets[i], nil, unsafe.Pointer(b)) {
+			if len(node) > mOverflowThreshold {
+				atomic.AddInt32(&n.overflow, int32(len(node)-mOverflowThreshold))
+			}
+			return b
+		}
+	}
+
+	return (*mBucket)(atomic.LoadPointer(&n.buckets[i]))
+}
+
+func (n *mNode) initBuckets() {
+	for i := range n.buckets {
+		n.initBucket(uint32(i))
+	}
+	atomic.StorePointer(&n.pred, nil)
+}
+
+// Cache is a 'cache map'.
+type Cache struct {
+	mu     sync.RWMutex
+	mHead  unsafe.Pointer // *mNode
+	nodes  int32
+	size   int32
+	cacher Cacher
+	closed bool
+}
+
+// NewCache creates a new 'cache map'. The cacher is optional and
+// may be nil.
+func NewCache(cacher Cacher) *Cache {
+	h := &mNode{
+		buckets:         make([]unsafe.Pointer, mInitialSize),
+		mask:            mInitialSize - 1,
+		growThreshold:   int32(mInitialSize * mOverflowThreshold),
+		shrinkThreshold: 0,
+	}
+	for i := range h.buckets {
+		h.buckets[i] = unsafe.Pointer(&mBucket{})
+	}
+	r := &Cache{
+		mHead:  unsafe.Pointer(h),
+		cacher: cacher,
+	}
+	return r
+}
+
+func (r *Cache) getBucket(hash uint32) (*mNode, *mBucket) {
+	h := (*mNode)(atomic.LoadPointer(&r.mHead))
+	i := hash & h.mask
+	b := (*mBucket)(atomic.LoadPointer(&h.buckets[i]))
+	if b == nil {
+		b = h.initBucket(i)
+	}
+	return h, b
+}
+
+func (r *Cache) delete(n *Node) bool {
+	for {
+		h, b := r.getBucket(n.hash)
+		done, deleted := b.delete(r, h, n.hash, n.ns, n.key)
+		if done {
+			return deleted
+		}
+	}
+	return false
+}
+
+// Nodes returns number of 'cache node' in the map.
+func (r *Cache) Nodes() int {
+	return int(atomic.LoadInt32(&r.nodes))
+}
+
+// Size returns sums of 'cache node' size in the map.
+func (r *Cache) Size() int {
+	return int(atomic.LoadInt32(&r.size))
+}
+
+// Capacity returns cache capacity.
+func (r *Cache) Capacity() int {
+	if r.cacher == nil {
+		return 0
+	}
+	return r.cacher.Capacity()
+}
+
+// SetCapacity sets cache capacity.
+func (r *Cache) SetCapacity(capacity int) {
+	if r.cacher != nil {
+		r.cacher.SetCapacity(capacity)
+	}
+}
+
+// Get gets 'cache node' with the given namespace and key.
+// If cache node is not found and setFunc is not nil, Get will atomically creates
+// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
+//
+// The returned 'cache handle' should be released after use by calling Release
+// method.
+func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return nil
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
+		if done {
+			if n != nil {
+				n.mu.Lock()
+				if n.value == nil {
+					if setFunc == nil {
+						n.mu.Unlock()
+						n.unref()
+						return nil
+					}
+
+					n.size, n.value = setFunc()
+					if n.value == nil {
+						n.size = 0
+						n.mu.Unlock()
+						n.unref()
+						return nil
+					}
+					atomic.AddInt32(&r.size, int32(n.size))
+				}
+				n.mu.Unlock()
+				if r.cacher != nil {
+					r.cacher.Promote(n)
+				}
+				return &Handle{unsafe.Pointer(n)}
+			}
+
+			break
+		}
 	}
 	return nil
 }
 
-func (h *fakeHandle) Release() {
-	if !atomic.CompareAndSwapUint32(&h.once, 0, 1) {
+// Delete removes and ban 'cache node' with the given namespace and key.
+// A banned 'cache node' will never inserted into the 'cache tree'. Ban
+// only attributed to the particular 'cache node', so when a 'cache node'
+// is recreated it will not be banned.
+//
+// If onDel is not nil, then it will be executed if such 'cache node'
+// doesn't exist or once the 'cache node' is released.
+//
+// Delete return true is such 'cache node' exist.
+func (r *Cache) Delete(ns, key uint64, onDel func()) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return false
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, true)
+		if done {
+			if n != nil {
+				if onDel != nil {
+					n.mu.Lock()
+					n.onDel = append(n.onDel, onDel)
+					n.mu.Unlock()
+				}
+				if r.cacher != nil {
+					r.cacher.Ban(n)
+				}
+				n.unref()
+				return true
+			}
+
+			break
+		}
+	}
+
+	if onDel != nil {
+		onDel()
+	}
+
+	return false
+}
+
+// Evict evicts 'cache node' with the given namespace and key. This will
+// simply call Cacher.Evict.
+//
+// Evict return true is such 'cache node' exist.
+func (r *Cache) Evict(ns, key uint64) bool {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return false
+	}
+
+	hash := murmur32(ns, key, 0xf00)
+	for {
+		h, b := r.getBucket(hash)
+		done, _, n := b.get(r, h, hash, ns, key, true)
+		if done {
+			if n != nil {
+				if r.cacher != nil {
+					r.cacher.Evict(n)
+				}
+				n.unref()
+				return true
+			}
+
+			break
+		}
+	}
+
+	return false
+}
+
+// EvictNS evicts 'cache node' with the given namespace. This will
+// simply call Cacher.EvictNS.
+func (r *Cache) EvictNS(ns uint64) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
 		return
 	}
-	if h.fin != nil {
-		h.fin()
-		h.fin = nil
+
+	if r.cacher != nil {
+		r.cacher.EvictNS(ns)
 	}
 }
+
+// EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
+func (r *Cache) EvictAll() {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if r.closed {
+		return
+	}
+
+	if r.cacher != nil {
+		r.cacher.EvictAll()
+	}
+}
+
+// Close closes the 'cache map' and releases all 'cache node'.
+func (r *Cache) Close() error {
+	r.mu.Lock()
+	if !r.closed {
+		r.closed = true
+
+		if r.cacher != nil {
+			if err := r.cacher.Close(); err != nil {
+				return err
+			}
+		}
+
+		h := (*mNode)(r.mHead)
+		h.initBuckets()
+
+		for i := range h.buckets {
+			b := (*mBucket)(h.buckets[i])
+			for _, n := range b.node {
+				// Call releaser.
+				if n.value != nil {
+					if r, ok := n.value.(util.Releaser); ok {
+						r.Release()
+					}
+					n.value = nil
+				}
+
+				// Call OnDel.
+				for _, f := range n.onDel {
+					f()
+				}
+			}
+		}
+	}
+	r.mu.Unlock()
+	return nil
+}
+
+// Node is a 'cache node'.
+type Node struct {
+	r *Cache
+
+	hash    uint32
+	ns, key uint64
+
+	mu    sync.Mutex
+	size  int
+	value Value
+
+	ref   int32
+	onDel []func()
+
+	CacheData unsafe.Pointer
+}
+
+// NS returns this 'cache node' namespace.
+func (n *Node) NS() uint64 {
+	return n.ns
+}
+
+// Key returns this 'cache node' key.
+func (n *Node) Key() uint64 {
+	return n.key
+}
+
+// Size returns this 'cache node' size.
+func (n *Node) Size() int {
+	return n.size
+}
+
+// Value returns this 'cache node' value.
+func (n *Node) Value() Value {
+	return n.value
+}
+
+// Ref returns this 'cache node' ref counter.
+func (n *Node) Ref() int32 {
+	return atomic.LoadInt32(&n.ref)
+}
+
+// GetHandle returns an handle for this 'cache node'.
+func (n *Node) GetHandle() *Handle {
+	if atomic.AddInt32(&n.ref, 1) <= 1 {
+		panic("BUG: Node.GetHandle on zero ref")
+	}
+	return &Handle{unsafe.Pointer(n)}
+}
+
+func (n *Node) unref() {
+	if atomic.AddInt32(&n.ref, -1) == 0 {
+		n.r.delete(n)
+	}
+}
+
+func (n *Node) unrefLocked() {
+	if atomic.AddInt32(&n.ref, -1) == 0 {
+		n.r.mu.RLock()
+		if !n.r.closed {
+			n.r.delete(n)
+		}
+		n.r.mu.RUnlock()
+	}
+}
+
+type Handle struct {
+	n unsafe.Pointer // *Node
+}
+
+func (h *Handle) Value() Value {
+	n := (*Node)(atomic.LoadPointer(&h.n))
+	if n != nil {
+		return n.value
+	}
+	return nil
+}
+
+func (h *Handle) Release() {
+	nPtr := atomic.LoadPointer(&h.n)
+	if nPtr != nil && atomic.CompareAndSwapPointer(&h.n, nPtr, nil) {
+		n := (*Node)(nPtr)
+		n.unrefLocked()
+	}
+}
+
+func murmur32(ns, key uint64, seed uint32) uint32 {
+	const (
+		m = uint32(0x5bd1e995)
+		r = 24
+	)
+
+	k1 := uint32(ns >> 32)
+	k2 := uint32(ns)
+	k3 := uint32(key >> 32)
+	k4 := uint32(key)
+
+	k1 *= m
+	k1 ^= k1 >> r
+	k1 *= m
+
+	k2 *= m
+	k2 ^= k2 >> r
+	k2 *= m
+
+	k3 *= m
+	k3 ^= k3 >> r
+	k3 *= m
+
+	k4 *= m
+	k4 ^= k4 >> r
+	k4 *= m
+
+	h := seed
+
+	h *= m
+	h ^= k1
+	h *= m
+	h ^= k2
+	h *= m
+	h ^= k3
+	h *= m
+	h ^= k4
+
+	h ^= h >> 13
+	h *= m
+	h ^= h >> 15
+
+	return h
+}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go

@@ -13,11 +13,26 @@ import (
 	"sync/atomic"
 	"testing"
 	"time"
+	"unsafe"
 )
 
+type int32o int32
+
+func (o *int32o) acquire() {
+	if atomic.AddInt32((*int32)(o), 1) != 1 {
+		panic("BUG: invalid ref")
+	}
+}
+
+func (o *int32o) Release() {
+	if atomic.AddInt32((*int32)(o), -1) != 0 {
+		panic("BUG: invalid ref")
+	}
+}
+
 type releaserFunc struct {
 	fn    func()
-	value interface{}
+	value Value
 }
 
 func (r releaserFunc) Release() {
@@ -26,8 +41,8 @@ func (r releaserFunc) Release() {
 	}
 }
 
-func set(ns Namespace, key uint64, value interface{}, charge int, relf func()) Handle {
-	return ns.Get(key, func() (int, interface{}) {
+func set(c *Cache, ns, key uint64, value Value, charge int, relf func()) *Handle {
+	return c.Get(ns, key, func() (int, Value) {
 		if relf != nil {
 			return charge, releaserFunc{relf, value}
 		} else {
@@ -36,7 +51,246 @@ func set(ns Namespace, key uint64, value interface{}, charge int, relf func()) H
 	})
 }
 
-func TestCache_HitMiss(t *testing.T) {
+func TestCacheMap(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	nsx := []struct {
+		nobjects, nhandles, concurrent, repeat int
+	}{
+		{10000, 400, 50, 3},
+		{100000, 1000, 100, 10},
+	}
+
+	var (
+		objects [][]int32o
+		handles [][]unsafe.Pointer
+	)
+
+	for _, x := range nsx {
+		objects = append(objects, make([]int32o, x.nobjects))
+		handles = append(handles, make([]unsafe.Pointer, x.nhandles))
+	}
+
+	c := NewCache(nil)
+
+	wg := new(sync.WaitGroup)
+	var done int32
+
+	for ns, x := range nsx {
+		for i := 0; i < x.concurrent; i++ {
+			wg.Add(1)
+			go func(ns, i, repeat int, objects []int32o, handles []unsafe.Pointer) {
+				defer wg.Done()
+				r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+				for j := len(objects) * repeat; j >= 0; j-- {
+					key := uint64(r.Intn(len(objects)))
+					h := c.Get(uint64(ns), key, func() (int, Value) {
+						o := &objects[key]
+						o.acquire()
+						return 1, o
+					})
+					if v := h.Value().(*int32o); v != &objects[key] {
+						t.Fatalf("#%d invalid value: want=%p got=%p", ns, &objects[key], v)
+					}
+					if objects[key] != 1 {
+						t.Fatalf("#%d invalid object %d: %d", ns, key, objects[key])
+					}
+					if !atomic.CompareAndSwapPointer(&handles[r.Intn(len(handles))], nil, unsafe.Pointer(h)) {
+						h.Release()
+					}
+				}
+			}(ns, i, x.repeat, objects[ns], handles[ns])
+		}
+
+		go func(handles []unsafe.Pointer) {
+			r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+			for atomic.LoadInt32(&done) == 0 {
+				i := r.Intn(len(handles))
+				h := (*Handle)(atomic.LoadPointer(&handles[i]))
+				if h != nil && atomic.CompareAndSwapPointer(&handles[i], unsafe.Pointer(h), nil) {
+					h.Release()
+				}
+				time.Sleep(time.Millisecond)
+			}
+		}(handles[ns])
+	}
+
+	go func() {
+		handles := make([]*Handle, 100000)
+		for atomic.LoadInt32(&done) == 0 {
+			for i := range handles {
+				handles[i] = c.Get(999999999, uint64(i), func() (int, Value) {
+					return 1, 1
+				})
+			}
+			for _, h := range handles {
+				h.Release()
+			}
+		}
+	}()
+
+	wg.Wait()
+
+	atomic.StoreInt32(&done, 1)
+
+	for _, handles0 := range handles {
+		for i := range handles0 {
+			h := (*Handle)(atomic.LoadPointer(&handles0[i]))
+			if h != nil && atomic.CompareAndSwapPointer(&handles0[i], unsafe.Pointer(h), nil) {
+				h.Release()
+			}
+		}
+	}
+
+	for ns, objects0 := range objects {
+		for i, o := range objects0 {
+			if o != 0 {
+				t.Fatalf("invalid object #%d.%d: ref=%d", ns, i, o)
+			}
+		}
+	}
+}
+
+func TestCacheMap_NodesAndSize(t *testing.T) {
+	c := NewCache(nil)
+	if c.Nodes() != 0 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
+	}
+	if c.Size() != 0 {
+		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
+	}
+	set(c, 0, 1, 1, 1, nil)
+	set(c, 0, 2, 2, 2, nil)
+	set(c, 1, 1, 3, 3, nil)
+	set(c, 2, 1, 4, 1, nil)
+	if c.Nodes() != 4 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 4, c.Nodes())
+	}
+	if c.Size() != 7 {
+		t.Errorf("invalid size counter: want=%d got=%d", 4, c.Size())
+	}
+}
+
+func TestLRUCache_Capacity(t *testing.T) {
+	c := NewCache(NewLRU(10))
+	if c.Capacity() != 10 {
+		t.Errorf("invalid capacity: want=%d got=%d", 10, c.Capacity())
+	}
+	set(c, 0, 1, 1, 1, nil).Release()
+	set(c, 0, 2, 2, 2, nil).Release()
+	set(c, 1, 1, 3, 3, nil).Release()
+	set(c, 2, 1, 4, 1, nil).Release()
+	set(c, 2, 2, 5, 1, nil).Release()
+	set(c, 2, 3, 6, 1, nil).Release()
+	set(c, 2, 4, 7, 1, nil).Release()
+	set(c, 2, 5, 8, 1, nil).Release()
+	if c.Nodes() != 7 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 7, c.Nodes())
+	}
+	if c.Size() != 10 {
+		t.Errorf("invalid size counter: want=%d got=%d", 10, c.Size())
+	}
+	c.SetCapacity(9)
+	if c.Capacity() != 9 {
+		t.Errorf("invalid capacity: want=%d got=%d", 9, c.Capacity())
+	}
+	if c.Nodes() != 6 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 6, c.Nodes())
+	}
+	if c.Size() != 8 {
+		t.Errorf("invalid size counter: want=%d got=%d", 8, c.Size())
+	}
+}
+
+func TestCacheMap_NilValue(t *testing.T) {
+	c := NewCache(NewLRU(10))
+	h := c.Get(0, 0, func() (size int, value Value) {
+		return 1, nil
+	})
+	if h != nil {
+		t.Error("cache handle is non-nil")
+	}
+	if c.Nodes() != 0 {
+		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
+	}
+	if c.Size() != 0 {
+		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
+	}
+}
+
+func TestLRUCache_GetLatency(t *testing.T) {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	const (
+		concurrentSet = 30
+		concurrentGet = 3
+		duration      = 3 * time.Second
+		delay         = 3 * time.Millisecond
+		maxkey        = 100000
+	)
+
+	var (
+		set, getHit, getAll        int32
+		getMaxLatency, getDuration int64
+	)
+
+	c := NewCache(NewLRU(5000))
+	wg := &sync.WaitGroup{}
+	until := time.Now().Add(duration)
+	for i := 0; i < concurrentSet; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			r := rand.New(rand.NewSource(time.Now().UnixNano()))
+			for time.Now().Before(until) {
+				c.Get(0, uint64(r.Intn(maxkey)), func() (int, Value) {
+					time.Sleep(delay)
+					atomic.AddInt32(&set, 1)
+					return 1, 1
+				}).Release()
+			}
+		}(i)
+	}
+	for i := 0; i < concurrentGet; i++ {
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			r := rand.New(rand.NewSource(time.Now().UnixNano()))
+			for {
+				mark := time.Now()
+				if mark.Before(until) {
+					h := c.Get(0, uint64(r.Intn(maxkey)), nil)
+					latency := int64(time.Now().Sub(mark))
+					m := atomic.LoadInt64(&getMaxLatency)
+					if latency > m {
+						atomic.CompareAndSwapInt64(&getMaxLatency, m, latency)
+					}
+					atomic.AddInt64(&getDuration, latency)
+					if h != nil {
+						atomic.AddInt32(&getHit, 1)
+						h.Release()
+					}
+					atomic.AddInt32(&getAll, 1)
+				} else {
+					break
+				}
+			}
+		}(i)
+	}
+
+	wg.Wait()
+	getAvglatency := time.Duration(getDuration) / time.Duration(getAll)
+	t.Logf("set=%d getHit=%d getAll=%d getMaxLatency=%v getAvgLatency=%v",
+		set, getHit, getAll, time.Duration(getMaxLatency), getAvglatency)
+
+	if getAvglatency > delay/3 {
+		t.Errorf("get avg latency > %v: got=%v", delay/3, getAvglatency)
+	}
+}
+
+func TestLRUCache_HitMiss(t *testing.T) {
 	cases := []struct {
 		key   uint64
 		value string
@@ -54,14 +308,13 @@ func TestCache_HitMiss(t *testing.T) {
 	}
 
 	setfin := 0
-	c := NewLRUCache(1000)
-	ns := c.GetNamespace(0)
+	c := NewCache(NewLRU(1000))
 	for i, x := range cases {
-		set(ns, x.key, x.value, len(x.value), func() {
+		set(c, 0, x.key, x.value, len(x.value), func() {
 			setfin++
 		}).Release()
 		for j, y := range cases {
-			h := ns.Get(y.key, nil)
+			h := c.Get(0, y.key, nil)
 			if j <= i {
 				// should hit
 				if h == nil {
@@ -85,7 +338,7 @@ func TestCache_HitMiss(t *testing.T) {
 
 	for i, x := range cases {
 		finalizerOk := false
-		ns.Delete(x.key, func(exist, pending bool) {
+		c.Delete(0, x.key, func() {
 			finalizerOk = true
 		})
 
@@ -94,7 +347,7 @@ func TestCache_HitMiss(t *testing.T) {
 		}
 
 		for j, y := range cases {
-			h := ns.Get(y.key, nil)
+			h := c.Get(0, y.key, nil)
 			if j > i {
 				// should hit
 				if h == nil {
@@ -122,20 +375,19 @@ func TestCache_HitMiss(t *testing.T) {
 }
 
 func TestLRUCache_Eviction(t *testing.T) {
-	c := NewLRUCache(12)
-	ns := c.GetNamespace(0)
-	o1 := set(ns, 1, 1, 1, nil)
-	set(ns, 2, 2, 1, nil).Release()
-	set(ns, 3, 3, 1, nil).Release()
-	set(ns, 4, 4, 1, nil).Release()
-	set(ns, 5, 5, 1, nil).Release()
-	if h := ns.Get(2, nil); h != nil { // 1,3,4,5,2
+	c := NewCache(NewLRU(12))
+	o1 := set(c, 0, 1, 1, 1, nil)
+	set(c, 0, 2, 2, 1, nil).Release()
+	set(c, 0, 3, 3, 1, nil).Release()
+	set(c, 0, 4, 4, 1, nil).Release()
+	set(c, 0, 5, 5, 1, nil).Release()
+	if h := c.Get(0, 2, nil); h != nil { // 1,3,4,5,2
 		h.Release()
 	}
-	set(ns, 9, 9, 10, nil).Release() // 5,2,9
+	set(c, 0, 9, 9, 10, nil).Release() // 5,2,9
 
 	for _, key := range []uint64{9, 2, 5, 1} {
-		h := ns.Get(key, nil)
+		h := c.Get(0, key, nil)
 		if h == nil {
 			t.Errorf("miss for key '%d'", key)
 		} else {
@@ -147,7 +399,7 @@ func TestLRUCache_Eviction(t *testing.T) {
 	}
 	o1.Release()
 	for _, key := range []uint64{1, 2, 5} {
-		h := ns.Get(key, nil)
+		h := c.Get(0, key, nil)
 		if h == nil {
 			t.Errorf("miss for key '%d'", key)
 		} else {
@@ -158,7 +410,7 @@ func TestLRUCache_Eviction(t *testing.T) {
 		}
 	}
 	for _, key := range []uint64{3, 4, 9} {
-		h := ns.Get(key, nil)
+		h := c.Get(0, key, nil)
 		if h != nil {
 			t.Errorf("hit for key '%d'", key)
 			if x := h.Value().(int); x != int(key) {
@@ -169,487 +421,150 @@ func TestLRUCache_Eviction(t *testing.T) {
 	}
 }
 
-func TestLRUCache_SetGet(t *testing.T) {
-	c := NewLRUCache(13)
-	ns := c.GetNamespace(0)
-	for i := 0; i < 200; i++ {
-		n := uint64(rand.Intn(99999) % 20)
-		set(ns, n, n, 1, nil).Release()
-		if h := ns.Get(n, nil); h != nil {
-			if h.Value() == nil {
-				t.Errorf("key '%d' contains nil value", n)
+func TestLRUCache_Evict(t *testing.T) {
+	c := NewCache(NewLRU(6))
+	set(c, 0, 1, 1, 1, nil).Release()
+	set(c, 0, 2, 2, 1, nil).Release()
+	set(c, 1, 1, 4, 1, nil).Release()
+	set(c, 1, 2, 5, 1, nil).Release()
+	set(c, 2, 1, 6, 1, nil).Release()
+	set(c, 2, 2, 7, 1, nil).Release()
+
+	for ns := 0; ns < 3; ns++ {
+		for key := 1; key < 3; key++ {
+			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
+				h.Release()
 			} else {
-				if x := h.Value().(uint64); x != n {
-					t.Errorf("invalid value for key '%d' want '%d', got '%d'", n, n, x)
-				}
+				t.Errorf("Cache.Get on #%d.%d return nil", ns, key)
 			}
+		}
+	}
+
+	if ok := c.Evict(0, 1); !ok {
+		t.Error("first Cache.Evict on #0.1 return false")
+	}
+	if ok := c.Evict(0, 1); ok {
+		t.Error("second Cache.Evict on #0.1 return true")
+	}
+	if h := c.Get(0, 1, nil); h != nil {
+		t.Errorf("Cache.Get on #0.1 return non-nil: %v", h.Value())
+	}
+
+	c.EvictNS(1)
+	if h := c.Get(1, 1, nil); h != nil {
+		t.Errorf("Cache.Get on #1.1 return non-nil: %v", h.Value())
+	}
+	if h := c.Get(1, 2, nil); h != nil {
+		t.Errorf("Cache.Get on #1.2 return non-nil: %v", h.Value())
+	}
+
+	c.EvictAll()
+	for ns := 0; ns < 3; ns++ {
+		for key := 1; key < 3; key++ {
+			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
+				t.Errorf("Cache.Get on #%d.%d return non-nil: %v", ns, key, h.Value())
+			}
+		}
+	}
+}
+
+func TestLRUCache_Delete(t *testing.T) {
+	delFuncCalled := 0
+	delFunc := func() {
+		delFuncCalled++
+	}
+
+	c := NewCache(NewLRU(2))
+	set(c, 0, 1, 1, 1, nil).Release()
+	set(c, 0, 2, 2, 1, nil).Release()
+
+	if ok := c.Delete(0, 1, delFunc); !ok {
+		t.Error("Cache.Delete on #1 return false")
+	}
+	if h := c.Get(0, 1, nil); h != nil {
+		t.Errorf("Cache.Get on #1 return non-nil: %v", h.Value())
+	}
+	if ok := c.Delete(0, 1, delFunc); ok {
+		t.Error("Cache.Delete on #1 return true")
+	}
+
+	h2 := c.Get(0, 2, nil)
+	if h2 == nil {
+		t.Error("Cache.Get on #2 return nil")
+	}
+	if ok := c.Delete(0, 2, delFunc); !ok {
+		t.Error("(1) Cache.Delete on #2 return false")
+	}
+	if ok := c.Delete(0, 2, delFunc); !ok {
+		t.Error("(2) Cache.Delete on #2 return false")
+	}
+
+	set(c, 0, 3, 3, 1, nil).Release()
+	set(c, 0, 4, 4, 1, nil).Release()
+	c.Get(0, 2, nil).Release()
+
+	for key := 2; key <= 4; key++ {
+		if h := c.Get(0, uint64(key), nil); h != nil {
 			h.Release()
 		} else {
-			t.Errorf("key '%d' doesn't exist", n)
-		}
-	}
-}
-
-func TestLRUCache_Purge(t *testing.T) {
-	c := NewLRUCache(3)
-	ns1 := c.GetNamespace(0)
-	o1 := set(ns1, 1, 1, 1, nil)
-	o2 := set(ns1, 2, 2, 1, nil)
-	ns1.Purge(nil)
-	set(ns1, 3, 3, 1, nil).Release()
-	for _, key := range []uint64{1, 2, 3} {
-		h := ns1.Get(key, nil)
-		if h == nil {
-			t.Errorf("miss for key '%d'", key)
-		} else {
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-	o1.Release()
-	o2.Release()
-	for _, key := range []uint64{1, 2} {
-		h := ns1.Get(key, nil)
-		if h != nil {
-			t.Errorf("hit for key '%d'", key)
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-}
-
-type testingCacheObjectCounter struct {
-	created  uint
-	released uint
-}
-
-func (c *testingCacheObjectCounter) createOne() {
-	c.created++
-}
-
-func (c *testingCacheObjectCounter) releaseOne() {
-	c.released++
-}
-
-type testingCacheObject struct {
-	t   *testing.T
-	cnt *testingCacheObjectCounter
-
-	ns, key uint64
-
-	releaseCalled bool
-}
-
-func (x *testingCacheObject) Release() {
-	if !x.releaseCalled {
-		x.releaseCalled = true
-		x.cnt.releaseOne()
-	} else {
-		x.t.Errorf("duplicate setfin NS#%d KEY#%d", x.ns, x.key)
-	}
-}
-
-func TestLRUCache_ConcurrentSetGet(t *testing.T) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	seed := time.Now().UnixNano()
-	t.Logf("seed=%d", seed)
-
-	const (
-		N = 2000000
-		M = 4000
-		C = 3
-	)
-
-	var set, get uint32
-
-	wg := &sync.WaitGroup{}
-	c := NewLRUCache(M / 4)
-	for ni := uint64(0); ni < C; ni++ {
-		r0 := rand.New(rand.NewSource(seed + int64(ni)))
-		r1 := rand.New(rand.NewSource(seed + int64(ni) + 1))
-		ns := c.GetNamespace(ni)
-
-		wg.Add(2)
-		go func(ns Namespace, r *rand.Rand) {
-			for i := 0; i < N; i++ {
-				x := uint64(r.Int63n(M))
-				o := ns.Get(x, func() (int, interface{}) {
-					atomic.AddUint32(&set, 1)
-					return 1, x
-				})
-				if v := o.Value().(uint64); v != x {
-					t.Errorf("#%d invalid value, got=%d", x, v)
-				}
-				o.Release()
-			}
-			wg.Done()
-		}(ns, r0)
-		go func(ns Namespace, r *rand.Rand) {
-			for i := 0; i < N; i++ {
-				x := uint64(r.Int63n(M))
-				o := ns.Get(x, nil)
-				if o != nil {
-					atomic.AddUint32(&get, 1)
-					if v := o.Value().(uint64); v != x {
-						t.Errorf("#%d invalid value, got=%d", x, v)
-					}
-					o.Release()
-				}
-			}
-			wg.Done()
-		}(ns, r1)
-	}
-
-	wg.Wait()
-
-	t.Logf("set=%d get=%d", set, get)
-}
-
-func TestLRUCache_Finalizer(t *testing.T) {
-	const (
-		capacity   = 100
-		goroutines = 100
-		iterations = 10000
-		keymax     = 8000
-	)
-
-	cnt := &testingCacheObjectCounter{}
-
-	c := NewLRUCache(capacity)
-
-	type instance struct {
-		seed       int64
-		rnd        *rand.Rand
-		nsid       uint64
-		ns         Namespace
-		effective  int
-		handles    []Handle
-		handlesMap map[uint64]int
-
-		delete          bool
-		purge           bool
-		zap             bool
-		wantDel         int
-		delfinCalled    int
-		delfinCalledAll int
-		delfinCalledEff int
-		purgefinCalled  int
-	}
-
-	instanceGet := func(p *instance, key uint64) {
-		h := p.ns.Get(key, func() (charge int, value interface{}) {
-			to := &testingCacheObject{
-				t: t, cnt: cnt,
-				ns:  p.nsid,
-				key: key,
-			}
-			p.effective++
-			cnt.createOne()
-			return 1, releaserFunc{func() {
-				to.Release()
-				p.effective--
-			}, to}
-		})
-		p.handles = append(p.handles, h)
-		p.handlesMap[key] = p.handlesMap[key] + 1
-	}
-	instanceRelease := func(p *instance, i int) {
-		h := p.handles[i]
-		key := h.Value().(releaserFunc).value.(*testingCacheObject).key
-		if n := p.handlesMap[key]; n == 0 {
-			t.Fatal("key ref == 0")
-		} else if n > 1 {
-			p.handlesMap[key] = n - 1
-		} else {
-			delete(p.handlesMap, key)
-		}
-		h.Release()
-		p.handles = append(p.handles[:i], p.handles[i+1:]...)
-		p.handles[len(p.handles) : len(p.handles)+1][0] = nil
-	}
-
-	seed := time.Now().UnixNano()
-	t.Logf("seed=%d", seed)
-
-	instances := make([]*instance, goroutines)
-	for i := range instances {
-		p := &instance{}
-		p.handlesMap = make(map[uint64]int)
-		p.seed = seed + int64(i)
-		p.rnd = rand.New(rand.NewSource(p.seed))
-		p.nsid = uint64(i)
-		p.ns = c.GetNamespace(p.nsid)
-		p.delete = i%6 == 0
-		p.purge = i%8 == 0
-		p.zap = i%12 == 0 || i%3 == 0
-		instances[i] = p
-	}
-
-	runr := rand.New(rand.NewSource(seed - 1))
-	run := func(rnd *rand.Rand, x []*instance, init func(p *instance) bool, fn func(p *instance, i int) bool) {
-		var (
-			rx []*instance
-			rn []int
-		)
-		if init == nil {
-			rx = append([]*instance{}, x...)
-			rn = make([]int, len(x))
-		} else {
-			for _, p := range x {
-				if init(p) {
-					rx = append(rx, p)
-					rn = append(rn, 0)
-				}
-			}
-		}
-		for len(rx) > 0 {
-			i := rand.Intn(len(rx))
-			if fn(rx[i], rn[i]) {
-				rn[i]++
-			} else {
-				rx = append(rx[:i], rx[i+1:]...)
-				rn = append(rn[:i], rn[i+1:]...)
-			}
+			t.Errorf("Cache.Get on #%d return nil", key)
 		}
 	}
 
-	// Get and release.
-	run(runr, instances, nil, func(p *instance, i int) bool {
-		if i < iterations {
-			if len(p.handles) == 0 || p.rnd.Int()%2 == 0 {
-				instanceGet(p, uint64(p.rnd.Intn(keymax)))
-			} else {
-				instanceRelease(p, p.rnd.Intn(len(p.handles)))
-			}
-			return true
-		} else {
-			return false
+	h2.Release()
+	if h := c.Get(0, 2, nil); h != nil {
+		t.Errorf("Cache.Get on #2 return non-nil: %v", h.Value())
+	}
+
+	if delFuncCalled != 4 {
+		t.Errorf("delFunc isn't called 4 times: got=%d", delFuncCalled)
+	}
+}
+
+func TestLRUCache_Close(t *testing.T) {
+	relFuncCalled := 0
+	relFunc := func() {
+		relFuncCalled++
+	}
+	delFuncCalled := 0
+	delFunc := func() {
+		delFuncCalled++
+	}
+
+	c := NewCache(NewLRU(2))
+	set(c, 0, 1, 1, 1, relFunc).Release()
+	set(c, 0, 2, 2, 1, relFunc).Release()
+
+	h3 := set(c, 0, 3, 3, 1, relFunc)
+	if h3 == nil {
+		t.Error("Cache.Get on #3 return nil")
+	}
+	if ok := c.Delete(0, 3, delFunc); !ok {
+		t.Error("Cache.Delete on #3 return false")
+	}
+
+	c.Close()
+
+	if relFuncCalled != 3 {
+		t.Errorf("relFunc isn't called 3 times: got=%d", relFuncCalled)
+	}
+	if delFuncCalled != 1 {
+		t.Errorf("delFunc isn't called 1 times: got=%d", delFuncCalled)
+	}
+}
+
+func BenchmarkLRUCache(b *testing.B) {
+	c := NewCache(NewLRU(10000))
+
+	b.SetParallelism(10)
+	b.RunParallel(func(pb *testing.PB) {
+		r := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+		for pb.Next() {
+			key := uint64(r.Intn(1000000))
+			c.Get(0, key, func() (int, Value) {
+				return 1, key
+			}).Release()
 		}
 	})
-
-	if used, cap := c.Used(), c.Capacity(); used > cap {
-		t.Errorf("Used > capacity, used=%d cap=%d", used, cap)
-	}
-
-	// Check effective objects.
-	for i, p := range instances {
-		if int(p.effective) < len(p.handlesMap) {
-			t.Errorf("#%d effective objects < acquired handle, eo=%d ah=%d", i, p.effective, len(p.handlesMap))
-		}
-	}
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	// First delete.
-	run(runr, instances, func(p *instance) bool {
-		p.wantDel = p.effective
-		return p.delete
-	}, func(p *instance, i int) bool {
-		key := uint64(i)
-		if key < keymax {
-			_, wantExist := p.handlesMap[key]
-			gotExist := p.ns.Delete(key, func(exist, pending bool) {
-				p.delfinCalledAll++
-				if exist {
-					p.delfinCalledEff++
-				}
-			})
-			if !gotExist && wantExist {
-				t.Errorf("delete on NS#%d KEY#%d not found", p.nsid, key)
-			}
-			return true
-		} else {
-			return false
-		}
-	})
-
-	// Second delete.
-	run(runr, instances, func(p *instance) bool {
-		p.delfinCalled = 0
-		return p.delete
-	}, func(p *instance, i int) bool {
-		key := uint64(i)
-		if key < keymax {
-			gotExist := p.ns.Delete(key, func(exist, pending bool) {
-				if exist && !pending {
-					t.Errorf("delete fin on NS#%d KEY#%d exist and not pending for deletion", p.nsid, key)
-				}
-				p.delfinCalled++
-			})
-			if gotExist {
-				t.Errorf("delete on NS#%d KEY#%d found", p.nsid, key)
-			}
-			return true
-		} else {
-			if p.delfinCalled != keymax {
-				t.Errorf("(2) NS#%d not all delete fin called, diff=%d", p.nsid, keymax-p.delfinCalled)
-			}
-			return false
-		}
-	})
-
-	// Purge.
-	run(runr, instances, func(p *instance) bool {
-		return p.purge
-	}, func(p *instance, i int) bool {
-		p.ns.Purge(func(ns, key uint64) {
-			p.purgefinCalled++
-		})
-		return false
-	})
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	// Release.
-	run(runr, instances, func(p *instance) bool {
-		return !p.zap
-	}, func(p *instance, i int) bool {
-		if len(p.handles) > 0 {
-			instanceRelease(p, len(p.handles)-1)
-			return true
-		} else {
-			return false
-		}
-	})
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	// Zap.
-	run(runr, instances, func(p *instance) bool {
-		return p.zap
-	}, func(p *instance, i int) bool {
-		p.ns.Zap()
-		p.handles = nil
-		p.handlesMap = nil
-		return false
-	})
-
-	if want := int(cnt.created - cnt.released); c.Size() != want {
-		t.Errorf("Invalid cache size, want=%d got=%d", want, c.Size())
-	}
-
-	if notrel, used := int(cnt.created-cnt.released), c.Used(); notrel != used {
-		t.Errorf("Invalid used value, want=%d got=%d", notrel, used)
-	}
-
-	c.Purge(nil)
-
-	for _, p := range instances {
-		if p.delete {
-			if p.delfinCalledAll != keymax {
-				t.Errorf("#%d not all delete fin called, purge=%v zap=%v diff=%d", p.nsid, p.purge, p.zap, keymax-p.delfinCalledAll)
-			}
-			if p.delfinCalledEff != p.wantDel {
-				t.Errorf("#%d not all effective delete fin called, diff=%d", p.nsid, p.wantDel-p.delfinCalledEff)
-			}
-			if p.purge && p.purgefinCalled > 0 {
-				t.Errorf("#%d some purge fin called, delete=%v zap=%v n=%d", p.nsid, p.delete, p.zap, p.purgefinCalled)
-			}
-		} else {
-			if p.purge {
-				if p.purgefinCalled != p.wantDel {
-					t.Errorf("#%d not all purge fin called, delete=%v zap=%v diff=%d", p.nsid, p.delete, p.zap, p.wantDel-p.purgefinCalled)
-				}
-			}
-		}
-	}
-
-	if cnt.created != cnt.released {
-		t.Errorf("Some cache object weren't released, created=%d released=%d", cnt.created, cnt.released)
-	}
-}
-
-func BenchmarkLRUCache_Set(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil)
-	}
-}
-
-func BenchmarkLRUCache_Get(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil)
-	}
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		ns.Get(i, nil)
-	}
-}
-
-func BenchmarkLRUCache_Get2(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil)
-	}
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		ns.Get(i, func() (charge int, value interface{}) {
-			return 0, nil
-		})
-	}
-}
-
-func BenchmarkLRUCache_Release(b *testing.B) {
-	c := NewLRUCache(0)
-	ns := c.GetNamespace(0)
-	handles := make([]Handle, b.N)
-	for i := uint64(0); i < uint64(b.N); i++ {
-		handles[i] = set(ns, i, "", 1, nil)
-	}
-	b.ResetTimer()
-	for _, h := range handles {
-		h.Release()
-	}
-}
-
-func BenchmarkLRUCache_SetRelease(b *testing.B) {
-	capacity := b.N / 100
-	if capacity <= 0 {
-		capacity = 10
-	}
-	c := NewLRUCache(capacity)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-	for i := uint64(0); i < uint64(b.N); i++ {
-		set(ns, i, "", 1, nil).Release()
-	}
-}
-
-func BenchmarkLRUCache_SetReleaseTwice(b *testing.B) {
-	capacity := b.N / 100
-	if capacity <= 0 {
-		capacity = 10
-	}
-	c := NewLRUCache(capacity)
-	ns := c.GetNamespace(0)
-	b.ResetTimer()
-
-	na := b.N / 2
-	nb := b.N - na
-
-	for i := uint64(0); i < uint64(na); i++ {
-		set(ns, i, "", 1, nil).Release()
-	}
-
-	for i := uint64(0); i < uint64(nb); i++ {
-		set(ns, i, "", 1, nil).Release()
-	}
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru.go

@@ -0,0 +1,195 @@
+// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
+// All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package cache
+
+import (
+	"sync"
+	"unsafe"
+)
+
+type lruNode struct {
+	n   *Node
+	h   *Handle
+	ban bool
+
+	next, prev *lruNode
+}
+
+func (n *lruNode) insert(at *lruNode) {
+	x := at.next
+	at.next = n
+	n.prev = at
+	n.next = x
+	x.prev = n
+}
+
+func (n *lruNode) remove() {
+	if n.prev != nil {
+		n.prev.next = n.next
+		n.next.prev = n.prev
+		n.prev = nil
+		n.next = nil
+	} else {
+		panic("BUG: removing removed node")
+	}
+}
+
+type lru struct {
+	mu       sync.Mutex
+	capacity int
+	used     int
+	recent   lruNode
+}
+
+func (r *lru) reset() {
+	r.recent.next = &r.recent
+	r.recent.prev = &r.recent
+	r.used = 0
+}
+
+func (r *lru) Capacity() int {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	return r.capacity
+}
+
+func (r *lru) SetCapacity(capacity int) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	r.capacity = capacity
+	for r.used > r.capacity {
+		rn := r.recent.prev
+		if rn == nil {
+			panic("BUG: invalid LRU used or capacity counter")
+		}
+		rn.remove()
+		rn.n.CacheData = nil
+		r.used -= rn.n.Size()
+		evicted = append(evicted, rn)
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Promote(n *Node) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	if n.CacheData == nil {
+		if n.Size() <= r.capacity {
+			rn := &lruNode{n: n, h: n.GetHandle()}
+			rn.insert(&r.recent)
+			n.CacheData = unsafe.Pointer(rn)
+			r.used += n.Size()
+
+			for r.used > r.capacity {
+				rn := r.recent.prev
+				if rn == nil {
+					panic("BUG: invalid LRU used or capacity counter")
+				}
+				rn.remove()
+				rn.n.CacheData = nil
+				r.used -= rn.n.Size()
+				evicted = append(evicted, rn)
+			}
+		}
+	} else {
+		rn := (*lruNode)(n.CacheData)
+		if !rn.ban {
+			rn.remove()
+			rn.insert(&r.recent)
+		}
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Ban(n *Node) {
+	r.mu.Lock()
+	if n.CacheData == nil {
+		n.CacheData = unsafe.Pointer(&lruNode{n: n, ban: true})
+	} else {
+		rn := (*lruNode)(n.CacheData)
+		if !rn.ban {
+			rn.remove()
+			rn.ban = true
+			r.used -= rn.n.Size()
+			r.mu.Unlock()
+
+			rn.h.Release()
+			rn.h = nil
+			return
+		}
+	}
+	r.mu.Unlock()
+}
+
+func (r *lru) Evict(n *Node) {
+	r.mu.Lock()
+	rn := (*lruNode)(n.CacheData)
+	if rn == nil || rn.ban {
+		r.mu.Unlock()
+		return
+	}
+	n.CacheData = nil
+	r.mu.Unlock()
+
+	rn.h.Release()
+}
+
+func (r *lru) EvictNS(ns uint64) {
+	var evicted []*lruNode
+
+	r.mu.Lock()
+	for e := r.recent.prev; e != &r.recent; {
+		rn := e
+		e = e.prev
+		if rn.n.NS() == ns {
+			rn.remove()
+			rn.n.CacheData = nil
+			r.used -= rn.n.Size()
+			evicted = append(evicted, rn)
+		}
+	}
+	r.mu.Unlock()
+
+	for _, rn := range evicted {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) EvictAll() {
+	r.mu.Lock()
+	back := r.recent.prev
+	for rn := back; rn != &r.recent; rn = rn.prev {
+		rn.n.CacheData = nil
+	}
+	r.reset()
+	r.mu.Unlock()
+
+	for rn := back; rn != &r.recent; rn = rn.prev {
+		rn.h.Release()
+	}
+}
+
+func (r *lru) Close() error {
+	return nil
+}
+
+// NewLRU create a new LRU-cache.
+func NewLRU(capacity int) Cacher {
+	r := &lru{capacity: capacity}
+	r.reset()
+	return r
+}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/lru_cache.go

@@ -1,622 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package cache
-
-import (
-	"sync"
-	"sync/atomic"
-
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-// The LLRB implementation were taken from https://github.com/petar/GoLLRB.
-// Which contains the following header:
-//
-// Copyright 2010 Petar Maymounkov. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// lruCache represent a LRU cache state.
-type lruCache struct {
-	mu                sync.Mutex
-	recent            lruNode
-	table             map[uint64]*lruNs
-	capacity          int
-	used, size, alive int
-}
-
-// NewLRUCache creates a new initialized LRU cache with the given capacity.
-func NewLRUCache(capacity int) Cache {
-	c := &lruCache{
-		table:    make(map[uint64]*lruNs),
-		capacity: capacity,
-	}
-	c.recent.rNext = &c.recent
-	c.recent.rPrev = &c.recent
-	return c
-}
-
-func (c *lruCache) Capacity() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.capacity
-}
-
-func (c *lruCache) Used() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.used
-}
-
-func (c *lruCache) Size() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.size
-}
-
-func (c *lruCache) NumObjects() int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	return c.alive
-}
-
-// SetCapacity set cache capacity.
-func (c *lruCache) SetCapacity(capacity int) {
-	c.mu.Lock()
-	c.capacity = capacity
-	c.evict()
-	c.mu.Unlock()
-}
-
-// GetNamespace return namespace object for given id.
-func (c *lruCache) GetNamespace(id uint64) Namespace {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if ns, ok := c.table[id]; ok {
-		return ns
-	}
-
-	ns := &lruNs{lru: c, id: id}
-	c.table[id] = ns
-	return ns
-}
-
-func (c *lruCache) ZapNamespace(id uint64) {
-	c.mu.Lock()
-	if ns, exist := c.table[id]; exist {
-		ns.zapNB()
-		delete(c.table, id)
-	}
-	c.mu.Unlock()
-}
-
-func (c *lruCache) PurgeNamespace(id uint64, fin PurgeFin) {
-	c.mu.Lock()
-	if ns, exist := c.table[id]; exist {
-		ns.purgeNB(fin)
-	}
-	c.mu.Unlock()
-}
-
-// Purge purge entire cache.
-func (c *lruCache) Purge(fin PurgeFin) {
-	c.mu.Lock()
-	for _, ns := range c.table {
-		ns.purgeNB(fin)
-	}
-	c.mu.Unlock()
-}
-
-func (c *lruCache) Zap() {
-	c.mu.Lock()
-	for _, ns := range c.table {
-		ns.zapNB()
-	}
-	c.table = make(map[uint64]*lruNs)
-	c.mu.Unlock()
-}
-
-func (c *lruCache) evict() {
-	top := &c.recent
-	for n := c.recent.rPrev; c.used > c.capacity && n != top; {
-		if n.state != nodeEffective {
-			panic("evicting non effective node")
-		}
-		n.state = nodeEvicted
-		n.rRemove()
-		n.derefNB()
-		c.used -= n.charge
-		n = c.recent.rPrev
-	}
-}
-
-type lruNs struct {
-	lru    *lruCache
-	id     uint64
-	rbRoot *lruNode
-	state  nsState
-}
-
-func (ns *lruNs) rbGetOrCreateNode(h *lruNode, key uint64) (hn, n *lruNode) {
-	if h == nil {
-		n = &lruNode{ns: ns, key: key}
-		return n, n
-	}
-
-	if key < h.key {
-		hn, n = ns.rbGetOrCreateNode(h.rbLeft, key)
-		if hn != nil {
-			h.rbLeft = hn
-		} else {
-			return nil, n
-		}
-	} else if key > h.key {
-		hn, n = ns.rbGetOrCreateNode(h.rbRight, key)
-		if hn != nil {
-			h.rbRight = hn
-		} else {
-			return nil, n
-		}
-	} else {
-		return nil, h
-	}
-
-	if rbIsRed(h.rbRight) && !rbIsRed(h.rbLeft) {
-		h = rbRotLeft(h)
-	}
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbLeft.rbLeft) {
-		h = rbRotRight(h)
-	}
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbRight) {
-		rbFlip(h)
-	}
-	return h, n
-}
-
-func (ns *lruNs) getOrCreateNode(key uint64) *lruNode {
-	hn, n := ns.rbGetOrCreateNode(ns.rbRoot, key)
-	if hn != nil {
-		ns.rbRoot = hn
-		ns.rbRoot.rbBlack = true
-	}
-	return n
-}
-
-func (ns *lruNs) rbGetNode(key uint64) *lruNode {
-	h := ns.rbRoot
-	for h != nil {
-		switch {
-		case key < h.key:
-			h = h.rbLeft
-		case key > h.key:
-			h = h.rbRight
-		default:
-			return h
-		}
-	}
-	return nil
-}
-
-func (ns *lruNs) getNode(key uint64) *lruNode {
-	return ns.rbGetNode(key)
-}
-
-func (ns *lruNs) rbDeleteNode(h *lruNode, key uint64) *lruNode {
-	if h == nil {
-		return nil
-	}
-
-	if key < h.key {
-		if h.rbLeft == nil { // key not present. Nothing to delete
-			return h
-		}
-		if !rbIsRed(h.rbLeft) && !rbIsRed(h.rbLeft.rbLeft) {
-			h = rbMoveLeft(h)
-		}
-		h.rbLeft = ns.rbDeleteNode(h.rbLeft, key)
-	} else {
-		if rbIsRed(h.rbLeft) {
-			h = rbRotRight(h)
-		}
-		// If @key equals @h.key and no right children at @h
-		if h.key == key && h.rbRight == nil {
-			return nil
-		}
-		if h.rbRight != nil && !rbIsRed(h.rbRight) && !rbIsRed(h.rbRight.rbLeft) {
-			h = rbMoveRight(h)
-		}
-		// If @key equals @h.key, and (from above) 'h.Right != nil'
-		if h.key == key {
-			var x *lruNode
-			h.rbRight, x = rbDeleteMin(h.rbRight)
-			if x == nil {
-				panic("logic")
-			}
-			x.rbLeft, h.rbLeft = h.rbLeft, nil
-			x.rbRight, h.rbRight = h.rbRight, nil
-			x.rbBlack = h.rbBlack
-			h = x
-		} else { // Else, @key is bigger than @h.key
-			h.rbRight = ns.rbDeleteNode(h.rbRight, key)
-		}
-	}
-
-	return rbFixup(h)
-}
-
-func (ns *lruNs) deleteNode(key uint64) {
-	ns.rbRoot = ns.rbDeleteNode(ns.rbRoot, key)
-	if ns.rbRoot != nil {
-		ns.rbRoot.rbBlack = true
-	}
-}
-
-func (ns *lruNs) rbIterateNodes(h *lruNode, pivot uint64, iter func(n *lruNode) bool) bool {
-	if h == nil {
-		return true
-	}
-	if h.key >= pivot {
-		if !ns.rbIterateNodes(h.rbLeft, pivot, iter) {
-			return false
-		}
-		if !iter(h) {
-			return false
-		}
-	}
-	return ns.rbIterateNodes(h.rbRight, pivot, iter)
-}
-
-func (ns *lruNs) iterateNodes(iter func(n *lruNode) bool) {
-	ns.rbIterateNodes(ns.rbRoot, 0, iter)
-}
-
-func (ns *lruNs) Get(key uint64, setf SetFunc) Handle {
-	ns.lru.mu.Lock()
-	defer ns.lru.mu.Unlock()
-
-	if ns.state != nsEffective {
-		return nil
-	}
-
-	var n *lruNode
-	if setf == nil {
-		n = ns.getNode(key)
-		if n == nil {
-			return nil
-		}
-	} else {
-		n = ns.getOrCreateNode(key)
-	}
-	switch n.state {
-	case nodeZero:
-		charge, value := setf()
-		if value == nil {
-			ns.deleteNode(key)
-			return nil
-		}
-		if charge < 0 {
-			charge = 0
-		}
-
-		n.value = value
-		n.charge = charge
-		n.state = nodeEvicted
-
-		ns.lru.size += charge
-		ns.lru.alive++
-
-		fallthrough
-	case nodeEvicted:
-		if n.charge == 0 {
-			break
-		}
-
-		// Insert to recent list.
-		n.state = nodeEffective
-		n.ref++
-		ns.lru.used += n.charge
-		ns.lru.evict()
-
-		fallthrough
-	case nodeEffective:
-		// Bump to front.
-		n.rRemove()
-		n.rInsert(&ns.lru.recent)
-	case nodeDeleted:
-		// Do nothing.
-	default:
-		panic("invalid state")
-	}
-	n.ref++
-
-	return &lruHandle{node: n}
-}
-
-func (ns *lruNs) Delete(key uint64, fin DelFin) bool {
-	ns.lru.mu.Lock()
-	defer ns.lru.mu.Unlock()
-
-	if ns.state != nsEffective {
-		if fin != nil {
-			fin(false, false)
-		}
-		return false
-	}
-
-	n := ns.getNode(key)
-	if n == nil {
-		if fin != nil {
-			fin(false, false)
-		}
-		return false
-
-	}
-
-	switch n.state {
-	case nodeEffective:
-		ns.lru.used -= n.charge
-		n.state = nodeDeleted
-		n.delfin = fin
-		n.rRemove()
-		n.derefNB()
-	case nodeEvicted:
-		n.state = nodeDeleted
-		n.delfin = fin
-	case nodeDeleted:
-		if fin != nil {
-			fin(true, true)
-		}
-		return false
-	default:
-		panic("invalid state")
-	}
-
-	return true
-}
-
-func (ns *lruNs) purgeNB(fin PurgeFin) {
-	if ns.state == nsEffective {
-		var nodes []*lruNode
-		ns.iterateNodes(func(n *lruNode) bool {
-			nodes = append(nodes, n)
-			return true
-		})
-		for _, n := range nodes {
-			switch n.state {
-			case nodeEffective:
-				ns.lru.used -= n.charge
-				n.state = nodeDeleted
-				n.purgefin = fin
-				n.rRemove()
-				n.derefNB()
-			case nodeEvicted:
-				n.state = nodeDeleted
-				n.purgefin = fin
-			case nodeDeleted:
-			default:
-				panic("invalid state")
-			}
-		}
-	}
-}
-
-func (ns *lruNs) Purge(fin PurgeFin) {
-	ns.lru.mu.Lock()
-	ns.purgeNB(fin)
-	ns.lru.mu.Unlock()
-}
-
-func (ns *lruNs) zapNB() {
-	if ns.state == nsEffective {
-		ns.state = nsZapped
-
-		ns.iterateNodes(func(n *lruNode) bool {
-			if n.state == nodeEffective {
-				ns.lru.used -= n.charge
-				n.rRemove()
-			}
-			ns.lru.size -= n.charge
-			n.state = nodeDeleted
-			n.fin()
-
-			return true
-		})
-		ns.rbRoot = nil
-	}
-}
-
-func (ns *lruNs) Zap() {
-	ns.lru.mu.Lock()
-	ns.zapNB()
-	delete(ns.lru.table, ns.id)
-	ns.lru.mu.Unlock()
-}
-
-type lruNode struct {
-	ns *lruNs
-
-	rNext, rPrev    *lruNode
-	rbLeft, rbRight *lruNode
-	rbBlack         bool
-
-	key      uint64
-	value    interface{}
-	charge   int
-	ref      int
-	state    nodeState
-	delfin   DelFin
-	purgefin PurgeFin
-}
-
-func (n *lruNode) rInsert(at *lruNode) {
-	x := at.rNext
-	at.rNext = n
-	n.rPrev = at
-	n.rNext = x
-	x.rPrev = n
-}
-
-func (n *lruNode) rRemove() bool {
-	if n.rPrev == nil {
-		return false
-	}
-
-	n.rPrev.rNext = n.rNext
-	n.rNext.rPrev = n.rPrev
-	n.rPrev = nil
-	n.rNext = nil
-
-	return true
-}
-
-func (n *lruNode) fin() {
-	if r, ok := n.value.(util.Releaser); ok {
-		r.Release()
-	}
-	if n.purgefin != nil {
-		if n.delfin != nil {
-			panic("conflicting delete and purge fin")
-		}
-		n.purgefin(n.ns.id, n.key)
-		n.purgefin = nil
-	} else if n.delfin != nil {
-		n.delfin(true, false)
-		n.delfin = nil
-	}
-}
-
-func (n *lruNode) derefNB() {
-	n.ref--
-	if n.ref == 0 {
-		if n.ns.state == nsEffective {
-			// Remove elemement.
-			n.ns.deleteNode(n.key)
-			n.ns.lru.size -= n.charge
-			n.ns.lru.alive--
-			n.fin()
-		}
-		n.value = nil
-	} else if n.ref < 0 {
-		panic("leveldb/cache: lruCache: negative node reference")
-	}
-}
-
-func (n *lruNode) deref() {
-	n.ns.lru.mu.Lock()
-	n.derefNB()
-	n.ns.lru.mu.Unlock()
-}
-
-type lruHandle struct {
-	node *lruNode
-	once uint32
-}
-
-func (h *lruHandle) Value() interface{} {
-	if atomic.LoadUint32(&h.once) == 0 {
-		return h.node.value
-	}
-	return nil
-}
-
-func (h *lruHandle) Release() {
-	if !atomic.CompareAndSwapUint32(&h.once, 0, 1) {
-		return
-	}
-	h.node.deref()
-	h.node = nil
-}
-
-func rbIsRed(h *lruNode) bool {
-	if h == nil {
-		return false
-	}
-	return !h.rbBlack
-}
-
-func rbRotLeft(h *lruNode) *lruNode {
-	x := h.rbRight
-	if x.rbBlack {
-		panic("rotating a black link")
-	}
-	h.rbRight = x.rbLeft
-	x.rbLeft = h
-	x.rbBlack = h.rbBlack
-	h.rbBlack = false
-	return x
-}
-
-func rbRotRight(h *lruNode) *lruNode {
-	x := h.rbLeft
-	if x.rbBlack {
-		panic("rotating a black link")
-	}
-	h.rbLeft = x.rbRight
-	x.rbRight = h
-	x.rbBlack = h.rbBlack
-	h.rbBlack = false
-	return x
-}
-
-func rbFlip(h *lruNode) {
-	h.rbBlack = !h.rbBlack
-	h.rbLeft.rbBlack = !h.rbLeft.rbBlack
-	h.rbRight.rbBlack = !h.rbRight.rbBlack
-}
-
-func rbMoveLeft(h *lruNode) *lruNode {
-	rbFlip(h)
-	if rbIsRed(h.rbRight.rbLeft) {
-		h.rbRight = rbRotRight(h.rbRight)
-		h = rbRotLeft(h)
-		rbFlip(h)
-	}
-	return h
-}
-
-func rbMoveRight(h *lruNode) *lruNode {
-	rbFlip(h)
-	if rbIsRed(h.rbLeft.rbLeft) {
-		h = rbRotRight(h)
-		rbFlip(h)
-	}
-	return h
-}
-
-func rbFixup(h *lruNode) *lruNode {
-	if rbIsRed(h.rbRight) {
-		h = rbRotLeft(h)
-	}
-
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbLeft.rbLeft) {
-		h = rbRotRight(h)
-	}
-
-	if rbIsRed(h.rbLeft) && rbIsRed(h.rbRight) {
-		rbFlip(h)
-	}
-
-	return h
-}
-
-func rbDeleteMin(h *lruNode) (hn, n *lruNode) {
-	if h == nil {
-		return nil, nil
-	}
-	if h.rbLeft == nil {
-		return nil, h
-	}
-
-	if !rbIsRed(h.rbLeft) && !rbIsRed(h.rbLeft.rbLeft) {
-		h = rbMoveLeft(h)
-	}
-
-	h.rbLeft, n = rbDeleteMin(h.rbLeft)
-
-	return rbFixup(h), n
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go

@@ -9,14 +9,12 @@ package leveldb
 import (
 	"bytes"
 	"fmt"
-	"io"
-	"math/rand"
-	"testing"
-
-	"github.com/syndtr/goleveldb/leveldb/cache"
 	"github.com/syndtr/goleveldb/leveldb/filter"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 	"github.com/syndtr/goleveldb/leveldb/storage"
+	"io"
+	"math/rand"
+	"testing"
 )
 
 const ctValSize = 1000
@@ -33,8 +31,8 @@ func newDbCorruptHarnessWopt(t *testing.T, o *opt.Options) *dbCorruptHarness {
 
 func newDbCorruptHarness(t *testing.T) *dbCorruptHarness {
 	return newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCache: cache.NewLRUCache(100),
-		Strict:     opt.StrictJournalChecksum,
+		BlockCacheCapacity: 100,
+		Strict:             opt.StrictJournalChecksum,
 	})
 }
 
@@ -269,9 +267,9 @@ func TestCorruptDB_TableIndex(t *testing.T) {
 func TestCorruptDB_MissingManifest(t *testing.T) {
 	rnd := rand.New(rand.NewSource(0x0badda7a))
 	h := newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCache:  cache.NewLRUCache(100),
-		Strict:      opt.StrictJournalChecksum,
-		WriteBuffer: 1000 * 60,
+		BlockCacheCapacity: 100,
+		Strict:             opt.StrictJournalChecksum,
+		WriteBuffer:        1000 * 60,
 	})
 
 	h.build(1000)

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db.go

@@ -823,8 +823,8 @@ func (db *DB) GetProperty(name string) (value string, err error) {
 	case p == "blockpool":
 		value = fmt.Sprintf("%v", db.s.tops.bpool)
 	case p == "cachedblock":
-		if bc := db.s.o.GetBlockCache(); bc != nil {
-			value = fmt.Sprintf("%d", bc.Size())
+		if db.s.tops.bcache != nil {
+			value = fmt.Sprintf("%d", db.s.tops.bcache.Size())
 		} else {
 			value = "<nil>"
 		}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_snapshot.go

@@ -8,6 +8,7 @@ package leveldb
 
 import (
 	"container/list"
+	"fmt"
 	"runtime"
 	"sync"
 	"sync/atomic"
@@ -89,6 +90,10 @@ func (db *DB) newSnapshot() *Snapshot {
 	return snap
 }
 
+func (snap *Snapshot) String() string {
+	return fmt.Sprintf("leveldb.Snapshot{%d}", snap.elem.seq)
+}
+
 // Get gets the value for the given key. It returns ErrNotFound if
 // the DB does not contains the key.
 //

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_test.go

@@ -1271,7 +1271,7 @@ func TestDB_DeletionMarkers2(t *testing.T) {
 }
 
 func TestDB_CompactionTableOpenError(t *testing.T) {
-	h := newDbHarnessWopt(t, &opt.Options{CachedOpenFiles: -1})
+	h := newDbHarnessWopt(t, &opt.Options{OpenFilesCacheCapacity: -1})
 	defer h.close()
 
 	im := 10
@@ -1629,8 +1629,8 @@ func TestDB_ManualCompaction(t *testing.T) {
 
 func TestDB_BloomFilter(t *testing.T) {
 	h := newDbHarnessWopt(t, &opt.Options{
-		BlockCache: opt.NoCache,
-		Filter:     filter.NewBloomFilter(10),
+		DisableBlockCache: true,
+		Filter:            filter.NewBloomFilter(10),
 	})
 	defer h.close()
 
@@ -2066,8 +2066,8 @@ func TestDB_GetProperties(t *testing.T) {
 
 func TestDB_GoleveldbIssue72and83(t *testing.T) {
 	h := newDbHarnessWopt(t, &opt.Options{
-		WriteBuffer:     1 * opt.MiB,
-		CachedOpenFiles: 3,
+		WriteBuffer:            1 * opt.MiB,
+		OpenFilesCacheCapacity: 3,
 	})
 	defer h.close()
 
@@ -2200,7 +2200,7 @@ func TestDB_GoleveldbIssue72and83(t *testing.T) {
 func TestDB_TransientError(t *testing.T) {
 	h := newDbHarnessWopt(t, &opt.Options{
 		WriteBuffer:              128 * opt.KiB,
-		CachedOpenFiles:          3,
+		OpenFilesCacheCapacity:   3,
 		DisableCompactionBackoff: true,
 	})
 	defer h.close()
@@ -2410,7 +2410,7 @@ func TestDB_TableCompactionBuilder(t *testing.T) {
 		CompactionTableSize:         43 * opt.KiB,
 		CompactionExpandLimitFactor: 1,
 		CompactionGPOverlapsFactor:  1,
-		BlockCache:                  opt.NoCache,
+		DisableBlockCache:           true,
 	}
 	s, err := newSession(stor, o)
 	if err != nil {

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_write.go

@@ -112,9 +112,9 @@ func (db *DB) flush(n int) (mem *memDB, nn int, err error) {
 		db.writeDelay += time.Since(start)
 		db.writeDelayN++
 	} else if db.writeDelayN > 0 {
+		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
 		db.writeDelay = 0
 		db.writeDelayN = 0
-		db.logf("db@write was delayed N·%d T·%v", db.writeDelayN, db.writeDelay)
 	}
 	return
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/external_test.go

@@ -17,14 +17,14 @@ import (
 var _ = testutil.Defer(func() {
 	Describe("Leveldb external", func() {
 		o := &opt.Options{
-			BlockCache:           opt.NoCache,
-			BlockRestartInterval: 5,
-			BlockSize:            80,
-			Compression:          opt.NoCompression,
-			CachedOpenFiles:      -1,
-			Strict:               opt.StrictAll,
-			WriteBuffer:          1000,
-			CompactionTableSize:  2000,
+			DisableBlockCache:      true,
+			BlockRestartInterval:   5,
+			BlockSize:              80,
+			Compression:            opt.NoCompression,
+			OpenFilesCacheCapacity: -1,
+			Strict:                 opt.StrictAll,
+			WriteBuffer:            1000,
+			CompactionTableSize:    2000,
 		}
 
 		Describe("write test", func() {

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/key.go

@@ -106,7 +106,7 @@ func (ik iKey) assert() {
 		panic("leveldb: nil iKey")
 	}
 	if len(ik) < 8 {
-		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", ik, len(ik)))
+		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid length", []byte(ik), len(ik)))
 	}
 }
 
@@ -124,7 +124,7 @@ func (ik iKey) parseNum() (seq uint64, kt kType) {
 	num := ik.num()
 	seq, kt = uint64(num>>8), kType(num&0xff)
 	if kt > ktVal {
-		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", ik, len(ik), kt))
+		panic(fmt.Sprintf("leveldb: iKey %q, len=%d: invalid type %#x", []byte(ik), len(ik), kt))
 	}
 	return
 }

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/opt/options.go

@@ -20,8 +20,9 @@ const (
 	GiB = MiB * 1024
 )
 
-const (
-	DefaultBlockCacheSize                = 8 * MiB
+var (
+	DefaultBlockCacher                   = LRUCacher
+	DefaultBlockCacheCapacity            = 8 * MiB
 	DefaultBlockRestartInterval          = 16
 	DefaultBlockSize                     = 4 * KiB
 	DefaultCompactionExpandLimitFactor   = 25
@@ -33,7 +34,8 @@ const (
 	DefaultCompactionTotalSize           = 10 * MiB
 	DefaultCompactionTotalSizeMultiplier = 10.0
 	DefaultCompressionType               = SnappyCompression
-	DefaultCachedOpenFiles               = 500
+	DefaultOpenFilesCacher               = LRUCacher
+	DefaultOpenFilesCacheCapacity        = 500
 	DefaultMaxMemCompationLevel          = 2
 	DefaultNumLevel                      = 7
 	DefaultWriteBuffer                   = 4 * MiB
@@ -41,22 +43,33 @@ const (
 	DefaultWriteL0SlowdownTrigger        = 8
 )
 
-type noCache struct{}
+// Cacher is a caching algorithm.
+type Cacher interface {
+	New(capacity int) cache.Cacher
+}
 
-func (noCache) SetCapacity(capacity int)                     {}
-func (noCache) Capacity() int                                { return 0 }
-func (noCache) Used() int                                    { return 0 }
-func (noCache) Size() int                                    { return 0 }
-func (noCache) NumObjects() int                              { return 0 }
-func (noCache) GetNamespace(id uint64) cache.Namespace       { return nil }
-func (noCache) PurgeNamespace(id uint64, fin cache.PurgeFin) {}
-func (noCache) ZapNamespace(id uint64)                       {}
-func (noCache) Purge(fin cache.PurgeFin)                     {}
-func (noCache) Zap()                                         {}
+type CacherFunc struct {
+	NewFunc func(capacity int) cache.Cacher
+}
 
-var NoCache cache.Cache = noCache{}
+func (f *CacherFunc) New(capacity int) cache.Cacher {
+	if f.NewFunc != nil {
+		return f.NewFunc(capacity)
+	}
+	return nil
+}
 
-// Compression is the per-block compression algorithm to use.
+func noCacher(int) cache.Cacher { return nil }
+
+var (
+	// LRUCacher is the LRU-cache algorithm.
+	LRUCacher = &CacherFunc{cache.NewLRU}
+
+	// NoCacher is the value to disable caching algorithm.
+	NoCacher = &CacherFunc{}
+)
+
+// Compression is the 'sorted table' block compression algorithm to use.
 type Compression uint
 
 func (c Compression) String() string {
@@ -133,16 +146,17 @@ type Options struct {
 	// The default value is nil
 	AltFilters []filter.Filter
 
-	// BlockCache provides per-block caching for LevelDB. Specify NoCache to
-	// disable block caching.
+	// BlockCacher provides cache algorithm for LevelDB 'sorted table' block caching.
+	// Specify NoCacher to disable caching algorithm.
 	//
-	// By default LevelDB will create LRU-cache with capacity of BlockCacheSize.
-	BlockCache cache.Cache
+	// The default value is LRUCacher.
+	BlockCacher Cacher
 
-	// BlockCacheSize defines the capacity of the default 'block cache'.
+	// BlockCacheCapacity defines the capacity of the 'sorted table' block caching.
+	// Use -1 for zero, this has same effect with specifying NoCacher to BlockCacher.
 	//
 	// The default value is 8MiB.
-	BlockCacheSize int
+	BlockCacheCapacity int
 
 	// BlockRestartInterval is the number of keys between restart points for
 	// delta encoding of keys.
@@ -156,13 +170,6 @@ type Options struct {
 	// The default value is 4KiB.
 	BlockSize int
 
-	// CachedOpenFiles defines number of open files to kept around when not
-	// in-use, the counting includes still in-use files.
-	// Set this to negative value to disable caching.
-	//
-	// The default value is 500.
-	CachedOpenFiles int
-
 	// CompactionExpandLimitFactor limits compaction size after expanded.
 	// This will be multiplied by table size limit at compaction target level.
 	//
@@ -237,11 +244,17 @@ type Options struct {
 	// The default value uses the same ordering as bytes.Compare.
 	Comparer comparer.Comparer
 
-	// Compression defines the per-block compression to use.
+	// Compression defines the 'sorted table' block compression to use.
 	//
 	// The default value (DefaultCompression) uses snappy compression.
 	Compression Compression
 
+	// DisableBlockCache allows disable use of cache.Cache functionality on
+	// 'sorted table' block.
+	//
+	// The default value is false.
+	DisableBlockCache bool
+
 	// DisableCompactionBackoff allows disable compaction retry backoff.
 	//
 	// The default value is false.
@@ -288,6 +301,18 @@ type Options struct {
 	// The default is 7.
 	NumLevel int
 
+	// OpenFilesCacher provides cache algorithm for open files caching.
+	// Specify NoCacher to disable caching algorithm.
+	//
+	// The default value is LRUCacher.
+	OpenFilesCacher Cacher
+
+	// OpenFilesCacheCapacity defines the capacity of the open files caching.
+	// Use -1 for zero, this has same effect with specifying NoCacher to OpenFilesCacher.
+	//
+	// The default value is 500.
+	OpenFilesCacheCapacity int
+
 	// Strict defines the DB strict level.
 	Strict Strict
 
@@ -320,18 +345,22 @@ func (o *Options) GetAltFilters() []filter.Filter {
 	return o.AltFilters
 }
 
-func (o *Options) GetBlockCache() cache.Cache {
-	if o == nil {
+func (o *Options) GetBlockCacher() Cacher {
+	if o == nil || o.BlockCacher == nil {
+		return DefaultBlockCacher
+	} else if o.BlockCacher == NoCacher {
 		return nil
 	}
-	return o.BlockCache
+	return o.BlockCacher
 }
 
-func (o *Options) GetBlockCacheSize() int {
-	if o == nil || o.BlockCacheSize <= 0 {
-		return DefaultBlockCacheSize
+func (o *Options) GetBlockCacheCapacity() int {
+	if o == nil || o.BlockCacheCapacity <= 0 {
+		return DefaultBlockCacheCapacity
+	} else if o.BlockCacheCapacity == -1 {
+		return 0
 	}
-	return o.BlockCacheSize
+	return o.BlockCacheCapacity
 }
 
 func (o *Options) GetBlockRestartInterval() int {
@@ -348,15 +377,6 @@ func (o *Options) GetBlockSize() int {
 	return o.BlockSize
 }
 
-func (o *Options) GetCachedOpenFiles() int {
-	if o == nil || o.CachedOpenFiles == 0 {
-		return DefaultCachedOpenFiles
-	} else if o.CachedOpenFiles < 0 {
-		return 0
-	}
-	return o.CachedOpenFiles
-}
-
 func (o *Options) GetCompactionExpandLimit(level int) int {
 	factor := DefaultCompactionExpandLimitFactor
 	if o != nil && o.CompactionExpandLimitFactor > 0 {
@@ -494,6 +514,25 @@ func (o *Options) GetNumLevel() int {
 	return o.NumLevel
 }
 
+func (o *Options) GetOpenFilesCacher() Cacher {
+	if o == nil || o.OpenFilesCacher == nil {
+		return DefaultOpenFilesCacher
+	}
+	if o.OpenFilesCacher == NoCacher {
+		return nil
+	}
+	return o.OpenFilesCacher
+}
+
+func (o *Options) GetOpenFilesCacheCapacity() int {
+	if o == nil || o.OpenFilesCacheCapacity <= 0 {
+		return DefaultOpenFilesCacheCapacity
+	} else if o.OpenFilesCacheCapacity == -1 {
+		return 0
+	}
+	return o.OpenFilesCacheCapacity
+}
+
 func (o *Options) GetStrict(strict Strict) bool {
 	if o == nil || o.Strict == 0 {
 		return DefaultStrict&strict != 0

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/options.go

@@ -7,7 +7,6 @@
 package leveldb
 
 import (
-	"github.com/syndtr/goleveldb/leveldb/cache"
 	"github.com/syndtr/goleveldb/leveldb/filter"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 )
@@ -32,13 +31,6 @@ func (s *session) setOptions(o *opt.Options) {
 			no.AltFilters[i] = &iFilter{filter}
 		}
 	}
-	// Block cache.
-	switch o.GetBlockCache() {
-	case nil:
-		no.BlockCache = cache.NewLRUCache(o.GetBlockCacheSize())
-	case opt.NoCache:
-		no.BlockCache = nil
-	}
 	// Comparer.
 	s.icmp = &iComparer{o.GetComparer()}
 	no.Comparer = s.icmp

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/session.go

@@ -73,7 +73,7 @@ func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
 		stCompPtrs: make([]iKey, o.GetNumLevel()),
 	}
 	s.setOptions(o)
-	s.tops = newTableOps(s, s.o.GetCachedOpenFiles())
+	s.tops = newTableOps(s)
 	s.setVersion(newVersion(s))
 	s.log("log@legend F·NumFile S·FileSize N·Entry C·BadEntry B·BadBlock Ke·KeyError D·DroppedEntry L·Level Q·SeqNum T·TimeElapsed")
 	return
@@ -82,9 +82,6 @@ func newSession(stor storage.Storage, o *opt.Options) (s *session, err error) {
 // Close session.
 func (s *session) close() {
 	s.tops.close()
-	if bc := s.o.GetBlockCache(); bc != nil {
-		bc.Purge(nil)
-	}
 	if s.manifest != nil {
 		s.manifest.Close()
 	}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go

@@ -221,7 +221,7 @@ func (fs *fileStorage) GetManifest() (f File, err error) {
 					fs.log(fmt.Sprintf("skipping %s: invalid file name", fn))
 					continue
 				}
-				if _, e1 := strconv.ParseUint(fn[7:], 10, 0); e1 != nil {
+				if _, e1 := strconv.ParseUint(fn[8:], 10, 0); e1 != nil {
 					fs.log(fmt.Sprintf("skipping %s: invalid file num: %v", fn, e1))
 					continue
 				}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table.go

@@ -286,10 +286,10 @@ func (x *tFilesSortByNum) Less(i, j int) bool {
 
 // Table operations.
 type tOps struct {
-	s       *session
-	cache   cache.Cache
-	cacheNS cache.Namespace
-	bpool   *util.BufferPool
+	s      *session
+	cache  *cache.Cache
+	bcache *cache.Cache
+	bpool  *util.BufferPool
 }
 
 // Creates an empty table and returns table writer.
@@ -338,26 +338,28 @@ func (t *tOps) createFrom(src iterator.Iterator) (f *tFile, n int, err error) {
 
 // Opens table. It returns a cache handle, which should
 // be released after use.
-func (t *tOps) open(f *tFile) (ch cache.Handle, err error) {
+func (t *tOps) open(f *tFile) (ch *cache.Handle, err error) {
 	num := f.file.Num()
-	ch = t.cacheNS.Get(num, func() (charge int, value interface{}) {
+	ch = t.cache.Get(0, num, func() (size int, value cache.Value) {
 		var r storage.Reader
 		r, err = f.file.Open()
 		if err != nil {
 			return 0, nil
 		}
 
-		var bcacheNS cache.Namespace
-		if bc := t.s.o.GetBlockCache(); bc != nil {
-			bcacheNS = bc.GetNamespace(num)
+		var bcache *cache.CacheGetter
+		if t.bcache != nil {
+			bcache = &cache.CacheGetter{Cache: t.bcache, NS: num}
 		}
+
 		var tr *table.Reader
-		tr, err = table.NewReader(r, int64(f.size), storage.NewFileInfo(f.file), bcacheNS, t.bpool, t.s.o.Options)
+		tr, err = table.NewReader(r, int64(f.size), storage.NewFileInfo(f.file), bcache, t.bpool, t.s.o.Options)
 		if err != nil {
 			r.Close()
 			return 0, nil
 		}
 		return 1, tr
+
 	})
 	if ch == nil && err == nil {
 		err = ErrClosed
@@ -412,16 +414,14 @@ func (t *tOps) newIterator(f *tFile, slice *util.Range, ro *opt.ReadOptions) ite
 // no one use the the table.
 func (t *tOps) remove(f *tFile) {
 	num := f.file.Num()
-	t.cacheNS.Delete(num, func(exist, pending bool) {
-		if !pending {
-			if err := f.file.Remove(); err != nil {
-				t.s.logf("table@remove removing @%d %q", num, err)
-			} else {
-				t.s.logf("table@remove removed @%d", num)
-			}
-			if bc := t.s.o.GetBlockCache(); bc != nil {
-				bc.ZapNamespace(num)
-			}
+	t.cache.Delete(0, num, func() {
+		if err := f.file.Remove(); err != nil {
+			t.s.logf("table@remove removing @%d %q", num, err)
+		} else {
+			t.s.logf("table@remove removed @%d", num)
+		}
+		if t.bcache != nil {
+			t.bcache.EvictNS(num)
 		}
 	})
 }
@@ -429,18 +429,34 @@ func (t *tOps) remove(f *tFile) {
 // Closes the table ops instance. It will close all tables,
 // regadless still used or not.
 func (t *tOps) close() {
-	t.cache.Zap()
 	t.bpool.Close()
+	t.cache.Close()
+	if t.bcache != nil {
+		t.bcache.Close()
+	}
 }
 
 // Creates new initialized table ops instance.
-func newTableOps(s *session, cacheCap int) *tOps {
-	c := cache.NewLRUCache(cacheCap)
+func newTableOps(s *session) *tOps {
+	var (
+		cacher cache.Cacher
+		bcache *cache.Cache
+	)
+	if s.o.GetOpenFilesCacheCapacity() > 0 {
+		cacher = cache.NewLRU(s.o.GetOpenFilesCacheCapacity())
+	}
+	if !s.o.DisableBlockCache {
+		var bcacher cache.Cacher
+		if s.o.GetBlockCacheCapacity() > 0 {
+			bcacher = cache.NewLRU(s.o.GetBlockCacheCapacity())
+		}
+		bcache = cache.NewCache(bcacher)
+	}
 	return &tOps{
-		s:       s,
-		cache:   c,
-		cacheNS: c.GetNamespace(0),
-		bpool:   util.NewBufferPool(s.o.GetBlockSize() + 5),
+		s:      s,
+		cache:  cache.NewCache(cacher),
+		bcache: bcache,
+		bpool:  util.NewBufferPool(s.o.GetBlockSize() + 5),
 	}
 }
 

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/table/reader.go

@@ -509,7 +509,7 @@ type Reader struct {
 	mu     sync.RWMutex
 	fi     *storage.FileInfo
 	reader io.ReaderAt
-	cache  cache.Namespace
+	cache  *cache.CacheGetter
 	err    error
 	bpool  *util.BufferPool
 	// Options
@@ -613,18 +613,22 @@ func (r *Reader) readBlock(bh blockHandle, verifyChecksum bool) (*block, error)
 
 func (r *Reader) readBlockCached(bh blockHandle, verifyChecksum, fillCache bool) (*block, util.Releaser, error) {
 	if r.cache != nil {
-		var err error
-		ch := r.cache.Get(bh.offset, func() (charge int, value interface{}) {
-			if !fillCache {
-				return 0, nil
-			}
-			var b *block
-			b, err = r.readBlock(bh, verifyChecksum)
-			if err != nil {
-				return 0, nil
-			}
-			return cap(b.data), b
-		})
+		var (
+			err error
+			ch  *cache.Handle
+		)
+		if fillCache {
+			ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+				var b *block
+				b, err = r.readBlock(bh, verifyChecksum)
+				if err != nil {
+					return 0, nil
+				}
+				return cap(b.data), b
+			})
+		} else {
+			ch = r.cache.Get(bh.offset, nil)
+		}
 		if ch != nil {
 			b, ok := ch.Value().(*block)
 			if !ok {
@@ -667,18 +671,22 @@ func (r *Reader) readFilterBlock(bh blockHandle) (*filterBlock, error) {
 
 func (r *Reader) readFilterBlockCached(bh blockHandle, fillCache bool) (*filterBlock, util.Releaser, error) {
 	if r.cache != nil {
-		var err error
-		ch := r.cache.Get(bh.offset, func() (charge int, value interface{}) {
-			if !fillCache {
-				return 0, nil
-			}
-			var b *filterBlock
-			b, err = r.readFilterBlock(bh)
-			if err != nil {
-				return 0, nil
-			}
-			return cap(b.data), b
-		})
+		var (
+			err error
+			ch  *cache.Handle
+		)
+		if fillCache {
+			ch = r.cache.Get(bh.offset, func() (size int, value cache.Value) {
+				var b *filterBlock
+				b, err = r.readFilterBlock(bh)
+				if err != nil {
+					return 0, nil
+				}
+				return cap(b.data), b
+			})
+		} else {
+			ch = r.cache.Get(bh.offset, nil)
+		}
 		if ch != nil {
 			b, ok := ch.Value().(*filterBlock)
 			if !ok {
@@ -980,7 +988,7 @@ func (r *Reader) Release() {
 // The fi, cache and bpool is optional and can be nil.
 //
 // The returned table reader instance is goroutine-safe.
-func NewReader(f io.ReaderAt, size int64, fi *storage.FileInfo, cache cache.Namespace, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
+func NewReader(f io.ReaderAt, size int64, fi *storage.FileInfo, cache *cache.CacheGetter, bpool *util.BufferPool, o *opt.Options) (*Reader, error) {
 	if f == nil {
 		return nil, errors.New("leveldb/table: nil file")
 	}

Godeps/_workspace/src/golang.org/x/text/transform/transform_test.go

@@ -16,7 +16,7 @@ import (
 	"unicode/utf8"
 )
 
-type lowerCaseASCII struct{ transform.NopResetter }
+type lowerCaseASCII struct{ NopResetter }
 
 func (lowerCaseASCII) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := len(src)
@@ -34,7 +34,7 @@ func (lowerCaseASCII) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, er
 
 var errYouMentionedX = errors.New("you mentioned X")
 
-type dontMentionX struct{ transform.NopResetter }
+type dontMentionX struct{ NopResetter }
 
 func (dontMentionX) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	n := len(src)
@@ -52,7 +52,7 @@ func (dontMentionX) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err
 
 // doublerAtEOF is a strange Transformer that transforms "this" to "tthhiiss",
 // but only if atEOF is true.
-type doublerAtEOF struct{ transform.NopResetter }
+type doublerAtEOF struct{ NopResetter }
 
 func (doublerAtEOF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 	if !atEOF {
@@ -71,7 +71,7 @@ func (doublerAtEOF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err
 // rleDecode and rleEncode implement a toy run-length encoding: "aabbbbbbbbbb"
 // is encoded as "2a10b". The decoding is assumed to not contain any numbers.
 
-type rleDecode struct{ transform.NopResetter }
+type rleDecode struct{ NopResetter }
 
 func (rleDecode) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 loop:
@@ -104,7 +104,7 @@ loop:
 }
 
 type rleEncode struct {
-	transform.NopResetter
+	NopResetter
 
 	// allowStutter means that "xxxxxxxx" can be encoded as "5x3x"
 	// instead of always as "8x".

NICKS

@@ -0,0 +1,35 @@
+# This file maps email addresses used in commits to nicks used the changelog.
+
+AudriusButkevicius	<audrius.butkevicius@gmail.com>
+Cathryne	<cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
+KayoticSully	<kayoticsully@gmail.com>
+Nutomic		<me@nutomic.com>
+Vilbrekin	<vilbrekin@gmail.com>
+Zillode		<zillode@zillode.be>
+alex2108	<register-github@alex-graf.de>
+andrew-d	<andrew@du.nham.ca>
+asdil12		<dominik@heidler.eu>
+bigbear2nd	<bigbear2nd@gmail.com>
+bsidhom		<bsidhom@gmail.com>
+calmh		<jakob@nym.se>
+cdata		<chris@scriptolo.gy>
+ceh		<emil@hessman.se>
+cqcallaw	<enlightened.despot@gmail.com>
+filoozoom	<philippe@schommers.be>
+frioux		<frew@afoolishmanifesto.com> <frioux@gmail.com>
+gillisig	<gilli@vx.is>
+jedie		<github.com@jensdiemer.de> <git@jensdiemer.de>
+jpjp		<jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
+kozec		<kozec@kozec.com>
+marcindziadus	<dziadus.marcin@gmail.com>
+mvdan		<mvdan@mvdan.cc>
+philips		<brandon@ifup.org>
+piobpl		<piotrb10@gmail.com>
+pluby		<phill.luby@newredo.com>
+pyfisch		<pyfisch@gmail.com>
+qbit		<qbit@deftly.net>
+seehuhn		<voss@seehuhn.de>
+snnd		<dw@risu.io>
+tojrobinson	<tully@tojr.org>
+uok		<ueomkail@gmail.com> <uok@users.noreply.github.com>
+veeti		<veeti.paananen@rojekti.fi>

README.md

@@ -11,7 +11,7 @@ This is the `syncthing` project. The following are the project goals:
     collaborating devices. The protocol should be well defined, unambiguous,
     easily understood, free to use, efficient, secure and language neutral.
     This is the [Block Exchange
-    Protocol](https://github.com/syncthing/syncthing/blob/master/protocol/PROTOCOL.md).
+    Protocol](https://github.com/syncthing/protocol/blob/master/BEPv1.md).
 
  2. Provide the reference implementation to demonstrate the usability of
     said protocol. This is the `syncthing` utility. It is the hope that
@@ -25,7 +25,8 @@ for incompatible changes.
 Getting Started
 ---------------
 
-Take a look at the [getting started guide](http://discourse.syncthing.net/t/46).
+Take a look at the [getting started
+guide](https://github.com/syncthing/syncthing/wiki/Getting-Started).
 
 There are a few examples for keeping syncthing running in the background
 on your system in [the etc directory](https://github.com/syncthing/syncthing/blob/master/etc).
@@ -37,7 +38,7 @@ Building
 --------
 
 Building Syncthing from source is easy, and there's a
-[guide](http://discourse.syncthing.net/t/44)
+[guide](https://github.com/syncthing/syncthing/wiki/Building).
 that describes it for both Unix and Windows.
 
 Signed Releases
@@ -52,15 +53,8 @@ Documentation
 =============
 
 The [syncthing
-documentation](http://discourse.syncthing.net/category/documentation) is
-on the discourse site.
-
-License
-=======
-
-All documentation and protocol specifications are licensed
-under the [Creative Commons Attribution 4.0 International
-License](http://creativecommons.org/licenses/by/4.0/).
+documentation](https://github.com/syncthing/syncthing/wiki/) is on the
+Github wiki.
 
 All code is licensed under the
 [GPL](https://github.com/syncthing/syncthing/blob/master/LICENSE), v3 or

build.go

@@ -22,6 +22,7 @@ import (
 	"archive/zip"
 	"bytes"
 	"compress/gzip"
+	"crypto/md5"
 	"flag"
 	"fmt"
 	"io"
@@ -72,11 +73,8 @@ func main() {
 	flag.Parse()
 
 	switch goarch {
-	case "386", "amd64", "armv5", "armv6", "armv7":
+	case "386", "amd64", "arm", "armv5", "armv6", "armv7":
 		break
-	case "arm":
-		log.Println("Invalid goarch \"arm\". Use one of \"armv5\", \"armv6\", \"armv7\".")
-		log.Fatalln("Note that producing a correct \"armv5\" binary requires a rebuilt stdlib.")
 	default:
 		log.Printf("Unknown goarch %q; proceed with caution!", goarch)
 	}
@@ -155,7 +153,7 @@ func checkRequiredGoVersion() {
 		// This is a standard go build. Verify that it's new enough.
 		f, err := strconv.ParseFloat(vs, 64)
 		if err != nil {
-			log.Printf("*** Could parse Go version out of %q.\n*** This isn't known to work, proceed on your own risk.", vs)
+			log.Printf("*** Couldn't parse Go version out of %q.\n*** This isn't known to work, proceed on your own risk.", vs)
 			return
 		}
 		if f < minGoVersion {
@@ -175,7 +173,7 @@ func setup() {
 
 func test(pkg string) {
 	setBuildEnv()
-	runPrint("go", "test", "-short", "-timeout", "10s", pkg)
+	runPrint("go", "test", "-short", "-timeout", "60s", pkg)
 }
 
 func install(pkg string, tags []string) {
@@ -193,7 +191,12 @@ func install(pkg string, tags []string) {
 }
 
 func build(pkg string, tags []string) {
-	rmr("syncthing", "syncthing.exe")
+	binary := "syncthing"
+	if goos == "windows" {
+		binary += ".exe"
+	}
+
+	rmr(binary, binary+".md5")
 	args := []string{"build", "-ldflags", ldflags()}
 	if len(tags) > 0 {
 		args = append(args, "-tags", strings.Join(tags, ","))
@@ -204,6 +207,13 @@ func build(pkg string, tags []string) {
 	args = append(args, pkg)
 	setBuildEnv()
 	runPrint("go", args...)
+
+	// Create an md5 checksum of the binary, to be included in the archive for
+	// automatic upgrades.
+	err := md5File(binary)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 
 func buildTar() {
@@ -220,6 +230,7 @@ func buildTar() {
 		{"LICENSE", name + "/LICENSE.txt"},
 		{"AUTHORS", name + "/AUTHORS.txt"},
 		{"syncthing", name + "/syncthing"},
+		{"syncthing.md5", name + "/syncthing.md5"},
 	}
 	for _, file := range listFiles("etc") {
 		files = append(files, archiveFile{file, name + "/" + file})
@@ -242,6 +253,7 @@ func buildZip() {
 		{"LICENSE", name + "/LICENSE.txt"},
 		{"AUTHORS", name + "/AUTHORS.txt"},
 		{"syncthing.exe", name + "/syncthing.exe"},
+		{"syncthing.exe.md5", name + "/syncthing.exe.md5"},
 	}
 	zipFile(filename, files)
 	log.Println(filename)
@@ -263,7 +275,7 @@ func listFiles(dir string) []string {
 
 func setBuildEnv() {
 	os.Setenv("GOOS", goos)
-	if strings.HasPrefix(goarch, "arm") {
+	if strings.HasPrefix(goarch, "armv") {
 		os.Setenv("GOARCH", "arm")
 		os.Setenv("GOARM", goarch[4:])
 	} else {
@@ -287,9 +299,7 @@ func assets() {
 }
 
 func xdr() {
-	for _, f := range []string{"internal/discover/packets", "internal/files/leveldb", "internal/protocol/message"} {
-		runPipe(f+"_xdr.go", "go", "run", "./Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go", "--", f+".go")
-	}
+	runPrint("go", "generate", "./internal/discover", "./internal/files", "./internal/protocol")
 }
 
 func translate() {
@@ -328,9 +338,6 @@ func ldflags() string {
 	b.WriteString(fmt.Sprintf(" -X main.BuildUser %s", buildUser()))
 	b.WriteString(fmt.Sprintf(" -X main.BuildHost %s", buildHost()))
 	b.WriteString(fmt.Sprintf(" -X main.BuildEnv %s", buildEnvironment()))
-	if strings.HasPrefix(goarch, "arm") {
-		b.WriteString(fmt.Sprintf(" -X main.GoArchExtra %s", goarch[3:]))
-	}
 	return b.String()
 }
 
@@ -562,3 +569,29 @@ func zipFile(out string, files []archiveFile) {
 		log.Fatal(err)
 	}
 }
+
+func md5File(file string) error {
+	fd, err := os.Open(file)
+	if err != nil {
+		return err
+	}
+	defer fd.Close()
+
+	h := md5.New()
+	_, err = io.Copy(h, fd)
+	if err != nil {
+		return err
+	}
+
+	out, err := os.Create(file + ".md5")
+	if err != nil {
+		return err
+	}
+
+	_, err = fmt.Fprintf(out, "%x\n", h.Sum(nil))
+	if err != nil {
+		return err
+	}
+
+	return out.Close()
+}

build.sh

@@ -2,7 +2,7 @@
 set -euo pipefail
 IFS=$'\n\t'
 
-DOCKERIMGV=1.3.3-4
+DOCKERIMGV=1.4-4
 
 case "${1:-default}" in
 	default)
@@ -105,7 +105,7 @@ case "${1:-default}" in
 		;;
 
 	docker-init)
-		docker build -q -t syncthing/build:$DOCKERIMGV docker >/dev/null
+		docker build -q -t syncthing/build:$DOCKERIMGV docker
 		;;
 
 	docker-all)
@@ -113,22 +113,24 @@ case "${1:-default}" in
 			-v $(pwd):/go/src/github.com/syncthing/syncthing \
 			-w /go/src/github.com/syncthing/syncthing \
 			syncthing/build:$DOCKERIMGV \
-			sh -c './build.sh clean && ./build.sh all && STTRACE=all ./build.sh test-cov'
+			sh -c './build.sh clean \
+				&& go vet ./cmd/... ./internal/... \
+				&& ( golint ./cmd/... ; golint ./internal/... ) | egrep -v "comment on exported|should have comment" \
+				&& ./build.sh all \
+				&& STTRACE=all ./build.sh test-cov'
 		;;
 
 	docker-test)
 		docker run --rm -h syncthing-builder -u $(id -u) -t \
-			-v $(pwd):/tmp/syncthing \
+			-v $(pwd):/go/src/github.com/syncthing/syncthing \
+			-w /go/src/github.com/syncthing/syncthing \
 			syncthing/build:$DOCKERIMGV \
-			sh -euxc 'mkdir -p /go/src/github.com/syncthing \
-				&& cd /go/src/github.com/syncthing \
-				&& cp -r /tmp/syncthing syncthing \
-				&& cd syncthing \
-				&& ./build.sh clean \
+			sh -euxc './build.sh clean \
 				&& go run build.go -race \
 				&& export GOPATH=$(pwd)/Godeps/_workspace:$GOPATH \
 				&& cd test \
-				&& go test -tags integration -v -timeout 30m -short'
+				&& go test -tags integration -v -timeout 60m -short \
+				&& git clean -fxd .'
 		;;
 
 	*)

changelog.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+since="$1"
+if [[ -z $since ]] ; then
+	since="$(git describe --abbrev=0 HEAD^).."
+fi
+
+git log --pretty=format:'* %s (%h, @%aN)' "$since" | egrep 'fixes #\d|ref #\d'
+

check-contrib.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 missing-authors() {
-	for email in $(git log --format=%ae master | sort | uniq) ; do
+	for email in $(git log --format=%ae HEAD | sort | uniq) ; do
 		grep -q "$email" AUTHORS || echo $email
 	done
 }
@@ -13,7 +13,10 @@ no-docs-typos() {
 	grep -v f2459ef3319b2f060dbcdacd0c35a1788a94b8bd |\
 	grep -v b61f418bf2d1f7d5a9d7088a20a2a448e5e66801 |\
 	grep -v f0621207e3953711f9ab86d99724f1d0faac45b1 |\
-	grep -v f1120d7aa936c0658429edef0037792520b46334
+	grep -v f1120d7aa936c0658429edef0037792520b46334 |\
+	grep -v a9339d0627fff439879d157c75077f02c9fac61b |\
+	grep -v 254c63763a3ad42fd82259f1767db526cff94a14 |\
+	grep -v 4b76ec40c07078beaa2c5e250ed7d9bd6276a718
 }
 
 print-missing-authors() {
@@ -23,22 +26,24 @@ print-missing-authors() {
 }
 
 print-missing-copyright() {
-	find . -name \*.go | xargs grep -L 'Copyright (C)' | grep -v Godeps
+	find . -name \*.go | xargs egrep -L 'Copyright \(C\)|automatically generated' | grep -v Godeps | grep -v internal/auto/
 }
 
-print-line-blame() {
-	for f in $(find . -name \*.go | grep -v Godep) gui/app.js gui/index.html ; do
-		git blame --line-porcelain $f | grep author-mail
-	done | sort | uniq -c | sort -n
-}
-echo Author emails missing in AUTHORS file:
-print-missing-authors
-echo
+authors=$(print-missing-authors)
+if [[ ! -z $authors ]] ; then
+	echo '***'
+	echo Author emails not in AUTHORS:
+	echo $authors
+	echo '***'
+	exit 1
+fi
 
-echo Files missing copyright notice:
-print-missing-copyright
-echo
-
-echo Blame lines per author:
-print-line-blame
+copy=$(print-missing-copyright)
+if [[ ! -z $copy ]] ; then
+	echo ***
+	echo Files missing copyright notice:
+	echo $copy
+	echo ***
+	exit 1
+fi
 

cmd/genassets/main.go

@@ -26,6 +26,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"strings"
 	"text/template"
 )
 
@@ -65,6 +66,11 @@ func walkerFor(basePath string) filepath.WalkFunc {
 			return err
 		}
 
+		if strings.HasPrefix(filepath.Base(name), ".") {
+			// Skip dotfiles
+			return nil
+		}
+
 		if info.Mode().IsRegular() {
 			fd, err := os.Open(name)
 			if err != nil {

cmd/stcompdirs/main.go

@@ -0,0 +1,177 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"crypto/md5"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/syncthing/syncthing/internal/symlinks"
+)
+
+func main() {
+	flag.Parse()
+	log.Println(compareDirectories(flag.Args()...))
+}
+
+// Compare a number of directories. Returns nil if the contents are identical,
+// otherwise an error describing the first found difference.
+func compareDirectories(dirs ...string) error {
+	chans := make([]chan fileInfo, len(dirs))
+	for i := range chans {
+		chans[i] = make(chan fileInfo)
+	}
+	errcs := make([]chan error, len(dirs))
+	abort := make(chan struct{})
+
+	for i := range dirs {
+		errcs[i] = startWalker(dirs[i], chans[i], abort)
+	}
+
+	res := make([]fileInfo, len(dirs))
+	for {
+		numDone := 0
+		for i := range chans {
+			fi, ok := <-chans[i]
+			if !ok {
+				err, hasError := <-errcs[i]
+				if hasError {
+					close(abort)
+					return err
+				}
+				numDone++
+			}
+			res[i] = fi
+		}
+
+		for i := 1; i < len(res); i++ {
+			if res[i] != res[0] {
+				close(abort)
+				if res[i].name < res[0].name {
+					return fmt.Errorf("%s missing %v (present in %s)", dirs[0], res[i], dirs[i])
+				} else if res[i].name > res[0].name {
+					return fmt.Errorf("%s missing %v (present in %s)", dirs[i], res[0], dirs[0])
+				}
+				return fmt.Errorf("Mismatch; %v (%s) != %v (%s)", res[i], dirs[i], res[0], dirs[0])
+			}
+		}
+
+		if numDone == len(dirs) {
+			return nil
+		}
+	}
+}
+
+type fileInfo struct {
+	name string
+	mode os.FileMode
+	mod  int64
+	hash [16]byte
+}
+
+func (f fileInfo) String() string {
+	return fmt.Sprintf("%s %04o %d %x", f.name, f.mode, f.mod, f.hash)
+}
+
+func startWalker(dir string, res chan<- fileInfo, abort <-chan struct{}) chan error {
+	walker := func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		rn, _ := filepath.Rel(dir, path)
+		if rn == "." || rn == ".stfolder" {
+			return nil
+		}
+		if rn == ".stversions" {
+			return filepath.SkipDir
+		}
+
+		var f fileInfo
+		if info.Mode()&os.ModeSymlink != 0 {
+			f = fileInfo{
+				name: rn,
+				mode: os.ModeSymlink,
+			}
+
+			tgt, _, err := symlinks.Read(path)
+			if err != nil {
+				return err
+			}
+			h := md5.New()
+			h.Write([]byte(tgt))
+			hash := h.Sum(nil)
+
+			copy(f.hash[:], hash)
+		} else if info.IsDir() {
+			f = fileInfo{
+				name: rn,
+				mode: info.Mode(),
+				// hash and modtime zero for directories
+			}
+		} else {
+			f = fileInfo{
+				name: rn,
+				mode: info.Mode(),
+				mod:  info.ModTime().Unix(),
+			}
+			sum, err := md5file(path)
+			if err != nil {
+				return err
+			}
+			f.hash = sum
+		}
+
+		select {
+		case res <- f:
+			return nil
+		case <-abort:
+			return errors.New("abort")
+		}
+	}
+
+	errc := make(chan error)
+	go func() {
+		err := filepath.Walk(dir, walker)
+		close(res)
+		if err != nil {
+			errc <- err
+		}
+		close(errc)
+	}()
+	return errc
+}
+
+func md5file(fname string) (hash [16]byte, err error) {
+	f, err := os.Open(fname)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+
+	h := md5.New()
+	io.Copy(h, f)
+	hb := h.Sum(nil)
+	copy(hash[:], hb)
+
+	return
+}

cmd/stfileinfo/main.go

@@ -0,0 +1,89 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"flag"
+	"log"
+	"os"
+	"path/filepath"
+
+	"github.com/syncthing/syncthing/internal/protocol"
+	"github.com/syncthing/syncthing/internal/scanner"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stdout)
+
+	standardBlocks := flag.Bool("s", false, "Use standard block size")
+	flag.Parse()
+
+	path := flag.Arg(0)
+	if path == "" {
+		log.Fatal("Need one argument: path to check")
+	}
+
+	log.Println("File:")
+	log.Println(" ", filepath.Clean(path))
+	log.Println()
+
+	fi, err := os.Lstat(path)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Println("Lstat:")
+	log.Printf("  Size: %d bytes", fi.Size())
+	log.Printf("  Mode: 0%o", fi.Mode())
+	log.Printf("  Time: %v (%d)", fi.ModTime(), fi.ModTime().Unix())
+	log.Println()
+
+	if !fi.Mode().IsDir() && !fi.Mode().IsRegular() {
+		fi, err = os.Stat(path)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		log.Println("Stat:")
+		log.Printf("  Size: %d bytes", fi.Size())
+		log.Printf("  Mode: 0%o", fi.Mode())
+		log.Printf("  Time: %v (%d)", fi.ModTime(), fi.ModTime().Unix())
+		log.Println()
+	}
+
+	if fi.Mode().IsRegular() {
+		log.Println("Blocks:")
+
+		fd, err := os.Open(path)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		blockSize := int(fi.Size())
+		if *standardBlocks || blockSize < protocol.BlockSize {
+			blockSize = protocol.BlockSize
+		}
+		bs, err := scanner.Blocks(fd, blockSize, fi.Size())
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, b := range bs {
+			log.Println(" ", b)
+		}
+	}
+}

cmd/syncthing/gui.go

@@ -70,7 +70,16 @@ func startGUI(cfg config.GUIConfiguration, assetDir string, m *model.Model) erro
 	if err != nil {
 		l.Infoln("Loading HTTPS certificate:", err)
 		l.Infoln("Creating new HTTPS certificate")
-		newCertificate(confDir, "https-")
+
+		// When generating the HTTPS certificate, use the system host name per
+		// default. If that isn't available, use the "syncthing" default.
+		var name string
+		name, err = os.Hostname()
+		if err != nil {
+			name = tlsDefaultCommonName
+		}
+
+		newCertificate(confDir, "https-", name)
 		cert, err = loadCert(confDir, "https-")
 	}
 	if err != nil {
@@ -78,7 +87,20 @@ func startGUI(cfg config.GUIConfiguration, assetDir string, m *model.Model) erro
 	}
 	tlsCfg := &tls.Config{
 		Certificates: []tls.Certificate{cert},
-		ServerName:   "syncthing",
+		MinVersion:   tls.VersionTLS10, // No SSLv3
+		CipherSuites: []uint16{
+			// No RC4
+			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+			tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+			tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+			tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+			tls.TLS_RSA_WITH_AES_128_CBC_SHA,
+			tls.TLS_RSA_WITH_AES_256_CBC_SHA,
+			tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
+			tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+		},
 	}
 
 	rawListener, err := net.Listen("tcp", cfg.Address)
@@ -108,6 +130,7 @@ func startGUI(cfg config.GUIConfiguration, assetDir string, m *model.Model) erro
 	getRestMux.HandleFunc("/rest/upgrade", restGetUpgrade)
 	getRestMux.HandleFunc("/rest/version", restGetVersion)
 	getRestMux.HandleFunc("/rest/stats/device", withModel(m, restGetDeviceStats))
+	getRestMux.HandleFunc("/rest/stats/folder", withModel(m, restGetFolderStats))
 
 	// Debug endpoints, not for general use
 	getRestMux.HandleFunc("/rest/debug/peerCompletion", withModel(m, restGetPeerCompletion))
@@ -126,6 +149,7 @@ func startGUI(cfg config.GUIConfiguration, assetDir string, m *model.Model) erro
 	postRestMux.HandleFunc("/rest/shutdown", restPostShutdown)
 	postRestMux.HandleFunc("/rest/upgrade", restPostUpgrade)
 	postRestMux.HandleFunc("/rest/scan", withModel(m, restPostScan))
+	postRestMux.HandleFunc("/rest/bump", withModel(m, restPostBump))
 
 	// A handler that splits requests between the two above and disables
 	// caching
@@ -291,19 +315,12 @@ func restGetNeed(m *model.Model, w http.ResponseWriter, r *http.Request) {
 	var qs = r.URL.Query()
 	var folder = qs.Get("folder")
 
-	files := m.NeedFolderFilesLimited(folder, 100) // max 100 files
+	progress, queued, rest := m.NeedFolderFiles(folder, 100)
 	// Convert the struct to a more loose structure, and inject the size.
-	output := make([]map[string]interface{}, 0, len(files))
-	for _, file := range files {
-		output = append(output, map[string]interface{}{
-			"Name":         file.Name,
-			"Flags":        file.Flags,
-			"Modified":     file.Modified,
-			"Version":      file.Version,
-			"LocalVersion": file.LocalVersion,
-			"NumBlocks":    file.NumBlocks,
-			"Size":         protocol.BlocksToSize(file.NumBlocks),
-		})
+	output := map[string][]map[string]interface{}{
+		"progress": toNeedSlice(progress),
+		"queued":   toNeedSlice(queued),
+		"rest":     toNeedSlice(rest),
 	}
 
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
@@ -322,6 +339,12 @@ func restGetDeviceStats(m *model.Model, w http.ResponseWriter, r *http.Request)
 	json.NewEncoder(w).Encode(res)
 }
 
+func restGetFolderStats(m *model.Model, w http.ResponseWriter, r *http.Request) {
+	var res = m.FolderStatistics()
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	json.NewEncoder(w).Encode(res)
+}
+
 func restGetConfig(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	json.NewEncoder(w).Encode(cfg.Raw())
@@ -334,44 +357,44 @@ func restPostConfig(m *model.Model, w http.ResponseWriter, r *http.Request) {
 		l.Warnln("decoding posted config:", err)
 		http.Error(w, err.Error(), 500)
 		return
-	} else {
-		if newCfg.GUI.Password != cfg.GUI().Password {
-			if newCfg.GUI.Password != "" {
-				hash, err := bcrypt.GenerateFromPassword([]byte(newCfg.GUI.Password), 0)
-				if err != nil {
-					l.Warnln("bcrypting password:", err)
-					http.Error(w, err.Error(), 500)
-					return
-				} else {
-					newCfg.GUI.Password = string(hash)
-				}
-			}
-		}
-
-		// Start or stop usage reporting as appropriate
-
-		if curAcc := cfg.Options().URAccepted; newCfg.Options.URAccepted > curAcc {
-			// UR was enabled
-			newCfg.Options.URAccepted = usageReportVersion
-			newCfg.Options.URUniqueID = randomString(6)
-			err := sendUsageReport(m)
-			if err != nil {
-				l.Infoln("Usage report:", err)
-			}
-			go usageReportingLoop(m)
-		} else if newCfg.Options.URAccepted < curAcc {
-			// UR was disabled
-			newCfg.Options.URAccepted = -1
-			newCfg.Options.URUniqueID = ""
-			stopUsageReporting()
-		}
-
-		// Activate and save
-
-		configInSync = !config.ChangeRequiresRestart(cfg.Raw(), newCfg)
-		cfg.Replace(newCfg)
-		cfg.Save()
 	}
+
+	if newCfg.GUI.Password != cfg.GUI().Password {
+		if newCfg.GUI.Password != "" {
+			hash, err := bcrypt.GenerateFromPassword([]byte(newCfg.GUI.Password), 0)
+			if err != nil {
+				l.Warnln("bcrypting password:", err)
+				http.Error(w, err.Error(), 500)
+				return
+			}
+
+			newCfg.GUI.Password = string(hash)
+		}
+	}
+
+	// Start or stop usage reporting as appropriate
+
+	if curAcc := cfg.Options().URAccepted; newCfg.Options.URAccepted > curAcc {
+		// UR was enabled
+		newCfg.Options.URAccepted = usageReportVersion
+		newCfg.Options.URUniqueID = randomString(8)
+		err := sendUsageReport(m)
+		if err != nil {
+			l.Infoln("Usage report:", err)
+		}
+		go usageReportingLoop(m)
+	} else if newCfg.Options.URAccepted < curAcc {
+		// UR was disabled
+		newCfg.Options.URAccepted = -1
+		newCfg.Options.URUniqueID = ""
+		stopUsageReporting()
+	}
+
+	// Activate and save
+
+	configInSync = !config.ChangeRequiresRestart(cfg.Raw(), newCfg)
+	cfg.Replace(newCfg)
+	cfg.Save()
 }
 
 func restGetConfigInSync(w http.ResponseWriter, r *http.Request) {
@@ -598,7 +621,7 @@ func restPostUpgrade(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if upgrade.CompareVersions(rel.Tag, Version) == 1 {
-		err = upgrade.UpgradeTo(rel, GoArchExtra)
+		err = upgrade.To(rel)
 		if err != nil {
 			l.Warnln("upgrading:", err)
 			http.Error(w, err.Error(), 500)
@@ -621,6 +644,14 @@ func restPostScan(m *model.Model, w http.ResponseWriter, r *http.Request) {
 	}
 }
 
+func restPostBump(m *model.Model, w http.ResponseWriter, r *http.Request) {
+	qs := r.URL.Query()
+	folder := qs.Get("folder")
+	file := qs.Get("file")
+	m.BringToFront(folder, file)
+	restGetNeed(m, w, r)
+}
+
 func getQR(w http.ResponseWriter, r *http.Request) {
 	var qs = r.URL.Query()
 	var text = qs.Get("text")
@@ -746,3 +777,19 @@ func mimeTypeForFile(file string) string {
 		return mime.TypeByExtension(ext)
 	}
 }
+
+func toNeedSlice(files []protocol.FileInfoTruncated) []map[string]interface{} {
+	output := make([]map[string]interface{}, len(files))
+	for i, file := range files {
+		output[i] = map[string]interface{}{
+			"Name":         file.Name,
+			"Flags":        file.Flags,
+			"Modified":     file.Modified,
+			"Version":      file.Version,
+			"LocalVersion": file.LocalVersion,
+			"NumBlocks":    file.NumBlocks,
+			"Size":         protocol.BlocksToSize(file.NumBlocks),
+		}
+	}
+	return output
+}

cmd/syncthing/gui_csrf.go

@@ -17,8 +17,6 @@ package main
 
 import (
 	"bufio"
-	"crypto/rand"
-	"encoding/base64"
 	"fmt"
 	"net/http"
 	"os"
@@ -88,7 +86,7 @@ func validCsrfToken(token string) bool {
 }
 
 func newCsrfToken() string {
-	token := randomString(30)
+	token := randomString(32)
 
 	csrfMut.Lock()
 	csrfTokens = append(csrfTokens, token)
@@ -140,13 +138,3 @@ func loadCsrfTokens() {
 		csrfTokens = append(csrfTokens, s.Text())
 	}
 }
-
-func randomString(len int) string {
-	bs := make([]byte, len)
-	_, err := rand.Reader.Read(bs)
-	if err != nil {
-		l.Fatalln(err)
-	}
-
-	return base64.StdEncoding.EncodeToString(bs)
-}

cmd/syncthing/main.go

@@ -21,7 +21,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"math/rand"
 	"net"
 	"net/http"
 	_ "net/http/pprof"
@@ -45,6 +44,7 @@ import (
 	"github.com/syncthing/syncthing/internal/model"
 	"github.com/syncthing/syncthing/internal/osutil"
 	"github.com/syncthing/syncthing/internal/protocol"
+	"github.com/syncthing/syncthing/internal/symlinks"
 	"github.com/syncthing/syncthing/internal/upgrade"
 	"github.com/syncthing/syncthing/internal/upnp"
 	"github.com/syndtr/goleveldb/leveldb"
@@ -62,7 +62,6 @@ var (
 	IsRelease   bool
 	IsBeta      bool
 	LongVersion string
-	GoArchExtra string // "", "v5", "v6", "v7"
 )
 
 const (
@@ -103,10 +102,10 @@ func init() {
 }
 
 var (
-	cfg            *config.ConfigWrapper
+	cfg            *config.Wrapper
 	myID           protocol.DeviceID
 	confDir        string
-	logFlags       int = log.Ltime
+	logFlags       = log.Ltime
 	writeRateLimit *ratelimit.Bucket
 	readRateLimit  *ratelimit.Bucket
 	stop           = make(chan int)
@@ -177,17 +176,15 @@ are mostly useful for developers. Use with care.
                available CPU cores.`
 )
 
-func init() {
-	rand.Seed(time.Now().UnixNano())
-}
-
 // Command line and environment options
 var (
 	reset             bool
 	showVersion       bool
 	doUpgrade         bool
 	doUpgradeCheck    bool
+	upgradeTo         string
 	noBrowser         bool
+	noConsole         bool
 	generateDir       string
 	logFile           string
 	noRestart         = os.Getenv("STNORESTART") != ""
@@ -214,6 +211,9 @@ func main() {
 
 		logFile = filepath.Join(defConfDir, "syncthing.log")
 		flag.StringVar(&logFile, "logfile", logFile, "Log file name (blank for stdout)")
+
+		// We also add an option to hide the console window
+		flag.BoolVar(&noConsole, "no-console", false, "Hide console window")
 	}
 
 	flag.StringVar(&generateDir, "generate", "", "Generate key and config in specified dir, then exit")
@@ -228,10 +228,15 @@ func main() {
 	flag.BoolVar(&doUpgrade, "upgrade", false, "Perform upgrade")
 	flag.BoolVar(&doUpgradeCheck, "upgrade-check", false, "Check for available upgrade")
 	flag.BoolVar(&showVersion, "version", false, "Show version")
+	flag.StringVar(&upgradeTo, "upgrade-to", upgradeTo, "Force upgrade directly from specified URL")
 
 	flag.Usage = usageFor(flag.CommandLine, usage, fmt.Sprintf(extraUsage, defConfDir))
 	flag.Parse()
 
+	if noConsole {
+		osutil.HideConsole()
+	}
+
 	if confDir == "" {
 		// Not set as default above because the string can be really long.
 		confDir = defConfDir
@@ -258,19 +263,22 @@ func main() {
 		}
 
 		info, err := os.Stat(dir)
-		if err != nil {
-			l.Fatalln("generate:", err)
-		}
-		if !info.IsDir() {
+		if err == nil && !info.IsDir() {
 			l.Fatalln(dir, "is not a directory")
 		}
+		if err != nil && os.IsNotExist(err) {
+			err = os.MkdirAll(dir, 0700)
+			if err != nil {
+				l.Fatalln("generate:", err)
+			}
+		}
 
 		cert, err := loadCert(dir, "")
 		if err == nil {
 			l.Warnln("Key exists; will not overwrite.")
 			l.Infoln("Device ID:", protocol.NewDeviceID(cert.Certificate[0]))
 		} else {
-			newCertificate(dir, "")
+			newCertificate(dir, "", tlsDefaultCommonName)
 			cert, err = loadCert(dir, "")
 			myID = protocol.NewDeviceID(cert.Certificate[0])
 			if err != nil {
@@ -309,6 +317,15 @@ func main() {
 	// Ensure that our home directory exists.
 	ensureDir(confDir, 0700)
 
+	if upgradeTo != "" {
+		err := upgrade.ToURL(upgradeTo)
+		if err != nil {
+			l.Fatalln("Upgrade:", err) // exits 1
+		}
+		l.Okln("Upgraded from", upgradeTo)
+		return
+	}
+
 	if doUpgrade || doUpgradeCheck {
 		rel, err := upgrade.LatestRelease(IsBeta)
 		if err != nil {
@@ -324,20 +341,19 @@ func main() {
 
 		if doUpgrade {
 			// Use leveldb database locks to protect against concurrent upgrades
-			_, err = leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{CachedOpenFiles: 100})
+			_, err = leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{OpenFilesCacheCapacity: 100})
 			if err != nil {
 				l.Fatalln("Cannot upgrade, database seems to be locked. Is another copy of Syncthing already running?")
 			}
 
-			err = upgrade.UpgradeTo(rel, GoArchExtra)
+			err = upgrade.To(rel)
 			if err != nil {
 				l.Fatalln("Upgrade:", err) // exits 1
 			}
 			l.Okf("Upgraded to %q", rel.Tag)
-			return
-		} else {
-			return
 		}
+
+		return
 	}
 
 	if reset {
@@ -368,13 +384,17 @@ func syncthingMain() {
 	// Ensure that that we have a certificate and key.
 	cert, err = loadCert(confDir, "")
 	if err != nil {
-		newCertificate(confDir, "")
+		newCertificate(confDir, "", tlsDefaultCommonName)
 		cert, err = loadCert(confDir, "")
 		if err != nil {
 			l.Fatalln("load cert:", err)
 		}
 	}
 
+	// We reinitialize the predictable RNG with our device ID, to get a
+	// sequence that is always the same but unique to this syncthing instance.
+	predictableRandom.Seed(seedFromBytes(cert.Certificate[0]))
+
 	myID = protocol.NewDeviceID(cert.Certificate[0])
 	l.SetPrefix(fmt.Sprintf("[%s] ", myID.String()[:5]))
 
@@ -458,6 +478,10 @@ func syncthingMain() {
 
 	opts := cfg.Options()
 
+	if !opts.SymlinksEnabled {
+		symlinks.Supported = false
+	}
+
 	if opts.MaxSendKbps > 0 {
 		writeRateLimit = ratelimit.NewBucketWithRate(float64(1000*opts.MaxSendKbps), int64(5*1000*opts.MaxSendKbps))
 	}
@@ -465,7 +489,7 @@ func syncthingMain() {
 		readRateLimit = ratelimit.NewBucketWithRate(float64(1000*opts.MaxRecvKbps), int64(5*1000*opts.MaxRecvKbps))
 	}
 
-	db, err := leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{CachedOpenFiles: 100})
+	db, err := leveldb.OpenFile(filepath.Join(confDir, "index"), &opt.Options{OpenFilesCacheCapacity: 100})
 	if err != nil {
 		l.Fatalln("Cannot open database:", err, "- Is another copy of Syncthing already running?")
 	}
@@ -562,7 +586,9 @@ func syncthingMain() {
 		if opts.URUniqueID == "" {
 			// Previously the ID was generated from the node ID. We now need
 			// to generate a new one.
-			opts.URUniqueID = randomString(6)
+			opts.URUniqueID = randomString(8)
+			cfg.SetOptions(opts)
+			cfg.Save()
 		}
 		go usageReportingLoop(m)
 		go func() {
@@ -597,7 +623,7 @@ func syncthingMain() {
 	os.Exit(code)
 }
 
-func setupGUI(cfg *config.ConfigWrapper, m *model.Model) {
+func setupGUI(cfg *config.Wrapper, m *model.Model) {
 	opts := cfg.Options()
 	guiCfg := overrideGUIConfig(cfg.GUI(), guiAddress, guiAuthentication, guiAPIKey)
 
@@ -638,7 +664,7 @@ func setupGUI(cfg *config.ConfigWrapper, m *model.Model) {
 	}
 }
 
-func sanityCheckFolders(cfg *config.ConfigWrapper, m *model.Model) {
+func sanityCheckFolders(cfg *config.Wrapper, m *model.Model) {
 nextFolder:
 	for id, folder := range cfg.Folders() {
 		if folder.Invalid != "" {
@@ -743,7 +769,7 @@ func setupUPnP() {
 			if len(igds) > 0 {
 				// Configure the first discovered IGD only. This is a work-around until we have a better mechanism
 				// for handling multiple IGDs, which will require changes to the global discovery service
-				igd = igds[0]
+				igd = &igds[0]
 
 				externalPort = setupExternalPort(igd, port)
 				if externalPort == 0 {
@@ -767,12 +793,9 @@ func setupExternalPort(igd *upnp.IGD, port int) int {
 		return 0
 	}
 
-	// We seed the random number generator with the node ID to get a
-	// repeatable sequence of random external ports.
-	rnd := rand.NewSource(certSeed(cert.Certificate[0]))
 	for i := 0; i < 10; i++ {
-		r := 1024 + int(rnd.Int63()%(65535-1024))
-		err := igd.AddPortMapping(upnp.TCP, r, port, "syncthing", cfg.Options().UPnPLease*60)
+		r := 1024 + predictableRandom.Intn(65535-1024)
+		err := igd.AddPortMapping(upnp.TCP, r, port, fmt.Sprintf("syncthing-%d", r), cfg.Options().UPnPLease*60)
 		if err == nil {
 			return r
 		}
@@ -794,7 +817,7 @@ func renewUPnP(port int) {
 			if len(igds) > 0 {
 				// Configure the first discovered IGD only. This is a work-around until we have a better mechanism
 				// for handling multiple IGDs, which will require changes to the global discovery service
-				igd = igds[0]
+				igd = &igds[0]
 			} else {
 				if debugNet {
 					l.Debugln("Failed to discover IGD during UPnP port mapping renewal.")
@@ -837,6 +860,17 @@ func renewUPnP(port int) {
 }
 
 func resetFolders() {
+	confDir, err := osutil.ExpandTilde(confDir)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	cfgFile := filepath.Join(confDir, "config.xml")
+	cfg, err := config.Load(cfgFile, myID)
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	suffix := fmt.Sprintf(".syncthing-reset-%d", time.Now().UnixNano())
 	for _, folder := range cfg.Folders() {
 		if _, err := os.Stat(folder.Path); err == nil {
@@ -900,7 +934,7 @@ next:
 				// the certificate and used another name.
 				certName := deviceCfg.CertName
 				if certName == "" {
-					certName = "syncthing"
+					certName = tlsDefaultCommonName
 				}
 				err := remoteCert.VerifyHostname(certName)
 				if err != nil {
@@ -914,12 +948,12 @@ next:
 
 				// If rate limiting is set, we wrap the connection in a
 				// limiter.
-				var wr io.Writer = conn
+				wr := io.Writer(conn)
 				if writeRateLimit != nil {
 					wr = &limitedWriter{conn, writeRateLimit}
 				}
 
-				var rd io.Reader = conn
+				rd := io.Reader(conn)
 				if readRateLimit != nil {
 					rd = &limitedReader{conn, readRateLimit}
 				}
@@ -941,11 +975,16 @@ next:
 			}
 		}
 
-		events.Default.Log(events.DeviceRejected, map[string]string{
-			"device":  remoteID.String(),
-			"address": conn.RemoteAddr().String(),
-		})
-		l.Infof("Connection from %s with unknown device ID %s; ignoring", conn.RemoteAddr(), remoteID)
+		if !cfg.IgnoredDevice(remoteID) {
+			events.Default.Log(events.DeviceRejected, map[string]string{
+				"device":  remoteID.String(),
+				"address": conn.RemoteAddr().String(),
+			})
+			l.Infof("Connection from %s with unknown device ID %s", conn.RemoteAddr(), remoteID)
+		} else {
+			l.Infof("Connection from %s with ignored device ID %s", conn.RemoteAddr(), remoteID)
+		}
+
 		conn.Close()
 	}
 }
@@ -992,7 +1031,7 @@ func listenTLS(conns chan *tls.Conn, addr string, tlsCfg *tls.Config) {
 }
 
 func dialTLS(m *model.Model, conns chan *tls.Conn, tlsCfg *tls.Config) {
-	var delay time.Duration = 1 * time.Second
+	delay := time.Second
 	for {
 	nextDevice:
 		for deviceID, deviceCfg := range cfg.Devices() {
@@ -1131,9 +1170,8 @@ func getDefaultConfDir() (string, error) {
 	default:
 		if xdgCfg := os.Getenv("XDG_CONFIG_HOME"); xdgCfg != "" {
 			return filepath.Join(xdgCfg, "syncthing"), nil
-		} else {
-			return osutil.ExpandTilde("~/.config/syncthing")
 		}
+		return osutil.ExpandTilde("~/.config/syncthing")
 	}
 }
 
@@ -1241,12 +1279,13 @@ func autoUpgrade() {
 			continue
 		}
 
-		if upgrade.CompareVersions(rel.Tag, Version) <= 0 {
+		if upgrade.CompareVersions(rel.Tag, Version) != upgrade.Newer {
+			// Skip equal, older or majorly newer (incompatible) versions
 			continue
 		}
 
 		l.Infof("Automatic upgrade (current %q < latest %q)", Version, rel.Tag)
-		err = upgrade.UpgradeTo(rel, GoArchExtra)
+		err = upgrade.To(rel)
 		if err != nil {
 			l.Warnln("Automatic upgrade:", err)
 			continue

cmd/syncthing/random.go

@@ -0,0 +1,68 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"crypto/md5"
+	cryptoRand "crypto/rand"
+	"encoding/binary"
+	"io"
+	mathRand "math/rand"
+)
+
+// randomCharset contains the characters that can make up a randomString().
+const randomCharset = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"
+
+// predictableRandom is an RNG that will always have the same sequence. It
+// will be seeded with the device ID during startup, so that the sequence is
+// predictable but varies between instances.
+var predictableRandom = mathRand.New(mathRand.NewSource(42))
+
+func init() {
+	// The default RNG should be seeded with something good.
+	mathRand.Seed(randomInt64())
+}
+
+// randomString returns a string of random characters (taken from
+// randomCharset) of the specified length.
+func randomString(l int) string {
+	bs := make([]byte, l)
+	for i := range bs {
+		bs[i] = randomCharset[mathRand.Intn(len(randomCharset))]
+	}
+	return string(bs)
+}
+
+// randomInt64 returns a strongly random int64, slowly
+func randomInt64() int64 {
+	var bs [8]byte
+	_, err := io.ReadFull(cryptoRand.Reader, bs[:])
+	if err != nil {
+		panic("randomness failure: " + err.Error())
+	}
+	return seedFromBytes(bs[:])
+}
+
+// seedFromBytes calculates a weak 64 bit hash from the given byte slice,
+// suitable for use a predictable random seed.
+func seedFromBytes(bs []byte) int64 {
+	h := md5.New()
+	h.Write(bs)
+	s := h.Sum(nil)
+	// The MD5 hash of the byte slice is 16 bytes long. We interpret it as two
+	// uint64s and XOR them together.
+	return int64(binary.BigEndian.Uint64(s[0:]) ^ binary.BigEndian.Uint64(s[8:]))
+}

cmd/syncthing/random_test.go

@@ -0,0 +1,80 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import "testing"
+
+func TestPredictableRandom(t *testing.T) {
+	// predictable random sequence is predictable
+	e := 3440579354231278675
+	if v := predictableRandom.Int(); v != e {
+		t.Errorf("Unexpected random value %d != %d", v, e)
+	}
+}
+
+func TestSeedFromBytes(t *testing.T) {
+	// should always return the same seed for the same bytes
+	tcs := []struct {
+		bs []byte
+		v  int64
+	}{
+		{[]byte("hello world"), -3639725434188061933},
+		{[]byte("hello worlx"), -2539100776074091088},
+	}
+
+	for _, tc := range tcs {
+		if v := seedFromBytes(tc.bs); v != tc.v {
+			t.Errorf("Unexpected seed value %d != %d", v, tc.v)
+		}
+	}
+}
+
+func TestRandomString(t *testing.T) {
+	for _, l := range []int{0, 1, 2, 3, 4, 8, 42} {
+		s := randomString(l)
+		if len(s) != l {
+			t.Errorf("Incorrect length %d != %d", len(s), l)
+		}
+	}
+
+	strings := make([]string, 1000)
+	for i := range strings {
+		strings[i] = randomString(8)
+		for j := range strings {
+			if i == j {
+				continue
+			}
+			if strings[i] == strings[j] {
+				t.Errorf("Repeated random string %q", strings[i])
+			}
+		}
+	}
+}
+
+func TestRandomInt64(t *testing.T) {
+	ints := make([]int64, 1000)
+	for i := range ints {
+		ints[i] = randomInt64()
+		for j := range ints {
+			if i == j {
+				continue
+			}
+			if ints[i] == ints[j] {
+				t.Errorf("Repeated random int64 %d", ints[i])
+			}
+		}
+	}
+}

cmd/syncthing/tls.go

@@ -19,11 +19,9 @@ import (
 	"bufio"
 	"crypto/rand"
 	"crypto/rsa"
-	"crypto/sha256"
 	"crypto/tls"
 	"crypto/x509"
 	"crypto/x509/pkix"
-	"encoding/binary"
 	"encoding/pem"
 	"io"
 	"math/big"
@@ -35,8 +33,8 @@ import (
 )
 
 const (
-	tlsRSABits = 3072
-	tlsName    = "syncthing"
+	tlsRSABits           = 3072
+	tlsDefaultCommonName = "syncthing"
 )
 
 func loadCert(dir string, prefix string) (tls.Certificate, error) {
@@ -45,15 +43,8 @@ func loadCert(dir string, prefix string) (tls.Certificate, error) {
 	return tls.LoadX509KeyPair(cf, kf)
 }
 
-func certSeed(bs []byte) int64 {
-	hf := sha256.New()
-	hf.Write(bs)
-	id := hf.Sum(nil)
-	return int64(binary.BigEndian.Uint64(id))
-}
-
-func newCertificate(dir string, prefix string) {
-	l.Infoln("Generating RSA key and certificate...")
+func newCertificate(dir, prefix, name string) {
+	l.Infof("Generating RSA key and certificate for %s...", name)
 
 	priv, err := rsa.GenerateKey(rand.Reader, tlsRSABits)
 	if err != nil {
@@ -66,7 +57,7 @@ func newCertificate(dir string, prefix string) {
 	template := x509.Certificate{
 		SerialNumber: new(big.Int).SetInt64(mr.Int63()),
 		Subject: pkix.Name{
-			CommonName: tlsName,
+			CommonName: name,
 		},
 		NotBefore: notBefore,
 		NotAfter:  notAfter,

docker/Dockerfile

@@ -1,12 +1,12 @@
 FROM debian:squeeze
 MAINTAINER Jakob Borg <jakob@nym.se>
 
-ENV GOLANG_VERSION 1.3.3
+ENV GOLANG_VERSION 1.4
 
 # SCMs for "go get", gcc for cgo
 RUN apt-get update && apt-get install -y \
         ca-certificates curl gcc libc6-dev make \
-        bzr git mercurial unzip \
+        bzr git mercurial unzip patch \
         --no-install-recommends \
 	&& apt-get clean \
         && rm -rf /var/lib/apt/lists/*
@@ -29,7 +29,16 @@ RUN go get github.com/calmh/gonative \
         && rm -rf go \
         && gonative -version $GOLANG_VERSION
 
-# Rebuild the special and missing versions
+# Rebuild the special and missing versions, using patches as appropriate
+
+RUN mkdir /tmp/patches
+ADD *.patch /tmp/patches/
+RUN bash -xec '\
+	cd /usr/local/go ; \
+	for patch in /tmp/patches/*.patch ; do \
+		patch -p0 < "$patch" ; \
+	done \
+	'
 
 RUN bash -xec '\
                 cd /usr/local/go/src; \
@@ -47,10 +56,15 @@ RUN bash -xec '\
 # Install packages needed for test coverage
 
 RUN go get github.com/tools/godep \
-	&& go get code.google.com/p/go.tools/cmd/cover \
+	&& go get golang.org/x/tools/cmd/cover \
 	&& go get github.com/axw/gocov/gocov \
 	&& go get github.com/AlekSi/gocov-xml
 
+# Install tools "go vet" and "golint"
+
+RUN go get golang.org/x/tools/cmd/vet \
+        && go get github.com/golang/lint/golint
+
 # Build standard library for race
 
 RUN go install -race std

docker/go-9102.patch

@@ -0,0 +1,22 @@
+--- src/syscall/route_openbsd.go.orig	Fri Jul 25 23:38:47 2014
++++ src/syscall/route_openbsd.go	Fri Jul 25 23:39:20 2014
+@@ -12,16 +12,16 @@ func (any *anyMessage) toRoutingMessage(b []byte) Rout
+ 	switch any.Type {
+ 	case RTM_ADD, RTM_DELETE, RTM_CHANGE, RTM_GET, RTM_LOSING, RTM_REDIRECT, RTM_MISS, RTM_LOCK, RTM_RESOLVE:
+ 		p := (*RouteMessage)(unsafe.Pointer(any))
+-		return &RouteMessage{Header: p.Header, Data: b[SizeofRtMsghdr:any.Msglen]}
++		return &RouteMessage{Header: p.Header, Data: b[p.Header.Hdrlen:any.Msglen]}
+ 	case RTM_IFINFO:
+ 		p := (*InterfaceMessage)(unsafe.Pointer(any))
+-		return &InterfaceMessage{Header: p.Header, Data: b[SizeofIfMsghdr:any.Msglen]}
++		return &InterfaceMessage{Header: p.Header, Data: b[p.Header.Hdrlen:any.Msglen]}
+ 	case RTM_IFANNOUNCE:
+ 		p := (*InterfaceAnnounceMessage)(unsafe.Pointer(any))
+ 		return &InterfaceAnnounceMessage{Header: p.Header}
+ 	case RTM_NEWADDR, RTM_DELADDR:
+ 		p := (*InterfaceAddrMessage)(unsafe.Pointer(any))
+-		return &InterfaceAddrMessage{Header: p.Header, Data: b[SizeofIfaMsghdr:any.Msglen]}
++		return &InterfaceAddrMessage{Header: p.Header, Data: b[p.Header.Hdrlen:any.Msglen]}
+ 	}
+ 	return nil
+ }

gui/assets/css/overrides.css

@@ -28,6 +28,19 @@ ul+h5 {
     margin-top: 1.5em;
 }
 
+.panel-progress {
+    background: #3498db;
+    height: 3px;
+    left: 0;
+    position: absolute;
+    top: 0;
+    display: block;
+}
+
+.panel-title {
+    position: relative;
+}
+
 identicon {
     display: inline-block;
     position: relative;
@@ -41,16 +54,19 @@ identicon {
     margin-top: 0px;
 }
 
+.popover {
+    max-width: none;
+}
+
 .identicon {
-    width: 30px;
-    height: 30px;
+    width: 20px;
+    height: 20px;
 }
 
 .panel-heading .identicon {
     display: block;
     position: absolute;
-    top: -4px;
-    left: -9px;
+    top: 1px;
 }
 
 .panel-heading {
@@ -61,18 +77,6 @@ identicon {
 .identicon rect {
     fill: #666;
 }
-.identicon-success rect {
-    fill: #2ecc71;
-}
-.identicon-info rect {
-    fill: #9b59b6;
-}
-.identicon-warning rect {
-    fill: #f1c40f;
-}
-.identicon-primary rect {
-    fill: #3498db;
-}
 
 .text-monospace {
     font-family: Menlo, Monaco, Consolas, "Courier New", monospace;
@@ -174,3 +178,20 @@ table.table-condensed td {
     display: block;
     width: 100%;
 }
+
+.three-columns {
+    -webkit-column-count: 3;
+    -moz-column-count: 3;
+    column-count: 3;
+}
+
+.two-columns {
+    -webkit-column-count: 2;
+    -moz-column-count: 2;
+    column-count: 2;
+}
+
+ul.three-columns li, ul.two-columns li {
+    padding-left: 0.5em;
+    text-indent: -0.5em;
+}

gui/assets/lang/lang-be.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Comment, when used at the start of a line",
     "Compression is recommended in most setups.": "Compression is recommended in most setups.",
     "Connection Error": "Connection Error",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg and the following Contributors:",
     "Delete": "Delete",
     "Device ID": "Device ID",
@@ -23,6 +25,8 @@
     "Disconnected": "Disconnected",
     "Documentation": "Documentation",
     "Download Rate": "Download Rate",
+    "Downloaded": "Downloaded",
+    "Downloading": "Downloading",
     "Edit": "Edit",
     "Edit Device": "Edit Device",
     "Edit Folder": "Edit Folder",
@@ -38,6 +42,7 @@
     "Folder ID": "Folder ID",
     "Folder Master": "Folder Master",
     "Folder Path": "Folder Path",
+    "Folders": "Folders",
     "GUI Authentication Password": "GUI Authentication Password",
     "GUI Authentication User": "GUI Authentication User",
     "GUI Listen Addresses": "GUI Listen Addresses",
@@ -52,6 +57,7 @@
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Inversion of the given condition (i.e. do not exclude)",
     "Keep Versions": "Keep Versions",
+    "Last File Synced": "Last File Synced",
     "Last seen": "Last seen",
     "Latest Release": "Latest Release",
     "Local Discovery": "Local Discovery",
@@ -80,10 +86,13 @@
     "Restart": "Restart",
     "Restart Needed": "Restart Needed",
     "Restarting": "Restarting",
+    "Reused": "Reused",
     "Save": "Save",
     "Scanning": "Scanning",
     "Select the devices to share this folder with.": "Select the devices to share this folder with.",
+    "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Settings",
+    "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Share With Devices",
     "Shared With": "Shared With",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Short identifier for the folder. Must be the same on all cluster devices.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
     "The rescan interval must be at least 5 seconds.": "The rescan interval must be at least 5 seconds.",
     "Unknown": "Unknown",
+    "Unshared": "Unshared",
+    "Unused": "Unused",
     "Up to Date": "Up to Date",
     "Upgrade To {%version%}": "Upgrade To {{version}}",
     "Upgrading": "Upgrading",

gui/assets/lang/lang-bg.json

@@ -8,13 +8,15 @@
     "Allow Anonymous Usage Reporting?": "Разреши анонимен доклад за ползване на програмата?",
     "Anonymous Usage Reporting": "Анонимен Доклад",
     "Any devices configured on an introducer device will be added to this device as well.": "Устройства настроени на introducer компютъра също ще бъдат добавени към този компютър.",
-    "Automatic upgrades": "Automatic upgrades",
+    "Automatic upgrades": "Автоматични ъпдейти",
     "Bugs": "Бъгове",
     "CPU Utilization": "Натоварване на Процесора",
     "Close": "Затвори",
     "Comment, when used at the start of a line": "Коментар, използван в началото на реда",
     "Compression is recommended in most setups.": "Компресията е препоръчителна в повечето конфигурации.",
     "Connection Error": "Грешка при Свързването",
+    "Copied from elsewhere": "Копиране от някъде другаде",
+    "Copied from original": "Копиран от оригинала",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Правата запазени © 2014 Jakob Borg и следните Сътрудници:",
     "Delete": "Изтрий",
     "Device ID": "Идентификатор на устройство",
@@ -23,6 +25,8 @@
     "Disconnected": "Прекрати Връзката",
     "Documentation": "Документация",
     "Download Rate": "Скорост на Теглене",
+    "Downloaded": "Изтеглен",
+    "Downloading": "Изтегляне",
     "Edit": "Промени",
     "Edit Device": "Промени устройство",
     "Edit Folder": "Промени папка",
@@ -34,10 +38,11 @@
     "File Versioning": "Файлови Версии",
     "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Битовете за права за достъп са игнорирани, когато се проверява за промени. Използвай с файлови системи тип FAT.",
     "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Когато syncthing замени или изтрие файл той се премества в  .stversions и преименува с дабавени дата и час.",
-    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Файловете са защитени от промени направени на други устройства, но промени направени на тава устройство ще бъдат синхронизирани до другите устройства.",
+    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Файловете са защитени от промени направени на други устройства, но промени направени на това устройство ще бъдат синхронизирани с другите устройства.",
     "Folder ID": "Идентификатор на папка",
     "Folder Master": "Главна папка",
     "Folder Path": "Път до папката",
+    "Folders": "Папки",
     "GUI Authentication Password": "Парола за Потребителския Интерфейс",
     "GUI Authentication User": "Потребител за Потребителския Интерфейс",
     "GUI Listen Addresses": "Адрес за Свързване с Потребителския Интерфейс",
@@ -48,10 +53,11 @@
     "Idle": "Без Работа",
     "Ignore Patterns": "Шаблони за Игнориране",
     "Ignore Permissions": "Игнорирай Права за Достъп",
-    "Incoming Rate Limit (KiB/s)": "Входящ Лимит на Скороста(KiB/s)",
+    "Incoming Rate Limit (KiB/s)": "Входящ Лимит на Скоростта (KiB/s)",
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Обратното на даденото условие (пр. не изключвай)",
     "Keep Versions": "Пази Версии",
+    "Last File Synced": "Последния синхронизиран файл",
     "Last seen": "Последно видян",
     "Latest Release": "Най-новата Версия",
     "Local Discovery": "Локално Откриване",
@@ -80,18 +86,21 @@
     "Restart": "Рестартирай",
     "Restart Needed": "Изискава се Рестартиране",
     "Restarting": "Рестартиране",
+    "Reused": "Повторно използван",
     "Save": "Запази",
     "Scanning": "Сканиране",
     "Select the devices to share this folder with.": "Избери устройствата, с които да споделиш тази папка.",
+    "Select the folders to share with this device.": "Изберете папките за споделяне с това устройство.",
     "Settings": "Настройки",
+    "Share Folders With Device": "Сподели папки с това устройство",
     "Share With Devices": "Сподели с устройства",
-    "Shared With": "Сподел С",
+    "Shared With": "Споделена със",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Кратък идентификатор на папката. Трябва да бъде същият на всички компютри.",
     "Show ID": "Покажи Идентификатора",
     "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Покажи вместо идентификатор на устройството в статус на клъстъра. Ще бъде предлагано на други комютри като име по подразбиране.",
     "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Покажи вместо идентификатор на устройството в статус на клъстъра. Ще бъде обновено с името по подразбиране изпратено от другия компютър.",
     "Shutdown": "Спри Програмата",
-    "Simple File Versioning": "Просто Файлови Версии",
+    "Simple File Versioning": "Опростени Файлови Версии",
     "Single level wildcard (matches within a directory only)": "Маска на едно ниво (покрива само в папка)",
     "Source Code": "Сорс Код",
     "Staggered File Versioning": "Наслагващи се Файлови Версии",
@@ -121,9 +130,11 @@
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Максималното време да се пазят весрсии (в дни, сложи 0, за да пазиш версии завинаги).",
     "The number of old versions to keep, per file.": "Броят стари версии, които да бъдат пазени за всеки файл.",
     "The number of versions must be a number and cannot be blank.": "Броят версии трябва да бъде число и не може да бъде празно.",
-    "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
+    "The rescan interval must be a non-negative number of seconds.": "Интервала на сканиране трябва да бъде не отрицателно число в секунди.",
     "The rescan interval must be at least 5 seconds.": "Интервала за повторно сканиране трябва да бъде поне 5 секунди.",
     "Unknown": "Неясен",
+    "Unshared": "Споделянето прекратено",
+    "Unused": "Неизползван",
     "Up to Date": "Актуален",
     "Upgrade To {%version%}": "Обновен До {{version}}",
     "Upgrading": "Обновяване",

gui/assets/lang/lang-cs.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Komentář, pokud použito na začátku řádku",
     "Compression is recommended in most setups.": "Komprese je doporučena pro většinu nastavení.",
     "Connection Error": "Chyba připojení",
+    "Copied from elsewhere": "Zkopírováno odjinud",
+    "Copied from original": "Zkopírováno z originálu",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg a následující přispěvatelé:",
     "Delete": "Smazat",
     "Device ID": "ID přístroje",
@@ -23,6 +25,8 @@
     "Disconnected": "Odpojeno",
     "Documentation": "Dokumentace",
     "Download Rate": "Rychlost stahování",
+    "Downloaded": "Staženo",
+    "Downloading": "Stahuji",
     "Edit": "Upravit",
     "Edit Device": "Upravit přístroj",
     "Edit Folder": "Upravit adresář",
@@ -37,7 +41,8 @@
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Soubory jsou chráněny před změnami na ostatních přístrojích, ale změny provedené z tohoto umístění budou rozeslány na zbytek clusteru.",
     "Folder ID": "ID adresáře",
     "Folder Master": "Master adresář",
-    "Folder Path": "Cesta adresáře",
+    "Folder Path": "Cesta k adresáři",
+    "Folders": "Adresáře",
     "GUI Authentication Password": "Přihlašovací heslo pro GUI",
     "GUI Authentication User": "Přihlašovací jméno pro GUI",
     "GUI Listen Addresses": "Adresa naslouchání GUI",
@@ -52,6 +57,7 @@
     "Introducer": "Zavaděč",
     "Inversion of the given condition (i.e. do not exclude)": "Prohození zadané podmínky (např. nevynechat)",
     "Keep Versions": "Ponechat verze",
+    "Last File Synced": "Poslední soubor synchronizován",
     "Last seen": "Naposledy spatřen",
     "Latest Release": "Poslední vydání",
     "Local Discovery": "Místní oznamování",
@@ -80,17 +86,20 @@
     "Restart": "Restart",
     "Restart Needed": "Je nutný restart",
     "Restarting": "Restartuji",
+    "Reused": "Opakovaně použité",
     "Save": "Uložit",
     "Scanning": "Skenování",
     "Select the devices to share this folder with.": "Vybrat přístroje se kterými sdílet tento adresář.",
+    "Select the folders to share with this device.": "Vybrat adresáře sdílené tomuto přístroji.",
     "Settings": "Nastavení",
+    "Share Folders With Device": "Sdílet adresáře tomuto přístroji",
     "Share With Devices": "Sdílet s přístroji",
     "Shared With": "Sdíleno s",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Krátký identifikátor tohoto adresáře. Musí být stejný na všech přístrojích v clusteru.",
     "Show ID": "Zobrazit ID",
     "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Zobrazeno místo ID přístroje na náhledu stavu clusteru. Bude odesíláno ostatním přístrojům jako dodatečné výchozí jméno.",
     "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Zobrazeno místo ID přístroje na náhledu stavu clusteru. Bude aktualizováno na jméno které přístroj odesílá pokud nebylo vyplněno.",
-    "Shutdown": "Vypnutí",
+    "Shutdown": "Vypnout",
     "Simple File Versioning": "Jednoduché verze souborů",
     "Single level wildcard (matches within a directory only)": "Jednoúrovňový zástupný znak (shody pouze uvnitř adresáře)",
     "Source Code": "Zdrojový kód",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "Interval pro opakování skenování musí být pozitivní číslo.",
     "The rescan interval must be at least 5 seconds.": "Interval opakování skenování musí být delší než 5 sekund.",
     "Unknown": "Neznámý",
+    "Unshared": "Nesdílené",
+    "Unused": "Nepoužité",
     "Up to Date": "Aktuální",
     "Upgrade To {%version%}": "Aktualizovat na {{version}}",
     "Upgrading": "Aktualizuji",

gui/assets/lang/lang-de.json

@@ -1,31 +1,35 @@
 {
-    "API Key": "API-Key",
+    "API Key": "API-Schlüssel",
     "About": "Über Syncthing",
     "Add Device": "Gerät hinzufügen",
     "Add Folder": "Verzeichnis hinzufügen",
     "Address": "Adresse",
     "Addresses": "Adressen",
-    "Allow Anonymous Usage Reporting?": "Übertragung von anonymen Nutzungsstatistiken erlauben?",
+    "Allow Anonymous Usage Reporting?": "Übertragung von anonymen Nutzungsberichten erlauben?",
     "Anonymous Usage Reporting": "Anonymer Nutzungsbericht",
     "Any devices configured on an introducer device will be added to this device as well.": "Alle Geräte, die beim Verteiler eingetragen sind, werden auch bei diesem Gerät eingetragen",
-    "Automatic upgrades": "Automatisches Upgrade",
+    "Automatic upgrades": "Automat. Updates",
     "Bugs": "Fehler",
     "CPU Utilization": "Prozessorauslastung",
     "Close": "Schließen",
     "Comment, when used at the start of a line": "Kommentar, wenn am Anfang der Zeile benutzt.",
     "Compression is recommended in most setups.": "Datenkomprimierung ist für die meisten Anwendungen empfohlen",
     "Connection Error": "Verbindungsfehler",
+    "Copied from elsewhere": "Von woanders kopiert",
+    "Copied from original": "Vom Originial kopiert",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg und folgende Unterstützer:",
     "Delete": "Löschen",
     "Device ID": "Geräte ID",
     "Device Identification": "Gerät Identifikation",
-    "Device Name": "Geräte-Name",
-    "Disconnected": "Verbindung getrennt",
+    "Device Name": "Gerätename",
+    "Disconnected": "Getrennt",
     "Documentation": "Dokumentation",
-    "Download Rate": "Downloadgeschwindigkeit",
-    "Edit": "Einstellungen bearbeiten",
+    "Download Rate": "Download",
+    "Downloaded": "Heruntergeladen",
+    "Downloading": "Lädt herunter",
+    "Edit": "Bearbeiten",
     "Edit Device": "Gerät bearbeiten",
-    "Edit Folder": "Verzeichnis Bearbeiten",
+    "Edit Folder": "Verzeichnis bearbeiten",
     "Editing": "Bearbeitung",
     "Enable UPnP": "UPnP aktivieren",
     "Enter comma separated \"ip:port\" addresses or \"dynamic\" to perform automatic discovery of the address.": "Trage durch ein Komma getrennte \"IP:Port\" Adressen oder \"dynamic\" ein um automatische Adresserkennung durchzuführen.",
@@ -33,11 +37,12 @@
     "Error": "Fehler",
     "File Versioning": "Dateiversionierung",
     "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Dateizugriffsrechte beim Suchen nach Veränderungen ignorieren. Bei FAT-Dateisystemen verwenden.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Dateien werden, bevor syncthing sie löscht oder ersetzt, als datierte Versionen in einen Ordner names .stversions verschoben.",
+    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Dateien werden, bevor Syncthing sie löscht oder ersetzt, als datierte Versionen in einen Ordner names .stversions verschoben.",
     "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Dateien sind vor Veränderung durch andere Geräte geschützt, auf diesem Gerät durchgeführte Veränderungen werden aber auf den Rest des Verbunds übertragen.",
     "Folder ID": "Verzeichnis ID",
     "Folder Master": "Keine Veränderungen zulassen",
-    "Folder Path": "Verzeichnis Pfad",
+    "Folder Path": "Verzeichnispfad",
+    "Folders": "Verzeichnisse",
     "GUI Authentication Password": "Passwort für Zugang zur Benutzeroberfläche",
     "GUI Authentication User": "Nutzername für Zugang zur Benutzeroberfläche",
     "GUI Listen Addresses": "Adresse(n) für die Benutzeroberfläche",
@@ -52,6 +57,7 @@
     "Introducer": "Verteilergerät",
     "Inversion of the given condition (i.e. do not exclude)": "Umkehrung der angegebenen Bedingung (z.B. schließe nicht aus)",
     "Keep Versions": "Versionen erhalten",
+    "Last File Synced": "Letzte Änderung",
     "Last seen": "Zuletzt online",
     "Latest Release": "Letzte Veröffentlichung",
     "Local Discovery": "Lokale Auffindung",
@@ -74,28 +80,31 @@
     "Preview": "Vorschau",
     "Preview Usage Report": "Vorschau des Nutzungsberichts",
     "Quick guide to supported patterns": "Schnellanleitung zu den unterstützten Suchstrukturen",
-    "RAM Utilization": "Verwendeter Arbeitsspeicher",
+    "RAM Utilization": "RAM Auslastung",
     "Rescan": "Überprüfen",
     "Rescan Interval": "Suchintervall",
     "Restart": "Neustart",
     "Restart Needed": "Neustart notwendig",
     "Restarting": "Wird neu gestartet",
+    "Reused": "Erneut benutzt",
     "Save": "Speichern",
-    "Scanning": "Sucht",
-    "Select the devices to share this folder with.": "Wähle die Geräte aus, mit denen du dieses Verzeichnis teilen willst.",
+    "Scanning": "Suche",
+    "Select the devices to share this folder with.": "Wähle die Geräte aus, mit denen Du dieses Verzeichnis teilen willst.",
+    "Select the folders to share with this device.": "Wähle die Verzeichnisse aus, die du mit diesem Gerät teilen möchtest",
     "Settings": "Einstellungen",
+    "Share Folders With Device": "Teile Order mit diesem Gerät",
     "Share With Devices": "Teile mit diesen Geräten",
     "Shared With": "Geteilt mit",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kurze ID für das Verzeichnis. Muss auf allen Verbunds-Geräten gleich sein.",
     "Show ID": "ID anzeigen",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Wird anstatt der Geräte-ID im Verbunds-Status angezeigt. Wird als optionaler Standardname an andere Geräte bekannt gegeben.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Wird anstatt der Geräte-ID im Verbunds-Status angezeigt. Wird auf den Namen aktualisiert, den das Gerät angibt.",
+    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Wird anstatt der Geräte ID im Verbunds-Status angezeigt. Wird als optionaler Standardname an andere Geräte bekannt gegeben.",
+    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Wird anstatt der Geräte ID im Verbunds-Status angezeigt. Wird auf den Namen aktualisiert, den das Gerät angibt.",
     "Shutdown": "Herunterfahren",
     "Simple File Versioning": "Einfache Dateiversionierung",
     "Single level wildcard (matches within a directory only)": "Einzelnes Maskenzeichen (wird für ein einzelnes Verzeichnis verwendet)",
-    "Source Code": "Sourcecode",
+    "Source Code": "Quellcode",
     "Staggered File Versioning": "Stufenweise Dateiversionierung",
-    "Start Browser": "Starte Browser",
+    "Start Browser": "Browser starten",
     "Stopped": "Gestoppt",
     "Support / Forum": "Support / Forum",
     "Sync Protocol Listen Addresses": "Adresse(n) für das Synchronisierungsprotokoll",
@@ -105,17 +114,17 @@
     "Syncthing includes the following software or portions thereof:": "Syncthing enthält die folgende Software oder Teile davon:",
     "Syncthing is restarting.": "Syncthing wird neu gestartet",
     "Syncthing is upgrading.": "Syncthing wird aktualisiert",
-    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing scheint nicht erreichbar zu sein oder es gibt ein Problem mit Ihrer Internetverbindung. Versuche erneut...",
+    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing scheint nicht erreichbar zu sein oder es gibt ein Problem mit Deiner Internetverbindung. Versuche erneut...",
     "The aggregated statistics are publicly available at {%url%}.": "Die gesammelten Statistiken sind öffentlich verfügbar unter {{url}}.",
     "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Die Konfiguration wurde gespeichert, aber nicht aktiviert. Syncthing muss neugestartet werden um die neue Konfiguration zu aktivieren.",
-    "The device ID cannot be blank.": "Die Geräte-ID darf nicht leer sein.",
-    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Die hier einzutragende Geräte-ID kann im \"Bearbeiten > Zeige ID\"-Dialog auf dem anderen Gerät gefunden werden. Leerzeichen und Striche sind optional (werden ignoriert).",
-    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Der verschlüsselte Benutzungsbericht wird täglich gesendet. Er wird benutzt um Statistiken über verwendete Betriebssysteme, Verzeichnis-Größen und Programm-Versionen zu erstellen. Sollte der Bericht in Zukunft weitere Daten erfassen, wird dieses Fenster erneut angezeigt.",
-    "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "Die eingegebene Geräte-ID scheint nicht gültig zu sein. Es sollte eine 52 oder 56 stellige Zeichenkette aus Buchstaben und Nummern sein. Leerzeichen und Bindestriche sind optional.",
-    "The folder ID cannot be blank.": "Die Verzeichnis-ID darf nicht leer sein.",
-    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "Die Verzeichnis-ID muss eine kurze Kennung (64 Zeichen oder weniger) sein. Sie kann nur aus Buchstaben, Zahlen und den Punkt- (.), Strich- (-), und Unterstrich- (_) Zeichen bestehen.",
-    "The folder ID must be unique.": "Die Verzeichnis-ID muss eindeutig sein.",
-    "The folder path cannot be blank.": "Der Verzeichnis-Pfad kann nicht leer sein",
+    "The device ID cannot be blank.": "Die Geräte ID darf nicht leer sein.",
+    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Die hier einzutragende Geräte ID kann im \"Bearbeiten > Zeige ID\"-Dialog auf dem anderen Gerät gefunden werden. Leerzeichen und Bindestriche sind optional (werden ignoriert).",
+    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Der verschlüsselte Nutzungsbericht wird täglich gesendet. Er wird benutzt um Statistiken über verwendete Betriebssysteme, Verzeichnis-Größen und Programm-Versionen zu erstellen. Sollte der Bericht in Zukunft weitere Daten erfassen, wird dieses Fenster erneut angezeigt.",
+    "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "Die eingegebene Geräte ID scheint nicht gültig zu sein. Es sollte eine 52 oder 56 stellige Zeichenkette aus Buchstaben und Nummern sein. Leerzeichen und Bindestriche sind optional.",
+    "The folder ID cannot be blank.": "Die Verzeichnis ID darf nicht leer sein.",
+    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "Die Verzeichnis ID muss eine kurze Kennung (64 Zeichen oder weniger) sein. Sie kann nur aus Buchstaben, Zahlen und dem Punkt- (.), Bindestrich- (-), und Unterstrich- (_) Zeichen bestehen.",
+    "The folder ID must be unique.": "Die Verzeichnis ID muss eindeutig sein.",
+    "The folder path cannot be blank.": "Der Verzeichnispfad kann nicht leer sein",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Es wird in folgenden Abständen versioniert: in der ersten Stunde wird alle 30 Sekunden eine Version behalten, am ersten Tag eine jede Stunde, in den ersten 30 Tagen eine jeden Tag, danach wird bis zum Höchstalter eine Version pro Woche beibehalten.",
     "The maximum age must be a number and cannot be blank.": "Das Höchstalter muss angegeben werden und eine Zahl sein.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Die längste Zeit, die alte Versionen vorgehalten werden (in Tagen, 0 bedeutet, alte Versionen für immer zu behalten).",
@@ -124,17 +133,19 @@
     "The rescan interval must be a non-negative number of seconds.": "Das Suchintervall muss eine nicht negative Anzahl von Sekunden sein.",
     "The rescan interval must be at least 5 seconds.": "Das Suchintervall muss mindestens 5 Sekunden betragen.",
     "Unknown": "Unbekannt",
+    "Unshared": "Ungeteilt",
+    "Unused": "Ungenutzt",
     "Up to Date": "Aktuell",
-    "Upgrade To {%version%}": "Upgrade auf {{version}}",
+    "Upgrade To {%version%}": "Update auf {{version}}",
     "Upgrading": "Wird aktualisiert",
-    "Upload Rate": "Uploadgeschwindigkeit",
+    "Upload Rate": "Upload",
     "Use Compression": "Benutze Komprimierung",
-    "Use HTTPS for GUI": "Benutze HTTPS für Benutzeroberfläche",
+    "Use HTTPS for GUI": "HTTPS für Benutzeroberfläche benutzen",
     "Version": "Version",
     "Versions Path": "Versionierungspfad",
     "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Alte Versionen werden automatisch gelöscht wenn sie älter als das angegebene Höchstalter sind oder die Höchstzahl der Dateien pro Zeitabschnitt überschritten wird.",
     "When adding a new device, keep in mind that this device must be added on the other side too.": "Beachte beim Hinzufügen eines neuen Gerätes, dass dieses Gerät auch auf der Gegenseite hinzugefügt werden muss.",
-    "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Beim Hinzufügen eines neuen Verzeichnisses, beachte dass die Verzeichnis-ID dazu verwendet wird, Verzeichnisse zwischen Geräten zu verbinden. Die ID muss also auf allen Geräten gleich sein, die Groß- und Kleinschreibung muss dabei beachtet werden.",
+    "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Beim Hinzufügen eines neuen Verzeichnisses, beachte dass die Verzeichnis ID dazu verwendet wird, Verzeichnisse zwischen Geräten zu verbinden. Die ID muss also auf allen Geräten gleich sein, die Groß- und Kleinschreibung muss dabei beachtet werden.",
     "Yes": "Ja",
     "You must keep at least one version.": "Du musst mindestens eine Version behalten.",
     "full documentation": "Komplette Dokumentation",

gui/assets/lang/lang-en.json

@@ -1,8 +1,10 @@
 {
    "API Key": "API Key",
    "About": "About",
+   "Add": "Add",
    "Add Device": "Add Device",
    "Add Folder": "Add Folder",
+   "Add new folder?": "Add new folder?",
    "Address": "Address",
    "Addresses": "Addresses",
    "Allow Anonymous Usage Reporting?": "Allow Anonymous Usage Reporting?",
@@ -22,6 +24,7 @@
    "Device ID": "Device ID",
    "Device Identification": "Device Identification",
    "Device Name": "Device Name",
+   "Device {%device%} ({%address%}) wants to connect. Add new device?": "Device {{device}} ({{address}}) wants to connect. Add new device?",
    "Disconnected": "Disconnected",
    "Documentation": "Documentation",
    "Download Rate": "Download Rate",
@@ -49,23 +52,26 @@
    "Generate": "Generate",
    "Global Discovery": "Global Discovery",
    "Global Discovery Server": "Global Discovery Server",
-   "Global Discovery Servers": "Global Discovery Servers",
    "Global State": "Global State",
    "Idle": "Idle",
+   "Ignore": "Ignore",
    "Ignore Patterns": "Ignore Patterns",
    "Ignore Permissions": "Ignore Permissions",
    "Incoming Rate Limit (KiB/s)": "Incoming Rate Limit (KiB/s)",
    "Introducer": "Introducer",
    "Inversion of the given condition (i.e. do not exclude)": "Inversion of the given condition (i.e. do not exclude)",
    "Keep Versions": "Keep Versions",
+   "Last File Synced": "Last File Synced",
    "Last seen": "Last seen",
+   "Later": "Later",
    "Latest Release": "Latest Release",
-   "Legend:": "Legend:",
    "Local Discovery": "Local Discovery",
    "Local State": "Local State",
    "Maximum Age": "Maximum Age",
    "Multi level wildcard (matches multiple directory levels)": "Multi level wildcard (matches multiple directory levels)",
    "Never": "Never",
+   "New Device": "New Device",
+   "New Folder": "New Folder",
    "No": "No",
    "No File Versioning": "No File Versioning",
    "Notice": "Notice",
@@ -91,8 +97,13 @@
    "Save": "Save",
    "Scanning": "Scanning",
    "Select the devices to share this folder with.": "Select the devices to share this folder with.",
+   "Select the folders to share with this device.": "Select the folders to share with this device.",
    "Settings": "Settings",
+   "Share": "Share",
+   "Share Folder": "Share Folder",
+   "Share Folders With Device": "Share Folders With Device",
    "Share With Devices": "Share With Devices",
+   "Share this folder?": "Share this folder?",
    "Shared With": "Shared With",
    "Short identifier for the folder. Must be the same on all cluster devices.": "Short identifier for the folder. Must be the same on all cluster devices.",
    "Show ID": "Show ID",
@@ -148,5 +159,6 @@
    "Yes": "Yes",
    "You must keep at least one version.": "You must keep at least one version.",
    "full documentation": "full documentation",
-   "items": "items"
+   "items": "items",
+   "{%device%} wants to share folder \"{%folder%}\".": "{{device}} wants to share folder \"{{folder}}\"."
 }

gui/assets/lang/lang-es.json

@@ -0,0 +1,153 @@
+{
+    "API Key": "Clave API",
+    "About": "Acerca de",
+    "Add Device": "Agregar dispositivo",
+    "Add Folder": "Agregar repositorio",
+    "Address": "Dirección",
+    "Addresses": "Direcciones",
+    "Allow Anonymous Usage Reporting?": "Permitir reporte anónimo de uso?",
+    "Anonymous Usage Reporting": "Reporte anónimo de uso",
+    "Any devices configured on an introducer device will be added to this device as well.": "Cualquier dispositivo configurado en un dispositivo introductor será también agregado a este dispositivo.",
+    "Automatic upgrades": "Actualizaciones automáticas",
+    "Bugs": "Errores",
+    "CPU Utilization": "Uso de la CPU",
+    "Close": "Cerrar",
+    "Comment, when used at the start of a line": "Comentario, cuando es utilizado al inicio de una línea.",
+    "Compression is recommended in most setups.": "La compresión de datos es recomendada para la mayoría de las configuraciones.",
+    "Connection Error": "Error de conexión",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
+    "Copyright © 2014 Jakob Borg and the following Contributors:": "Derechos de autor © 2014 Jakob Borg y los siguientes  colaboradores:",
+    "Delete": "Suprimir",
+    "Device ID": "ID del dispositivo",
+    "Device Identification": "Identificación del dispositivo",
+    "Device Name": "Nombre del dispositivo",
+    "Disconnected": "Desconectado",
+    "Documentation": "Documentación",
+    "Download Rate": "Tasa de descarga",
+    "Downloaded": "Descargado",
+    "Downloading": "Descargando",
+    "Edit": "Editar",
+    "Edit Device": "Editar dispositivo",
+    "Edit Folder": "Editar repositorio",
+    "Editing": "Editando",
+    "Enable UPnP": "Permitir UPnP",
+    "Enter comma separated \"ip:port\" addresses or \"dynamic\" to perform automatic discovery of the address.": "Ingrese las direcciones \"ip:puerto\" separadas por coma, o \"dynamic\" para descubrir automáticamente las direcciones.",
+    "Enter ignore patterns, one per line.": "Añadir patrones de exclusión, uno por línea.",
+    "Error": "Error",
+    "File Versioning": "Control de versiones",
+    "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Los permisos de archivo son ignorados al buscar cambios. Usar en sistemas de archivos FAT.",
+    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Los archivos son movidos al directorio .stversions y renombrados a versiones marcadas por fecha cuando son reemplazados o eliminados por Syncthing,",
+    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Los archivos están protegidos frente a los cambios realizados en otros dispositivos, peros los cambios realizados en este dispositivo serán envíados al resto del grupo",
+    "Folder ID": "ID del repositorio",
+    "Folder Master": "Repositorio maestro",
+    "Folder Path": "Ruta del repositorio",
+    "Folders": "Repositorios",
+    "GUI Authentication Password": "Contraseña de autenticación de la GUI",
+    "GUI Authentication User": "Usuario de la GUI",
+    "GUI Listen Addresses": "Direcciones de escucha para la GUI.",
+    "Generate": "Generar",
+    "Global Discovery": "Búsqueda en internet",
+    "Global Discovery Server": "Servidor global de identificación",
+    "Global State": "Estado Global",
+    "Idle": "Inactivo",
+    "Ignore Patterns": "Patrones de exclusión",
+    "Ignore Permissions": "Ignorar permisos",
+    "Incoming Rate Limit (KiB/s)": "Límite de velocidad de entrada (KiB/s)",
+    "Introducer": "Introductor",
+    "Inversion of the given condition (i.e. do not exclude)": "Inversión de la condición dada (es decir, no excluir)",
+    "Keep Versions": "Conservar versiones",
+    "Last File Synced": "Último archivo sincronizado.",
+    "Last seen": "Visto por ultima vez",
+    "Latest Release": "Última versión",
+    "Local Discovery": "Búsqueda en red local",
+    "Local State": "Estado Local",
+    "Maximum Age": "Edad máxima",
+    "Multi level wildcard (matches multiple directory levels)": "Multi level wildcard (matches multiple directory levels)",
+    "Never": "Nunca",
+    "No": "No",
+    "No File Versioning": "Sin control de versiones de archivos",
+    "Notice": "Aviso",
+    "OK": "OK",
+    "Offline": "Fuera de linea",
+    "Online": "En linea",
+    "Out Of Sync": "Fuera de sincronización",
+    "Outgoing Rate Limit (KiB/s)": "Tasa máxima de envío (KiB/s)",
+    "Override Changes": "Reemplazar los cambios",
+    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Ruta del repositorio en el equipo local. Será creado si no existe. El carácter tilde (~) puede ser utilizado como atajo de ",
+    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Ruta donde serán guardas las versiones (dejar vacío para usar el directorio predifinido \".stversions\" en el repositorio)",
+    "Please wait": "Aguarde por favor",
+    "Preview": "Vista previa",
+    "Preview Usage Report": "Ver reporte de uso",
+    "Quick guide to supported patterns": "Guía rápida sobre los patrones soportados",
+    "RAM Utilization": "Utilización de RAM",
+    "Rescan": "Reescanear",
+    "Rescan Interval": "Intervalo de Reescaneo",
+    "Restart": "Reiniciar",
+    "Restart Needed": "Es necesario reiniciar",
+    "Restarting": "Reiniciando",
+    "Reused": "Reused",
+    "Save": "Guardar",
+    "Scanning": "Actualización",
+    "Select the devices to share this folder with.": "Seleccione los dispositivos con los cuales compartir este repositorio.",
+    "Select the folders to share with this device.": "Seleccione los repositorios para compartir con este dispositivo.",
+    "Settings": "Configuración",
+    "Share Folders With Device": "Compartir repositorios con dispositivo",
+    "Share With Devices": "Compartir con los dispositivos",
+    "Shared With": "Compartido con",
+    "Short identifier for the folder. Must be the same on all cluster devices.": "Identificador corto para el repositorio. Debe ser el mismo en todos los dispositivos del grupo.",
+    "Show ID": "Mostrar ID",
+    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.",
+    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Mostrado en vez del ID del dispositivo en el estado del grupo. Si dejado en blanco, será usado el nombre sugerido por el dispositivo.",
+    "Shutdown": "Apagar",
+    "Simple File Versioning": "Versiones simple de archivos",
+    "Single level wildcard (matches within a directory only)": "Single level wildcard (matches within a directory only)",
+    "Source Code": "Código fuente",
+    "Staggered File Versioning": "Versiones del archivo escalonado",
+    "Start Browser": "Iniciar navegador",
+    "Stopped": "Parado",
+    "Support / Forum": "Soporte / Foro",
+    "Sync Protocol Listen Addresses": "Dirección de escucha del protocolo de sincronización",
+    "Synchronization": "Sincronización",
+    "Syncing": "Sincronización",
+    "Syncthing has been shut down.": "La sincronización esta apagada",
+    "Syncthing includes the following software or portions thereof:": "Syncthing incluye los siguientes softwares o partes de ellos:",
+    "Syncthing is restarting.": "Syncthing está reiniciando.",
+    "Syncthing is upgrading.": "Syncthing se está actualizando.",
+    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing parece estar apagado, o hay un problema con su conexión de Internet. Reintentando...",
+    "The aggregated statistics are publicly available at {%url%}.": "Las estadísticas acumuladas están públicamente disponibles en {{url}}.",
+    "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "La configuración ha sido guardada pero no activada.\nSyncthing debe reiniciarse para activar la nueva configuración.",
+    "The device ID cannot be blank.": "El ID del dispositivo no puede estar en blanco.",
+    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "La ID del dispositivo a introducir se puede encontrar en la opción de menú \"Edición > Mostrar ID\" en el otro dispositivo. Espacios y guiones son opcionales (ignorados).",
+    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "El informe de uso se envía encriptado diariamente. Se utiliza para hacer un seguimiento de plataformas comunes, tamaño de repositorios y versiones de la aplicación. Si el conjunto de datos cambia será notificado mediante este dialogo nuevamente.",
+    "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "La ID del dispositivo introducida no es válida. Debe ser una cadena de 52 o 56 caracteres consistente en letras y números, con espacios y guiones opcionales.",
+    "The folder ID cannot be blank.": "La ID del repositorio no puede estar en blanco.",
+    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "La ID del repositorio debe ser un identificador corto (64 caracteres o menos) consistente solamente en letras, números, punto (.), guion (-) y guion bajo (_).",
+    "The folder ID must be unique.": "La ID del repositorio debe ser única.",
+    "The folder path cannot be blank.": "La ruta del repositorio no puede estar vacía.",
+    "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Los siguientes intervalos se utilizan: para la primera hora una versión se mantiene cada 30 segundos, para el primer día de una versión se mantiene cada hora, durante los primeros 30 días de la versión se mantiene todos los días, hasta que la edad máxima de una versión se mantiene cada semana.",
+    "The maximum age must be a number and cannot be blank.": "La edad máxima debe ser un número y no puede estar en blanco.",
+    "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "El tiempo máximo para mantener una versión (en días, establece en 0 para mantener versiones para siempre).",
+    "The number of old versions to keep, per file.": "El numero de versiones anteriores a conservar, por archivo.",
+    "The number of versions must be a number and cannot be blank.": "El número de versiones debe ser un número y no puede estar vacío.",
+    "The rescan interval must be a non-negative number of seconds.": "El intervalo de reescaneo debe ser un número no negativo de segundos.",
+    "The rescan interval must be at least 5 seconds.": "El intervalo de reescaneo debe ser al menos de 5 segundos.",
+    "Unknown": "Desconocido",
+    "Unshared": "No compartido",
+    "Unused": "Unused",
+    "Up to Date": "Actualizado",
+    "Upgrade To {%version%}": "Actualizar a {{version}}",
+    "Upgrading": "Actualizando",
+    "Upload Rate": "Tasa de subida",
+    "Use Compression": "Usar compresión",
+    "Use HTTPS for GUI": "Usar HTTPS para la GUI",
+    "Version": "Versión",
+    "Versions Path": "Ruta de versiones",
+    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Las versiones se eliminan automáticamente si son mayores de la edad máxima o mayor que el número de archivos permitidos en un intervalo.",
+    "When adding a new device, keep in mind that this device must be added on the other side too.": "Al agregar un nuevo dispositivo, tenga en cuenta que este dispositivo se debe agregar en el otro lado también.",
+    "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Al agregar un nuevo repositorio, tenga en cuenta que la ID del repositorio se utiliza para conectar los repositorios entre dispositivos. Se distingue entre mayúsculas y minúsculas y debe ser exactamente igual en todos los dispositivos.",
+    "Yes": "Sí",
+    "You must keep at least one version.": "Debe mantener al menos una versión",
+    "full documentation": "documentación completa",
+    "items": "Artículos"
+}

gui/assets/lang/lang-fr.json

@@ -8,28 +8,32 @@
     "Allow Anonymous Usage Reporting?": "Autoriser le rapport anonyme de statistiques d'utilisation ?",
     "Anonymous Usage Reporting": "Rapport anonyme de statistiques d'utilisation",
     "Any devices configured on an introducer device will be added to this device as well.": "Tout appareil ajouté depuis un appareil initiateur sera aussi ajouté sur cet appareil.",
-    "Automatic upgrades": "Automatic upgrades",
+    "Automatic upgrades": "Mises à jour automatiques",
     "Bugs": "Bugs",
     "CPU Utilization": "Utilisation du CPU",
     "Close": "Fermer",
     "Comment, when used at the start of a line": "Commentaire, lorsque utilisé en début de ligne",
     "Compression is recommended in most setups.": "La compression est recommandée pour la plupart des configurations.",
     "Connection Error": "Erreur de connexion",
+    "Copied from elsewhere": "Copié d'ailleurs",
+    "Copied from original": "Copié de l'original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg et les contributeurs suivants :",
     "Delete": "Supprimer",
-    "Device ID": "ID de l'appareil",
+    "Device ID": "ID du périphérique",
     "Device Identification": "Identification de l'appareil",
-    "Device Name": "Nom de l'appareil",
+    "Device Name": "Nom du périphérique",
     "Disconnected": "Déconnecté",
     "Documentation": "Documentation",
     "Download Rate": "Débit de réception",
+    "Downloaded": "Téléchargé",
+    "Downloading": "En cours de téléchargement",
     "Edit": "Éditer",
-    "Edit Device": "Éditer l'appareil",
+    "Edit Device": "Éditer le périphérique",
     "Edit Folder": "Éditer le répertoire",
     "Editing": "Édition",
     "Enable UPnP": "Activer l'UPnP",
     "Enter comma separated \"ip:port\" addresses or \"dynamic\" to perform automatic discovery of the address.": "Entrer les adresses \"ip:port\" séparées par une virgule ou \"dynamic\" afin d'activer la recherche automatique de l'adresse.",
-    "Enter ignore patterns, one per line.": "Entrer les modèles à ignorer, un par ligne.",
+    "Enter ignore patterns, one per line.": "Entrer les masques de filtrage, un par ligne.",
     "Error": "Erreur",
     "File Versioning": "Versions de fichier",
     "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Les permissions de fichier sont ignorées lors de la recherche de changements. À utiliser sur les systèmes de fichiers de type FAT.",
@@ -38,6 +42,7 @@
     "Folder ID": "ID du répertoire",
     "Folder Master": "Répertoire maître",
     "Folder Path": "Chemin du répertoire",
+    "Folders": "Dossiers",
     "GUI Authentication Password": "Mot de passe d'authentification GUI",
     "GUI Authentication User": "Utilistateur autorisé GUI",
     "GUI Listen Addresses": "Adresse du GUI",
@@ -52,6 +57,7 @@
     "Introducer": "Initiateur",
     "Inversion of the given condition (i.e. do not exclude)": "Inverser la condition donnée (i.e. ne pas exclure)",
     "Keep Versions": "Conserver les versions",
+    "Last File Synced": "Dernier fichier synchronisé",
     "Last seen": "Dernière apparition",
     "Latest Release": "Dernière version",
     "Local Discovery": "Recherche locale",
@@ -73,25 +79,28 @@
     "Please wait": "Merci de patienter",
     "Preview": "Aperçu",
     "Preview Usage Report": "Aperçu du rapport de statistiques d'utilisation",
-    "Quick guide to supported patterns": "Guide rapide des modèles supportés",
+    "Quick guide to supported patterns": "Guide rapide des masques supportés",
     "RAM Utilization": "Utilisation de la RAM",
     "Rescan": "Rescanner",
     "Rescan Interval": "Intervalle de scan",
     "Restart": "Redémarrer",
     "Restart Needed": "Redémarrage nécessaire",
     "Restarting": "Redémarrage",
+    "Reused": "Réutilisé",
     "Save": "Sauver",
     "Scanning": "En cours de scan",
-    "Select the devices to share this folder with.": "Sélectionner les appareils avec qui partager ce répertoire.",
+    "Select the devices to share this folder with.": "Sélectionner les machines avec qui partager ce répertoire.",
+    "Select the folders to share with this device.": "Sélectionner les dossiers à partager avec cette machine.",
     "Settings": "Configuration",
-    "Share With Devices": "Partager avec les appareils",
+    "Share Folders With Device": "Partage du dossier avec les machines",
+    "Share With Devices": "Partager avec les machines",
     "Shared With": "Partagé avec",
-    "Short identifier for the folder. Must be the same on all cluster devices.": "Court identifiant du répertoire. Il doit être le même sur l'ensemble des appareils du groupe.",
+    "Short identifier for the folder. Must be the same on all cluster devices.": "Court identifiant du répertoire. Il doit être le même sur l'ensemble des machines du groupe.",
     "Show ID": "Montrer l'ID",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Affiché à la place de l'ID de l'appareil dans le statut du groupe. Sera proposé aux autres nœuds comme un nom par défaut optionnel.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Affiché à la place de l'ID de l'appareil dans le statut du groupe. Si laissé vide, il sera changé par le nom proposé par l'appareil.",
+    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Affiché à la place de l'ID de la machine dans le groupe. Sera proposé aux autres machines comme nom optionnel par défaut.",
+    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Affiché à la place de l'ID de la machine dans le groupe. Si laissé vide, il sera mis à jour par le nom proposé par la machine distante.",
     "Shutdown": "Éteindre",
-    "Simple File Versioning": "Versions simples de fichier",
+    "Simple File Versioning": "Suivi simple des versions de fichier",
     "Single level wildcard (matches within a directory only)": "Astérisque à un seul niveau (correspond uniquement à l’intérieur du répertoire)",
     "Source Code": "Code source",
     "Staggered File Versioning": "Versions échelonnées de fichier",
@@ -120,10 +129,12 @@
     "The maximum age must be a number and cannot be blank.": "L'ancienneté maximum doit être un nombre et ne peut être vide.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Le temps maximum de conservation d'une version (en jours, mettre à 0 pour conserver les versions pour toujours)",
     "The number of old versions to keep, per file.": "Le nombre d'anciennes versions à garder, par fichier.",
-    "The number of versions must be a number and cannot be blank.": "Le nombre de version doit être un nombre et ne peut pas être vide.",
-    "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
+    "The number of versions must be a number and cannot be blank.": "Le nombre de versions doit être numérique, et ne peut pas être vide.",
+    "The rescan interval must be a non-negative number of seconds.": "L'intervalle de scan ne doit pas être un nombre négatif de secondes.",
     "The rescan interval must be at least 5 seconds.": "L'intervalle de scan doit être d'au minimum 5 secondes.",
     "Unknown": "Inconnu",
+    "Unshared": "Non partagé",
+    "Unused": "Non utilisé",
     "Up to Date": "Synchronisation à jour",
     "Upgrade To {%version%}": "Mettre à jour vers {{version}}",
     "Upgrading": "Mise à jour de Syncthing",
@@ -132,7 +143,7 @@
     "Use HTTPS for GUI": "Utiliser l'HTTPS pour le GUI",
     "Version": "Version",
     "Versions Path": "Emplacement des versions",
-    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Les versions sont supprimées automatiquement si celles-ci sont plus anciennes que l'ancienneté maximum ou que leur nombre est supérieur au nombre autorisé dans une intervale.",
+    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Les versions seront supprimées automatiquement, si elles dépassent la durée maximum de conservation, ou si leur nombre est supérieur à la valeur autorisée dans l'intervalle.",
     "When adding a new device, keep in mind that this device must be added on the other side too.": "Lorsqu'un appareil est ajouté, gardez à l'esprit que cet appareil doit aussi être ajouté de l'autre coté.",
     "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Lorsqu'un nouveau répertoire est ajouté, gardez à l'esprit que son ID est utilisé pour lier les répertoires à travers les appareils. Les ID sont sensibles à la casse et doivent être identiques à travers tous les nœuds.",
     "Yes": "Oui",

gui/assets/lang/lang-hu.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Megjegyzés, a sor elején használva",
     "Compression is recommended in most setups.": "A tömörítés a a legtöbb esetben ajánlott",
     "Connection Error": "Kapcsolódási hiba",
+    "Copied from elsewhere": "Másolva máshonnan",
+    "Copied from original": "Másolva az eredetiről",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg és az alábbi Közreműködők",
     "Delete": "Törlés",
     "Device ID": "Eszköz azonosító",
@@ -23,6 +25,8 @@
     "Disconnected": "Kapcsolat bontva",
     "Documentation": "Dokumentáció",
     "Download Rate": "Letöltési sebesség",
+    "Downloaded": "Letöltve",
+    "Downloading": "Letöltés",
     "Edit": "Szerkesztés",
     "Edit Device": "Eszköz szerkesztése",
     "Edit Folder": "Mappa szerkesztése",
@@ -38,6 +42,7 @@
     "Folder ID": "Mappa azonosító",
     "Folder Master": "Központi mappa",
     "Folder Path": "Mappa elérési útja",
+    "Folders": "Mappák",
     "GUI Authentication Password": "Grafikus felület jelszava",
     "GUI Authentication User": "Grafikus felület felhasználó neve ",
     "GUI Listen Addresses": "Grafikus felület címe",
@@ -52,6 +57,7 @@
     "Introducer": "Bevezető",
     "Inversion of the given condition (i.e. do not exclude)": "A feltétel ellentéte (pl. ki nem hagyás)",
     "Keep Versions": "Megtartott verziók",
+    "Last File Synced": "Utolsó szinkronizált fájl",
     "Last seen": "Utoljára látva",
     "Latest Release": "Utolsó kiadás",
     "Local Discovery": "Helyi felfedezés",
@@ -80,10 +86,13 @@
     "Restart": "Újraindítás",
     "Restart Needed": "Újraindítás szükséges",
     "Restarting": "Újraindulás",
+    "Reused": "Újrafelhasználva",
     "Save": "Mentés",
     "Scanning": "Átnézés",
     "Select the devices to share this folder with.": "Válaszd ki az eszközöket amelyekkel meg szeretnéd osztani a mappát",
+    "Select the folders to share with this device.": "Válaszd ki a mappákat amiket meg szeretnél osztani ezzel az eszközzel",
     "Settings": "Beállítások",
+    "Share Folders With Device": "Mappák megosztása az eszközzel",
     "Share With Devices": "Megosztás más eszközzel",
     "Shared With": "Megosztva ezekkel:",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Rövid azonosító. Minden megosztott eszközön azonosnak kell lennie.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "Az átnézési intervallum nullánál nagyobb másodperc érték kell legyen",
     "The rescan interval must be at least 5 seconds.": "Az átnézési intervallumnak legalább 5 másodpercnek kell lennie.",
     "Unknown": "Ismeretlen",
+    "Unshared": "Nincs megosztva",
+    "Unused": "Nincs használatban",
     "Up to Date": "Friss",
     "Upgrade To {%version%}": "Frissítés a {{version}} verzióra",
     "Upgrading": "Frissítés",

gui/assets/lang/lang-it.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Per commentare, va inserito all'inizio di una riga",
     "Compression is recommended in most setups.": "La compressione è raccomandata nella maggior parte delle configurazioni.",
     "Connection Error": "Errore di Connessione",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg e i seguenti Collaboratori:",
     "Delete": "Elimina",
     "Device ID": "ID Dispositivo",
@@ -23,6 +25,8 @@
     "Disconnected": "Disconnesso",
     "Documentation": "Documentazione",
     "Download Rate": "Velocità Download",
+    "Downloaded": "Downloaded",
+    "Downloading": "Downloading",
     "Edit": "Modifica",
     "Edit Device": "Modifica Dispositivo",
     "Edit Folder": "Modifica Cartella",
@@ -38,6 +42,7 @@
     "Folder ID": "ID Cartella",
     "Folder Master": "Cartella Principale",
     "Folder Path": "Percorso Cartella",
+    "Folders": "Folders",
     "GUI Authentication Password": "Password di Autenticazione dell'Utente",
     "GUI Authentication User": "Utente dell'Interfaccia Grafica",
     "GUI Listen Addresses": "Indirizzi dell'Interfaccia Grafica",
@@ -52,6 +57,7 @@
     "Introducer": "Introduttore",
     "Inversion of the given condition (i.e. do not exclude)": "Inversione della condizione indicata (ad es. non escludere)",
     "Keep Versions": "Versioni Mantenute",
+    "Last File Synced": "Last File Synced",
     "Last seen": "Ultima connessione",
     "Latest Release": "Ultima Versione",
     "Local Discovery": "Individuazione Locale",
@@ -80,10 +86,13 @@
     "Restart": "Riavvia",
     "Restart Needed": "Riavvio Necessario",
     "Restarting": "Riavvio",
+    "Reused": "Reused",
     "Save": "Salva",
     "Scanning": "Scansione in corso",
     "Select the devices to share this folder with.": "Seleziona i dispositivi con i quali condividere questa cartella.",
+    "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Impostazioni",
+    "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Condividi con i Dispositivi",
     "Shared With": "Condiviso Con",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Breve identificatore della cartella. Deve essere lo stesso su tutti i dispositivi del cluster.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
     "The rescan interval must be at least 5 seconds.": "L'intervallo di scansione non può essere inferiore a 5 secondi.",
     "Unknown": "Sconosciuto",
+    "Unshared": "Unshared",
+    "Unused": "Unused",
     "Up to Date": "Sincronizzato",
     "Upgrade To {%version%}": "Aggiorna alla {{version}}",
     "Upgrading": "Aggiornamento",

gui/assets/lang/lang-lt.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Komentaras naudojamas naujoje eilutėje",
     "Compression is recommended in most setups.": "Daugumoje atvejų spaudimas rekomenduojamas.",
     "Connection Error": "Susijungimo klaida",
+    "Copied from elsewhere": "Nukopijuota iš betkur",
+    "Copied from original": "Nukopijuota iš originalo",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Visos teisės saugomos © 2014 Jakob Borg ir šių bendraautorių:",
     "Delete": "Trinti",
     "Device ID": "Įrenginio ID",
@@ -23,6 +25,8 @@
     "Disconnected": "Atsijungęs",
     "Documentation": "Aprašymas",
     "Download Rate": "Parsisiuntimo greitis",
+    "Downloaded": "Parsisiųstas",
+    "Downloading": "Siunčiama",
     "Edit": "Redaguoti",
     "Edit Device": "Keisti įrenginį",
     "Edit Folder": "Keisti aplanką",
@@ -38,6 +42,7 @@
     "Folder ID": "Aplanko ID",
     "Folder Master": "Aplanko vadovas",
     "Folder Path": "Kelias iki apkanko",
+    "Folders": "Aplankai",
     "GUI Authentication Password": "Valdymo skydelio slaptažodis",
     "GUI Authentication User": "Valdymo skydelio vartotojo vardas",
     "GUI Listen Addresses": "Valdymo skydelio adresas",
@@ -52,6 +57,7 @@
     "Introducer": "Supažindintojas",
     "Inversion of the given condition (i.e. do not exclude)": "Apversti sąlygas (pvz.: nenustoti naudoti)",
     "Keep Versions": "Saugojamų versijų kiekis",
+    "Last File Synced": "Paskutinis failas sinchronizuotas",
     "Last seen": "Paskutinį kartą matytas",
     "Latest Release": "Paskutinė versija",
     "Local Discovery": "Vietinis matomumas",
@@ -80,10 +86,13 @@
     "Restart": "Perleisti",
     "Restart Needed": "Reikalingas perleidimas",
     "Restarting": "Persileidžia",
+    "Reused": "Pakartotinas",
     "Save": "Išsaugoti",
     "Scanning": "Skenuojama",
     "Select the devices to share this folder with.": "Pasirinkite įrenginius, su kuriais dalinsitės šį aplanką.",
+    "Select the folders to share with this device.": "Pasirinkite aplankus kuriais norite dalintis su šiuo įrenginiu.",
     "Settings": "Nustatymai",
+    "Share Folders With Device": "Dalintis aplankalais su šiuo įrenginiu",
     "Share With Devices": "Dalintis su įrenginiais",
     "Shared With": "Dalinamasi su",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Trumpas aplanko identifikatorius. Privalo būti toks pat visuose įrenginiuose.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "Nuskaitymo dažnis negali būti neigiamas skaičius.",
     "The rescan interval must be at least 5 seconds.": "Nuskaityti galima nedažniau nei kas 5 sekundes.",
     "Unknown": "Nežinoma",
+    "Unshared": "Nesidalinama",
+    "Unused": "Nenaudojamas",
     "Up to Date": "Atnaujinta",
     "Upgrade To {%version%}": "Atnaujinti į  {{version}}",
     "Upgrading": "Atnaujinama",

gui/assets/lang/lang-nb.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Kommentar, når det blir brukt i starten av en linje.",
     "Compression is recommended in most setups.": "Komprimering er anbefalt i de fleste tilfeller.",
     "Connection Error": "Tilkoblingsfeil",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg og følgende Bidragsytere:",
     "Delete": "Slett",
     "Device ID": "Enhet ID",
@@ -23,6 +25,8 @@
     "Disconnected": "Frakoblet",
     "Documentation": "Dokumentasjon",
     "Download Rate": "Nedlastingsrate",
+    "Downloaded": "Downloaded",
+    "Downloading": "Downloading",
     "Edit": "Rediger",
     "Edit Device": "Rediger Enhet",
     "Edit Folder": "Rediger Mappe",
@@ -38,6 +42,7 @@
     "Folder ID": "Mappe ID",
     "Folder Master": "Styrende Mappe",
     "Folder Path": "Mappeplassering",
+    "Folders": "Folders",
     "GUI Authentication Password": "GUI Passord",
     "GUI Authentication User": "GUI Bruker",
     "GUI Listen Addresses": "GUI Lytteadresse",
@@ -52,6 +57,7 @@
     "Introducer": "Introduktør",
     "Inversion of the given condition (i.e. do not exclude)": "Invers av den gitte tilstanden (t.d. ikke ekskluder)",
     "Keep Versions": "Behold Versjoner",
+    "Last File Synced": "Last File Synced",
     "Last seen": "Sist sett",
     "Latest Release": "Nyeste Versjon",
     "Local Discovery": "Lokal Søking",
@@ -80,10 +86,13 @@
     "Restart": "Omstart",
     "Restart Needed": "Omstart Kreves",
     "Restarting": "Starter På Ny",
+    "Reused": "Reused",
     "Save": "Lagre",
     "Scanning": "Skanner",
     "Select the devices to share this folder with.": "Velg enhetene du vil dele denne mappen med.",
+    "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Innstillinger",
+    "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Del Med Enheter",
     "Shared With": "Del Med",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kort kjennemerke på mappen. Må være det samme på alle enheter i en gruppe.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "Antall sekund i skanneintervallet kan ikke være negativt.",
     "The rescan interval must be at least 5 seconds.": "Skanneintervallet må være minst 5 sekund.",
     "Unknown": "Ukjent",
+    "Unshared": "Unshared",
+    "Unused": "Unused",
     "Up to Date": "Oppdatert",
     "Upgrade To {%version%}": "Oppgrader Til {{version}}",
     "Upgrading": "Oppgraderer",

gui/assets/lang/lang-nl.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Commentaar, indien gebruikt aan het begin van de lijn",
     "Compression is recommended in most setups.": "Gegevenscompressie is aan te raden in de meeste situaties.",
     "Connection Error": "Verbindingsfout",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg en de onderstaande bijdragers:",
     "Delete": "Verwijderen",
     "Device ID": "Toestel ID",
@@ -23,6 +25,8 @@
     "Disconnected": "Niet Verbonden",
     "Documentation": "Documentatie",
     "Download Rate": "Downloadsnelheid",
+    "Downloaded": "Downloaded",
+    "Downloading": "Downloading",
     "Edit": "Bewerk",
     "Edit Device": "Toestel aanpassen",
     "Edit Folder": "Folder aanpassen",
@@ -38,6 +42,7 @@
     "Folder ID": "Folder ID",
     "Folder Master": "Hoofdfolder",
     "Folder Path": "Locatie folder",
+    "Folders": "Folders",
     "GUI Authentication Password": "GUI Authentificatie Wachtwoord",
     "GUI Authentication User": "GUI Authentificatie Gebruikersnaam",
     "GUI Listen Addresses": "GUI Inkomend adres",
@@ -52,6 +57,7 @@
     "Introducer": "Introductietoestel",
     "Inversion of the given condition (i.e. do not exclude)": "Inversie van de gegeven voorwaarde (bv. niet uitsluiten)",
     "Keep Versions": "Versies behouden",
+    "Last File Synced": "Last File Synced",
     "Last seen": "Laatst gezien op",
     "Latest Release": "Laatste uitgave",
     "Local Discovery": "Lokaal zoeken",
@@ -80,10 +86,13 @@
     "Restart": "Herstart",
     "Restart Needed": "Herstart nodig",
     "Restarting": "Herstarten",
+    "Reused": "Reused",
     "Save": "Bewaar",
     "Scanning": "Aan het zoeken",
     "Select the devices to share this folder with.": "Selecteer de toestellen om deze folder mee te delen.",
+    "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Instellingen",
+    "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Delen met toestellen",
     "Shared With": "Gedeeld met",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Korte aanduiding voor deze folder. Moet dezelfde zijn op alle toestellen in de cluster.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "De scanfrequentie moet een positief getal in seconden zijn.",
     "The rescan interval must be at least 5 seconds.": "De scanfrequentie moet minimaal 5 seconden zijn.",
     "Unknown": "Onbekend",
+    "Unshared": "Unshared",
+    "Unused": "Unused",
     "Up to Date": "Gesynchroniseerd",
     "Upgrade To {%version%}": "Upgrade naar {{version}}",
     "Upgrading": "Bezig met upgrade",

gui/assets/lang/lang-nn.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Kommentar, når det vert brukt i starten av ei linje.",
     "Compression is recommended in most setups.": "Komprimering er tilrådd i dei fleste høve.",
     "Connection Error": "Tilkoplingsfeil",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg og følgjande Bidragsytarar:",
     "Delete": "Slett",
     "Device ID": "Eining ID",
@@ -23,6 +25,8 @@
     "Disconnected": "Fråkopla",
     "Documentation": "Dokumentasjon",
     "Download Rate": "Nedlastingsrate",
+    "Downloaded": "Downloaded",
+    "Downloading": "Downloading",
     "Edit": "Rediger",
     "Edit Device": "Rediger Eining",
     "Edit Folder": "Rediger Mappe",
@@ -38,6 +42,7 @@
     "Folder ID": "Mappe ID",
     "Folder Master": "Styrande Mappe",
     "Folder Path": "Mappeplassering",
+    "Folders": "Folders",
     "GUI Authentication Password": "GUI Passord",
     "GUI Authentication User": "GUI Brukar",
     "GUI Listen Addresses": "GUI Lytteadresse",
@@ -52,6 +57,7 @@
     "Introducer": "Introduktør",
     "Inversion of the given condition (i.e. do not exclude)": "Invers av den gitte tilstanden (t.d. ikkje ekskluder)",
     "Keep Versions": "Behald Versjonar",
+    "Last File Synced": "Last File Synced",
     "Last seen": "Sist sett",
     "Latest Release": "Nyaste Versjon",
     "Local Discovery": "Lokal Søking",
@@ -80,10 +86,13 @@
     "Restart": "Omstart",
     "Restart Needed": "Omstart Trengs",
     "Restarting": "Startar På Ny",
+    "Reused": "Reused",
     "Save": "Lagre",
     "Scanning": "Skannar",
     "Select the devices to share this folder with.": "Vel einingane du vil dela denne mappa med.",
+    "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Innstillingar",
+    "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Del Med Einingar",
     "Shared With": "Delt Med",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kort kjennemerke på mappa. Må vera det same på alle einingar i ei gruppe.",
@@ -117,13 +126,15 @@
     "The folder ID must be unique.": "Mappe ID må vera unik.",
     "The folder path cannot be blank.": "Mappeplasseringa kan ikkje vera tom.",
     "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Fylgjande intervall vert brukt: den fyrste timen vert ein versjon lagra kvart 30. sekund, den fyrste dagen vert ein versjon lagra kvar time, dei fyrste 30 dagane vert ein versjon lagra kvar dag, og inntil høgaste levetid vert ein versjon lagra kvar uke.",
-    "The maximum age must be a number and cannot be blank.": "Maksimal levetid må vera eit tal og kan ikkje vera blankt.",
+    "The maximum age must be a number and cannot be blank.": "Maksimal levetid må vera eit tal og kan ikkje vera tomt.",
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Maksimalt tidsrom å behalda ein versjon (i dagar, set til 0 for å behalda versjonar for ubegrensa tid.)",
     "The number of old versions to keep, per file.": "Tal på gamle versjonar ein skal behalda, per fil.",
     "The number of versions must be a number and cannot be blank.": "Tal på versjonar må vera eit tal og kan ikkje vera tomt.",
     "The rescan interval must be a non-negative number of seconds.": "Talet på sekund i skanneintervallet kan ikkje vera negativt.",
     "The rescan interval must be at least 5 seconds.": "Skanneintervallet må vera minst 5 sekund.",
     "Unknown": "Ukjent",
+    "Unshared": "Unshared",
+    "Unused": "Unused",
     "Up to Date": "Oppdatert",
     "Upgrade To {%version%}": "Oppgrader Til {{version}}",
     "Upgrading": "Oppgraderer",

gui/assets/lang/lang-pl.json

@@ -8,13 +8,15 @@
     "Allow Anonymous Usage Reporting?": "Zezwalaj na anonimowe statystyki użycia",
     "Anonymous Usage Reporting": "Anonimowe statystyki użycia",
     "Any devices configured on an introducer device will be added to this device as well.": "Wszystkie urządzenia skonfigurowane na urządzeniu wprowadzającym zostaną dodane także do tego urządzenia.",
-    "Automatic upgrades": "Automatic upgrades",
+    "Automatic upgrades": "Automatyczne aktualizacje",
     "Bugs": "Błędy",
     "CPU Utilization": "Użycie CPU",
     "Close": "Zamknij",
     "Comment, when used at the start of a line": "Komentarz, jeżeli użyty na początku linii",
     "Compression is recommended in most setups.": "Kompresja jest zalecana w większości przypadków",
     "Connection Error": "Błąd połączenia",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg i następujący współautorzy:",
     "Delete": "Usuń",
     "Device ID": "ID urządzenia",
@@ -23,6 +25,8 @@
     "Disconnected": "Rozłączony",
     "Documentation": "Dokumentacja",
     "Download Rate": "Prędkość pobierania",
+    "Downloaded": "Downloaded",
+    "Downloading": "Downloading",
     "Edit": "Edytuj",
     "Edit Device": "Edytuj urządzenie",
     "Edit Folder": "Edytuj folder",
@@ -38,6 +42,7 @@
     "Folder ID": "ID folderu",
     "Folder Master": "Główny folder",
     "Folder Path": "Ścieżka folderu",
+    "Folders": "Folders",
     "GUI Authentication Password": "Hasło",
     "GUI Authentication User": "Użytkownik",
     "GUI Listen Addresses": "Adres nasłuchiwania",
@@ -52,6 +57,7 @@
     "Introducer": "Wprowadzający",
     "Inversion of the given condition (i.e. do not exclude)": "Odwrócenie podanego wzorca (np. nie wykluczaj)",
     "Keep Versions": "Zachowuj wersje",
+    "Last File Synced": "Last File Synced",
     "Last seen": "Ostatnio widziany",
     "Latest Release": "Najnowsza wersja",
     "Local Discovery": "Lokalne odnajdywanie",
@@ -80,10 +86,13 @@
     "Restart": "Uruchom ponownie",
     "Restart Needed": "Wymagane ponowne uruchomienie",
     "Restarting": "Uruchamianie ponowne",
+    "Reused": "Reused",
     "Save": "Zapisz",
     "Scanning": "Skanowanie",
     "Select the devices to share this folder with.": "Wybierz urządzenie, któremu udostępnić folder.",
+    "Select the folders to share with this device.": "Select the folders to share with this device.",
     "Settings": "Ustawienia",
+    "Share Folders With Device": "Share Folders With Device",
     "Share With Devices": "Udostępnij dla urządzenia",
     "Shared With": "Współdzielony z",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Krótki identyfikator folderu. Musi być taki sam na wszystkich urządzeniach.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
     "The rescan interval must be at least 5 seconds.": "Interwał skanowania musi wynosić co najmniej 5 sekund.",
     "Unknown": "Nieznany",
+    "Unshared": "Unshared",
+    "Unused": "Unused",
     "Up to Date": "Aktualny",
     "Upgrade To {%version%}": "Aktualizuj do {{version}}",
     "Upgrading": "Aktualizowanie",

gui/assets/lang/lang-pt-PT.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Comentário, quando usado no início de uma linha",
     "Compression is recommended in most setups.": "A compressão é recomendada na maior parte dos casos.",
     "Connection Error": "Erro de ligação",
+    "Copied from elsewhere": "Copiado doutro sítio",
+    "Copied from original": "Copiado do original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Direitos reservados © 2014 Jakob Borg e os seguintes contribuidores:",
     "Delete": "Eliminar",
     "Device ID": "ID do dispositivo",
@@ -23,6 +25,8 @@
     "Disconnected": "Desconectado",
     "Documentation": "Documentação",
     "Download Rate": "Velocidade de recepção",
+    "Downloaded": "Recebido",
+    "Downloading": "Recebendo",
     "Edit": "Editar",
     "Edit Device": "Editar dispositivo",
     "Edit Folder": "Editar pasta",
@@ -38,6 +42,7 @@
     "Folder ID": "ID da pasta",
     "Folder Master": "Pasta mestre",
     "Folder Path": "Caminho da pasta",
+    "Folders": "Pastas",
     "GUI Authentication Password": "Senha da autenticação na interface gráfica",
     "GUI Authentication User": "Utilizador da autenticação na interface gráfica",
     "GUI Listen Addresses": "Endereço de escuta da interface gráfica",
@@ -52,6 +57,7 @@
     "Introducer": "Apresentador",
     "Inversion of the given condition (i.e. do not exclude)": "Inversão de uma dada condição (ou seja, não excluir)",
     "Keep Versions": "Manter versões",
+    "Last File Synced": "Último ficheiro sincronizado",
     "Last seen": "Última vez que foi verificado",
     "Latest Release": "Última versão",
     "Local Discovery": "Busca local",
@@ -80,10 +86,13 @@
     "Restart": "Reiniciar",
     "Restart Needed": "É preciso reiniciar",
     "Restarting": "Reiniciando",
+    "Reused": "Reutilizado",
     "Save": "Gravar",
     "Scanning": "Verificando",
     "Select the devices to share this folder with.": "Seleccione os dispositivos com os quais vai partilhar esta pasta.",
+    "Select the folders to share with this device.": "Seleccione as pastas a partilhar com este dispositivo.",
     "Settings": "Configurações",
+    "Share Folders With Device": "Partilhar pastas com dispositivo",
     "Share With Devices": "Partilhar com os dispositivos",
     "Shared With": "Partilhado com",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Identificador curto para a pasta. Tem que ser igual em todos os dispositivos do grupo.",
@@ -124,7 +133,9 @@
     "The rescan interval must be a non-negative number of seconds.": "O intervalo entre verificações tem que ser um valor não negativo de segundos.",
     "The rescan interval must be at least 5 seconds.": "O intervalo entre verificações tem que ser pelo menos de 5 segundos.",
     "Unknown": "Desconhecido",
-    "Up to Date": "Actualizado",
+    "Unshared": "Não partilhada",
+    "Unused": "Não utilizada",
+    "Up to Date": "Actualizada",
     "Upgrade To {%version%}": "Actualizar para {{version}}",
     "Upgrading": "Actualizando",
     "Upload Rate": "Velocidade de envio",

gui/assets/lang/lang-ru.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "Комментарий, если используется в начале строки",
     "Compression is recommended in most setups.": "Сжатие рекомендуется в большинстве случаев.",
     "Connection Error": "Ошибка подключения",
+    "Copied from elsewhere": "Скопировано из другого места",
+    "Copied from original": "Скопировано с оригинала",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Все права защищены © 2014 Jakob Borg и следующие участники:",
     "Delete": "Удалить",
     "Device ID": "ID устройства",
@@ -23,6 +25,8 @@
     "Disconnected": "Нет соединения",
     "Documentation": "Документация",
     "Download Rate": "Скорость загрузки",
+    "Downloaded": "Загружено",
+    "Downloading": "Загрузка",
     "Edit": "Изменить",
     "Edit Device": "Изменить устройство",
     "Edit Folder": "Изменение папки",
@@ -38,6 +42,7 @@
     "Folder ID": "ID папки",
     "Folder Master": "Папка-оригинал",
     "Folder Path": "Путь к папке",
+    "Folders": "Папки",
     "GUI Authentication Password": "Пароль для доступа к панели управления",
     "GUI Authentication User": "Имя пользователя для доступа к панели управления",
     "GUI Listen Addresses": "Адрес панели управления",
@@ -52,6 +57,7 @@
     "Introducer": "Рекомендатель",
     "Inversion of the given condition (i.e. do not exclude)": "Инвертировать текущее условие (например, исключить)",
     "Keep Versions": "Количество хранимых версий",
+    "Last File Synced": "Последний синхронизированный файл",
     "Last seen": "Был доступен",
     "Latest Release": "Последняя версия",
     "Local Discovery": "Локальное обнаружение",
@@ -80,10 +86,13 @@
     "Restart": "Перезапуск",
     "Restart Needed": "Требуется перезапуск",
     "Restarting": "Перезапуск",
+    "Reused": "Повторно использовано",
     "Save": "Сохранить",
     "Scanning": "Сканирование",
     "Select the devices to share this folder with.": "Выберите устройства, для которых будет доступна эта папка.",
+    "Select the folders to share with this device.": "Выберите папку для предоставления доступа данному устройству",
     "Settings": "Настройки",
+    "Share Folders With Device": "Предоставить доступ устройству к папкам",
     "Share With Devices": "Предоставить доступ устройствам",
     "Shared With": "Доступ предоставлен",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Короткий идентификатор папки. Должен быть одинаковым на всех устройствах кластера.",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "Интервал пересканирования должен быть неотрицательным количеством секунд.",
     "The rescan interval must be at least 5 seconds.": "Интервал пересканирования должен быть хотя бы 5 секунд.",
     "Unknown": "Неизвестно",
+    "Unshared": "Необщедоступно",
+    "Unused": "Не используется",
     "Up to Date": "Обновлено",
     "Upgrade To {%version%}": "Обновить до {{version}}",
     "Upgrading": "Обновление",

gui/assets/lang/lang-sv.json

@@ -8,13 +8,15 @@
     "Allow Anonymous Usage Reporting?": "Tillåt anonym användarstatistik?",
     "Anonymous Usage Reporting": "Anonym användarstatistik",
     "Any devices configured on an introducer device will be added to this device as well.": "Any devices configured on an introducer device will be added to this device as well.",
-    "Automatic upgrades": "Automatic upgrades",
+    "Automatic upgrades": "Automatisk uppgradering",
     "Bugs": "Buggar",
     "CPU Utilization": "CPU-användning",
     "Close": "Stäng",
     "Comment, when used at the start of a line": "Kommentar, vid början av en rad.",
     "Compression is recommended in most setups.": "Komprimering är rekommenderat för de flesta.",
     "Connection Error": "Anslutningsproblem",
+    "Copied from elsewhere": "Kopierat utifrån",
+    "Copied from original": "Oförändrat",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg och de följande medarbetarna:",
     "Delete": "Radera",
     "Device ID": "Enhets-ID",
@@ -23,6 +25,8 @@
     "Disconnected": "Ej ansluten",
     "Documentation": "Dokumentation",
     "Download Rate": "Nedladdningshastighet",
+    "Downloaded": "Nerladdat",
+    "Downloading": "Laddar ner",
     "Edit": "Redigera",
     "Edit Device": "Redigera enhet",
     "Edit Folder": "Redigera katalog",
@@ -38,6 +42,7 @@
     "Folder ID": "Katalog-ID",
     "Folder Master": "Huvudlagring",
     "Folder Path": "Sökväg",
+    "Folders": "Kataloger",
     "GUI Authentication Password": "GUI-lösenord",
     "GUI Authentication User": "GUI-användare",
     "GUI Listen Addresses": "GUI-adress",
@@ -52,6 +57,7 @@
     "Introducer": "Introducer",
     "Inversion of the given condition (i.e. do not exclude)": "Vänder på villkoret, d.v.s. exkluderar inte.",
     "Keep Versions": "Behåll versioner",
+    "Last File Synced": "Senast uppdaterad fil",
     "Last seen": "Senast online",
     "Latest Release": "Senaste version",
     "Local Discovery": "Lokal uppslagning",
@@ -80,10 +86,13 @@
     "Restart": "Starta om",
     "Restart Needed": "Omstart behövs",
     "Restarting": "Startar om",
+    "Reused": "Återanvänt",
     "Save": "Spara",
     "Scanning": "Uppdaterar",
     "Select the devices to share this folder with.": "Ange enheterna att dela den här katalogen med.",
+    "Select the folders to share with this device.": "Välja kataloger att dela med den här enheten",
     "Settings": "Inställningar",
+    "Share Folders With Device": "Dela kataloger med enhet",
     "Share With Devices": "Dela med enheter",
     "Shared With": "Delat med",
     "Short identifier for the folder. Must be the same on all cluster devices.": "Kort identifieringssträng för katalogen. Måste vara samma på alla enheter i klustern.",
@@ -121,9 +130,11 @@
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Den längsta tid att behålla en version (i dagar, sätt till 0 för att behålla versioner för evigt).",
     "The number of old versions to keep, per file.": "Antalet gamla versioner som ska behållas, per fil.",
     "The number of versions must be a number and cannot be blank.": "Antalet versioner måste vara ett nummer och kan inte lämnas blankt.",
-    "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
+    "The rescan interval must be a non-negative number of seconds.": "Förnyelseintervallet måste vara ett positivt antal sekunder",
     "The rescan interval must be at least 5 seconds.": "Uppdateringsintervallet måste vara minst 5 sekunder.",
     "Unknown": "Okänt",
+    "Unshared": "Odelat",
+    "Unused": "Oanvänd",
     "Up to Date": "Helt uppdaterad",
     "Upgrade To {%version%}": "Uppgradera till {{version}}",
     "Upgrading": "Uppgraderar",

gui/assets/lang/lang-zh-CN.json

@@ -15,6 +15,8 @@
     "Comment, when used at the start of a line": "注释，在行首使用",
     "Compression is recommended in most setups.": "在大多数场合，建议开启压缩",
     "Connection Error": "连接出错",
+    "Copied from elsewhere": "从其他地点复制",
+    "Copied from original": "从源复制",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "版权© 2014 Jakob Borg 及以下贡献者:",
     "Delete": "删除",
     "Device ID": "设备ID",
@@ -23,6 +25,8 @@
     "Disconnected": "连接已断开",
     "Documentation": "文档",
     "Download Rate": "下载速度",
+    "Downloaded": "已下载",
+    "Downloading": "下载中",
     "Edit": "选项",
     "Edit Device": "修改设备选项",
     "Edit Folder": "修改文件夹选项",
@@ -38,6 +42,7 @@
     "Folder ID": "文件夹ID",
     "Folder Master": "母文件夹",
     "Folder Path": "文件夹路径",
+    "Folders": "文件夹",
     "GUI Authentication Password": "登陆web管理页面的密码",
     "GUI Authentication User": "登陆web管理页面的用户名",
     "GUI Listen Addresses": "web管理页面监听地址",
@@ -52,6 +57,7 @@
     "Introducer": "介绍人节点",
     "Inversion of the given condition (i.e. do not exclude)": "对本条件取反（例如：不要排除某项）",
     "Keep Versions": "保留历史版本数量",
+    "Last File Synced": "最近同步的文件",
     "Last seen": "最后可见",
     "Latest Release": "最新版本",
     "Local Discovery": "在局域网上寻找节点",
@@ -80,10 +86,13 @@
     "Restart": "重启syncthing",
     "Restart Needed": "需要重启Syncthing",
     "Restarting": "重启中",
+    "Reused": "复用",
     "Save": "保存",
     "Scanning": "扫描中",
     "Select the devices to share this folder with.": "选择将本文件夹共享给哪些设备",
+    "Select the folders to share with this device.": "选择与该设备共享的文件夹。",
     "Settings": "设置",
+    "Share Folders With Device": "将指定文件夹共享给设备",
     "Share With Devices": "共享给",
     "Shared With": "共享给",
     "Short identifier for the folder. Must be the same on all cluster devices.": "文件夹的别名。必须在所有设备上保持一致。",
@@ -124,6 +133,8 @@
     "The rescan interval must be a non-negative number of seconds.": "扫描间隔单位为秒，且不能为负数。",
     "The rescan interval must be at least 5 seconds.": "扫描间隔必须至少为5秒。",
     "Unknown": "未知",
+    "Unshared": "未共享",
+    "Unused": "已共享",
     "Up to Date": "同步完成",
     "Upgrade To {%version%}": "升级至版本{{version}}",
     "Upgrading": "升级中",

gui/assets/lang/lang-zh-TW.json

@@ -8,13 +8,15 @@
     "Allow Anonymous Usage Reporting?": "允許匿名的使用資訊回報？",
     "Anonymous Usage Reporting": "匿名的使用資訊回報",
     "Any devices configured on an introducer device will be added to this device as well.": "任何在引入者裝置所設置的裝置將會一併新增至此裝置",
-    "Automatic upgrades": "Automatic upgrades",
+    "Automatic upgrades": "自動升級",
     "Bugs": "程式錯誤",
     "CPU Utilization": "CPU 使用率",
     "Close": "關閉",
     "Comment, when used at the start of a line": "註解，當輸入在一行的開頭時",
     "Compression is recommended in most setups.": "建議在大多數的設置中使用壓縮。",
     "Connection Error": "連線錯誤",
+    "Copied from elsewhere": "Copied from elsewhere",
+    "Copied from original": "Copied from original",
     "Copyright © 2014 Jakob Borg and the following Contributors:": "版權所有 © 2014 Jakob Borg 及以下貢獻者：",
     "Delete": "刪除",
     "Device ID": "裝置識別碼",
@@ -23,6 +25,8 @@
     "Disconnected": "斷線",
     "Documentation": "說明文件",
     "Download Rate": "下載速率",
+    "Downloaded": "已下載",
+    "Downloading": "正在下載",
     "Edit": "編輯",
     "Edit Device": "編輯裝置",
     "Edit Folder": "編輯資料夾",
@@ -38,6 +42,7 @@
     "Folder ID": "資料夾識別碼",
     "Folder Master": "主資料夾",
     "Folder Path": "資料夾路徑",
+    "Folders": "資料夾",
     "GUI Authentication Password": "GUI 認證密碼",
     "GUI Authentication User": "GUI 認證使用者名稱",
     "GUI Listen Addresses": "GUI 監聽位址",
@@ -52,6 +57,7 @@
     "Introducer": "引入者",
     "Inversion of the given condition (i.e. do not exclude)": "反轉給定條件 (即：不要排除)",
     "Keep Versions": "保留歷史版本數",
+    "Last File Synced": "最後同步檔案",
     "Last seen": "最後發現時間",
     "Latest Release": "最新發佈",
     "Local Discovery": "本地探索",
@@ -80,10 +86,13 @@
     "Restart": "重新啟動",
     "Restart Needed": "需要重新啟動",
     "Restarting": "正在重新啟動",
+    "Reused": "Reused",
     "Save": "儲存",
     "Scanning": "正在掃描",
     "Select the devices to share this folder with.": "選擇要共享這個資料夾的裝置。",
+    "Select the folders to share with this device.": "選擇要共享這個資料夾的裝置。",
     "Settings": "設定",
+    "Share Folders With Device": "與裝置共享資料夾",
     "Share With Devices": "與這些裝置共享",
     "Shared With": "與誰共享",
     "Short identifier for the folder. Must be the same on all cluster devices.": "資料夾的簡短識別字。必須在叢集內所有的裝置上皆相同。",
@@ -121,9 +130,11 @@
     "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "一個版本被保留的最長時間 (單位為天，若設定為 0 則表示永遠保留)。",
     "The number of old versions to keep, per file.": "每個檔案要保留的舊版本數量。",
     "The number of versions must be a number and cannot be blank.": "每個檔案要保留的舊版本數量必須是數字且不能為空白。",
-    "The rescan interval must be a non-negative number of seconds.": "The rescan interval must be a non-negative number of seconds.",
+    "The rescan interval must be a non-negative number of seconds.": "重新掃描間隔必須為一個非負數的秒數。",
     "The rescan interval must be at least 5 seconds.": "重新掃描間隔至少須為 5 秒。",
     "Unknown": "未知",
+    "Unshared": "未共享",
+    "Unused": "未使用",
     "Up to Date": "最新",
     "Upgrade To {%version%}": "升級至 {{version}}",
     "Upgrading": "正在升級",

gui/assets/lang/valid-langs.js

@@ -1 +1 @@
-var validLangs = ["be","bg","cs","de","en","fr","hu","it","lt","nb","nl","nn","pl","pt-PT","ru","sv","zh-CN","zh-TW"]
+var validLangs = ["be","bg","cs","de","en","es","fr","hu","it","lt","nb","nl","nn","pl","pt-PT","ru","sv","zh-CN","zh-TW"]

gui/index.html

@@ -91,6 +91,7 @@
         <div class="panel-group" id="folders">
           <div class="panel panel-default" ng-repeat="folder in folderList()">
             <div class="panel-heading" data-toggle="collapse" data-parent="#folders" href="#folder-{{$index}}" style="cursor: pointer">
+              <div class="panel-progress" ng-show="folderStatus(folder) == 'syncing'" ng-attr-style="width: {{syncPercentage(folder.ID)}}%"></div>
               <h3 class="panel-title">
                 <span class="glyphicon glyphicon-hdd"></span>&emsp;{{folder.ID}}
                 <span class="pull-right hidden-xs text-{{folderClass(folder)}}" ng-switch="folderStatus(folder)">
@@ -148,13 +149,25 @@
                       <th><span class="glyphicon glyphicon-refresh"></span>&emsp;<span translate>Rescan Interval</span></th>
                       <td class="text-right">{{folder.RescanIntervalS}} s</td>
                     </tr>
+                    <tr>
+                      <th><span class="glyphicon glyphicon-share-alt"></span>&emsp;<span translate>Shared With</span></th>
+                      <td class="text-right">{{sharesFolder(folder)}}</td>
+                    </tr>
+                    <tr ng-if="folderStats[folder.ID].LastFile">
+                      <th><span class="glyphicon glyphicon-transfer"></span>&emsp;<span translate>Last File Synced</span></th>
+                      <td class="text-right">
+                        <span title="{{folderStats[folder.ID].LastFile.Filename}} @ {{folderStats[folder.ID].LastFile.At | date:'yyyy-MM-dd HH:mm'}}">
+                          {{folderStats[folder.ID].LastFile.Filename | basename}}
+                        </span>
+                      </td>
+                    </tr>
                   </tbody>
                 </table>
               </div>
               <div class="panel-footer">
                 <button class="btn btn-sm btn-danger" ng-if="folder.ReadOnly && model[folder.ID].needFiles > 0" ng-click="override(folder.ID)" href=""><span class="glyphicon glyphicon-upload"></span>&emsp;<span translate>Override Changes</span></button>
                 <span class="pull-right">
-                  <button class="btn btn-sm btn-default" href="" ng-show="folderStatus(folder.ID) == 'idle'" ng-click="rescanFolder(folder.ID)"><span class="glyphicon glyphicon-refresh"></span>&emsp;<span translate>Rescan</span></button>
+                  <button class="btn btn-sm btn-default" href="" ng-show="folderStatus(folder) == 'idle'" ng-click="rescanFolder(folder.ID)"><span class="glyphicon glyphicon-refresh"></span>&emsp;<span translate>Rescan</span></button>
                   <button class="btn btn-sm btn-default" href="" ng-click="editFolder(folder)"><span class="glyphicon glyphicon-pencil"></span>&emsp;<span translate>Edit</span></button>
                 </span>
                 <div class="clearfix"></div>
@@ -201,7 +214,7 @@
                     <td class="text-right">{{system.cpuPercent | alwaysNumber | natural:1}}%</td>
                   </tr>
                   <tr ng-if="system.extAnnounceOK != undefined && announceServersTotal > 0">
-                    <th><span class="glyphicon glyphicon-bullhorn"></span>&emsp;<span translate>Global Discovery Servers</span></th>
+                    <th><span class="glyphicon glyphicon-bullhorn"></span>&emsp;<span translate>Global Discovery</span></th>
                     <td class="text-right">
                       <span ng-if="announceServersFailed.length == 0" class="data text-success">
                         <span>OK</span>
@@ -228,6 +241,7 @@
         <div class="panel-group" id="devices">
           <div class="panel panel-default" ng-repeat="deviceCfg in otherDevices()">
             <div class="panel-heading" data-toggle="collapse" data-parent="#devices" href="#device-{{$index}}" style="cursor: pointer">
+              <div class="panel-progress" ng-show="deviceStatus(deviceCfg) == 'syncing'" ng-attr-style="width: {{completion[deviceCfg.DeviceID]._total | number:0}}%"></div>
               <h3 class="panel-title">
                 <identicon data-value="deviceCfg.DeviceID"></identicon>&emsp;{{deviceName(deviceCfg)}}
                 <span ng-switch="deviceStatus(deviceCfg)" class="pull-right hidden-xs text-{{deviceClass(deviceCfg)}}">
@@ -270,8 +284,8 @@
                     </tr>
                     <tr ng-if="!connections[deviceCfg.DeviceID]">
                       <th><span class="glyphicon glyphicon-eye-open"></span>&emsp;<span translate>Last seen</span></th>
-                      <td translate ng-if="!stats[deviceCfg.DeviceID].LastSeenDays || stats[deviceCfg.DeviceID].LastSeenDays >= 365" class="text-right">Never</td>
-                      <td ng-if="stats[deviceCfg.DeviceID].LastSeenDays < 365" class="text-right">{{stats[deviceCfg.DeviceID].LastSeen | date:"yyyy-MM-dd HH:mm"}}</td>
+                      <td translate ng-if="!deviceStats[deviceCfg.DeviceID].LastSeenDays || deviceStats[deviceCfg.DeviceID].LastSeenDays >= 365" class="text-right">Never</td>
+                      <td ng-if="deviceStats[deviceCfg.DeviceID].LastSeenDays < 365" class="text-right">{{deviceStats[deviceCfg.DeviceID].LastSeen | date:"yyyy-MM-dd HH:mm"}}</td>
                     </tr>
                     <tr ng-if="deviceFolders(deviceCfg).length > 0">
                       <th><span class="glyphicon glyphicon-hdd"></span>&emsp;<span translate>Folders</span></th>
@@ -294,6 +308,73 @@
       </div>
     </div> <!-- /row -->
 
+    <!-- Device Rejections -->
+
+    <div ng-repeat="(device, event) in deviceRejections" class="row">
+      <div class="col-md-12">
+        <div class="panel panel-warning">
+          <div class="panel-heading">
+            <h3 class="panel-title">
+              <identicon data-value="device"></identicon>&emsp;<span translate>New Device</span>
+            </h3>
+          </div>
+          <div class="panel-body">
+            <p>
+              <small>{{ event.time | date:"H:mm:ss" }}:</small>
+              <span translate translate-value-device="{{ device }}" translate-value-address="{{ event.data.address }}">
+                Device {%device%} ({%address%}) wants to connect. Add new device?
+              <span>
+            </p>
+          </div>
+          <div class="panel-footer clearfix">
+            <div class="pull-right">
+              <button class="btn btn-sm btn-success" ng-click="addNewDeviceID(device)"><span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Add</span></button>
+              <button class="btn btn-sm btn-danger" ng-click="ignoreRejectedDevice(device)"><span class="glyphicon glyphicon-remove"></span>&emsp;<span translate>Ignore</span></button>
+              <button class="btn btn-sm btn-default" ng-click="dismissDeviceRejection(device)"><span class="glyphicon glyphicon-time"></span>&emsp;<span translate>Later</span></button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Folder Rejections -->
+
+    <div ng-repeat="(key, event) in folderRejections" class="row reject">
+      <div class="col-md-12">
+        <div class="panel panel-warning">
+          <div class="panel-heading">
+            <h3 class="panel-title">
+              <span translate ng-if="!folders[event.data.folder]">New Folder</span>
+              <span translate ng-if="folders[event.data.folder]">Share Folder</span>
+            </h3>
+          </div>
+          <div class="panel-body">
+            <p>
+              <small>{{ event.time | date:"H:mm:ss" }}:</small>
+              <span translate translate-value-device="{{ deviceName(findDevice(event.data.device)) }}" translate-value-folder="{{ event.data.folder }}">
+                {%device%} wants to share folder "{%folder%}".
+              </span>
+              <span translate ng-if="folders[event.data.folder]">Share this folder?</span>
+              <span translate ng-if="!folders[event.data.folder]">Add new folder?</span>
+            </p>
+          </div>
+          <div class="panel-footer clearfix">
+            <div class="pull-right">
+              <button class="btn btn-sm btn-success" ng-click="addFolderAndShare(event.data.folder, event.data.device)" ng-if="!folders[event.data.folder]">
+                <span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Add</span>
+              </button>
+              <button class="btn btn-sm btn-success" ng-click="shareFolderWithDevice(event.data.folder, event.data.device)" ng-if="folders[event.data.folder]">
+                <span class="glyphicon glyphicon-ok"></span>&emsp;<span translate>Share</span>
+              </button>
+              <button class="btn btn-sm btn-default" ng-click="dismissFolderRejection(event.data.folder, event.data.device)">
+                <span class="glyphicon glyphicon-time"></span>&emsp;<span translate>Later</span>
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
     <!-- Errors -->
 
     <div ng-if="errorList().length > 0" class="row">
@@ -412,6 +493,23 @@
                 <p translate class="help-block">Any devices configured on an introducer device will be added to this device as well.</p>
               </div>
             </div>
+
+            <div class="row" ng-if="!editingSelf">
+              <div class="col-md-12">
+                <div class="form-group">
+                  <label translate for="folders">Share Folders With Device</label>
+                  <p translate class="help-block">Select the folders to share with this device.</p>
+                  <div class="three-columns">
+                    <div class="checkbox" ng-repeat="folder in folderList()">
+                      <label>
+                        <input type="checkbox" ng-model="currentDevice.selectedFolders[folder.ID]"> {{folder.ID}}
+                      </label>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+
           </form>
         </div>
         <div class="modal-footer">
@@ -537,7 +635,7 @@
                 <div class="form-group">
                   <label translate for="devices">Share With Devices</label>
                   <p translate class="help-block">Select the devices to share this folder with.</p>
-                  <div style="-webkit-column-count: 3; -moz-column-count: 3; column-count: 3; vertical-align: top;">
+                  <div class="three-columns">
                     <div class="checkbox" ng-repeat="device in otherDevices()">
                       <label>
                         <input type="checkbox" ng-model="currentFolder.selectedDevices[device.DeviceID]"> {{deviceName(device)}}
@@ -625,14 +723,14 @@
                   <div class="form-group">
                     <div class="checkbox">
                       <label>
-                        <span translate>Enable UPnP</span> <input id="UPnPEnabled" type="checkbox" ng-model="tmpOptions.UPnPEnabled">
+                        <input id="UPnPEnabled" type="checkbox" ng-model="tmpOptions.UPnPEnabled"> <span translate>Enable UPnP</span>
                       </label>
                     </div>
                   </div>
                   <div class="form-group">
                     <div class="checkbox">
                       <label>
-                        <span translate>Global Discovery</span> <input id="GlobalAnnEnabled" type="checkbox" ng-model="tmpOptions.GlobalAnnEnabled">
+                        <input id="GlobalAnnEnabled" type="checkbox" ng-model="tmpOptions.GlobalAnnEnabled"> <span translate>Global Discovery</span>
                       </label>
                     </div>
                   </div>
@@ -641,14 +739,14 @@
                   <div class="form-group">
                     <div class="checkbox">
                       <label ng-if="upgradeInfo">
-                        <span translate>Automatic upgrades</span> <input id="AutoUpgradeEnabled" type="checkbox" ng-model="tmpOptions.AutoUpgradeEnabled">
+                        <input id="AutoUpgradeEnabled" type="checkbox" ng-model="tmpOptions.AutoUpgradeEnabled"> <span translate>Automatic upgrades</span>
                       </label>
                     </div>
                   </div>
                   <div class="form-group">
                     <div class="checkbox">
                       <label>
-                        <span translate>Local Discovery</span> <input id="LocalAnnEnabled" type="checkbox" ng-model="tmpOptions.LocalAnnEnabled">
+                        <input id="LocalAnnEnabled" type="checkbox" ng-model="tmpOptions.LocalAnnEnabled"> <span translate>Local Discovery</span>
                       </label>
                     </div>
                   </div>
@@ -675,21 +773,21 @@
                 <div class="form-group">
                   <div class="checkbox">
                     <label>
-                      <span translate>Use HTTPS for GUI</span> <input id="UseTLS" type="checkbox" ng-model="tmpGUI.UseTLS">
+                      <input id="UseTLS" type="checkbox" ng-model="tmpGUI.UseTLS"> <span translate>Use HTTPS for GUI</span>
                     </label>
                   </div>
                 </div>
                 <div class="form-group">
                   <div class="checkbox">
                     <label>
-                      <span translate>Start Browser</span> <input id="StartBrowser" type="checkbox" ng-model="tmpOptions.StartBrowser">
+                      <input id="StartBrowser" type="checkbox" ng-model="tmpOptions.StartBrowser"> <span translate>Start Browser</span>
                     </label>
                   </div>
                 </div>
                 <div class="form-group">
                   <div class="checkbox">
                     <label>
-                      <span translate>Anonymous Usage Reporting</span> <input id="UREnabled" type="checkbox" ng-model="tmpOptions.UREnabled"> (<a translate ng-click="showURPreview()" href="#">Preview</a>)
+                      <input id="UREnabled" type="checkbox" ng-model="tmpOptions.UREnabled"> <span translate>Anonymous Usage Reporting</span> (<a translate ng-click="showURPreview()" href="#">Preview</a>)
                     </label>
                   </div>
                 </div>
@@ -759,33 +857,51 @@
   <!-- Needed files modal -->
 
   <modal id="needed" large="yes" status="info" icon="cloud-download" close="yes" title="Out of Sync Items">
-    <table class="table table-striped table-condensed">
-      <tr ng-repeat="f in needed" ng-init="a = needAction(f)">
-        <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
-        <td title="{{f.Name}}">{{f.Name | basename}}</td>
-        <td>
-          <span ng-if="a == 'sync' && progress[neededFolder] && progress[neededFolder][f.Name]">
-            <div class="progress progress-striped active">
-              <div class="progress-bar progress-bar-success" style="width: {{progress[neededFolder][f.Name].Reused}}%"></div>
-              <div class="progress-bar" style="width: {{progress[neededFolder][f.Name].CopiedFromOrigin}}%"></div>
-              <div class="progress-bar progress-bar-info" style="width: {{progress[neededFolder][f.Name].CopiedFromElsewhere}}%"></div>
-              <div class="progress-bar progress-bar-warning" style="width: {{progress[neededFolder][f.Name].Pulled}}%"></div>
-              <div class="progress-bar progress-bar-danger" style="width: {{progress[neededFolder][f.Name].Pulling}}%"></div>
-              <span class="show frontal">{{progress[neededFolder][f.Name].BytesDone | binary}}B / {{progress[neededFolder][f.Name].BytesTotal | binary}}B</span>
-            </div>
-          </span>
-        </td>
-      </tr>
-    </table>
-    <span translate>Legend:</span>
-    <div class="progress progress-striped active">
+    <div class="progress">
       <div class="progress-bar progress-bar-success" style="width: 20%"><span translate class="show">Reused</span></div>
       <div class="progress-bar" style="width: 20%"><span translate class="show">Copied from original</span></div>
       <div class="progress-bar progress-bar-info" style="width: 20%"><span translate class="show">Copied from elsewhere</span></div>
       <div class="progress-bar progress-bar-warning" style="width: 20%"><span translate class="show">Downloaded</span></div>
-      <div class="progress-bar progress-bar-danger" style="width: 20%"><span translate class="show">Downloading</span></div>
+      <div class="progress-bar progress-bar-danger progress-bar-striped active" style="width: 20%"><span translate class="show">Downloading</span></div>
     </div>
 
+    <hr/>
+
+    <table class="table table-striped table-condensed">
+      <tr ng-repeat="f in needed.progress" ng-init="a = needAction(f)">
+        <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
+        <td title="{{f.Name}}">{{f.Name | basename}}</td>
+        <td ng-if="a == 'sync' && progress[neededFolder] && progress[neededFolder][f.Name]">
+          <div class="progress">
+            <div class="progress-bar progress-bar-success" style="width: {{progress[neededFolder][f.Name].Reused}}%"></div>
+            <div class="progress-bar" style="width: {{progress[neededFolder][f.Name].CopiedFromOrigin}}%"></div>
+            <div class="progress-bar progress-bar-info" style="width: {{progress[neededFolder][f.Name].CopiedFromElsewhere}}%"></div>
+            <div class="progress-bar progress-bar-warning" style="width: {{progress[neededFolder][f.Name].Pulled}}%"></div>
+            <div class="progress-bar progress-bar-danger progress-bar-striped active" style="width: {{progress[neededFolder][f.Name].Pulling}}%"></div>
+            <span class="show frontal">
+              {{progress[neededFolder][f.Name].BytesDone | binary}}B / {{progress[neededFolder][f.Name].BytesTotal | binary}}B
+            </span>
+          </div>
+        </td>
+        <td class="text-right small-data" ng-if="a != 'sync' || !progress[neededFolder] || !progress[neededFolder][f.Name]">
+          <span ng-if="f.Size > 0">{{f.Size | binary}}B</span>
+        </td>
+      </tr>
+      <tr ng-repeat="f in needed.queued" ng-init="a = needAction(f)">
+        <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
+        <td title="{{f.Name}}">{{f.Name | basename}}</td>
+        <td class="text-right small-data">
+          <span ng-if="$index != 0" class="glyphicon glyphicon-chevron-up" ng-click="bumpFile(neededFolder, f.Name)"></span>
+          <span ng-if="f.Size > 0">{{f.Size | binary}}B</span>
+         </td>
+      </tr>
+      <tr ng-repeat="f in needed.rest" ng-init="a = needAction(f)">
+        <td class="small-data"><span class="glyphicon glyphicon-{{needIcons[a]}}"></span> {{needActions[a]}}</td>
+        <td title="{{f.Name}}">{{f.Name | basename}}</td>
+        <td class="text-right small-data"><span ng-if="f.Size > 0">{{f.Size | binary}}B</span></td>
+      </tr>
+    </table>
+
   </modal>
 
   <!-- About modal -->
@@ -796,27 +912,26 @@
 
     <p translate>Copyright &copy; 2014 Jakob Borg and the following Contributors:</p>
     <div class="row">
-      <div class="col-md-6">
-        <ul>
+      <div class="col-md-12">
+        <ul class="list-unstyled three-columns">
           <li>Aaron Bieber</li>
           <li>Andrew Dunham</li>
           <li>Alexander Graf</li>
           <li>Arthur Axel fREW Schmidt</li>
           <li>Audrius Butkevicius</li>
+          <li>Ben Schulz</li>
           <li>Ben Sidhom</li>
           <li>Brandon Philips</li>
           <li>Caleb Callaway</li>
+          <li>Cathryne Linenweaver</li>
           <li>Chris Joel</li>
           <li>Daniel Martí</li>
           <li>Dennis Wilson</li>
+          <li>Dominik Heidler</li>
           <li>Emil Hessman</li>
           <li>Felix Ableitner</li>
           <li>Felix Unterpaintner</li>
           <li>Gilli Sigurdsson</li>
-        </ul>
-      </div>
-      <div class="col-md-6">
-        <ul>
           <li>James Patterson</li>
           <li>Jens Diemer</li>
           <li>Jochen Voss</li>
@@ -837,7 +952,7 @@
     <hr/>
 
     <p translate>Syncthing includes the following software or portions thereof:</p>
-    <ul>
+    <ul class="list-unstyled two-columns">
       <li><a href="http://golang.org/">The Go Programming Language</a>, Copyright &copy; 2012 The Go Authors.</li>
       <li><a href="https://bitbucket.org/kardianos/osext">kardianos/osext</a>, Copyright &copy; 2012 Daniel Theophanes.</li>
       <li><a href="https://code.google.com/p/snappy-go/">snappy-go</a>, Copyright &copy; 2011 The Snappy-Go Authors.</li>
@@ -871,6 +986,7 @@
   <script src="scripts/syncthing/core/filters/basenameFilter.js"></script>
   <script src="scripts/syncthing/core/filters/binaryFilter.js"></script>
   <script src="scripts/syncthing/core/filters/naturalFilter.js"></script>
+  <script src="scripts/syncthing/core/services/localeService.js"></script>
 
   <script src="assets/lang/valid-langs.js"></script>
   <script src="scripts/syncthing/app.js"></script>

gui/lang/lang-nl.json

@@ -1,142 +0,0 @@
-{
-    "API Key": "API-sleutel",
-    "About": "Over",
-    "Add Device": "Toestel toevoegen",
-    "Add Folder": "Folder toevoegen",
-    "Address": "Adres",
-    "Addresses": "Adressen",
-    "Allow Anonymous Usage Reporting?": "Bijhouden van anonieme gebruikers statistieken toestaan?",
-    "Anonymous Usage Reporting": "Bijhouden anonieme gebruikers statistieken",
-    "Any devices configured on an introducer device will be added to this device as well.": "Toestellen geconfigureerd op een introductie toestel zullen ook aan dit toestel worden toegevoegd.",
-    "Automatic upgrades": "Automatisch bijwerken",
-    "Bugs": "Fouten",
-    "CPU Utilization": "CPU Gebruik",
-    "Close": "Sluiten",
-    "Comment, when used at the start of a line": "Commentaar, indien gebruikt aan het begin van de lijn",
-    "Compression is recommended in most setups.": "Gegevenscompressie is aan te raden in de meeste situaties.",
-    "Connection Error": "Verbindingsfout",
-    "Copyright © 2014 Jakob Borg and the following Contributors:": "Copyright © 2014 Jakob Borg en de onderstaande bijdragers:",
-    "Delete": "Verwijderen",
-    "Device ID": "Toestel ID",
-    "Device Identification": "Toestel identificatie",
-    "Device Name": "Naam toestel",
-    "Disconnected": "Niet Verbonden",
-    "Documentation": "Documentatie",
-    "Download Rate": "Downloadsnelheid",
-    "Edit": "Bewerk",
-    "Edit Device": "Toestel aanpassen",
-    "Edit Folder": "Folder aanpassen",
-    "Editing": "Bezig met aanpassen",
-    "Enable UPnP": "UPnP aanzetten",
-    "Enter comma separated \"ip:port\" addresses or \"dynamic\" to perform automatic discovery of the address.": "Geef, gescheiden door komma's, \"ip:port\" adressen of \"dynamic\" voor het automatische vinden van de addressen.",
-    "Enter ignore patterns, one per line.": "Geef te negeren patronen, één per regel.",
-    "Error": "Fout",
-    "File Versioning": "Versiebeheer",
-    "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Bestands permissiebits worden genegeerd wanneer naar veranderingen wordt gekeken. Gebruik dit op FAT bestandsystemen",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Bestanden worden naar de .stversions map verplaatst met een tijdsaanduiding, wanneer ze aangepast of verwijderd worden door syncthing.",
-    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Bestanden zijn beschermt tegen aanpassingen gemaakt door andere toestellen maar aanpassingen op dit toestel worden doorgestuurd naar de rest van de cluster.",
-    "Folder ID": "Folder ID",
-    "Folder Master": "Hoofdfolder",
-    "Folder Path": "Locatie folder",
-    "GUI Authentication Password": "GUI Authentificatie Wachtwoord",
-    "GUI Authentication User": "GUI Authentificatie Gebruikersnaam",
-    "GUI Listen Addresses": "GUI Inkomend adres",
-    "Generate": "Genereer",
-    "Global Discovery": "Globaal zoeken",
-    "Global Discovery Server": "Globale zoekserver",
-    "Global State": "Globale status",
-    "Idle": "Inactief",
-    "Ignore Patterns": "Te negeren patronen",
-    "Ignore Permissions": "Rechten negeren",
-    "Incoming Rate Limit (KiB/s)": "Download snelheidslimiet (KiB/s)",
-    "Introducer": "Introductietoestel",
-    "Inversion of the given condition (i.e. do not exclude)": "Inversie van de gegeven voorwaarde (bv. niet uitsluiten)",
-    "Keep Versions": "Versies behouden",
-    "Last seen": "Laatst gezien op",
-    "Latest Release": "Laatste uitgave",
-    "Local Discovery": "Lokaal zoeken",
-    "Local State": "Lokale status",
-    "Maximum Age": "Maximum leeftijd",
-    "Multi level wildcard (matches multiple directory levels)": "Wildcard op meerder niveaus (toepasbaar op meerdere niveaus van folders)",
-    "Never": "Nooit",
-    "No": "Nee",
-    "No File Versioning": "Geen versiebeheer",
-    "Notice": "Notificatie",
-    "OK": "OK",
-    "Offline": "Offline",
-    "Online": "Online",
-    "Out Of Sync": "Niet gesynchroniseerd",
-    "Outgoing Rate Limit (KiB/s)": "Uitgaande snelheidslimiet (KiB/s)",
-    "Override Changes": "Veranderingen overschrijven",
-    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Locatie van de folder op de lokale computer. Zal aangemaakt worden wanneer deze niet bestaat. De tilde (~) kan gebruikt in plaats van",
-    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Locatie waar de versies opgeslagen moeten worden (leeg laten voor de standaard .stversions subfolder).",
-    "Please wait": "Even geduld",
-    "Preview": "Voorbeeld",
-    "Preview Usage Report": "Bekijk gebruiksstatistieken",
-    "Quick guide to supported patterns": "Snelgids voor ondersteunde patronen",
-    "RAM Utilization": "RAM gebruik",
-    "Rescan": "Opnieuw scannen",
-    "Rescan Interval": "Scanfrequentie",
-    "Restart": "Herstart",
-    "Restart Needed": "Herstart nodig",
-    "Restarting": "Herstarten",
-    "Save": "Bewaar",
-    "Scanning": "Aan het zoeken",
-    "Select the devices to share this folder with.": "Selecteer de toestellen om deze folder mee te delen.",
-    "Settings": "Instellingen",
-    "Share With Devices": "Delen met toestellen",
-    "Shared With": "Gedeeld met",
-    "Short identifier for the folder. Must be the same on all cluster devices.": "Korte aanduiding voor deze folder. Moet dezelfde zijn op alle toestellen in de cluster.",
-    "Show ID": "Toon ID",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Wordt getoond in plaats van de toestel ID in de cluster staat. Wordt doorgegeven aan andere toestellen as een bijkomende standaard toestelnaam.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Wordt getoond in plaats van de toestel ID in de cluster staat. Wanneer leeg wordt deze aangepast met de naam aangekondigd door het toestel.",
-    "Shutdown": "Sluit af",
-    "Simple File Versioning": "Eenvoudig versiebeheer",
-    "Single level wildcard (matches within a directory only)": "Wildcard op enkel niveau (toepasbaar binnen een enkele folder)",
-    "Source Code": "Broncode",
-    "Staggered File Versioning": "Gelaagd versiebeheer",
-    "Start Browser": "Start browser",
-    "Stopped": "Gestopt",
-    "Support / Forum": "Support / Forum",
-    "Sync Protocol Listen Addresses": "Synchronisatie protocol luister adres",
-    "Synchronization": "Synchronisatie",
-    "Syncing": "Aan het synchroniseren",
-    "Syncthing has been shut down.": "Syncthing is afgesloten",
-    "Syncthing includes the following software or portions thereof:": "De volgende software of delen daarvan zijn onderdeel van syncthing:",
-    "Syncthing is restarting.": "Syncthing is aan het herstarten.",
-    "Syncthing is upgrading.": "Syncthing is aan het upgraden.",
-    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing lijkt afgesloten te zijn, of er is een verbindingsprobleem met het internet. Nieuwe poging....",
-    "The aggregated statistics are publicly available at {%url%}.": "The verzamelde statistieken zijn publiek beschikbaar op {{url}}",
-    "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "De configuratie is opslagen maar nog niet actief. Syncthing moet opnieuw opgestart worden om de nieuwe configuratie te activeren.",
-    "The device ID cannot be blank.": "Het toestel ID mag niet leeg zijn.",
-    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Het verwachte toestel ID kan teruggevonden worden in het \"Aanpassen > Toon ID\" scherm op het andere toestel. Spaties en streepjes zijn facultatief (worden genegeerd).",
-    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Het versleutelde gebruiksrapport wordt dagelijks opgestuurd en wordt gebruikt om de verschillende platformen, folder groottes en versies op te volgen. Als de reeks gegevens wijzigt zal opnieuw toestemming gevraagd worden.",
-    "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "Dit toestel ID lijkt ongeldig. Het toestel ID bestaat uit 52 of 56 letters en nummers met facultatieve spaties en streepjes.",
-    "The folder ID cannot be blank.": "De folder ID mag niet leeg zijn.",
-    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "De folder ID mag maximaal 64 tekens lang zijn en bestaat enkel uit letters, nummers, punten (.), streepjes (-) en onderstrepingstekens (_).",
-    "The folder ID must be unique.": "De folder ID moet uniek zijn.",
-    "The folder path cannot be blank.": "De folder locatie mag niet leeg zijn.",
-    "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "De volgende intervallen worden gebruikt: het eerste uur worden versies iedere 30 seconden bewaard, de eerste dag worden versies ieder uur bewaard, de eerste 30 dagen worden versies iedere dag bewaard, tot de maximale leeftijd worden versies iedere week bewaard.",
-    "The maximum age must be a number and cannot be blank.": "De maximum leeftijd moet uit cijfers bestaan en mag niet leeggelaten worden.",
-    "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "De maximale tijdsduur om een versie te bewaren (in dagen, gebruik 0 om versies voor altijd te bewaren).",
-    "The number of old versions to keep, per file.": "Het aantal versies dat bewaard moet worden per file.",
-    "The number of versions must be a number and cannot be blank.": "Het aantal nummers moet een getal zijn en mag niet leeg blijven.",
-    "The rescan interval must be a non-negative number of seconds.": "De scanfrequentie moet een positief getal in seconden zijn.",
-    "The rescan interval must be at least 5 seconds.": "De scanfrequentie moet minimaal 5 seconden zijn.",
-    "Unknown": "Onbekend",
-    "Up to Date": "Gesynchroniseerd",
-    "Upgrade To {%version%}": "Upgrade naar {{version}}",
-    "Upgrading": "Bezig met upgrade",
-    "Upload Rate": "Upload snelheid",
-    "Use Compression": "Compressie gebruiken",
-    "Use HTTPS for GUI": "Gebruik HTTPS voor de GUI",
-    "Version": "Versie",
-    "Versions Path": "Locatie versies",
-    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Versies worden automatisch verwijderd als deze ouder zijn dan de maximale leeftijd of als ze het maximaal aantal toegestane bestanden per interval overschrijden. ",
-    "When adding a new device, keep in mind that this device must be added on the other side too.": "Onthoud dat een toegevoegd toestel ook aan de andere kant moet worden toegevoegd.",
-    "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Onthoud, bij het toevoegen van een folder, dat de folder ID gebruikt wordt om folders tussen toestellen te verbinden. Ze zijn hoofdletter gevoelig en moeten exact hetzelfde zijn op de andere toestellen.",
-    "Yes": "Ja",
-    "You must keep at least one version.": "Minstens 1 versie moet bewaard blijven.",
-    "full documentation": "volledige documentatie",
-    "items": "objecten"
-}

gui/lang/lang-ru.json

@@ -1,142 +0,0 @@
-{
-    "API Key": "Ключ API",
-    "About": "О программе",
-    "Add Device": "Добавить устройство",
-    "Add Folder": "Добавить папку",
-    "Address": "Адрес",
-    "Addresses": "Адреса",
-    "Allow Anonymous Usage Reporting?": "Разрешить сбор анонимной статистики использования?",
-    "Anonymous Usage Reporting": "Анонимная статистика использования",
-    "Any devices configured on an introducer device will be added to this device as well.": "Все устройства, подключённые к устройству-рекомендателю, будут добавлены к текущему устройству.",
-    "Automatic upgrades": "Автообновление",
-    "Bugs": "Ошибки",
-    "CPU Utilization": "Загрузка ЦПУ",
-    "Close": "Закрыть",
-    "Comment, when used at the start of a line": "Комментарий, если используется в начале строки",
-    "Compression is recommended in most setups.": "Сжатие рекомендуется в большинстве случаев.",
-    "Connection Error": "Ошибка подключения",
-    "Copyright © 2014 Jakob Borg and the following Contributors:": "Все права защищены © 2014 Jakob Borg и следующие участники:",
-    "Delete": "Удалить",
-    "Device ID": "ID устройства",
-    "Device Identification": "Идентификация устройства",
-    "Device Name": "Имя устройства",
-    "Disconnected": "Нет соединения",
-    "Documentation": "Документация",
-    "Download Rate": "Скорость загрузки",
-    "Edit": "Изменить",
-    "Edit Device": "Изменить устройство",
-    "Edit Folder": "Изменение папки",
-    "Editing": "Редактирование",
-    "Enable UPnP": "Включить UPnP",
-    "Enter comma separated \"ip:port\" addresses or \"dynamic\" to perform automatic discovery of the address.": " Введите пары \"IP:PORT\" разделённые запятыми, или слово \"dynamic\" для автоматического обнаружения адреса.",
-    "Enter ignore patterns, one per line.": "Введите шаблон игнорирования, по-одному на строку.",
-    "Error": "Ошибка",
-    "File Versioning": "Управление версиями",
-    "File permission bits are ignored when looking for changes. Use on FAT filesystems.": "Права доступа к файлам будут игнорироваться. Используйте на файловых системах типа FAT.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by syncthing.": "Версии файлов с временнОй меткой перемещаются в директорию .stversions, если они удалены или перемещены в процессе синхронизации.",
-    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Файлы защищены от изменений сделанных на других устройствах, но изменения сделанные на этом устройстве будут отправлены всему кластеру.",
-    "Folder ID": "ID папки",
-    "Folder Master": "Папка-оригинал",
-    "Folder Path": "Путь к папке",
-    "GUI Authentication Password": "Пароль для доступа к панели управления",
-    "GUI Authentication User": "Имя пользователя для доступа к панели управления",
-    "GUI Listen Addresses": "Адрес панели управления",
-    "Generate": "Сгенерировать",
-    "Global Discovery": "Глобальное обнаружение",
-    "Global Discovery Server": "Сервер глобального обнаружения",
-    "Global State": "Глобальное состояние",
-    "Idle": "Бездействует",
-    "Ignore Patterns": "Шаблоны игнорирования",
-    "Ignore Permissions": "Игнорировать файловые права доступа",
-    "Incoming Rate Limit (KiB/s)": "Ограничение входящего потока (Кбит/сек)",
-    "Introducer": "Рекомендатель",
-    "Inversion of the given condition (i.e. do not exclude)": "Инвертировать текущее условие (например, исключить)",
-    "Keep Versions": "Количество хранимых версий",
-    "Last seen": "Был доступен",
-    "Latest Release": "Последняя версия",
-    "Local Discovery": "Локальное обнаружение",
-    "Local State": "Локальное состояние",
-    "Maximum Age": "Максимальный срок",
-    "Multi level wildcard (matches multiple directory levels)": "Многоуровневая маска (поиск совпадений во всех подпапках)",
-    "Never": "Никогда",
-    "No": "Нет",
-    "No File Versioning": "Без управления версиями файлов",
-    "Notice": "Внимание",
-    "OK": "ОК",
-    "Offline": "Оффлайн",
-    "Online": "Онлайн",
-    "Out Of Sync": "Не синхронизировано",
-    "Outgoing Rate Limit (KiB/s)": "Предел скорости отдачи (KiB/s)",
-    "Override Changes": "Перезаписать изменения",
-    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Путь к папке на локальном компьютере. Если её не существует, то она будет создана. Тильда (~) может использоваться как сокращение для",
-    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Путь, где должны храниться версии (оставьте пустым по-умолчанию для папки .stversions в папке).",
-    "Please wait": "Пожалуйста, подождите",
-    "Preview": "Предварительный просмотр",
-    "Preview Usage Report": "Посмотреть отчёт об использовании",
-    "Quick guide to supported patterns": "Краткое руководство по поддерживаемым шаблонам",
-    "RAM Utilization": "Использование ОЗУ",
-    "Rescan": "Пересканирование",
-    "Rescan Interval": "Интервал пересканирования",
-    "Restart": "Перезапуск",
-    "Restart Needed": "Требуется перезапуск",
-    "Restarting": "Перезапуск",
-    "Save": "Сохранить",
-    "Scanning": "Сканирование",
-    "Select the devices to share this folder with.": "Выберите устройства, для которых будет доступна эта папка.",
-    "Settings": "Настройки",
-    "Share With Devices": "Предоставить доступ устройствам",
-    "Shared With": "Доступ предоставлен",
-    "Short identifier for the folder. Must be the same on all cluster devices.": "Короткий идентификатор папки. Должен быть одинаковым на всех устройствах кластера.",
-    "Show ID": "Показать ID",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Отображается вместо ID устройства в статусе группы. Будет разослан другим устройствам в качестве имени по умолчанию.",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Отображается вместо ID устройства в статусе группы. Если поле не заполнено, то будет установлено имя, передаваемое этим устройством.",
-    "Shutdown": "Выключить",
-    "Simple File Versioning": "Простое управление версиями файлов",
-    "Single level wildcard (matches within a directory only)": "Одноуровневая маска (поиск совпадений только внутри папки)",
-    "Source Code": "Исходный код",
-    "Staggered File Versioning": "Ступенчатое управление версиями файлов",
-    "Start Browser": "Открыть браузер",
-    "Stopped": "Остановлено",
-    "Support / Forum": "Поддержка / Форум",
-    "Sync Protocol Listen Addresses": "Адрес протокола синхронизации",
-    "Synchronization": "Синхронизация",
-    "Syncing": "Синхронизация",
-    "Syncthing has been shut down.": "Syncthing выключен.",
-    "Syncthing includes the following software or portions thereof:": "Syncthing включает в себя следующее ПО или его части:",
-    "Syncthing is restarting.": "Перезапуск Syncthing",
-    "Syncthing is upgrading.": "Обновление Syncthing ",
-    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Кажется, Syncthing не запущен или есть проблемы с подключением к Интернету. Переподключаюсь...",
-    "The aggregated statistics are publicly available at {%url%}.": "Суммарная статистика общедоступна на {{url}}.",
-    "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Конфигурация была сохранена но не активирована. Для активации новой конфигурации необходимо рестартовать Syncthing.",
-    "The device ID cannot be blank.": "ID устройства не может быть пустым.",
-    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "Идентификатор устройства для ввода здесь, может быть найден в диалоге \"Редактирование > Показать ID\" на другом устройстве. Пробелы и тире не обязательны (игнорируются).",
-    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Зашифрованный отчет об использовании отправляется ежедневно. Это используется для отслеживания общих платформ, размеров папок и версий приложения. Если отчетные данные изменятся, вам будет снова показано это диалоговое окно.",
-    "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "Введённое ID устройства не валидное. Оно должно состоять из букв и цифр, может включать пробелы и дефисы, его длина должна быть от 52 до 56 символов, ",
-    "The folder ID cannot be blank.": "ID папки не может быть пустым.",
-    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "ID папки должен быть коротким (не более 64 символов), должен состоять только из букв, цифр, точек (.), дефисов (-) или подчёркиваний (_).",
-    "The folder ID must be unique.": "ID папки должен быть уникальным.",
-    "The folder path cannot be blank.": "Путь к папке не должен быть пустым.",
-    "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "Используются следующие интервалы: в первый час версия меняется каждые 30 секунд, в первый день - каждый час, первые 30 дней - каждый день, после, до максимального срока - каждую неделю.",
-    "The maximum age must be a number and cannot be blank.": "Максимальный срок должен быть числом и не может быть пустым.",
-    "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Максимальный срок хранения версии (в днях, 0 значит вечное хранение).",
-    "The number of old versions to keep, per file.": "Количество хранимых версий файла.",
-    "The number of versions must be a number and cannot be blank.": "Количество версий должно быть числом и не может быть пустым.",
-    "The rescan interval must be a non-negative number of seconds.": "Интервал пересканирования должен быть неотрицательным количеством секунд.",
-    "The rescan interval must be at least 5 seconds.": "Интервал пересканирования должен быть хотя бы 5 секунд.",
-    "Unknown": "Неизвестно",
-    "Up to Date": "Обновлено",
-    "Upgrade To {%version%}": "Обновить до {{version}}",
-    "Upgrading": "Обновление",
-    "Upload Rate": "Скорость отдачи",
-    "Use Compression": "Использовать сжатие",
-    "Use HTTPS for GUI": "Использовать HTTPS для панели управления",
-    "Version": "Версия",
-    "Versions Path": "Путь к версиям",
-    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Версии удаляются автоматически, если они существуют дольше максимального срока или превышают разрешённое количество файлов за интервал.",
-    "When adding a new device, keep in mind that this device must be added on the other side too.": "Когда добавляете устройство, помните о том, что это же устройство должно быть добавлено и другой стороной.",
-    "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Когда добавляете новую папку, помните, что ID папки используются для того, чтобы связывать папки между всеми устройствами. Они чувствительны к регистру и должны совпадать на всех используемых устройствах.",
-    "Yes": "Да",
-    "You must keep at least one version.": "Вы должны хранить как минимум одну версию.",
-    "full documentation": "полная документация",
-    "items": "элементы"
-}

gui/scripts/syncthing/app.js

@@ -25,7 +25,7 @@ var syncthing = angular.module('syncthing', [
 var urlbase = 'rest';
 var guiVersion = null;
 
-syncthing.config(function ($httpProvider, $translateProvider) {
+syncthing.config(function ($httpProvider, $translateProvider, LocaleServiceProvider) {
     $httpProvider.defaults.xsrfHeaderName = 'X-CSRF-Token';
     $httpProvider.defaults.xsrfCookieName = 'CSRF-Token';
     $httpProvider.interceptors.push(function () {
@@ -42,11 +42,16 @@ syncthing.config(function ($httpProvider, $translateProvider) {
         };
     });
 
+    // language and localisation
+
     $translateProvider.useStaticFilesLoader({
         prefix: 'assets/lang/lang-',
         suffix: '.json'
     });
 
+    LocaleServiceProvider.setAvailableLocales(validLangs);
+    LocaleServiceProvider.setDefaultLocale('en');
+
 });
 
 // @TODO: extract global level functions into seperate service(s)
@@ -99,15 +104,12 @@ function decimals(val, num) {
     return decs;
 }
 
-function randomString(len, bits) {
-    bits = bits || 36;
-    var outStr = "",
-        newStr;
-    while (outStr.length < len) {
-        newStr = Math.random().toString(bits).slice(2);
-        outStr += newStr.slice(0, Math.min(newStr.length, (len - outStr.length)));
+function randomString(len) {
+    var i, result = '', chars = '01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-';
+    for (i = 0; i < len; i++) {
+        result += chars[Math.round(Math.random() * (chars.length - 1))];
     }
-    return outStr.toLowerCase();
+    return result;
 }
 
 function isEmptyObject(obj) {

gui/scripts/syncthing/core/controllers/syncthingController.js

@@ -1,13 +1,44 @@
 angular.module('syncthing.core')
-    .controller('SyncthingController', function ($scope, $http, $translate, $location) {
+    .controller('SyncthingController', function ($scope, $http, $location, LocaleService) {
         'use strict';
 
+        // private/helper definitions
+
         var prevDate = 0;
-        var getOK = true;
         var navigatingAway = false;
         var online = false;
         var restarting = false;
 
+        function initController() {
+
+            LocaleService.autoConfigLocale();
+
+            refreshSystem();
+            refreshConfig();
+            refreshConnectionStats();
+            refreshDeviceStats();
+            refreshFolderStats();
+
+            $http.get(urlbase + '/version').success(function (data) {
+                $scope.version = data.version;
+            });
+
+            $http.get(urlbase + '/report').success(function (data) {
+                $scope.reportData = data;
+            });
+
+            $http.get(urlbase + '/upgrade').success(function (data) {
+                $scope.upgradeInfo = data;
+            }).error(function () {
+                $scope.upgradeInfo = null;
+            });
+
+            setInterval($scope.refresh, 10000);
+        }
+
+
+        // pubic/scope definitions
+
         $scope.completion = {};
         $scope.config = {};
         $scope.configInSync = true;
@@ -16,56 +47,24 @@ angular.module('syncthing.core')
         $scope.model = {};
         $scope.myID = '';
         $scope.devices = [];
+        $scope.deviceRejections = {};
+        $scope.folderRejections = {};
         $scope.protocolChanged = false;
         $scope.reportData = {};
         $scope.reportPreview = false;
         $scope.folders = {};
         $scope.seenError = '';
         $scope.upgradeInfo = null;
-        $scope.stats = {};
+        $scope.deviceStats = {};
+        $scope.folderStats = {};
         $scope.progress = {};
 
-        $http.get(urlbase + "/lang").success(function (langs) {
-            // Find the first language in the list provided by the user's browser
-            // that is a prefix of a language we have available. That is, "en"
-            // sent by the browser will match "en" or "en-US", while "zh-TW" will
-            // match only "zh-TW" and not "zh-CN".
-
-            var lang, matching;
-            for (var i = 0; i < langs.length; i++) {
-                lang = langs[i];
-                if (lang.length < 2) {
-                    continue;
-                }
-                matching = validLangs.filter(function (possibleLang) {
-                    // The langs returned by the /rest/langs call will be in lower
-                    // case. We compare to the lowercase version of the language
-                    // code we have as well.
-                    possibleLang = possibleLang.toLowerCase();
-                    if (possibleLang.length > lang.length) {
-                        return possibleLang.indexOf(lang) === 0;
-                    } else {
-                        return lang.indexOf(possibleLang) === 0;
-                    }
-                });
-                if (matching.length >= 1) {
-                    $translate.use(matching[0]);
-                    return;
-                }
-            }
-            // Fallback if nothing matched
-            $translate.use("en");
-        });
-
         $(window).bind('beforeunload', function () {
             navigatingAway = true;
         });
 
         $scope.$on("$locationChangeSuccess", function () {
-            var lang = $location.search().lang;
-            if (lang) {
-                $translate.use(lang);
-            }
+            LocaleService.useLocale($location.search().lang);
         });
 
         $scope.needActions = {
@@ -87,7 +86,7 @@ angular.module('syncthing.core')
             }
 
             console.log('UIOnline');
-            $scope.init();
+            initController();
             online = true;
             restarting = false;
             $('#networkError').modal('hide');
@@ -117,6 +116,7 @@ angular.module('syncthing.core')
         $scope.$on('LocalIndexUpdated', function (event, arg) {
             var data = arg.data;
             refreshFolder(data.folder);
+            refreshFolderStats();
 
             // Update completion status for all devices that we share this folder with.
             $scope.folders[data.folder].Devices.forEach(function (deviceCfg) {
@@ -170,6 +170,14 @@ angular.module('syncthing.core')
             }
         });
 
+        $scope.$on('DeviceRejected', function (event, arg) {
+            $scope.deviceRejections[arg.data.device] = arg;
+        });
+
+        $scope.$on('FolderRejected', function (event, arg) {
+            $scope.folderRejections[arg.data.folder + "-" + arg.data.device] = arg;
+        });
+
         $scope.$on('ConfigSaved', function (event, arg) {
             updateLocalConfig(arg.data);
 
@@ -181,40 +189,39 @@ angular.module('syncthing.core')
         $scope.$on('DownloadProgress', function (event, arg) {
             var stats = arg.data;
             var progress = {};
-            for(var folder in stats){
+            for (var folder in stats) {
                 refreshFolder(folder);
                 progress[folder] = {};
-                for(var file in stats[folder]){
+                for (var file in stats[folder]) {
                     var s = stats[folder][file];
-                    var reused = Math.floor(100 * s.Reused / s.Total);
-                    var copiedFromOrigin = Math.floor(100 * s.CopiedFromOrigin / s.Total);
-                    var copiedFromElsewhere = Math.floor(100 * s.CopiedFromElsewhere / s.Total);
-                    var pulled = Math.floor(100 * s.Pulled / s.Total);
-                    var pulling = Math.floor(100 * s.Pulling / s.Total);
-                    // We can do the following, because if s.Pulling > 0, than reused + copied + pulled < 100 because off rounding them down.
-                    // We do this to show which files are currently being pulled
-                    if (s.Pulling && pulling == 0) {
+                    var reused = 100 * s.Reused / s.Total;
+                    var copiedFromOrigin = 100 * s.CopiedFromOrigin / s.Total;
+                    var copiedFromElsewhere = 100 * s.CopiedFromElsewhere / s.Total;
+                    var pulled = 100 * s.Pulled / s.Total;
+                    var pulling = 100 * s.Pulling / s.Total;
+                    // We try to round up pulling to atleast a percent so that it would be atleast a bit visible.
+                    if (pulling < 1 && pulled + copiedFromElsewhere + copiedFromOrigin + reused <= 99) {
                         pulling = 1;
                     }
                     progress[folder][file] = {
-                        Reused:              reused,
-                        CopiedFromOrigin:    copiedFromOrigin,
+                        Reused: reused,
+                        CopiedFromOrigin: copiedFromOrigin,
                         CopiedFromElsewhere: copiedFromElsewhere,
-                        Pulled:              pulled,
-                        Pulling:             pulling,
-                        BytesTotal:          s.BytesTotal,
-                        BytesDone:           s.BytesDone,
+                        Pulled: pulled,
+                        Pulling: pulling,
+                        BytesTotal: s.BytesTotal,
+                        BytesDone: s.BytesDone,
                     };
                 }
             }
-            for(var folder in $scope.progress){
+            for (var folder in $scope.progress) {
                 if (!(folder in progress)) {
                     refreshFolder(folder);
                     if ($scope.neededFolder == folder) {
                         refreshNeed(folder);
                     }
                 } else if ($scope.neededFolder == folder) {
-                    for(file in $scope.progress[folder]){
+                    for (file in $scope.progress[folder]) {
                         if (!(file in progress[folder])) {
                             refreshNeed(folder);
                             break;
@@ -273,7 +280,7 @@ 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;
+                $scope.announceServersTotal = data.extAnnounceOK ? Object.keys(data.extAnnounceOK).length : 0;
                 var failed = [];
                 for (var server in data.extAnnounceOK) {
                     if (!data.extAnnounceOK[server]) {
@@ -370,35 +377,26 @@ angular.module('syncthing.core')
 
         var refreshDeviceStats = debounce(function () {
             $http.get(urlbase + "/stats/device").success(function (data) {
-                $scope.stats = data;
-                for (var device in $scope.stats) {
-                    $scope.stats[device].LastSeen = new Date($scope.stats[device].LastSeen);
-                    $scope.stats[device].LastSeenDays = (new Date() - $scope.stats[device].LastSeen) / 1000 / 86400;
+                $scope.deviceStats = data;
+                for (var device in $scope.deviceStats) {
+                    $scope.deviceStats[device].LastSeen = new Date($scope.deviceStats[device].LastSeen);
+                    $scope.deviceStats[device].LastSeenDays = (new Date() - $scope.deviceStats[device].LastSeen) / 1000 / 86400;
                 }
                 console.log("refreshDeviceStats", data);
             });
         }, 500);
 
-        $scope.init = function () {
-            refreshSystem();
-            refreshConfig();
-            refreshConnectionStats();
-            refreshDeviceStats();
-
-            $http.get(urlbase + '/version').success(function (data) {
-                $scope.version = data.version;
+        var refreshFolderStats = debounce(function () {
+            $http.get(urlbase + "/stats/folder").success(function (data) {
+                $scope.folderStats = data;
+                for (var folder in $scope.folderStats) {
+                    if ($scope.folderStats[folder].LastFile) {
+                        $scope.folderStats[folder].LastFile.At = new Date($scope.folderStats[folder].LastFile.At);
+                    }
+                }
+                console.log("refreshfolderStats", data);
             });
-
-            $http.get(urlbase + '/report').success(function (data) {
-                $scope.reportData = data;
-            });
-
-            $http.get(urlbase + '/upgrade').success(function (data) {
-                $scope.upgradeInfo = data;
-            }).error(function () {
-                $scope.upgradeInfo = null;
-            });
-        };
+        }, 500);
 
         $scope.refresh = function () {
             refreshSystem();
@@ -610,7 +608,7 @@ angular.module('syncthing.core')
                 $scope.config.GUI = angular.copy($scope.tmpGUI);
 
                 ['ListenAddress', 'GlobalAnnServers'].forEach(function (key) {
-                   $scope.config.Options[key] = $scope.config.Options[key + "Str"].split(/[ ,]+/).map(function (x) {
+                    $scope.config.Options[key] = $scope.config.Options[key + "Str"].split(/[ ,]+/).map(function (x) {
                         return x.trim();
                     });
                 });
@@ -667,6 +665,12 @@ angular.module('syncthing.core')
             $scope.editingExisting = true;
             $scope.editingSelf = (deviceCfg.DeviceID == $scope.myID);
             $scope.currentDevice.AddressesStr = deviceCfg.Addresses.join(', ');
+            if (!$scope.editingSelf) {
+                $scope.currentDevice.selectedFolders = {};
+                $scope.deviceFolders($scope.currentDevice).forEach(function (folder) {
+                    $scope.currentDevice.selectedFolders[folder] = true;
+                });
+            }
             $scope.deviceEditor.$setPristine();
             $('#editDevice').modal();
         };
@@ -684,7 +688,8 @@ angular.module('syncthing.core')
                     $scope.currentDevice = {
                         AddressesStr: 'dynamic',
                         Compression: true,
-                        Introducer: false
+                        Introducer: false,
+                        selectedFolders: {}
                     };
                     $scope.editingExisting = false;
                     $scope.editingSelf = false;
@@ -703,6 +708,11 @@ angular.module('syncthing.core')
                 return n.DeviceID !== $scope.currentDevice.DeviceID;
             });
             $scope.config.Devices = $scope.devices;
+            // In case we later added the device manually, remove the ignoral
+            // record.
+            $scope.config.IgnoredDevices = $scope.config.IgnoredDevices.filter(function (id) {
+                return id !== $scope.currentDevice.DeviceID;
+            });
 
             for (var id in $scope.folders) {
                 $scope.folders[id].Devices = $scope.folders[id].Devices.filter(function (n) {
@@ -714,10 +724,24 @@ angular.module('syncthing.core')
         };
 
         $scope.saveDevice = function () {
-            var deviceCfg, done, i;
-
             $('#editDevice').modal('hide');
-            deviceCfg = $scope.currentDevice;
+            $scope.saveDeviceConfig($scope.currentDevice);
+        };
+
+        $scope.addNewDeviceID = function (device) {
+            var deviceCfg = {
+                DeviceID: device,
+                AddressesStr: 'dynamic',
+                Compression: true,
+                Introducer: false,
+                selectedFolders: {}
+            };
+            $scope.saveDeviceConfig(deviceCfg);
+            $scope.dismissDeviceRejection(device);
+        };
+
+        $scope.saveDeviceConfig = function (deviceCfg) {
+            var done, i;
             deviceCfg.Addresses = deviceCfg.AddressesStr.split(',').map(function (x) {
                 return x.trim();
             });
@@ -737,10 +761,49 @@ angular.module('syncthing.core')
 
             $scope.devices.sort(deviceCompare);
             $scope.config.Devices = $scope.devices;
+            // In case we are adding the device manually, remove the ignoral
+            // record.
+            $scope.config.IgnoredDevices = $scope.config.IgnoredDevices.filter(function (id) {
+                return id !== deviceCfg.DeviceID;
+            });
+
+            if (!$scope.editingSelf) {
+                for (var id in deviceCfg.selectedFolders) {
+                    if (deviceCfg.selectedFolders[id]) {
+                        var found = false;
+                        for (i = 0; i < $scope.folders[id].Devices.length; i++) {
+                            if ($scope.folders[id].Devices[i].DeviceID == deviceCfg.DeviceID) {
+                                found = true;
+                                break;
+                            }
+                        }
+
+                        if (!found) {
+                            $scope.folders[id].Devices.push({
+                                DeviceID: deviceCfg.DeviceID
+                            });
+                        }
+                    } else {
+                        $scope.folders[id].Devices = $scope.folders[id].Devices.filter(function (n) {
+                            return n.DeviceID != deviceCfg.DeviceID;
+                        });
+                    }
+                }
+            }
 
             $scope.saveConfig();
         };
 
+        $scope.dismissDeviceRejection = function (device) {
+            delete $scope.deviceRejections[device];
+        };
+
+        $scope.ignoreRejectedDevice = function (device) {
+            $scope.config.IgnoredDevices.push(device);
+            $scope.saveConfig();
+            $scope.dismissDeviceRejection(device);
+        };
+
         $scope.otherDevices = function () {
             return $scope.devices.filter(function (n) {
                 return n.DeviceID !== $scope.myID;
@@ -797,8 +860,8 @@ angular.module('syncthing.core')
             });
         });
 
-        $scope.editFolder = function (deviceCfg) {
-            $scope.currentFolder = angular.copy(deviceCfg);
+        $scope.editFolder = function (folderCfg) {
+            $scope.currentFolder = angular.copy(folderCfg);
             $scope.currentFolder.selectedDevices = {};
             $scope.currentFolder.Devices.forEach(function (n) {
                 $scope.currentFolder.selectedDevices[n.DeviceID] = true;
@@ -847,6 +910,34 @@ angular.module('syncthing.core')
             $('#editFolder').modal();
         };
 
+        $scope.addFolderAndShare = function (folder, device) {
+            $scope.dismissFolderRejection(folder, device);
+            $scope.currentFolder = {
+                ID: folder,
+                selectedDevices: {}
+            };
+            $scope.currentFolder.selectedDevices[device] = true;
+
+            $scope.currentFolder.RescanIntervalS = 60;
+            $scope.currentFolder.FileVersioningSelector = "none";
+            $scope.currentFolder.simpleKeep = 5;
+            $scope.currentFolder.staggeredMaxAge = 365;
+            $scope.currentFolder.staggeredCleanInterval = 3600;
+            $scope.currentFolder.staggeredVersionsPath = "";
+            $scope.editingExisting = false;
+            $scope.folderEditor.$setPristine();
+            $('#editFolder').modal();
+        };
+
+        $scope.shareFolderWithDevice = function (folder, device) {
+            $scope.folders[folder].Devices.push({
+                DeviceID: device
+            });
+            $scope.config.Folders = folderList($scope.folders);
+            $scope.saveConfig();
+            $scope.dismissFolderRejection(folder, device);
+        };
+
         $scope.saveFolder = function () {
             var folderCfg, done, i;
 
@@ -896,17 +987,33 @@ angular.module('syncthing.core')
             $scope.saveConfig();
         };
 
+        $scope.dismissFolderRejection = function (folder, device) {
+            delete $scope.folderRejections[folder + "-" + device];
+        };
+
+        $scope.sharesFolder = function (folderCfg) {
+            var names = [];
+            folderCfg.Devices.forEach(function (device) {
+                if (device.DeviceID != $scope.myID) {
+                    names.push($scope.deviceName($scope.findDevice(device.DeviceID)));
+                }
+            });
+            names.sort();
+            return names.join(", ");
+        }
+
         $scope.deviceFolders = function (deviceCfg) {
             var folders = [];
             for (var folderID in $scope.folders) {
                 var devices = $scope.folders[folderID].Devices
                 for (var i = 0; i < devices.length; i++) {
                     if (devices[i].DeviceID == deviceCfg.DeviceID) {
-                        folders.push(folderID)
-                        break
+                        folders.push(folderID);
+                        break;
                     }
                 }
             };
+
             folders.sort();
             return folders;
         };
@@ -962,7 +1069,7 @@ angular.module('syncthing.core')
         };
 
         $scope.setAPIKey = function (cfg) {
-            cfg.APIKey = randomString(30, 32);
+            cfg.APIKey = randomString(32);
         };
 
         $scope.showURPreview = function () {
@@ -987,7 +1094,7 @@ angular.module('syncthing.core')
         $scope.showNeed = function (folder) {
             $scope.neededFolder = folder;
             refreshNeed(folder);
-            $('#needed').modal().on('hidden.bs.modal', function(){
+            $('#needed').modal().on('hidden.bs.modal', function () {
                 $scope.neededFolder = undefined;
                 $scope.needed = undefined;
             });
@@ -1024,6 +1131,15 @@ angular.module('syncthing.core')
             $http.post(urlbase + "/scan?folder=" + encodeURIComponent(folder));
         };
 
-        $scope.init();
-        setInterval($scope.refresh, 10000);
+        $scope.bumpFile = function (folder, file) {
+            $http.post(urlbase + "/bump?folder=" + encodeURIComponent(folder) + "&file=" + encodeURIComponent(file)).success(function (data) {
+                if ($scope.neededFolder == folder) {
+                    console.log("bumpFile", folder, data);
+                    $scope.needed = data;
+                }
+            });
+        };
+
+        // pseudo main. called on all definitions assigned
+        initController();
     });

gui/scripts/syncthing/core/services/localeService.js

@@ -0,0 +1,88 @@
+angular.module('syncthing.core')
+    .provider('LocaleService', function () {
+
+        var _defaultLocale,
+            _availableLocales;
+
+        this.setDefaultLocale = function (locale) {
+            _defaultLocale = locale;
+        };
+
+        this.setAvailableLocales = function (locales) {
+            _availableLocales = locales;
+        };
+
+        this.$get = ['$http', '$translate', '$location', function ($http, $translate, $location) {
+
+            /**
+             * Requests the server in order to get the browser's requested locale strings.
+             *
+             * @returns promise which on success resolves with a locales array
+             */
+            function readBrowserLocales() {
+                // @TODO: check if there is nice way to utilize window.navigator.languages or similiar api.
+
+                return $http.get(urlbase + "/lang");
+            }
+
+            function autoConfigLocale() {
+                var params = $location.search();
+
+                if(params.lang) {
+                    $translate.use(params.lang);
+                } else {
+                    readBrowserLocales().success(function (langs) {
+                        // Find the first language in the list provided by the user's browser
+                        // that is a prefix of a language we have available. That is, "en"
+                        // sent by the browser will match "en" or "en-US", while "zh-TW" will
+                        // match only "zh-TW" and not "zh-CN".
+
+                        var i,
+                            lang,
+                            matching,
+                            locale = _defaultLocale;
+
+                        for (i = 0; i < langs.length; i++) {
+                            lang = langs[i];
+
+                            if (lang.length < 2) {
+                                continue;
+                            }
+
+                            matching = _availableLocales.filter(function (possibleLang) {
+                                // The langs returned by the /rest/langs call will be in lower
+                                // case. We compare to the lowercase version of the language
+                                // code we have as well.
+                                possibleLang = possibleLang.toLowerCase();
+                                if (possibleLang.length > lang.length) {
+                                    return possibleLang.indexOf(lang) === 0;
+                                } else {
+                                    return lang.indexOf(possibleLang) === 0;
+                                }
+                            });
+
+                            if (matching.length >= 1) {
+                                locale = matching[0];
+                                break;
+                            }
+                        }
+                        // Fallback if nothing matched
+                        $translate.use(locale);
+                    });
+                }
+            }
+
+            function useLocale(language) {
+                // @TODO: eventually check for valid locale format
+                if (language) {
+                    $translate.use(language);
+                }
+            }
+
+            return {
+                autoConfigLocale: autoConfigLocale,
+                useLocale: useLocale
+            }
+        }];
+
+    });

internal/config/config.go

@@ -20,6 +20,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -34,15 +35,16 @@ import (
 
 var l = logger.DefaultLogger
 
-const CurrentVersion = 6
+const CurrentVersion = 7
 
 type Configuration struct {
-	Version int                   `xml:"version,attr"`
-	Folders []FolderConfiguration `xml:"folder"`
-	Devices []DeviceConfiguration `xml:"device"`
-	GUI     GUIConfiguration      `xml:"gui"`
-	Options OptionsConfiguration  `xml:"options"`
-	XMLName xml.Name              `xml:"configuration" json:"-"`
+	Version        int                   `xml:"version,attr"`
+	Folders        []FolderConfiguration `xml:"folder"`
+	Devices        []DeviceConfiguration `xml:"device"`
+	GUI            GUIConfiguration      `xml:"gui"`
+	Options        OptionsConfiguration  `xml:"options"`
+	IgnoredDevices []protocol.DeviceID   `xml:"ignoredDevice"`
+	XMLName        xml.Name              `xml:"configuration" json:"-"`
 
 	OriginalVersion         int                   `xml:"-" json:"-"` // The version we read from disk, before any conversion
 	Deprecated_Repositories []FolderConfiguration `xml:"repository" json:"-"`
@@ -92,13 +94,13 @@ func (f *FolderConfiguration) HasMarker() bool {
 	return true
 }
 
-func (r *FolderConfiguration) DeviceIDs() []protocol.DeviceID {
-	if r.deviceIDs == nil {
-		for _, n := range r.Devices {
-			r.deviceIDs = append(r.deviceIDs, n.DeviceID)
+func (f *FolderConfiguration) DeviceIDs() []protocol.DeviceID {
+	if f.deviceIDs == nil {
+		for _, n := range f.Devices {
+			f.deviceIDs = append(f.deviceIDs, n.DeviceID)
 		}
 	}
-	return r.deviceIDs
+	return f.deviceIDs
 }
 
 type VersioningConfiguration struct {
@@ -160,7 +162,7 @@ type FolderDeviceConfiguration struct {
 
 type OptionsConfiguration struct {
 	ListenAddress           []string `xml:"listenAddress" default:"0.0.0.0:22000"`
-	GlobalAnnServers        []string `xml:"globalAnnounceServer" default:"announce.syncthing.net:22026"`
+	GlobalAnnServers        []string `xml:"globalAnnounceServer" default:"udp4://announce.syncthing.net:22026"`
 	GlobalAnnEnabled        bool     `xml:"globalAnnounceEnabled" default:"true"`
 	LocalAnnEnabled         bool     `xml:"localAnnounceEnabled" default:"true"`
 	LocalAnnPort            int      `xml:"localAnnouncePort" default:"21025"`
@@ -179,6 +181,7 @@ type OptionsConfiguration struct {
 	KeepTemporariesH        int      `xml:"keepTemporariesH" default:"24"`     // 0 for off
 	CacheIgnoredFiles       bool     `xml:"cacheIgnoredFiles" default:"true"`
 	ProgressUpdateIntervalS int      `xml:"progressUpdateIntervalS" default:"5"`
+	SymlinksEnabled         bool     `xml:"symlinksEnabled" default:"true"`
 
 	Deprecated_RescanIntervalS int    `xml:"rescanIntervalS,omitempty" json:"-"`
 	Deprecated_UREnabled       bool   `xml:"urEnabled,omitempty" json:"-"`
@@ -239,10 +242,13 @@ func (cfg *Configuration) WriteXML(w io.Writer) error {
 func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 	fillNilSlices(&cfg.Options)
 
-	// Initialize an empty slice for folders if the config has none
+	// Initialize an empty slices
 	if cfg.Folders == nil {
 		cfg.Folders = []FolderConfiguration{}
 	}
+	if cfg.IgnoredDevices == nil {
+		cfg.IgnoredDevices = []protocol.DeviceID{}
+	}
 
 	// Check for missing, bad or duplicate folder ID:s
 	var seenFolders = map[string]*FolderConfiguration{}
@@ -307,6 +313,11 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 		convertV5V6(cfg)
 	}
 
+	// Upgrade to v7 configuration if appropriate
+	if cfg.Version == 6 {
+		convertV6V7(cfg)
+	}
+
 	// Hash old cleartext passwords
 	if len(cfg.GUI.Password) > 0 && cfg.GUI.Password[0] != '$' {
 		hash, err := bcrypt.GenerateFromPassword([]byte(cfg.GUI.Password), 0)
@@ -363,6 +374,10 @@ func (cfg *Configuration) prepare(myID protocol.DeviceID) {
 
 	cfg.Options.ListenAddress = uniqueStrings(cfg.Options.ListenAddress)
 	cfg.Options.GlobalAnnServers = uniqueStrings(cfg.Options.GlobalAnnServers)
+
+	if cfg.GUI.APIKey == "" {
+		cfg.GUI.APIKey = randomString(32)
+	}
 }
 
 // ChangeRequiresRestart returns true if updating the configuration requires a
@@ -396,6 +411,15 @@ func ChangeRequiresRestart(from, to Configuration) bool {
 	return false
 }
 
+func convertV6V7(cfg *Configuration) {
+	// Migrate announce server addresses to the new URL based format
+	for i := range cfg.Options.GlobalAnnServers {
+		cfg.Options.GlobalAnnServers[i] = "udp4://" + cfg.Options.GlobalAnnServers[i]
+	}
+
+	cfg.Version = 7
+}
+
 func convertV5V6(cfg *Configuration) {
 	// Added ".stfolder" file at folder roots to identify mount issues
 	// Doesn't affect the config itself, but uses config migrations to identify
@@ -659,3 +683,16 @@ func (l FolderDeviceConfigurationList) Swap(a, b int) {
 func (l FolderDeviceConfigurationList) Len() int {
 	return len(l)
 }
+
+// randomCharset contains the characters that can make up a randomString().
+const randomCharset = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-"
+
+// randomString returns a string of random characters (taken from
+// randomCharset) of the specified length.
+func randomString(l int) string {
+	bs := make([]byte, l)
+	for i := range bs {
+		bs[i] = randomCharset[rand.Intn(len(randomCharset))]
+	}
+	return string(bs)
+}

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"},
-		GlobalAnnServers:        []string{"announce.syncthing.net:22026"},
+		GlobalAnnServers:        []string{"udp4://announce.syncthing.net:22026"},
 		GlobalAnnEnabled:        true,
 		LocalAnnEnabled:         true,
 		LocalAnnPort:            21025,
@@ -53,6 +53,7 @@ func TestDefaultValues(t *testing.T) {
 		KeepTemporariesH:        24,
 		CacheIgnoredFiles:       true,
 		ProgressUpdateIntervalS: 5,
+		SymlinksEnabled:         true,
 	}
 
 	cfg := New(device1)
@@ -138,7 +139,7 @@ func TestNoListenAddress(t *testing.T) {
 func TestOverriddenValues(t *testing.T) {
 	expected := OptionsConfiguration{
 		ListenAddress:           []string{":23000"},
-		GlobalAnnServers:        []string{"syncthing.nym.se:22026"},
+		GlobalAnnServers:        []string{"udp4://syncthing.nym.se:22026"},
 		GlobalAnnEnabled:        false,
 		LocalAnnEnabled:         false,
 		LocalAnnPort:            42123,
@@ -155,6 +156,7 @@ func TestOverriddenValues(t *testing.T) {
 		KeepTemporariesH:        48,
 		CacheIgnoredFiles:       false,
 		ProgressUpdateIntervalS: 10,
+		SymlinksEnabled:         false,
 	}
 
 	cfg, err := Load("testdata/overridenvalues.xml", device1)

internal/config/testdata/overridenvalues.xml

@@ -20,5 +20,6 @@
         <keepTemporariesH>48</keepTemporariesH>
         <cacheIgnoredFiles>false</cacheIgnoredFiles>
         <progressUpdateIntervalS>10</progressUpdateIntervalS>
+        <symlinksEnabled>false</symlinksEnabled>
     </options>
 </configuration>

internal/config/testdata/v7.xml

@@ -0,0 +1,12 @@
+<configuration version="7">
+    <folder id="test" path="testdata/" ro="true" ignorePerms="false" rescanIntervalS="600">
+        <device id="AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR"></device>
+        <device id="P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2"></device>
+    </folder>
+    <device id="AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR" name="node one" compression="true">
+        <address>a</address>
+    </device>
+    <device id="P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2" name="node two" compression="true">
+        <address>b</address>
+    </device>
+</configuration>

internal/config/wrapper.go

@@ -42,7 +42,7 @@ func (fn HandlerFunc) Changed(cfg Configuration) error {
 // A wrapper around a Configuration that manages loads, saves and published
 // notifications of changes to registered Handlers
 
-type ConfigWrapper struct {
+type Wrapper struct {
 	cfg  Configuration
 	path string
 
@@ -57,8 +57,8 @@ type ConfigWrapper struct {
 
 // Wrap wraps an existing Configuration structure and ties it to a file on
 // disk.
-func Wrap(path string, cfg Configuration) *ConfigWrapper {
-	w := &ConfigWrapper{cfg: cfg, path: path}
+func Wrap(path string, cfg Configuration) *Wrapper {
+	w := &Wrapper{cfg: cfg, path: path}
 	w.replaces = make(chan Configuration)
 	go w.Serve()
 	return w
@@ -66,7 +66,7 @@ func Wrap(path string, cfg Configuration) *ConfigWrapper {
 
 // Load loads an existing file on disk and returns a new configuration
 // wrapper.
-func Load(path string, myID protocol.DeviceID) (*ConfigWrapper, error) {
+func Load(path string, myID protocol.DeviceID) (*Wrapper, error) {
 	fd, err := os.Open(path)
 	if err != nil {
 		return nil, err
@@ -84,7 +84,7 @@ func Load(path string, myID protocol.DeviceID) (*ConfigWrapper, error) {
 // Serve handles configuration replace events and calls any interested
 // handlers. It is started automatically by Wrap() and Load() and should not
 // be run manually.
-func (w *ConfigWrapper) Serve() {
+func (w *Wrapper) Serve() {
 	for cfg := range w.replaces {
 		w.sMut.Lock()
 		subs := w.subs
@@ -97,25 +97,25 @@ func (w *ConfigWrapper) Serve() {
 
 // Stop stops the Serve() loop. Set and Replace operations will panic after a
 // Stop.
-func (w *ConfigWrapper) Stop() {
+func (w *Wrapper) Stop() {
 	close(w.replaces)
 }
 
 // Subscribe registers the given handler to be called on any future
 // configuration changes.
-func (w *ConfigWrapper) Subscribe(h Handler) {
+func (w *Wrapper) Subscribe(h Handler) {
 	w.sMut.Lock()
 	w.subs = append(w.subs, h)
 	w.sMut.Unlock()
 }
 
 // Raw returns the currently wrapped Configuration object.
-func (w *ConfigWrapper) Raw() Configuration {
+func (w *Wrapper) Raw() Configuration {
 	return w.cfg
 }
 
 // Replace swaps the current configuration object for the given one.
-func (w *ConfigWrapper) Replace(cfg Configuration) {
+func (w *Wrapper) Replace(cfg Configuration) {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 
@@ -127,7 +127,7 @@ func (w *ConfigWrapper) Replace(cfg Configuration) {
 
 // Devices returns a map of devices. Device structures should not be changed,
 // other than for the purpose of updating via SetDevice().
-func (w *ConfigWrapper) Devices() map[protocol.DeviceID]DeviceConfiguration {
+func (w *Wrapper) Devices() map[protocol.DeviceID]DeviceConfiguration {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 	if w.deviceMap == nil {
@@ -141,7 +141,7 @@ func (w *ConfigWrapper) Devices() map[protocol.DeviceID]DeviceConfiguration {
 
 // SetDevice adds a new device to the configuration, or overwrites an existing
 // device with the same ID.
-func (w *ConfigWrapper) SetDevice(dev DeviceConfiguration) {
+func (w *Wrapper) SetDevice(dev DeviceConfiguration) {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 
@@ -161,7 +161,7 @@ func (w *ConfigWrapper) SetDevice(dev DeviceConfiguration) {
 
 // Devices returns a map of folders. Folder structures should not be changed,
 // other than for the purpose of updating via SetFolder().
-func (w *ConfigWrapper) Folders() map[string]FolderConfiguration {
+func (w *Wrapper) Folders() map[string]FolderConfiguration {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 	if w.folderMap == nil {
@@ -181,7 +181,7 @@ func (w *ConfigWrapper) Folders() map[string]FolderConfiguration {
 
 // SetFolder adds a new folder to the configuration, or overwrites an existing
 // folder with the same ID.
-func (w *ConfigWrapper) SetFolder(fld FolderConfiguration) {
+func (w *Wrapper) SetFolder(fld FolderConfiguration) {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 
@@ -200,14 +200,14 @@ func (w *ConfigWrapper) SetFolder(fld FolderConfiguration) {
 }
 
 // Options returns the current options configuration object.
-func (w *ConfigWrapper) Options() OptionsConfiguration {
+func (w *Wrapper) Options() OptionsConfiguration {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 	return w.cfg.Options
 }
 
 // SetOptions replaces the current options configuration object.
-func (w *ConfigWrapper) SetOptions(opts OptionsConfiguration) {
+func (w *Wrapper) SetOptions(opts OptionsConfiguration) {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 	w.cfg.Options = opts
@@ -215,14 +215,14 @@ func (w *ConfigWrapper) SetOptions(opts OptionsConfiguration) {
 }
 
 // GUI returns the current GUI configuration object.
-func (w *ConfigWrapper) GUI() GUIConfiguration {
+func (w *Wrapper) GUI() GUIConfiguration {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 	return w.cfg.GUI
 }
 
 // SetGUI replaces the current GUI configuration object.
-func (w *ConfigWrapper) SetGUI(gui GUIConfiguration) {
+func (w *Wrapper) SetGUI(gui GUIConfiguration) {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 	w.cfg.GUI = gui
@@ -230,7 +230,7 @@ func (w *ConfigWrapper) SetGUI(gui GUIConfiguration) {
 }
 
 // InvalidateFolder sets the invalid marker on the given folder.
-func (w *ConfigWrapper) InvalidateFolder(id string, err string) {
+func (w *Wrapper) InvalidateFolder(id string, err string) {
 	w.mut.Lock()
 	defer w.mut.Unlock()
 
@@ -245,8 +245,21 @@ func (w *ConfigWrapper) InvalidateFolder(id string, err string) {
 	}
 }
 
+// Returns whether or not connection attempts from the given device should be
+// silently ignored.
+func (w *Wrapper) IgnoredDevice(id protocol.DeviceID) bool {
+	w.mut.Lock()
+	defer w.mut.Unlock()
+	for _, device := range w.cfg.IgnoredDevices {
+		if device == id {
+			return true
+		}
+	}
+	return false
+}
+
 // Save writes the configuration to disk, and generates a ConfigSaved event.
-func (w *ConfigWrapper) Save() error {
+func (w *Wrapper) Save() error {
 	fd, err := ioutil.TempFile(filepath.Dir(w.path), "cfg")
 	if err != nil {
 		return err

internal/discover/client.go

@@ -0,0 +1,59 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package discover
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/syncthing/syncthing/internal/protocol"
+)
+
+type Factory func(*url.URL, *Announce) (Client, error)
+
+var (
+	factories                      = make(map[string]Factory)
+	DefaultErrorRetryInternval     = 60 * time.Second
+	DefaultGlobalBroadcastInterval = 1800 * time.Second
+)
+
+func Register(proto string, factory Factory) {
+	factories[proto] = factory
+}
+
+func New(addr string, pkt *Announce) (Client, error) {
+	uri, err := url.Parse(addr)
+	if err != nil {
+		return nil, err
+	}
+	factory, ok := factories[uri.Scheme]
+	if !ok {
+		return nil, fmt.Errorf("Unsupported scheme: %s", uri.Scheme)
+	}
+	client, err := factory(uri, pkt)
+	if err != nil {
+		return nil, err
+	}
+	return client, nil
+}
+
+type Client interface {
+	Lookup(device protocol.DeviceID) []string
+	StatusOK() bool
+	Address() string
+	Stop()
+}

internal/discover/client_test.go

@@ -0,0 +1,227 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package discover
+
+import (
+	"fmt"
+	"net"
+	"sync"
+	"time"
+
+	"testing"
+
+	"github.com/syncthing/syncthing/internal/protocol"
+)
+
+var device protocol.DeviceID
+
+func init() {
+	device, _ = protocol.DeviceIDFromString("P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2")
+}
+
+func TestUDP4Success(t *testing.T) {
+	conn, err := net.ListenUDP("udp4", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	port := conn.LocalAddr().(*net.UDPAddr).Port
+
+	address := fmt.Sprintf("udp4://127.0.0.1:%d", port)
+	pkt := &Announce{
+		Magic: AnnouncementMagic,
+		This: Device{
+			device[:],
+			[]Address{{
+				IP:   net.IPv4(123, 123, 123, 123),
+				Port: 1234,
+			}},
+		},
+	}
+
+	client, err := New(address, pkt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	udpclient := client.(*UDPClient)
+	if udpclient.errorRetryInterval != DefaultErrorRetryInternval {
+		t.Fatal("Incorrect retry interval")
+	}
+
+	if udpclient.listenAddress.IP != nil || udpclient.listenAddress.Port != 0 {
+		t.Fatal("Wrong listen IP or port", udpclient.listenAddress)
+	}
+
+	if client.Address() != address {
+		t.Fatal("Incorrect address")
+	}
+
+	buf := make([]byte, 2048)
+
+	// First announcement
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Announcement verification
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 1100))
+	_, addr, err := conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Reply to it.
+	_, err = conn.WriteToUDP(pkt.MustMarshalXDR(), addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// We should get nothing else
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err == nil {
+		t.Fatal("Expected error")
+	}
+
+	// Status should be ok
+	if !client.StatusOK() {
+		t.Fatal("Wrong status")
+	}
+
+	// Do a lookup in a separate routine
+	addrs := []string{}
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		addrs = client.Lookup(device)
+		wg.Done()
+	}()
+
+	// Receive the lookup and reply
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, addr, err = conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	conn.WriteToUDP(pkt.MustMarshalXDR(), addr)
+
+	// Wait for the lookup to arrive, verify that the number of answers is correct
+	wg.Wait()
+
+	if len(addrs) != 1 || addrs[0] != "123.123.123.123:1234" {
+		t.Fatal("Wrong number of answers")
+	}
+
+	client.Stop()
+}
+
+func TestUDP4Failure(t *testing.T) {
+	conn, err := net.ListenUDP("udp4", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	port := conn.LocalAddr().(*net.UDPAddr).Port
+
+	address := fmt.Sprintf("udp4://127.0.0.1:%d/?listenaddress=127.0.0.1&retry=5", port)
+
+	pkt := &Announce{
+		Magic: AnnouncementMagic,
+		This: Device{
+			device[:],
+			[]Address{{
+				IP:   net.IPv4(123, 123, 123, 123),
+				Port: 1234,
+			}},
+		},
+	}
+
+	client, err := New(address, pkt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	udpclient := client.(*UDPClient)
+	if udpclient.errorRetryInterval != time.Second*5 {
+		t.Fatal("Incorrect retry interval")
+	}
+
+	if !udpclient.listenAddress.IP.Equal(net.IPv4(127, 0, 0, 1)) || udpclient.listenAddress.Port != 0 {
+		t.Fatal("Wrong listen IP or port", udpclient.listenAddress)
+	}
+
+	if client.Address() != address {
+		t.Fatal("Incorrect address")
+	}
+
+	buf := make([]byte, 2048)
+
+	// First announcement
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Announcement verification
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 1100))
+	_, _, err = conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Don't reply
+	// We should get nothing else
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, err = conn.Read(buf)
+	if err == nil {
+		t.Fatal("Expected error")
+	}
+
+	// Status should be failure
+	if client.StatusOK() {
+		t.Fatal("Wrong status")
+	}
+
+	// Do a lookup in a separate routine
+	addrs := []string{}
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		addrs = client.Lookup(device)
+		wg.Done()
+	}()
+
+	// Receive the lookup and don't reply
+	conn.SetDeadline(time.Now().Add(time.Millisecond * 100))
+	_, _, err = conn.ReadFromUDP(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Wait for the lookup to timeout, verify that the number of answers is none
+	wg.Wait()
+
+	if len(addrs) != 0 {
+		t.Fatal("Wrong number of answers")
+	}
+
+	client.Stop()
+}

internal/discover/client_udp.go

@@ -0,0 +1,246 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package discover
+
+import (
+	"encoding/hex"
+	"io"
+	"net"
+	"net/url"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/syncthing/syncthing/internal/protocol"
+)
+
+func init() {
+	for _, proto := range []string{"udp", "udp4", "udp6"} {
+		Register(proto, func(uri *url.URL, pkt *Announce) (Client, error) {
+			c := &UDPClient{}
+			err := c.Start(uri, pkt)
+			if err != nil {
+				return nil, err
+			}
+			return c, nil
+		})
+	}
+}
+
+type UDPClient struct {
+	url *url.URL
+
+	id protocol.DeviceID
+
+	stop          chan struct{}
+	wg            sync.WaitGroup
+	listenAddress *net.UDPAddr
+
+	globalBroadcastInterval time.Duration
+	errorRetryInterval      time.Duration
+
+	status bool
+	mut    sync.RWMutex
+}
+
+func (d *UDPClient) Start(uri *url.URL, pkt *Announce) error {
+	d.url = uri
+	d.id = protocol.DeviceIDFromBytes(pkt.This.ID)
+	d.stop = make(chan struct{})
+
+	params := uri.Query()
+	// The address must not have a port, as otherwise both announce and lookup
+	// sockets would try to bind to the same port.
+	addr, err := net.ResolveUDPAddr(d.url.Scheme, params.Get("listenaddress")+":0")
+	if err != nil {
+		return err
+	}
+	d.listenAddress = addr
+
+	broadcastSeconds, err := strconv.ParseUint(params.Get("broadcast"), 0, 0)
+	if err != nil {
+		d.globalBroadcastInterval = DefaultGlobalBroadcastInterval
+	} else {
+		d.globalBroadcastInterval = time.Duration(broadcastSeconds) * time.Second
+	}
+
+	retrySeconds, err := strconv.ParseUint(params.Get("retry"), 0, 0)
+	if err != nil {
+		d.errorRetryInterval = DefaultErrorRetryInternval
+	} else {
+		d.errorRetryInterval = time.Duration(retrySeconds) * time.Second
+	}
+
+	d.wg.Add(1)
+	go d.broadcast(pkt.MustMarshalXDR())
+	return nil
+}
+
+func (d *UDPClient) broadcast(pkt []byte) {
+	defer d.wg.Done()
+
+	conn, err := net.ListenUDP(d.url.Scheme, d.listenAddress)
+	for err != nil {
+		l.Warnf("Global UDP discovery (%s): %v; trying again in %v", d.url, err, d.errorRetryInterval)
+		select {
+		case <-d.stop:
+			return
+		case <-time.After(d.errorRetryInterval):
+		}
+		conn, err = net.ListenUDP(d.url.Scheme, d.listenAddress)
+	}
+	defer conn.Close()
+
+	remote, err := net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
+	for err != nil {
+		l.Warnf("Global UDP discovery (%s): %v; trying again in %v", d.url, err, d.errorRetryInterval)
+		select {
+		case <-d.stop:
+			return
+		case <-time.After(d.errorRetryInterval):
+		}
+		remote, err = net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
+	}
+
+	timer := time.NewTimer(0)
+	for {
+		select {
+		case <-d.stop:
+			return
+
+		case <-timer.C:
+			var ok bool
+
+			if debug {
+				l.Debugf("Global UDP discovery (%s): send announcement -> %v\n%s", d.url, remote, hex.Dump(pkt))
+			}
+
+			_, err := conn.WriteTo(pkt, remote)
+			if err != nil {
+				if debug {
+					l.Debugf("discover %s: warning: %s", d.url, err)
+				}
+				ok = false
+			} else {
+				// Verify that the announce server responds positively for our device ID
+
+				time.Sleep(1 * time.Second)
+
+				res := d.Lookup(d.id)
+				if debug {
+					l.Debugf("discover %s: external lookup check: %v", d.url, res)
+				}
+				ok = len(res) > 0
+			}
+
+			d.mut.Lock()
+			d.status = ok
+			d.mut.Unlock()
+
+			if ok {
+				timer.Reset(d.globalBroadcastInterval)
+			} else {
+				timer.Reset(d.errorRetryInterval)
+			}
+		}
+	}
+}
+
+func (d *UDPClient) Lookup(device protocol.DeviceID) []string {
+	extIP, err := net.ResolveUDPAddr(d.url.Scheme, d.url.Host)
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+		}
+		return nil
+	}
+
+	conn, err := net.DialUDP(d.url.Scheme, d.listenAddress, extIP)
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+		}
+		return nil
+	}
+	defer conn.Close()
+
+	err = conn.SetDeadline(time.Now().Add(5 * time.Second))
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+		}
+		return nil
+	}
+
+	buf := Query{QueryMagic, device[:]}.MustMarshalXDR()
+	_, err = conn.Write(buf)
+	if err != nil {
+		if debug {
+			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+		}
+		return nil
+	}
+
+	buf = make([]byte, 2048)
+	n, err := conn.Read(buf)
+	if err != nil {
+		if err, ok := err.(net.Error); ok && err.Timeout() {
+			// Expected if the server doesn't know about requested device ID
+			return nil
+		}
+		if debug {
+			l.Debugf("discover %s: %v; no external lookup", d.url, err)
+		}
+		return nil
+	}
+
+	if debug {
+		l.Debugf("discover %s: read external:\n%s", d.url, hex.Dump(buf[:n]))
+	}
+
+	var pkt Announce
+	err = pkt.UnmarshalXDR(buf[:n])
+	if err != nil && err != io.EOF {
+		if debug {
+			l.Debugln("discover %s:", d.url, err)
+		}
+		return nil
+	}
+
+	var addrs []string
+	for _, a := range pkt.This.Addresses {
+		deviceAddr := net.JoinHostPort(net.IP(a.IP).String(), strconv.Itoa(int(a.Port)))
+		addrs = append(addrs, deviceAddr)
+	}
+	return addrs
+}
+
+func (d *UDPClient) Stop() {
+	if d.stop != nil {
+		close(d.stop)
+		d.wg.Wait()
+	}
+}
+
+func (d *UDPClient) StatusOK() bool {
+	d.mut.RLock()
+	defer d.mut.RUnlock()
+	return d.status
+}
+
+func (d *UDPClient) Address() string {
+	return d.url.String()
+}

internal/discover/discover.go

@@ -31,25 +31,21 @@ import (
 )
 
 type Discoverer struct {
-	myID             protocol.DeviceID
-	listenAddrs      []string
-	localBcastIntv   time.Duration
-	localBcastStart  time.Time
-	globalBcastIntv  time.Duration
-	errorRetryIntv   time.Duration
-	cacheLifetime    time.Duration
-	broadcastBeacon  beacon.Interface
-	multicastBeacon  beacon.Interface
-	registry         map[protocol.DeviceID][]CacheEntry
-	registryLock     sync.RWMutex
-	extServers       []string
-	extPort          uint16
-	localBcastTick   <-chan time.Time
-	stopGlobal       chan struct{}
-	globalWG         sync.WaitGroup
-	forcedBcastTick  chan time.Time
-	extAnnounceOK    map[string]bool
-	extAnnounceOKmut sync.Mutex
+	myID            protocol.DeviceID
+	listenAddrs     []string
+	localBcastIntv  time.Duration
+	localBcastStart time.Time
+	cacheLifetime   time.Duration
+	broadcastBeacon beacon.Interface
+	multicastBeacon beacon.Interface
+	registry        map[protocol.DeviceID][]CacheEntry
+	registryLock    sync.RWMutex
+	extPort         uint16
+	localBcastTick  <-chan time.Time
+	forcedBcastTick chan time.Time
+
+	clients []Client
+	mut     sync.RWMutex
 }
 
 type CacheEntry struct {
@@ -63,14 +59,11 @@ var (
 
 func NewDiscoverer(id protocol.DeviceID, addresses []string) *Discoverer {
 	return &Discoverer{
-		myID:            id,
-		listenAddrs:     addresses,
-		localBcastIntv:  30 * time.Second,
-		globalBcastIntv: 1800 * time.Second,
-		errorRetryIntv:  60 * time.Second,
-		cacheLifetime:   5 * time.Minute,
-		registry:        make(map[protocol.DeviceID][]CacheEntry),
-		extAnnounceOK:   make(map[string]bool),
+		myID:           id,
+		listenAddrs:    addresses,
+		localBcastIntv: 30 * time.Second,
+		cacheLifetime:  5 * time.Minute,
+		registry:       make(map[protocol.DeviceID][]CacheEntry),
 	}
 }
 
@@ -112,38 +105,60 @@ func (d *Discoverer) StartLocal(localPort int, localMCAddr string) {
 }
 
 func (d *Discoverer) StartGlobal(servers []string, extPort uint16) {
-	// Wait for any previous announcer to stop before starting a new one.
-	d.globalWG.Wait()
-	d.extServers = servers
+	d.mut.Lock()
+	defer d.mut.Unlock()
+
+	if len(d.clients) > 0 {
+		d.stopGlobal()
+	}
+
 	d.extPort = extPort
-	d.stopGlobal = make(chan struct{})
-	d.globalWG.Add(1)
-	go func() {
-		defer d.globalWG.Done()
+	pkt := d.announcementPkt()
+	wg := sync.WaitGroup{}
+	clients := make(chan Client, len(servers))
+	for _, address := range servers {
+		wg.Add(1)
+		go func(addr string) {
+			defer wg.Done()
+			client, err := New(addr, pkt)
+			if err != nil {
+				l.Infoln("Error creating discovery client", addr, err)
+				return
+			}
+			clients <- client
+		}(address)
+	}
 
-		buf := d.announcementPkt()
+	wg.Wait()
+	close(clients)
 
-		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() {
-	if d.stopGlobal != nil {
-		close(d.stopGlobal)
-		d.globalWG.Wait()
+	for client := range clients {
+		d.clients = append(d.clients, client)
 	}
 }
 
+func (d *Discoverer) StopGlobal() {
+	d.mut.Lock()
+	defer d.mut.Unlock()
+	d.stopGlobal()
+}
+
+func (d *Discoverer) stopGlobal() {
+	for _, client := range d.clients {
+		client.Stop()
+	}
+	d.clients = []Client{}
+}
+
 func (d *Discoverer) ExtAnnounceOK() map[string]bool {
-	d.extAnnounceOKmut.Lock()
-	defer d.extAnnounceOKmut.Unlock()
-	return d.extAnnounceOK
+	d.mut.RLock()
+	defer d.mut.RUnlock()
+
+	ret := make(map[string]bool)
+	for _, client := range d.clients {
+		ret[client.Address()] = client.StatusOK()
+	}
+	return ret
 }
 
 func (d *Discoverer) Lookup(device protocol.DeviceID) []string {
@@ -151,22 +166,47 @@ func (d *Discoverer) Lookup(device protocol.DeviceID) []string {
 	cached := d.filterCached(d.registry[device])
 	d.registryLock.RUnlock()
 
+	d.mut.RLock()
+	defer d.mut.RUnlock()
+
+	var addrs []string
 	if len(cached) > 0 {
-		addrs := make([]string, len(cached))
+		addrs = make([]string, len(cached))
 		for i := range cached {
 			addrs[i] = cached[i].Address
 		}
-		return addrs
-	} else if len(d.extServers) != 0 && time.Since(d.localBcastStart) > d.localBcastIntv {
+	} else if len(d.clients) != 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.
-		addrs := d.externalLookup(device)
-		cached = make([]CacheEntry, len(addrs))
-		for i := range addrs {
-			cached[i] = CacheEntry{
-				Address: addrs[i],
-				Seen:    time.Now(),
+		// server client and one local announcement interval has passed. This is
+		// to avoid finding local peers on their remote address at startup.
+		results := make(chan []string, len(d.clients))
+		wg := sync.WaitGroup{}
+		for _, client := range d.clients {
+			wg.Add(1)
+			go func(c Client) {
+				defer wg.Done()
+				results <- c.Lookup(device)
+			}(client)
+		}
+
+		wg.Wait()
+		close(results)
+
+		cached := []CacheEntry{}
+		seen := make(map[string]struct{})
+		now := time.Now()
+
+		for result := range results {
+			for _, addr := range result {
+				_, ok := seen[addr]
+				if !ok {
+					cached = append(cached, CacheEntry{
+						Address: addr,
+						Seen:    now,
+					})
+					seen[addr] = struct{}{}
+					addrs = append(addrs, addr)
+				}
 			}
 		}
 
@@ -174,7 +214,7 @@ func (d *Discoverer) Lookup(device protocol.DeviceID) []string {
 		d.registry[device] = cached
 		d.registryLock.Unlock()
 	}
-	return nil
+	return addrs
 }
 
 func (d *Discoverer) Hint(device string, addrs []string) {
@@ -199,7 +239,7 @@ func (d *Discoverer) All() map[protocol.DeviceID][]CacheEntry {
 	return devices
 }
 
-func (d *Discoverer) announcementPkt() []byte {
+func (d *Discoverer) announcementPkt() *Announce {
 	var addrs []Address
 	if d.extPort != 0 {
 		addrs = []Address{{Port: d.extPort}}
@@ -221,11 +261,10 @@ func (d *Discoverer) announcementPkt() []byte {
 			}
 		}
 	}
-	var pkt = Announce{
+	return &Announce{
 		Magic: AnnouncementMagic,
 		This:  Device{d.myID[:], addrs},
 	}
-	return pkt.MustMarshalXDR()
 }
 
 func (d *Discoverer) sendLocalAnnouncements() {
@@ -252,80 +291,6 @@ func (d *Discoverer) sendLocalAnnouncements() {
 	}
 }
 
-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)
-		select {
-		case <-d.stopGlobal:
-			return
-		case <-timer.C:
-		}
-		conn, err = net.ListenUDP("udp", nil)
-	}
-
-	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:
-		}
-		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.
-	timer.Reset(d.localBcastIntv)
-
-	for {
-		select {
-		case <-d.stopGlobal:
-			return
-
-		case <-timer.C:
-			var ok bool
-
-			if debug {
-				l.Debugf("discover: send announcement -> %v\n%s", remote, hex.Dump(buf))
-			}
-
-			_, err := conn.WriteTo(buf, remote)
-			if err != nil {
-				if debug {
-					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.externalLookupOnServer(extServer, d.myID)
-
-				if debug {
-					l.Debugln("discover:", extServer, "external lookup check:", res)
-				}
-				ok = len(res) > 0
-			}
-
-			d.extAnnounceOKmut.Lock()
-			d.extAnnounceOK[extServer] = ok
-			d.extAnnounceOKmut.Unlock()
-
-			if ok {
-				timer.Reset(d.globalBcastIntv)
-			} else {
-				timer.Reset(d.errorRetryIntv)
-			}
-		}
-	}
-}
-
 func (d *Discoverer) recvAnnouncements(b beacon.Interface) {
 	for {
 		buf, addr := b.Recv()
@@ -406,104 +371,6 @@ func (d *Discoverer) registerDevice(addr net.Addr, device Device) bool {
 	return len(current) > len(orig)
 }
 
-func (d *Discoverer) externalLookup(device protocol.DeviceID) []string {
-	// 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: %s: %v; no external lookup", extServer, err)
-		}
-		return nil
-	}
-
-	conn, err := net.DialUDP("udp", nil, extIP)
-	if err != nil {
-		if debug {
-			l.Debugf("discover: %s: %v; no external lookup", extServer, err)
-		}
-		return nil
-	}
-	defer conn.Close()
-
-	err = conn.SetDeadline(time.Now().Add(5 * time.Second))
-	if err != nil {
-		if debug {
-			l.Debugf("discover: %s: %v; no external lookup", extServer, err)
-		}
-		return nil
-	}
-
-	buf := Query{QueryMagic, device[:]}.MustMarshalXDR()
-	_, err = conn.Write(buf)
-	if err != nil {
-		if debug {
-			l.Debugf("discover: %s: %v; no external lookup", extServer, err)
-		}
-		return nil
-	}
-
-	buf = make([]byte, 2048)
-	n, err := conn.Read(buf)
-	if err != nil {
-		if err, ok := err.(net.Error); ok && err.Timeout() {
-			// Expected if the server doesn't know about requested device ID
-			return nil
-		}
-		if debug {
-			l.Debugf("discover: %s: %v; no external lookup", extServer, err)
-		}
-		return nil
-	}
-
-	if debug {
-		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:", extServer, err)
-		}
-		return nil
-	}
-
-	var addrs []string
-	for _, a := range pkt.This.Addresses {
-		deviceAddr := net.JoinHostPort(net.IP(a.IP).String(), strconv.Itoa(int(a.Port)))
-		addrs = append(addrs, deviceAddr)
-	}
-	return addrs
-}
-
 func (d *Discoverer) filterCached(c []CacheEntry) []CacheEntry {
 	for i := 0; i < len(c); {
 		if ago := time.Since(c[i].Seen); ago > d.cacheLifetime {

internal/discover/discover_test.go

@@ -13,6 +13,136 @@
 // You should have received a copy of the GNU General Public License along
 // with this program. If not, see <http://www.gnu.org/licenses/>.
 
-package discover_test
+package discover
 
-// Empty test file to generate 0% coverage rather than no coverage
+import (
+	"net/url"
+	"time"
+
+	"testing"
+
+	"github.com/syncthing/syncthing/internal/protocol"
+)
+
+type DummyClient struct {
+	url          *url.URL
+	lookups      []protocol.DeviceID
+	lookupRet    []string
+	stops        int
+	statusRet    bool
+	statusChecks int
+}
+
+func (c *DummyClient) Lookup(device protocol.DeviceID) []string {
+	c.lookups = append(c.lookups, device)
+	return c.lookupRet
+}
+
+func (c *DummyClient) StatusOK() bool {
+	c.statusChecks++
+	return c.statusRet
+}
+
+func (c *DummyClient) Stop() {
+	c.stops++
+}
+
+func (c *DummyClient) Address() string {
+	return c.url.String()
+}
+
+func TestGlobalDiscovery(t *testing.T) {
+	c1 := &DummyClient{
+		statusRet: false,
+		lookupRet: []string{"test.com:1234"},
+	}
+
+	c2 := &DummyClient{
+		statusRet: true,
+		lookupRet: []string{},
+	}
+
+	c3 := &DummyClient{
+		statusRet: true,
+		lookupRet: []string{"best.com:2345"},
+	}
+
+	clients := []*DummyClient{c1, c2}
+
+	Register("test1", func(uri *url.URL, pkt *Announce) (Client, error) {
+		c := clients[0]
+		clients = clients[1:]
+		c.url = uri
+		return c, nil
+	})
+
+	Register("test2", func(uri *url.URL, pkt *Announce) (Client, error) {
+		c3.url = uri
+		return c3, nil
+	})
+
+	d := NewDiscoverer(device, []string{})
+	d.localBcastStart = time.Time{}
+	servers := []string{
+		"test1://123.123.123.123:1234",
+		"test1://23.23.23.23:234",
+		"test2://234.234.234.234.2345",
+	}
+	d.StartGlobal(servers, 1234)
+
+	if len(d.clients) != 3 {
+		t.Fatal("Wrong number of clients")
+	}
+
+	status := d.ExtAnnounceOK()
+
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if status[c.url.String()] != c.statusRet || c.statusChecks != 1 {
+			t.Fatal("Wrong status")
+		}
+	}
+
+	addrs := d.Lookup(device)
+	if len(addrs) != 2 {
+		t.Fatal("Wrong numer of addresses", addrs)
+	}
+
+	for _, addr := range []string{"test.com:1234", "best.com:2345"} {
+		found := false
+		for _, laddr := range addrs {
+			if laddr == addr {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Fatal("Couldn't find", addr)
+		}
+	}
+
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if len(c.lookups) != 1 || c.lookups[0] != device {
+			t.Fatal("Wrong lookups")
+		}
+	}
+
+	addrs = d.Lookup(device)
+	if len(addrs) != 2 {
+		t.Fatal("Wrong numer of addresses", addrs)
+	}
+
+	// Answer should be cached, so number of lookups should have not incresed
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if len(c.lookups) != 1 || c.lookups[0] != device {
+			t.Fatal("Wrong lookups")
+		}
+	}
+
+	d.StopGlobal()
+
+	for _, c := range []*DummyClient{c1, c2, c3} {
+		if c.stops != 1 {
+			t.Fatal("Wrong number of stops")
+		}
+	}
+}

internal/discover/packets.go

@@ -13,6 +13,9 @@
 // You should have received a copy of the GNU General Public License along
 // with this program. If not, see <http://www.gnu.org/licenses/>.
 
+//go:generate -command genxdr go run ../../Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go
+//go:generate genxdr -o packets_xdr.go packets.go
+
 package discover
 
 const (

internal/events/events.go

@@ -86,7 +86,7 @@ const BufferSize = 64
 
 type Logger struct {
 	subs   map[int]*Subscription
-	nextId int
+	nextID int
 	mutex  sync.Mutex
 }
 
@@ -120,15 +120,15 @@ func NewLogger() *Logger {
 func (l *Logger) Log(t EventType, data interface{}) {
 	l.mutex.Lock()
 	if debug {
-		dl.Debugln("log", l.nextId, t.String(), data)
+		dl.Debugln("log", l.nextID, t.String(), data)
 	}
 	e := Event{
-		ID:   l.nextId,
+		ID:   l.nextID,
 		Time: time.Now(),
 		Type: t,
 		Data: data,
 	}
-	l.nextId++
+	l.nextID++
 	for _, s := range l.subs {
 		if s.mask&t != 0 {
 			select {
@@ -148,10 +148,10 @@ func (l *Logger) Subscribe(mask EventType) *Subscription {
 	}
 	s := &Subscription{
 		mask:   mask,
-		id:     l.nextId,
+		id:     l.nextID,
 		events: make(chan Event, BufferSize),
 	}
-	l.nextId++
+	l.nextID++
 	l.subs[s.id] = s
 	l.mutex.Unlock()
 	return s

internal/files/blockmap.go

@@ -126,7 +126,7 @@ type BlockFinder struct {
 	mut     sync.RWMutex
 }
 
-func NewBlockFinder(db *leveldb.DB, cfg *config.ConfigWrapper) *BlockFinder {
+func NewBlockFinder(db *leveldb.DB, cfg *config.Wrapper) *BlockFinder {
 	if blockFinder != nil {
 		return blockFinder
 	}

internal/files/concurrency_test.go

@@ -144,7 +144,7 @@ func TestConcurrentSetClear(t *testing.T) {
 	var wg sync.WaitGroup
 
 	os.RemoveAll("testdata/concurrent-set-clear.db")
-	db, err := leveldb.OpenFile("testdata/concurrent-set-clear.db", &opt.Options{CachedOpenFiles: 10})
+	db, err := leveldb.OpenFile("testdata/concurrent-set-clear.db", &opt.Options{OpenFilesCacheCapacity: 10})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -200,7 +200,7 @@ func TestConcurrentSetOnly(t *testing.T) {
 	var wg sync.WaitGroup
 
 	os.RemoveAll("testdata/concurrent-set-only.db")
-	db, err := leveldb.OpenFile("testdata/concurrent-set-only.db", &opt.Options{CachedOpenFiles: 10})
+	db, err := leveldb.OpenFile("testdata/concurrent-set-only.db", &opt.Options{OpenFilesCacheCapacity: 10})
 	if err != nil {
 		t.Fatal(err)
 	}

internal/files/leveldb.go

@@ -13,6 +13,9 @@
 // You should have received a copy of the GNU General Public License along
 // with this program. If not, see <http://www.gnu.org/licenses/>.
 
+//go:generate -command genxdr go run ../../Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go
+//go:generate genxdr -o leveldb_xdr.go leveldb.go
+
 package files
 
 import (

internal/fnmatch/fnmatch.go

@@ -55,6 +55,7 @@ func Convert(pattern string, flags int) (*regexp.Regexp, error) {
 		pattern = strings.Replace(pattern, "\\.", "[:escapeddot:]", -1)
 	}
 	pattern = strings.Replace(pattern, ".", "\\.", -1)
+	pattern = strings.Replace(pattern, "+", "\\+", -1)
 	pattern = strings.Replace(pattern, "**", "[:doublestar:]", -1)
 	pattern = strings.Replace(pattern, "*", any+"*", -1)
 	pattern = strings.Replace(pattern, "[:doublestar:]", ".*", -1)

internal/ignore/cache.go

@@ -0,0 +1,61 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package ignore
+
+import "time"
+
+type cache struct {
+	patterns []Pattern
+	entries  map[string]cacheEntry
+}
+
+type cacheEntry struct {
+	value  bool
+	access time.Time
+}
+
+func newCache(patterns []Pattern) *cache {
+	return &cache{
+		patterns: patterns,
+		entries:  make(map[string]cacheEntry),
+	}
+}
+
+func (c *cache) clean(d time.Duration) {
+	for k, v := range c.entries {
+		if time.Since(v.access) > d {
+			delete(c.entries, k)
+		}
+	}
+}
+
+func (c *cache) get(key string) (result, ok bool) {
+	res, ok := c.entries[key]
+	if ok {
+		res.access = time.Now()
+		c.entries[key] = res
+	}
+	return res.value, ok
+}
+
+func (c *cache) set(key string, val bool) {
+	c.entries[key] = cacheEntry{val, time.Now()}
+}
+
+func (c *cache) len() int {
+	l := len(c.entries)
+	return l
+}

internal/ignore/cache_test.go

@@ -0,0 +1,84 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package ignore
+
+import (
+	"testing"
+	"time"
+)
+
+func TestCache(t *testing.T) {
+	c := newCache(nil)
+
+	res, ok := c.get("nonexistent")
+	if res != false || ok != false {
+		t.Errorf("res %v, ok %v for nonexistent item", res, ok)
+	}
+
+	// Set and check some items
+
+	c.set("true", true)
+	c.set("false", false)
+
+	res, ok = c.get("true")
+	if res != true || ok != true {
+		t.Errorf("res %v, ok %v for true item", res, ok)
+	}
+
+	res, ok = c.get("false")
+	if res != false || ok != true {
+		t.Errorf("res %v, ok %v for false item", res, ok)
+	}
+
+	// Don't clean anything
+
+	c.clean(time.Second)
+
+	// Same values should exist
+
+	res, ok = c.get("true")
+	if res != true || ok != true {
+		t.Errorf("res %v, ok %v for true item", res, ok)
+	}
+
+	res, ok = c.get("false")
+	if res != false || ok != true {
+		t.Errorf("res %v, ok %v for false item", res, ok)
+	}
+
+	// Sleep and access, to get some data for clean
+
+	time.Sleep(100 * time.Millisecond)
+	c.get("true")
+	time.Sleep(100 * time.Millisecond)
+
+	// "false" was accessed 200 ms ago, "true" was accessed 100 ms ago.
+	// This should clean out "false" but not "true"
+
+	c.clean(150 * time.Millisecond)
+
+	// Same values should exist
+
+	_, ok = c.get("true")
+	if !ok {
+		t.Error("item should still exist")
+	}
+
+	_, ok = c.get("false")
+	if ok {
+		t.Errorf("item should have been cleaned")
+	}
+}

internal/ignore/ignore.go

@@ -17,6 +17,8 @@ package ignore
 
 import (
 	"bufio"
+	"bytes"
+	"crypto/md5"
 	"fmt"
 	"io"
 	"os"
@@ -24,114 +26,163 @@ import (
 	"regexp"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/syncthing/syncthing/internal/fnmatch"
 )
 
-var caches = make(map[string]MatcherCache)
-
 type Pattern struct {
 	match   *regexp.Regexp
 	include bool
 }
 
+func (p Pattern) String() string {
+	if p.include {
+		return p.match.String()
+	} else {
+		return "(?exclude)" + p.match.String()
+	}
+}
+
 type Matcher struct {
-	patterns   []Pattern
-	oldMatches map[string]bool
-
-	newMatches map[string]bool
-	mut        sync.Mutex
+	patterns  []Pattern
+	withCache bool
+	matches   *cache
+	curHash   string
+	stop      chan struct{}
+	mut       sync.Mutex
 }
 
-type MatcherCache struct {
-	patterns []Pattern
-	matches  *map[string]bool
+func New(withCache bool) *Matcher {
+	m := &Matcher{
+		withCache: withCache,
+		stop:      make(chan struct{}),
+	}
+	if withCache {
+		go m.clean(2 * time.Hour)
+	}
+	return m
 }
 
-func Load(file string, cache bool) (*Matcher, error) {
-	seen := make(map[string]bool)
-	matcher, err := loadIgnoreFile(file, seen)
-	if !cache || err != nil {
-		return matcher, err
-	}
+func (m *Matcher) Load(file string) error {
+	// No locking, Parse() does the locking
 
-	// Get the current cache object for the given file
-	cached, ok := caches[file]
-	if !ok || !patternsEqual(cached.patterns, matcher.patterns) {
-		// Nothing in cache or a cache mismatch, create a new cache which will
-		// store matches for the given set of patterns.
-		// Initialize oldMatches to indicate that we are interested in
-		// caching.
-		matcher.oldMatches = make(map[string]bool)
-		matcher.newMatches = make(map[string]bool)
-		caches[file] = MatcherCache{
-			patterns: matcher.patterns,
-			matches:  &matcher.newMatches,
-		}
-		return matcher, nil
+	fd, err := os.Open(file)
+	if err != nil {
+		// We do a parse with empty patterns to clear out the hash, cache etc.
+		m.Parse(&bytes.Buffer{}, file)
+		return err
 	}
+	defer fd.Close()
 
-	// Patterns haven't changed, so we can reuse the old matches, create a new
-	// matches map and update the pointer. (This prevents matches map from
-	// growing indefinately, as we only cache whatever we've matched in the last
-	// iteration, rather than through runtime history)
-	matcher.oldMatches = *cached.matches
-	matcher.newMatches = make(map[string]bool)
-	cached.matches = &matcher.newMatches
-	caches[file] = cached
-	return matcher, nil
+	return m.Parse(fd, file)
 }
 
-func Parse(r io.Reader, file string) (*Matcher, error) {
-	seen := map[string]bool{
-		file: true,
+func (m *Matcher) Parse(r io.Reader, file string) error {
+	m.mut.Lock()
+	defer m.mut.Unlock()
+
+	seen := map[string]bool{file: true}
+	patterns, err := parseIgnoreFile(r, file, seen)
+	// Error is saved and returned at the end. We process the patterns
+	// (possibly blank) anyway.
+
+	newHash := hashPatterns(patterns)
+	if newHash == m.curHash {
+		// We've already loaded exactly these patterns.
+		return err
 	}
-	return parseIgnoreFile(r, file, seen)
+
+	m.curHash = newHash
+	m.patterns = patterns
+	if m.withCache {
+		m.matches = newCache(patterns)
+	}
+
+	return err
 }
 
 func (m *Matcher) Match(file string) (result bool) {
+	m.mut.Lock()
+	defer m.mut.Unlock()
+
 	if len(m.patterns) == 0 {
 		return false
 	}
 
-	// We have old matches map set, means we should do caching
-	if m.oldMatches != nil {
-		// Capture the result to the new matches regardless of who returns it
-		defer func() {
-			m.mut.Lock()
-			m.newMatches[file] = result
-			m.mut.Unlock()
-		}()
-		// Check perhaps we've seen this file before, and we already know
-		// what the outcome is going to be.
-		result, ok := m.oldMatches[file]
+	if m.matches != nil {
+		// Check the cache for a known result.
+		res, ok := m.matches.get(file)
 		if ok {
-			return result
+			return res
 		}
+
+		// Update the cache with the result at return time
+		defer func() {
+			m.matches.set(file, result)
+		}()
 	}
 
+	// Check all the patterns for a match.
 	for _, pattern := range m.patterns {
 		if pattern.match.MatchString(file) {
 			return pattern.include
 		}
 	}
+
+	// Default to false.
 	return false
 }
 
 // Patterns return a list of the loaded regexp patterns, as strings
 func (m *Matcher) Patterns() []string {
+	m.mut.Lock()
+	defer m.mut.Unlock()
+
 	patterns := make([]string, len(m.patterns))
 	for i, pat := range m.patterns {
-		if pat.include {
-			patterns[i] = pat.match.String()
-		} else {
-			patterns[i] = "(?exclude)" + pat.match.String()
-		}
+		patterns[i] = pat.String()
 	}
 	return patterns
 }
 
-func loadIgnoreFile(file string, seen map[string]bool) (*Matcher, error) {
+func (m *Matcher) Hash() string {
+	m.mut.Lock()
+	defer m.mut.Unlock()
+	return m.curHash
+}
+
+func (m *Matcher) Stop() {
+	close(m.stop)
+}
+
+func (m *Matcher) clean(d time.Duration) {
+	t := time.NewTimer(d / 2)
+	for {
+		select {
+		case <-m.stop:
+			return
+		case <-t.C:
+			m.mut.Lock()
+			if m.matches != nil {
+				m.matches.clean(d)
+			}
+			t.Reset(d / 2)
+			m.mut.Unlock()
+		}
+	}
+}
+
+func hashPatterns(patterns []Pattern) string {
+	h := md5.New()
+	for _, pat := range patterns {
+		h.Write([]byte(pat.String()))
+		h.Write([]byte("\n"))
+	}
+	return fmt.Sprintf("%x", h.Sum(nil))
+}
+
+func loadIgnoreFile(file string, seen map[string]bool) ([]Pattern, error) {
 	if seen[file] {
 		return nil, fmt.Errorf("Multiple include of ignore file %q", file)
 	}
@@ -146,8 +197,8 @@ func loadIgnoreFile(file string, seen map[string]bool) (*Matcher, error) {
 	return parseIgnoreFile(fd, file, seen)
 }
 
-func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) (*Matcher, error) {
-	var exps Matcher
+func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) ([]Pattern, error) {
+	var patterns []Pattern
 
 	addPattern := func(line string) error {
 		include := true
@@ -162,28 +213,27 @@ func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) (*M
 			if err != nil {
 				return fmt.Errorf("Invalid pattern %q in ignore file", line)
 			}
-			exps.patterns = append(exps.patterns, Pattern{exp, include})
+			patterns = append(patterns, Pattern{exp, include})
 		} else if strings.HasPrefix(line, "**/") {
 			// Add the pattern as is, and without **/ so it matches in current dir
 			exp, err := fnmatch.Convert(line, fnmatch.FNM_PATHNAME)
 			if err != nil {
 				return fmt.Errorf("Invalid pattern %q in ignore file", line)
 			}
-			exps.patterns = append(exps.patterns, Pattern{exp, include})
+			patterns = append(patterns, Pattern{exp, include})
 
 			exp, err = fnmatch.Convert(line[3:], fnmatch.FNM_PATHNAME)
 			if err != nil {
 				return fmt.Errorf("Invalid pattern %q in ignore file", line)
 			}
-			exps.patterns = append(exps.patterns, Pattern{exp, include})
+			patterns = append(patterns, Pattern{exp, include})
 		} else if strings.HasPrefix(line, "#include ") {
 			includeFile := filepath.Join(filepath.Dir(currentFile), line[len("#include "):])
 			includes, err := loadIgnoreFile(includeFile, seen)
 			if err != nil {
 				return err
-			} else {
-				exps.patterns = append(exps.patterns, includes.patterns...)
 			}
+			patterns = append(patterns, includes...)
 		} else {
 			// Path name or pattern, add it so it matches files both in
 			// current directory and subdirs.
@@ -191,13 +241,13 @@ func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) (*M
 			if err != nil {
 				return fmt.Errorf("Invalid pattern %q in ignore file", line)
 			}
-			exps.patterns = append(exps.patterns, Pattern{exp, include})
+			patterns = append(patterns, Pattern{exp, include})
 
 			exp, err = fnmatch.Convert("**/"+line, fnmatch.FNM_PATHNAME)
 			if err != nil {
 				return fmt.Errorf("Invalid pattern %q in ignore file", line)
 			}
-			exps.patterns = append(exps.patterns, Pattern{exp, include})
+			patterns = append(patterns, Pattern{exp, include})
 		}
 		return nil
 	}
@@ -231,17 +281,5 @@ func parseIgnoreFile(fd io.Reader, currentFile string, seen map[string]bool) (*M
 		}
 	}
 
-	return &exps, nil
-}
-
-func patternsEqual(a, b []Pattern) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := range a {
-		if a[i].include != b[i].include || a[i].match.String() != b[i].match.String() {
-			return false
-		}
-	}
-	return true
+	return patterns, nil
 }

internal/ignore/ignore_test.go

@@ -25,7 +25,8 @@ import (
 )
 
 func TestIgnore(t *testing.T) {
-	pats, err := Load("testdata/.stignore", true)
+	pats := New(true)
+	err := pats.Load("testdata/.stignore")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -55,6 +56,8 @@ func TestIgnore(t *testing.T) {
 
 		{filepath.Join("dir3"), true},
 		{filepath.Join("dir3", "afile"), true},
+
+		{"lost+found", true},
 	}
 
 	for i, tc := range tests {
@@ -72,7 +75,8 @@ func TestExcludes(t *testing.T) {
 	i*2
 	!ign2
 	`
-	pats, err := Parse(bytes.NewBufferString(stignore), ".stignore")
+	pats := New(true)
+	err := pats.Parse(bytes.NewBufferString(stignore), ".stignore")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -112,15 +116,19 @@ func TestBadPatterns(t *testing.T) {
 	}
 
 	for _, pat := range badPatterns {
-		parsed, err := Parse(bytes.NewBufferString(pat), ".stignore")
+		err := New(true).Parse(bytes.NewBufferString(pat), ".stignore")
 		if err == nil {
-			t.Errorf("No error for pattern %q: %v", pat, parsed)
+			t.Errorf("No error for pattern %q", pat)
 		}
 	}
 }
 
 func TestCaseSensitivity(t *testing.T) {
-	ign, _ := Parse(bytes.NewBufferString("test"), ".stignore")
+	ign := New(true)
+	err := ign.Parse(bytes.NewBufferString("test"), ".stignore")
+	if err != nil {
+		t.Error(err)
+	}
 
 	match := []string{"test"}
 	dontMatch := []string{"foo"}
@@ -168,17 +176,14 @@ func TestCaching(t *testing.T) {
 
 	fd2.WriteString("/y/\n")
 
-	pats, err := Load(fd1.Name(), true)
+	pats := New(true)
+	err = pats.Load(fd1.Name())
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if pats.oldMatches == nil || len(pats.oldMatches) != 0 {
-		t.Fatal("Expected empty map")
-	}
-
-	if pats.newMatches == nil || len(pats.newMatches) != 0 {
-		t.Fatal("Expected empty map")
+	if pats.matches.len() != 0 {
+		t.Fatal("Expected empty cache")
 	}
 
 	if len(pats.patterns) != 4 {
@@ -191,50 +196,30 @@ func TestCaching(t *testing.T) {
 		pats.Match(letter)
 	}
 
-	if len(pats.newMatches) != 4 {
+	if pats.matches.len() != 4 {
 		t.Fatal("Expected 4 cached results")
 	}
 
-	// Reload file, expect old outcomes to be provided
+	// Reload file, expect old outcomes to be preserved
 
-	pats, err = Load(fd1.Name(), true)
+	err = pats.Load(fd1.Name())
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(pats.oldMatches) != 4 {
+	if pats.matches.len() != 4 {
 		t.Fatal("Expected 4 cached results")
 	}
 
-	// Match less this time
-
-	for _, letter := range []string{"b", "x", "y"} {
-		pats.Match(letter)
-	}
-
-	if len(pats.newMatches) != 3 {
-		t.Fatal("Expected 3 cached results")
-	}
-
-	// Reload file, expect the new outcomes to be provided
-
-	pats, err = Load(fd1.Name(), true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(pats.oldMatches) != 3 {
-		t.Fatal("Expected 3 cached results", len(pats.oldMatches))
-	}
-
 	// Modify the include file, expect empty cache
 
 	fd2.WriteString("/z/\n")
 
-	pats, err = Load(fd1.Name(), true)
+	err = pats.Load(fd1.Name())
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	if len(pats.oldMatches) != 0 {
+	if pats.matches.len() != 0 {
 		t.Fatal("Expected 0 cached results")
 	}
 
@@ -244,13 +229,13 @@ func TestCaching(t *testing.T) {
 		pats.Match(letter)
 	}
 
-	// Verify that outcomes provided on next laod
+	// Verify that outcomes preserved on next laod
 
-	pats, err = Load(fd1.Name(), true)
+	err = pats.Load(fd1.Name())
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(pats.oldMatches) != 3 {
+	if pats.matches.len() != 3 {
 		t.Fatal("Expected 3 cached results")
 	}
 
@@ -258,11 +243,11 @@ func TestCaching(t *testing.T) {
 
 	fd1.WriteString("/a/\n")
 
-	pats, err = Load(fd1.Name(), true)
+	err = pats.Load(fd1.Name())
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(pats.oldMatches) != 0 {
+	if pats.matches.len() != 0 {
 		t.Fatal("Expected cache invalidation")
 	}
 
@@ -274,11 +259,11 @@ func TestCaching(t *testing.T) {
 
 	// Verify that outcomes provided on next laod
 
-	pats, err = Load(fd1.Name(), true)
+	err = pats.Load(fd1.Name())
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(pats.oldMatches) != 3 {
+	if pats.matches.len() != 3 {
 		t.Fatal("Expected 3 cached results")
 	}
 }
@@ -295,7 +280,11 @@ func TestCommentsAndBlankLines(t *testing.T) {
 
 
 	`
-	pats, _ := Parse(bytes.NewBufferString(stignore), ".stignore")
+	pats := New(true)
+	err := pats.Parse(bytes.NewBufferString(stignore), ".stignore")
+	if err != nil {
+		t.Error(err)
+	}
 	if len(pats.patterns) > 0 {
 		t.Errorf("Expected no patterns")
 	}
@@ -319,7 +308,11 @@ flamingo
 *.crow
 *.crow
 	`
-	pats, _ := Parse(bytes.NewBufferString(stignore), ".stignore")
+	pats := New(false)
+	err := pats.Parse(bytes.NewBufferString(stignore), ".stignore")
+	if err != nil {
+		b.Error(err)
+	}
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -357,7 +350,8 @@ flamingo
 	}
 
 	// Load the patterns
-	pats, err := Load(fd.Name(), true)
+	pats := New(true)
+	err = pats.Load(fd.Name())
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -366,7 +360,7 @@ flamingo
 
 	// This load should now load the cached outcomes as the set of patterns
 	// has not changed.
-	pats, err = Load(fd.Name(), true)
+	err = pats.Load(fd.Name())
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -375,3 +369,152 @@ flamingo
 		result = pats.Match("filename")
 	}
 }
+
+func TestCacheReload(t *testing.T) {
+	fd, err := ioutil.TempFile("", "")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	defer fd.Close()
+	defer os.Remove(fd.Name())
+
+	// Ignore file matches f1 and f2
+
+	_, err = fd.WriteString("f1\nf2\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pats := New(true)
+	err = pats.Load(fd.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify that both are ignored
+
+	if !pats.Match("f1") {
+		t.Error("Unexpected non-match for f1")
+	}
+	if !pats.Match("f2") {
+		t.Error("Unexpected non-match for f2")
+	}
+	if pats.Match("f3") {
+		t.Error("Unexpected match for f3")
+	}
+
+	// Rewrite file to match f1 and f3
+
+	err = fd.Truncate(0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = fd.Seek(0, os.SEEK_SET)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = fd.WriteString("f1\nf3\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = pats.Load(fd.Name())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify that the new patterns are in effect
+
+	if !pats.Match("f1") {
+		t.Error("Unexpected non-match for f1")
+	}
+	if pats.Match("f2") {
+		t.Error("Unexpected match for f2")
+	}
+	if !pats.Match("f3") {
+		t.Error("Unexpected non-match for f3")
+	}
+}
+
+func TestHash(t *testing.T) {
+	p1 := New(true)
+	err := p1.Load("testdata/.stignore")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Same list of patterns as testdata/.stignore, after expansion
+	stignore := `
+	dir2/dfile
+	dir3
+	bfile
+	dir1/cfile
+	**/efile
+	/ffile
+	lost+found
+	`
+	p2 := New(true)
+	err = p2.Parse(bytes.NewBufferString(stignore), ".stignore")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Not same list of patterns
+	stignore = `
+	dir2/dfile
+	dir3
+	bfile
+	dir1/cfile
+	/ffile
+	lost+found
+	`
+	p3 := New(true)
+	err = p3.Parse(bytes.NewBufferString(stignore), ".stignore")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if p1.Hash() == "" {
+		t.Error("p1 hash blank")
+	}
+	if p2.Hash() == "" {
+		t.Error("p2 hash blank")
+	}
+	if p3.Hash() == "" {
+		t.Error("p3 hash blank")
+	}
+	if p1.Hash() != p2.Hash() {
+		t.Error("p1-p2 hashes differ")
+	}
+	if p1.Hash() == p3.Hash() {
+		t.Error("p1-p3 hashes same")
+	}
+}
+
+func TestHashOfEmpty(t *testing.T) {
+	p1 := New(true)
+	err := p1.Load("testdata/.stignore")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	firstHash := p1.Hash()
+
+	// Reloading with a non-existent file should empty the patterns and
+	// recalculate the hash. d41d8cd98f00b204e9800998ecf8427e is the md5 of
+	// nothing.
+
+	p1.Load("file/does/not/exist")
+	secondHash := p1.Hash()
+
+	if firstHash == secondHash {
+		t.Error("hash did not change")
+	}
+	if secondHash != "d41d8cd98f00b204e9800998ecf8427e" {
+		t.Error("second hash is not hash of empty string")
+	}
+	if len(p1.patterns) != 0 {
+		t.Error("there are more than zero patterns")
+	}
+}

internal/ignore/testdata/.stignore

@@ -4,3 +4,4 @@ bfile
 dir1/cfile
 **/efile
 /ffile
+lost+found

internal/model/deviceactivity.go

@@ -37,7 +37,7 @@ func newDeviceActivity() *deviceActivity {
 
 func (m *deviceActivity) leastBusy(availability []protocol.DeviceID) protocol.DeviceID {
 	m.mut.Lock()
-	var low int = 2<<30 - 1
+	low := 2<<30 - 1
 	var selected protocol.DeviceID
 	for _, device := range availability {
 		if usage := m.act[device]; usage < low {

internal/model/deviceactivity_test.go

@@ -22,9 +22,9 @@ import (
 )
 
 func TestDeviceActivity(t *testing.T) {
-	n0 := protocol.DeviceID{1, 2, 3, 4}
-	n1 := protocol.DeviceID{5, 6, 7, 8}
-	n2 := protocol.DeviceID{9, 10, 11, 12}
+	n0 := protocol.DeviceID([32]byte{1, 2, 3, 4})
+	n1 := protocol.DeviceID([32]byte{5, 6, 7, 8})
+	n2 := protocol.DeviceID([32]byte{9, 10, 11, 12})
 	devices := []protocol.DeviceID{n0, n1, n2}
 	na := newDeviceActivity()
 

internal/model/model.go

@@ -79,10 +79,12 @@ const (
 type service interface {
 	Serve()
 	Stop()
+	Jobs() ([]string, []string) // In progress, Queued
+	BringToFront(string)
 }
 
 type Model struct {
-	cfg             *config.ConfigWrapper
+	cfg             *config.Wrapper
 	db              *leveldb.DB
 	finder          *files.BlockFinder
 	progressEmitter *ProgressEmitter
@@ -98,6 +100,7 @@ type Model struct {
 	deviceStatRefs map[protocol.DeviceID]*stats.DeviceStatisticsReference // deviceID -> statsRef
 	folderIgnores  map[string]*ignore.Matcher                             // folder -> matcher object
 	folderRunners  map[string]service                                     // folder -> puller or scanner
+	folderStatRefs map[string]*stats.FolderStatisticsReference            // folder -> statsRef
 	fmut           sync.RWMutex                                           // protects the above
 
 	folderState        map[string]folderState // folder -> state
@@ -123,7 +126,7 @@ var (
 // NewModel creates and starts a new model. The model starts in read-only mode,
 // where it sends index information to connected peers and responds to requests
 // for file data without altering the local folder in any way.
-func NewModel(cfg *config.ConfigWrapper, deviceName, clientName, clientVersion string, db *leveldb.DB) *Model {
+func NewModel(cfg *config.Wrapper, deviceName, clientName, clientVersion string, db *leveldb.DB) *Model {
 	m := &Model{
 		cfg:                cfg,
 		db:                 db,
@@ -137,6 +140,7 @@ func NewModel(cfg *config.ConfigWrapper, deviceName, clientName, clientVersion s
 		deviceStatRefs:     make(map[protocol.DeviceID]*stats.DeviceStatisticsReference),
 		folderIgnores:      make(map[string]*ignore.Matcher),
 		folderRunners:      make(map[string]service),
+		folderStatRefs:     make(map[string]*stats.FolderStatisticsReference),
 		folderState:        make(map[string]folderState),
 		folderStateChanged: make(map[string]time.Time),
 		protoConn:          make(map[protocol.DeviceID]protocol.Connection),
@@ -187,6 +191,7 @@ func (m *Model) StartFolderRW(folder string) {
 		copiers:         cfg.Copiers,
 		pullers:         cfg.Pullers,
 		finishers:       cfg.Finishers,
+		queue:           newJobQueue(),
 	}
 	m.folderRunners[folder] = p
 	m.fmut.Unlock()
@@ -283,6 +288,15 @@ func (m *Model) DeviceStatistics() map[string]stats.DeviceStatistics {
 	return res
 }
 
+// Returns statistics about each folder
+func (m *Model) FolderStatistics() map[string]stats.FolderStatistics {
+	var res = make(map[string]stats.FolderStatistics)
+	for id := range m.cfg.Folders() {
+		res[id] = m.folderStatRef(id).GetStatistics()
+	}
+	return res
+}
+
 // Returns the completion status, in percent, for the given device and folder.
 func (m *Model) Completion(device protocol.DeviceID, folder string) float64 {
 	defer m.leveldbPanicWorkaround()
@@ -405,22 +419,50 @@ func (m *Model) NeedSize(folder string) (files int, bytes int64) {
 	return
 }
 
-// NeedFiles returns the list of currently needed files, stopping at maxFiles
-// files. Limit <= 0 is ignored.
-func (m *Model) NeedFolderFilesLimited(folder string, maxFiles int) []protocol.FileInfoTruncated {
+// NeedFiles returns the list of currently needed files in progress, queued,
+// and to be queued on next puller iteration. Also takes a soft cap which is
+// only respected when adding files from the model rather than the runner queue.
+func (m *Model) NeedFolderFiles(folder string, max int) ([]protocol.FileInfoTruncated, []protocol.FileInfoTruncated, []protocol.FileInfoTruncated) {
 	defer m.leveldbPanicWorkaround()
 
 	m.fmut.RLock()
 	defer m.fmut.RUnlock()
 	if rf, ok := m.folderFiles[folder]; ok {
-		fs := make([]protocol.FileInfoTruncated, 0, maxFiles)
-		rf.WithNeedTruncated(protocol.LocalDeviceID, func(f protocol.FileIntf) bool {
-			fs = append(fs, f.(protocol.FileInfoTruncated))
-			return maxFiles <= 0 || len(fs) < maxFiles
-		})
-		return fs
+		var progress, queued, rest []protocol.FileInfoTruncated
+		var seen map[string]bool
+
+		runner, ok := m.folderRunners[folder]
+		if ok {
+			progressNames, queuedNames := runner.Jobs()
+
+			progress = make([]protocol.FileInfoTruncated, len(progressNames))
+			queued = make([]protocol.FileInfoTruncated, len(queuedNames))
+			seen = make(map[string]bool, len(progressNames)+len(queuedNames))
+
+			for i, name := range progressNames {
+				progress[i] = rf.GetGlobal(name).ToTruncated() /// XXX: Should implement GetGlobalTruncated directly
+				seen[name] = true
+			}
+
+			for i, name := range queuedNames {
+				queued[i] = rf.GetGlobal(name).ToTruncated() /// XXX: Should implement GetGlobalTruncated directly
+				seen[name] = true
+			}
+		}
+		left := max - len(progress) - len(queued)
+		if max < 1 || left > 0 {
+			rf.WithNeedTruncated(protocol.LocalDeviceID, func(f protocol.FileIntf) bool {
+				left--
+				ft := f.(protocol.FileInfoTruncated)
+				if !seen[ft.Name] {
+					rest = append(rest, ft)
+				}
+				return max < 1 || left > 0
+			})
+		}
+		return progress, queued, rest
 	}
-	return nil
+	return nil, nil, nil
 }
 
 // Index is called when a new device is connected and we receive their full index.
@@ -435,13 +477,12 @@ func (m *Model) Index(deviceID protocol.DeviceID, folder string, fs []protocol.F
 			"folder": folder,
 			"device": deviceID.String(),
 		})
-		l.Warnf("Unexpected folder ID %q sent from device %q; ensure that the folder exists and that this device is selected under \"Share With\" in the folder configuration.", folder, deviceID)
+		l.Infof("Unexpected folder ID %q sent from device %q; ensure that the folder exists and that this device is selected under \"Share With\" in the folder configuration.", folder, deviceID)
 		return
 	}
 
 	m.fmut.RLock()
 	files, ok := m.folderFiles[folder]
-	ignores, _ := m.folderIgnores[folder]
 	m.fmut.RUnlock()
 
 	if !ok {
@@ -450,9 +491,9 @@ func (m *Model) Index(deviceID protocol.DeviceID, folder string, fs []protocol.F
 
 	for i := 0; i < len(fs); {
 		lamport.Default.Tick(fs[i].Version)
-		if (ignores != nil && ignores.Match(fs[i].Name)) || symlinkInvalid(fs[i].IsSymlink()) {
+		if symlinkInvalid(fs[i].IsSymlink()) {
 			if debug {
-				l.Debugln("dropping update for ignored/unsupported symlink", fs[i])
+				l.Debugln("dropping update for unsupported symlink", fs[i])
 			}
 			fs[i] = fs[len(fs)-1]
 			fs = fs[:len(fs)-1]
@@ -485,7 +526,6 @@ func (m *Model) IndexUpdate(deviceID protocol.DeviceID, folder string, fs []prot
 
 	m.fmut.RLock()
 	files, ok := m.folderFiles[folder]
-	ignores, _ := m.folderIgnores[folder]
 	m.fmut.RUnlock()
 
 	if !ok {
@@ -494,9 +534,9 @@ func (m *Model) IndexUpdate(deviceID protocol.DeviceID, folder string, fs []prot
 
 	for i := 0; i < len(fs); {
 		lamport.Default.Tick(fs[i].Version)
-		if (ignores != nil && ignores.Match(fs[i].Name)) || symlinkInvalid(fs[i].IsSymlink()) {
+		if symlinkInvalid(fs[i].IsSymlink()) {
 			if debug {
-				l.Debugln("dropping update for ignored/unsupported symlink", fs[i])
+				l.Debugln("dropping update for unsupported symlink", fs[i])
 			}
 			fs[i] = fs[len(fs)-1]
 			fs = fs[:len(fs)-1]
@@ -572,7 +612,7 @@ func (m *Model) ClusterConfig(deviceID protocol.DeviceID, cm protocol.ClusterCon
 					l.Infof("Adding device %v to config (vouched for by introducer %v)", id, deviceID)
 					newDeviceCfg := config.DeviceConfiguration{
 						DeviceID:    id,
-						Compression: true,
+						Compression: m.cfg.Devices()[deviceID].Compression,
 						Addresses:   []string{"dynamic"},
 					}
 
@@ -862,17 +902,33 @@ func (m *Model) deviceStatRef(deviceID protocol.DeviceID) *stats.DeviceStatistic
 
 	if sr, ok := m.deviceStatRefs[deviceID]; ok {
 		return sr
-	} else {
-		sr = stats.NewDeviceStatisticsReference(m.db, deviceID)
-		m.deviceStatRefs[deviceID] = sr
-		return sr
 	}
+
+	sr := stats.NewDeviceStatisticsReference(m.db, deviceID)
+	m.deviceStatRefs[deviceID] = sr
+	return sr
 }
 
 func (m *Model) deviceWasSeen(deviceID protocol.DeviceID) {
 	m.deviceStatRef(deviceID).WasSeen()
 }
 
+func (m *Model) folderStatRef(folder string) *stats.FolderStatisticsReference {
+	m.fmut.Lock()
+	defer m.fmut.Unlock()
+
+	sr, ok := m.folderStatRefs[folder]
+	if !ok {
+		sr = stats.NewFolderStatisticsReference(m.db, folder)
+		m.folderStatRefs[folder] = sr
+	}
+	return sr
+}
+
+func (m *Model) receivedFile(folder, filename string) {
+	m.folderStatRef(folder).ReceivedFile(filename)
+}
+
 func sendIndexes(conn protocol.Connection, folder string, fs *files.Set, ignores *ignore.Matcher) {
 	deviceID := conn.ID()
 	name := conn.Name()
@@ -1013,7 +1069,8 @@ func (m *Model) AddFolder(cfg config.FolderConfiguration) {
 		m.deviceFolders[device.DeviceID] = append(m.deviceFolders[device.DeviceID], cfg.ID)
 	}
 
-	ignores, _ := ignore.Load(filepath.Join(cfg.Path, ".stignore"), m.cfg.Options().CacheIgnoredFiles)
+	ignores := ignore.New(m.cfg.Options().CacheIgnoredFiles)
+	_ = ignores.Load(filepath.Join(cfg.Path, ".stignore")) // Ignore error, there might not be an .stignore
 	m.folderIgnores[cfg.ID] = ignores
 
 	m.addedFolder = true
@@ -1054,26 +1111,27 @@ func (m *Model) ScanFolderSub(folder, sub string) error {
 
 	m.fmut.Lock()
 	fs, ok := m.folderFiles[folder]
-	dir := m.folderCfgs[folder].Path
-
-	ignores, _ := ignore.Load(filepath.Join(dir, ".stignore"), m.cfg.Options().CacheIgnoredFiles)
-	m.folderIgnores[folder] = ignores
-
-	w := &scanner.Walker{
-		Dir:          dir,
-		Sub:          sub,
-		Matcher:      ignores,
-		BlockSize:    protocol.BlockSize,
-		TempNamer:    defTempNamer,
-		CurrentFiler: cFiler{m, folder},
-		IgnorePerms:  m.folderCfgs[folder].IgnorePerms,
-	}
+	folderCfg := m.folderCfgs[folder]
+	ignores := m.folderIgnores[folder]
 	m.fmut.Unlock()
 
 	if !ok {
 		return errors.New("no such folder")
 	}
 
+	_ = ignores.Load(filepath.Join(folderCfg.Path, ".stignore")) // Ignore error, there might not be an .stignore
+
+	w := &scanner.Walker{
+		Dir:          folderCfg.Path,
+		Sub:          sub,
+		Matcher:      ignores,
+		BlockSize:    protocol.BlockSize,
+		TempNamer:    defTempNamer,
+		TempLifetime: time.Duration(m.cfg.Options().KeepTemporariesH) * time.Hour,
+		CurrentFiler: cFiler{m, folder},
+		IgnorePerms:  folderCfg.IgnorePerms,
+	}
+
 	m.setState(folder, FolderScanning)
 	fchan, err := w.Walk()
 
@@ -1142,7 +1200,7 @@ func (m *Model) ScanFolderSub(folder, sub string) error {
 					"size":     f.Size(),
 				})
 				batch = append(batch, nf)
-			} else if _, err := os.Lstat(filepath.Join(dir, f.Name)); err != nil && os.IsNotExist(err) {
+			} else if _, err := os.Lstat(filepath.Join(folderCfg.Path, f.Name)); err != nil && os.IsNotExist(err) {
 				// File has been deleted
 				nf := protocol.FileInfo{
 					Name:     f.Name,
@@ -1309,9 +1367,9 @@ func (m *Model) RemoteLocalVersion(folder string) uint64 {
 	return ver
 }
 
-func (m *Model) availability(folder string, file string) []protocol.DeviceID {
+func (m *Model) availability(folder, file string) []protocol.DeviceID {
 	// Acquire this lock first, as the value returned from foldersFiles can
-	// gen heavily modified on Close()
+	// get heavily modified on Close()
 	m.pmut.RLock()
 	defer m.pmut.RUnlock()
 
@@ -1332,6 +1390,17 @@ func (m *Model) availability(folder string, file string) []protocol.DeviceID {
 	return availableDevices
 }
 
+// Bump the given files priority in the job queue
+func (m *Model) BringToFront(folder, file string) {
+	m.pmut.RLock()
+	defer m.pmut.RUnlock()
+
+	runner, ok := m.folderRunners[folder]
+	if ok {
+		runner.BringToFront(file)
+	}
+}
+
 func (m *Model) String() string {
 	return fmt.Sprintf("model@%p", m)
 }
@@ -1360,7 +1429,7 @@ func (m *Model) leveldbPanicWorkaround() {
 func symlinkInvalid(isLink bool) bool {
 	if !symlinks.Supported && isLink {
 		SymlinkWarning.Do(func() {
-			l.Warnln("Symlinks are unsupported as they require Administrator priviledges. This might cause your folder to appear out of sync.")
+			l.Warnln("Symlinks are disabled, unsupported or require Administrator priviledges. This might cause your folder to appear out of sync.")
 		})
 		return true
 	}

internal/model/progressemitter.go

@@ -1,3 +1,18 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
 package model
 
 import (
@@ -23,7 +38,7 @@ type ProgressEmitter struct {
 
 // Creates a new progress emitter which emits DownloadProgress events every
 // interval.
-func NewProgressEmitter(cfg *config.ConfigWrapper) *ProgressEmitter {
+func NewProgressEmitter(cfg *config.Wrapper) *ProgressEmitter {
 	t := &ProgressEmitter{
 		stop:     make(chan struct{}),
 		registry: make(map[string]*sharedPullerState),

internal/model/progressemitter_test.go

@@ -31,15 +31,15 @@ func expectEvent(w *events.Subscription, t *testing.T, size int) {
 		t.Fatal("Unexpected error:", err)
 	}
 	if event.Type != events.DownloadProgress {
-		t.Fatal("Unexpected event:", event)		
+		t.Fatal("Unexpected event:", event)
 	}
 	data := event.Data.(map[string]map[string]*pullerProgress)
 	if len(data) != size {
-		t.Fatal("Unexpected event data size:", data)				
+		t.Fatal("Unexpected event data size:", data)
 	}
 }
 
-func expectTimeout(w *events.Subscription, t *testing.T){
+func expectTimeout(w *events.Subscription, t *testing.T) {
 	_, err := w.Poll(timeout)
 	if err != events.ErrTimeout {
 		t.Fatal("Unexpected non-Timeout error:", err)
@@ -78,7 +78,7 @@ func TestProgressEmitter(t *testing.T) {
 	expectTimeout(w, t)
 
 	s.pullStarted()
-	
+
 	expectEvent(w, t, 1)
 	expectTimeout(w, t)
 

internal/model/puller.go

@@ -16,11 +16,10 @@
 package model
 
 import (
-	"bytes"
-	"crypto/sha256"
 	"errors"
 	"fmt"
 	"io/ioutil"
+	"math/rand"
 	"os"
 	"path/filepath"
 	"sync"
@@ -30,6 +29,7 @@ import (
 
 	"github.com/syncthing/syncthing/internal/config"
 	"github.com/syncthing/syncthing/internal/events"
+	"github.com/syncthing/syncthing/internal/ignore"
 	"github.com/syncthing/syncthing/internal/osutil"
 	"github.com/syncthing/syncthing/internal/protocol"
 	"github.com/syncthing/syncthing/internal/scanner"
@@ -77,6 +77,7 @@ type Puller struct {
 	copiers         int
 	pullers         int
 	finishers       int
+	queue           *jobQueue
 }
 
 // Serve will run scans and pulls. It will return when Stop()ed or on a
@@ -91,20 +92,16 @@ func (p *Puller) Serve() {
 
 	pullTimer := time.NewTimer(checkPullIntv)
 	scanTimer := time.NewTimer(time.Millisecond) // The first scan should be done immediately.
-	cleanTimer := time.NewTicker(time.Hour)
 
 	defer func() {
 		pullTimer.Stop()
 		scanTimer.Stop()
-		cleanTimer.Stop()
 		// TODO: Should there be an actual FolderStopped state?
 		p.model.setState(p.folder, FolderIdle)
 	}()
 
 	var prevVer uint64
-
-	// Clean out old temporaries before we start pulling
-	p.clean()
+	var prevIgnoreHash string
 
 	// We don't start pulling files until a scan has been completed.
 	initialScanCompleted := false
@@ -130,6 +127,20 @@ loop:
 				continue
 			}
 
+			p.model.fmut.RLock()
+			curIgnores := p.model.folderIgnores[p.folder]
+			p.model.fmut.RUnlock()
+
+			if newHash := curIgnores.Hash(); newHash != prevIgnoreHash {
+				// The ignore patterns have changed. We need to re-evaluate if
+				// there are files we need now that were ignored before.
+				if debug {
+					l.Debugln(p, "ignore patterns have changed, resetting prevVer")
+				}
+				prevVer = 0
+				prevIgnoreHash = newHash
+			}
+
 			// RemoteLocalVersion() is a fast call, doesn't touch the database.
 			curVer := p.model.RemoteLocalVersion(p.folder)
 			if curVer == prevVer {
@@ -145,16 +156,10 @@ loop:
 			}
 			p.model.setState(p.folder, FolderSyncing)
 			tries := 0
-			checksum := false
 			for {
 				tries++
-				// Last resort mode, to get around corrupt/invalid block maps.
-				if tries == 10 {
-					l.Infoln("Desperation mode ON")
-					checksum = true
-				}
 
-				changed := p.pullerIteration(checksum)
+				changed := p.pullerIteration(curIgnores)
 				if debug {
 					l.Debugln(p, "changed", changed)
 				}
@@ -172,7 +177,7 @@ loop:
 						// them, but at the same time we have the local
 						// version that includes those files in curVer. So we
 						// catch the case that localVersion might have
-						// decresed here.
+						// decreased here.
 						l.Debugln(p, "adjusting curVer", lv)
 						curVer = lv
 					}
@@ -213,19 +218,19 @@ loop:
 			}
 			p.model.setState(p.folder, FolderIdle)
 			if p.scanIntv > 0 {
+				// Sleep a random time between 3/4 and 5/4 of the configured interval.
+				sleepNanos := (p.scanIntv.Nanoseconds()*3 + rand.Int63n(2*p.scanIntv.Nanoseconds())) / 4
+				intv := time.Duration(sleepNanos) * time.Nanosecond
+
 				if debug {
-					l.Debugln(p, "next rescan in", p.scanIntv)
+					l.Debugln(p, "next rescan in", intv)
 				}
-				scanTimer.Reset(p.scanIntv)
+				scanTimer.Reset(intv)
 			}
 			if !initialScanCompleted {
 				l.Infoln("Completed initial scan (rw) of folder", p.folder)
 				initialScanCompleted = true
 			}
-
-		// Clean out old temporaries
-		case <-cleanTimer.C:
-			p.clean()
 		}
 	}
 }
@@ -242,7 +247,7 @@ func (p *Puller) String() string {
 // returns the number items that should have been synced (even those that
 // might have failed). One puller iteration handles all files currently
 // flagged as needed in the folder.
-func (p *Puller) pullerIteration(checksum bool) int {
+func (p *Puller) pullerIteration(ignores *ignore.Matcher) int {
 	pullChan := make(chan pullBlockState)
 	copyChan := make(chan copyBlocksState)
 	finisherChan := make(chan *sharedPullerState)
@@ -259,7 +264,7 @@ func (p *Puller) pullerIteration(checksum bool) int {
 		copyWg.Add(1)
 		go func() {
 			// copierRoutine finishes when copyChan is closed
-			p.copierRoutine(copyChan, pullChan, finisherChan, checksum)
+			p.copierRoutine(copyChan, pullChan, finisherChan)
 			copyWg.Done()
 		}()
 	}
@@ -307,6 +312,11 @@ func (p *Puller) pullerIteration(checksum bool) int {
 
 		file := intf.(protocol.FileInfo)
 
+		if ignores.Match(file.Name) {
+			// This is an ignored file. Skip it, continue iteration.
+			return true
+		}
+
 		events.Default.Log(events.ItemStarted, map[string]string{
 			"folder": p.folder,
 			"item":   file.Name,
@@ -325,15 +335,23 @@ func (p *Puller) pullerIteration(checksum bool) int {
 			p.handleDir(file)
 		default:
 			// A new or changed file or symlink. This is the only case where we
-			// do stuff in the background; the other three are done
-			// synchronously.
-			p.handleFile(file, copyChan, finisherChan)
+			// do stuff concurrently in the background
+			p.queue.Push(file.Name)
 		}
 
 		changed++
 		return true
 	})
 
+	for {
+		fileName, ok := p.queue.Pop()
+		if !ok {
+			break
+		}
+		f := p.model.CurrentGlobalFile(p.folder, fileName)
+		p.handleFile(f, copyChan, finisherChan)
+	}
+
 	// Signal copy and puller routines that we are done with the in data for
 	// this iteration. Wait for them to finish.
 	close(copyChan)
@@ -373,12 +391,11 @@ func (p *Puller) handleDir(file protocol.FileInfo) {
 	}
 
 	info, err := os.Lstat(realName)
-	isLink, _ := symlinks.IsSymlink(realName)
 	switch {
 	// There is already something under that name, but it's a file/link.
 	// Most likely a file/link is getting replaced with a directory.
 	// Remove the file/link and fall through to directory creation.
-	case isLink || (err == nil && !info.IsDir()):
+	case err == nil && (!info.IsDir() || info.Mode()&os.ModeSymlink != 0):
 		err = osutil.InWritableDir(os.Remove, realName)
 		if err != nil {
 			l.Infof("Puller (folder %q, dir %q): %v", p.folder, file.Name, err)
@@ -472,6 +489,7 @@ func (p *Puller) handleFile(file protocol.FileInfo, copyChan chan<- copyBlocksSt
 		if debug {
 			l.Debugln(p, "taking shortcut on", file.Name)
 		}
+		p.queue.Done(file.Name)
 		if file.IsSymlink() {
 			p.shortcutSymlink(curFile, file)
 		} else {
@@ -587,7 +605,7 @@ func (p *Puller) shortcutSymlink(curFile, file protocol.FileInfo) {
 
 // copierRoutine reads copierStates until the in channel closes and performs
 // the relevant copies when possible, or passes it to the puller routine.
-func (p *Puller) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pullBlockState, out chan<- *sharedPullerState, checksum bool) {
+func (p *Puller) copierRoutine(in <-chan copyBlocksState, pullChan chan<- pullBlockState, out chan<- *sharedPullerState) {
 	buf := make([]byte, protocol.BlockSize)
 
 nextFile:
@@ -623,7 +641,6 @@ nextFile:
 		}
 		p.model.fmut.RUnlock()
 
-		hasher := sha256.New()
 		for _, block := range state.blocks {
 			buf = buf[:int(block.Size)]
 			found := p.model.finder.Iterate(block.Hash, func(folder, file string, index uint32) bool {
@@ -647,12 +664,9 @@ nextFile:
 					return false
 				}
 
-				// Only done on second to last puller attempt
-				if checksum {
-					hasher.Write(buf)
-					hash := hasher.Sum(nil)
-					hasher.Reset()
-					if !bytes.Equal(hash, block.Hash) {
+				hash, err := scanner.VerifyBuffer(buf, block)
+				if err != nil {
+					if hash != nil {
 						if debug {
 							l.Debugf("Finder block mismatch in %s:%s:%d expected %q got %q", folder, file, index, block.Hash, hash)
 						}
@@ -660,8 +674,10 @@ nextFile:
 						if err != nil {
 							l.Warnln("finder fix:", err)
 						}
-						return false
+					} else if debug {
+						l.Debugln("Finder failed to verify buffer", err)
 					}
+					return false
 				}
 
 				_, err = dstFd.WriteAt(buf, block.Offset)
@@ -696,20 +712,9 @@ nextFile:
 }
 
 func (p *Puller) pullerRoutine(in <-chan pullBlockState, out chan<- *sharedPullerState) {
-nextBlock:
 	for state := range in {
 		if state.failed() != nil {
-			continue nextBlock
-		}
-
-		// Select the least busy device to pull the block from. If we found no
-		// feasible device at all, fail the block (and in the long run, the
-		// file).
-		potentialDevices := p.model.availability(p.folder, state.file.Name)
-		selected := activity.leastBusy(potentialDevices)
-		if selected == (protocol.DeviceID{}) {
-			state.earlyClose("pull", errNoDevice)
-			continue nextBlock
+			continue
 		}
 
 		// Get an fd to the temporary file. Tehcnically we don't need it until
@@ -717,45 +722,58 @@ nextBlock:
 		// no point in issuing the request to the network.
 		fd, err := state.tempFile()
 		if err != nil {
-			continue nextBlock
+			continue
 		}
 
-		// Fetch the block, while marking the selected device as in use so that
-		// leastBusy can select another device when someone else asks.
-		activity.using(selected)
-		buf, err := p.model.requestGlobal(selected, p.folder, state.file.Name, state.block.Offset, int(state.block.Size), state.block.Hash)
-		activity.done(selected)
-		if err != nil {
-			state.earlyClose("pull", err)
-			continue nextBlock
-		}
+		var lastError error
+		potentialDevices := p.model.availability(p.folder, state.file.Name)
+		for {
+			// Select the least busy device to pull the block from. If we found no
+			// feasible device at all, fail the block (and in the long run, the
+			// file).
+			selected := activity.leastBusy(potentialDevices)
+			if selected == (protocol.DeviceID{}) {
+				if lastError != nil {
+					state.earlyClose("pull", lastError)
+				} else {
+					state.earlyClose("pull", errNoDevice)
+				}
+				break
+			}
 
-		// Save the block data we got from the cluster
-		_, err = fd.WriteAt(buf, state.block.Offset)
-		if err != nil {
-			state.earlyClose("save", err)
-			continue nextBlock
-		}
+			potentialDevices = removeDevice(potentialDevices, selected)
 
-		state.pullDone()
-		out <- state.sharedPullerState
+			// Fetch the block, while marking the selected device as in use so that
+			// leastBusy can select another device when someone else asks.
+			activity.using(selected)
+			buf, lastError := p.model.requestGlobal(selected, p.folder, state.file.Name, state.block.Offset, int(state.block.Size), state.block.Hash)
+			activity.done(selected)
+			if lastError != nil {
+				continue
+			}
+
+			// Verify that the received block matches the desired hash, if not
+			// try pulling it from another device.
+			_, lastError = scanner.VerifyBuffer(buf, state.block)
+			if lastError != nil {
+				continue
+			}
+
+			// Save the block data we got from the cluster
+			_, err = fd.WriteAt(buf, state.block.Offset)
+			if err != nil {
+				state.earlyClose("save", err)
+			} else {
+				state.pullDone()
+				out <- state.sharedPullerState
+			}
+			break
+		}
 	}
 }
 
 func (p *Puller) performFinish(state *sharedPullerState) {
-	// Verify the file against expected hashes
-	fd, err := os.Open(state.tempName)
-	if err != nil {
-		l.Warnln("puller: final:", err)
-		return
-	}
-	err = scanner.Verify(fd, protocol.BlockSize, state.file.Blocks)
-	fd.Close()
-	if err != nil {
-		l.Infoln("puller:", state.file.Name, err, "(file changed during pull?)")
-		return
-	}
-
+	var err error
 	// Set the correct permission bits on the new file
 	if !p.ignorePerms {
 		err = os.Chmod(state.tempName, os.FileMode(state.file.Flags&0777))
@@ -795,8 +813,7 @@ func (p *Puller) performFinish(state *sharedPullerState) {
 	// If the target path is a symlink or a directory, we cannot copy
 	// over it, hence remove it before proceeding.
 	stat, err := os.Lstat(state.realName)
-	isLink, _ := symlinks.IsSymlink(state.realName)
-	if isLink || (err == nil && stat.IsDir()) {
+	if err == nil && (stat.IsDir() || stat.Mode()&os.ModeSymlink != 0) {
 		osutil.InWritableDir(os.Remove, state.realName)
 	}
 	// Replace the original content with the new one
@@ -840,7 +857,9 @@ func (p *Puller) finisherRoutine(in <-chan *sharedPullerState) {
 				continue
 			}
 
+			p.queue.Done(state.file.Name)
 			p.performFinish(state)
+			p.model.receivedFile(p.folder, state.file.Name)
 			if p.progressEmitter != nil {
 				p.progressEmitter.Deregister(state)
 			}
@@ -848,21 +867,13 @@ func (p *Puller) finisherRoutine(in <-chan *sharedPullerState) {
 	}
 }
 
-// clean deletes orphaned temporary files
-func (p *Puller) clean() {
-	keep := time.Duration(p.model.cfg.Options().KeepTemporariesH) * time.Hour
-	now := time.Now()
-	filepath.Walk(p.dir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
+// Moves the given filename to the front of the job queue
+func (p *Puller) BringToFront(filename string) {
+	p.queue.BringToFront(filename)
+}
 
-		if info.Mode().IsRegular() && defTempNamer.IsTemporary(path) && info.ModTime().Add(keep).Before(now) {
-			os.Remove(path)
-		}
-
-		return nil
-	})
+func (p *Puller) Jobs() ([]string, []string) {
+	return p.queue.Jobs()
 }
 
 func invalidateFolder(cfg *config.Configuration, folderID string, err error) {
@@ -874,3 +885,13 @@ func invalidateFolder(cfg *config.Configuration, folderID string, err error) {
 		}
 	}
 }
+
+func removeDevice(devices []protocol.DeviceID, device protocol.DeviceID) []protocol.DeviceID {
+	for i := range devices {
+		if devices[i] == device {
+			devices[i] = devices[len(devices)-1]
+			return devices[:len(devices)-1]
+		}
+	}
+	return devices
+}

internal/model/puller_test.go

@@ -19,6 +19,7 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"github.com/syncthing/syncthing/internal/config"
 	"github.com/syncthing/syncthing/internal/protocol"
@@ -28,6 +29,16 @@ import (
 	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
+func init() {
+	// We do this to make sure that the temp file required for the tests does
+	// not get removed during the tests.
+	future := time.Now().Add(time.Hour)
+	err := os.Chtimes(filepath.Join("testdata", defTempNamer.TempName("file")), future, future)
+	if err != nil {
+		panic(err)
+	}
+}
+
 var blocks = []protocol.BlockInfo{
 	{Hash: []uint8{0xfa, 0x43, 0x23, 0x9b, 0xce, 0xe7, 0xb9, 0x7c, 0xa6, 0x2f, 0x0, 0x7c, 0xc6, 0x84, 0x87, 0x56, 0xa, 0x39, 0xe1, 0x9f, 0x74, 0xf3, 0xdd, 0xe7, 0x48, 0x6d, 0xb3, 0xf9, 0x8d, 0xf8, 0xe4, 0x71}}, // Zero'ed out block
 	{Offset: 0, Size: 0x20000, Hash: []uint8{0x7e, 0xad, 0xbc, 0x36, 0xae, 0xbb, 0xcf, 0x74, 0x43, 0xe2, 0x7a, 0x5a, 0x4b, 0xb8, 0x5b, 0xce, 0xe6, 0x9e, 0x1e, 0x10, 0xf9, 0x8a, 0xbc, 0x77, 0x95, 0x2, 0x29, 0x60, 0x9e, 0x96, 0xae, 0x6c}},
@@ -210,7 +221,7 @@ func TestCopierFinder(t *testing.T) {
 	finisherChan := make(chan *sharedPullerState, 1)
 
 	// Run a single fetcher routine
-	go p.copierRoutine(copyChan, pullChan, finisherChan, false)
+	go p.copierRoutine(copyChan, pullChan, finisherChan)
 
 	p.handleFile(requiredFile, copyChan, finisherChan)
 
@@ -306,9 +317,8 @@ func TestCopierCleanup(t *testing.T) {
 	}
 }
 
-// On the 10th iteration, we start hashing the content which we receive by
-// following blockfinder's instructions. Make sure that the copier routine
-// hashes the content when asked, and pulls if it fails to find the block.
+// Make sure that the copier routine hashes the content when asked, and pulls
+// if it fails to find the block.
 func TestLastResortPulling(t *testing.T) {
 	fcfg := config.FolderConfiguration{ID: "default", Path: "testdata"}
 	cfg := config.Configuration{Folders: []config.FolderConfiguration{fcfg}}
@@ -350,8 +360,8 @@ func TestLastResortPulling(t *testing.T) {
 	pullChan := make(chan pullBlockState, 1)
 	finisherChan := make(chan *sharedPullerState, 1)
 
-	// Run a single copier routine with checksumming enabled
-	go p.copierRoutine(copyChan, pullChan, finisherChan, true)
+	// Run a single copier routine
+	go p.copierRoutine(copyChan, pullChan, finisherChan)
 
 	p.handleFile(file, copyChan, finisherChan)
 

internal/model/queue.go

@@ -0,0 +1,94 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package model
+
+import "sync"
+
+type jobQueue struct {
+	progress []string
+	queued   []string
+	mut      sync.Mutex
+}
+
+func newJobQueue() *jobQueue {
+	return &jobQueue{}
+}
+
+func (q *jobQueue) Push(file string) {
+	q.mut.Lock()
+	q.queued = append(q.queued, file)
+	q.mut.Unlock()
+}
+
+func (q *jobQueue) Pop() (string, bool) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	if len(q.queued) == 0 {
+		return "", false
+	}
+
+	var f string
+	f = q.queued[0]
+	q.queued = q.queued[1:]
+	q.progress = append(q.progress, f)
+
+	return f, true
+}
+
+func (q *jobQueue) BringToFront(filename string) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	for i, cur := range q.queued {
+		if cur == filename {
+			if i > 0 {
+				// Shift the elements before the selected element one step to
+				// the right, overwriting the selected element
+				copy(q.queued[1:i+1], q.queued[0:])
+				// Put the selected element at the front
+				q.queued[0] = cur
+			}
+			return
+		}
+	}
+}
+
+func (q *jobQueue) Done(file string) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	for i := range q.progress {
+		if q.progress[i] == file {
+			copy(q.progress[i:], q.progress[i+1:])
+			q.progress = q.progress[:len(q.progress)-1]
+			return
+		}
+	}
+}
+
+func (q *jobQueue) Jobs() ([]string, []string) {
+	q.mut.Lock()
+	defer q.mut.Unlock()
+
+	progress := make([]string, len(q.progress))
+	copy(progress, q.progress)
+
+	queued := make([]string, len(q.queued))
+	copy(queued, q.queued)
+
+	return progress, queued
+}

internal/model/queue_test.go

@@ -0,0 +1,200 @@
+// Copyright (C) 2014 The Syncthing Authors.
+//
+// This program is free software: you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package model
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestJobQueue(t *testing.T) {
+	// Some random actions
+	q := newJobQueue()
+	q.Push("f1")
+	q.Push("f2")
+	q.Push("f3")
+	q.Push("f4")
+
+	progress, queued := q.Jobs()
+	if len(progress) != 0 || len(queued) != 4 {
+		t.Fatal("Wrong length")
+	}
+
+	for i := 1; i < 5; i++ {
+		n, ok := q.Pop()
+		if !ok || n != fmt.Sprintf("f%d", i) {
+			t.Fatal("Wrong element")
+		}
+		progress, queued = q.Jobs()
+		if len(progress) != 1 || len(queued) != 3 {
+			t.Log(progress)
+			t.Log(queued)
+			t.Fatal("Wrong length")
+		}
+
+		q.Done(n)
+		progress, queued = q.Jobs()
+		if len(progress) != 0 || len(queued) != 3 {
+			t.Fatal("Wrong length", len(progress), len(queued))
+		}
+
+		q.Push(n)
+		progress, queued = q.Jobs()
+		if len(progress) != 0 || len(queued) != 4 {
+			t.Fatal("Wrong length")
+		}
+
+		q.Done("f5") // Does not exist
+		progress, queued = q.Jobs()
+		if len(progress) != 0 || len(queued) != 4 {
+			t.Fatal("Wrong length")
+		}
+	}
+
+	if len(q.progress) > 0 || len(q.queued) != 4 {
+		t.Fatal("Wrong length")
+	}
+
+	for i := 4; i > 0; i-- {
+		progress, queued = q.Jobs()
+		if len(progress) != 4-i || len(queued) != i {
+			t.Fatal("Wrong length")
+		}
+
+		s := fmt.Sprintf("f%d", i)
+
+		q.BringToFront(s)
+		progress, queued = q.Jobs()
+		if len(progress) != 4-i || len(queued) != i {
+			t.Fatal("Wrong length")
+		}
+
+		n, ok := q.Pop()
+		if !ok || n != s {
+			t.Fatal("Wrong element")
+		}
+		progress, queued = q.Jobs()
+		if len(progress) != 5-i || len(queued) != i-1 {
+			t.Fatal("Wrong length")
+		}
+
+		q.Done("f5") // Does not exist
+		progress, queued = q.Jobs()
+		if len(progress) != 5-i || len(queued) != i-1 {
+			t.Fatal("Wrong length")
+		}
+	}
+
+	_, ok := q.Pop()
+	if len(q.progress) != 4 || ok {
+		t.Fatal("Wrong length")
+	}
+
+	q.Done("f1")
+	q.Done("f2")
+	q.Done("f3")
+	q.Done("f4")
+	q.Done("f5") // Does not exist
+
+	_, ok = q.Pop()
+	if len(q.progress) != 0 || ok {
+		t.Fatal("Wrong length")
+	}
+
+	progress, queued = q.Jobs()
+	if len(progress) != 0 || len(queued) != 0 {
+		t.Fatal("Wrong length")
+	}
+	q.BringToFront("")
+	q.Done("f5") // Does not exist
+	progress, queued = q.Jobs()
+	if len(progress) != 0 || len(queued) != 0 {
+		t.Fatal("Wrong length")
+	}
+}
+
+func TestBringToFront(t *testing.T) {
+	q := newJobQueue()
+	q.Push("f1")
+	q.Push("f2")
+	q.Push("f3")
+	q.Push("f4")
+
+	_, queued := q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f1", "f2", "f3", "f4"}) {
+		t.Errorf("Incorrect order %v at start", queued)
+	}
+
+	q.BringToFront("f1") // corner case: does nothing
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f1", "f2", "f3", "f4"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+
+	q.BringToFront("f3")
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f3", "f1", "f2", "f4"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+
+	q.BringToFront("f2")
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f2", "f3", "f1", "f4"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+
+	q.BringToFront("f4") // corner case: last element
+
+	_, queued = q.Jobs()
+	if !reflect.DeepEqual(queued, []string{"f4", "f2", "f3", "f1"}) {
+		t.Errorf("Incorrect order %v", queued)
+	}
+}
+
+func BenchmarkJobQueueBump(b *testing.B) {
+	files := genFiles(b.N)
+
+	q := newJobQueue()
+	for _, f := range files {
+		q.Push(f.Name)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		q.BringToFront(files[i].Name)
+	}
+}
+
+func BenchmarkJobQueuePushPopDone10k(b *testing.B) {
+	files := genFiles(10000)
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		q := newJobQueue()
+		for _, f := range files {
+			q.Push(f.Name)
+		}
+		for range files {
+			n, _ := q.Pop()
+			q.Done(n)
+		}
+	}
+
+}