Rename Repository -> Folder, Node -> Device (fixes #739)

internal/files/leveldb.go

@@ -35,13 +35,13 @@ func clock(v uint64) uint64 {
 }
 
 const (
-	keyTypeNode = iota
+	keyTypeDevice = iota
 	keyTypeGlobal
 )
 
 type fileVersion struct {
 	version uint64
-	node    []byte
+	device    []byte
 }
 
 type versionList struct {
@@ -73,47 +73,47 @@ type dbWriter interface {
 
 /*
 
-keyTypeNode (1 byte)
-    repository (64 bytes)
-        node (32 bytes)
+keyTypeDevice (1 byte)
+    folder (64 bytes)
+        device (32 bytes)
             name (variable size)
 		|
 		scanner.File
 
 keyTypeGlobal (1 byte)
-	repository (64 bytes)
+	folder (64 bytes)
 		name (variable size)
 			|
 			[]fileVersion (sorted)
 
 */
 
-func nodeKey(repo, node, file []byte) []byte {
+func deviceKey(folder, device, file []byte) []byte {
 	k := make([]byte, 1+64+32+len(file))
-	k[0] = keyTypeNode
-	copy(k[1:], []byte(repo))
-	copy(k[1+64:], node[:])
+	k[0] = keyTypeDevice
+	copy(k[1:], []byte(folder))
+	copy(k[1+64:], device[:])
 	copy(k[1+64+32:], []byte(file))
 	return k
 }
 
-func globalKey(repo, file []byte) []byte {
+func globalKey(folder, file []byte) []byte {
 	k := make([]byte, 1+64+len(file))
 	k[0] = keyTypeGlobal
-	copy(k[1:], []byte(repo))
+	copy(k[1:], []byte(folder))
 	copy(k[1+64:], []byte(file))
 	return k
 }
 
-func nodeKeyName(key []byte) []byte {
+func deviceKeyName(key []byte) []byte {
 	return key[1+64+32:]
 }
-func nodeKeyRepo(key []byte) []byte {
-	repo := key[1 : 1+64]
-	izero := bytes.IndexByte(repo, 0)
-	return repo[:izero]
+func deviceKeyFolder(key []byte) []byte {
+	folder := key[1 : 1+64]
+	izero := bytes.IndexByte(folder, 0)
+	return folder[:izero]
 }
-func nodeKeyNode(key []byte) []byte {
+func deviceKeyDevice(key []byte) []byte {
 	return key[1+64 : 1+64+32]
 }
 
@@ -121,23 +121,23 @@ func globalKeyName(key []byte) []byte {
 	return key[1+64:]
 }
 
-func globalKeyRepo(key []byte) []byte {
-	repo := key[1 : 1+64]
-	izero := bytes.IndexByte(repo, 0)
-	return repo[:izero]
+func globalKeyFolder(key []byte) []byte {
+	folder := key[1 : 1+64]
+	izero := bytes.IndexByte(folder, 0)
+	return folder[:izero]
 }
 
-type deletionHandler func(db dbReader, batch dbWriter, repo, node, name []byte, dbi iterator.Iterator) uint64
+type deletionHandler func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) uint64
 
 type fileIterator func(f protocol.FileIntf) bool
 
-func ldbGenericReplace(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo, deleteFn deletionHandler) uint64 {
+func ldbGenericReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo, deleteFn deletionHandler) uint64 {
 	runtime.GC()
 
 	sort.Sort(fileList(fs)) // sort list on name, same as on disk
 
-	start := nodeKey(repo, node, nil)                            // before all repo/node files
-	limit := nodeKey(repo, node, []byte{0xff, 0xff, 0xff, 0xff}) // after all repo/node files
+	start := deviceKey(folder, device, nil)                            // before all folder/device files
+	limit := deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
 
 	batch := new(leveldb.Batch)
 	snap, err := db.GetSnapshot()
@@ -171,42 +171,42 @@ func ldbGenericReplace(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo
 		}
 
 		if moreDb {
-			oldName = nodeKeyName(dbi.Key())
+			oldName = deviceKeyName(dbi.Key())
 		}
 
 		cmp := bytes.Compare(newName, oldName)
 
 		if debug {
-			l.Debugf("generic replace; repo=%q node=%v moreFs=%v moreDb=%v cmp=%d newName=%q oldName=%q", repo, protocol.NodeIDFromBytes(node), moreFs, moreDb, cmp, newName, oldName)
+			l.Debugf("generic replace; folder=%q device=%v moreFs=%v moreDb=%v cmp=%d newName=%q oldName=%q", folder, protocol.DeviceIDFromBytes(device), moreFs, moreDb, cmp, newName, oldName)
 		}
 
 		switch {
 		case moreFs && (!moreDb || cmp == -1):
 			// Disk is missing this file. Insert it.
-			if lv := ldbInsert(batch, repo, node, newName, fs[fsi]); lv > maxLocalVer {
+			if lv := ldbInsert(batch, folder, device, newName, fs[fsi]); lv > maxLocalVer {
 				maxLocalVer = lv
 			}
 			if fs[fsi].IsInvalid() {
-				ldbRemoveFromGlobal(snap, batch, repo, node, newName)
+				ldbRemoveFromGlobal(snap, batch, folder, device, newName)
 			} else {
-				ldbUpdateGlobal(snap, batch, repo, node, newName, fs[fsi].Version)
+				ldbUpdateGlobal(snap, batch, folder, device, newName, fs[fsi].Version)
 			}
 			fsi++
 
 		case moreFs && moreDb && cmp == 0:
 			// File exists on both sides - compare versions. We might get an
-			// update with the same version and different flags if a node has
+			// update with the same version and different flags if a device has
 			// marked a file as invalid, so handle that too.
 			var ef protocol.FileInfoTruncated
 			ef.UnmarshalXDR(dbi.Value())
 			if fs[fsi].Version > ef.Version || fs[fsi].Version != ef.Version {
-				if lv := ldbInsert(batch, repo, node, newName, fs[fsi]); lv > maxLocalVer {
+				if lv := ldbInsert(batch, folder, device, newName, fs[fsi]); lv > maxLocalVer {
 					maxLocalVer = lv
 				}
 				if fs[fsi].IsInvalid() {
-					ldbRemoveFromGlobal(snap, batch, repo, node, newName)
+					ldbRemoveFromGlobal(snap, batch, folder, device, newName)
 				} else {
-					ldbUpdateGlobal(snap, batch, repo, node, newName, fs[fsi].Version)
+					ldbUpdateGlobal(snap, batch, folder, device, newName, fs[fsi].Version)
 				}
 			}
 			// Iterate both sides.
@@ -215,7 +215,7 @@ func ldbGenericReplace(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo
 
 		case moreDb && (!moreFs || cmp == 1):
 			if deleteFn != nil {
-				if lv := deleteFn(snap, batch, repo, node, oldName, dbi); lv > maxLocalVer {
+				if lv := deleteFn(snap, batch, folder, device, oldName, dbi); lv > maxLocalVer {
 					maxLocalVer = lv
 				}
 			}
@@ -231,21 +231,21 @@ func ldbGenericReplace(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo
 	return maxLocalVer
 }
 
-func ldbReplace(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo) uint64 {
+func ldbReplace(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) uint64 {
 	// TODO: Return the remaining maxLocalVer?
-	return ldbGenericReplace(db, repo, node, fs, func(db dbReader, batch dbWriter, repo, node, name []byte, dbi iterator.Iterator) uint64 {
+	return ldbGenericReplace(db, folder, device, fs, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) uint64 {
 		// Disk has files that we are missing. Remove it.
 		if debug {
-			l.Debugf("delete; repo=%q node=%v name=%q", repo, protocol.NodeIDFromBytes(node), name)
+			l.Debugf("delete; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name)
 		}
-		ldbRemoveFromGlobal(db, batch, repo, node, name)
+		ldbRemoveFromGlobal(db, batch, folder, device, name)
 		batch.Delete(dbi.Key())
 		return 0
 	})
 }
 
-func ldbReplaceWithDelete(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo) uint64 {
-	return ldbGenericReplace(db, repo, node, fs, func(db dbReader, batch dbWriter, repo, node, name []byte, dbi iterator.Iterator) uint64 {
+func ldbReplaceWithDelete(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) uint64 {
+	return ldbGenericReplace(db, folder, device, fs, func(db dbReader, batch dbWriter, folder, device, name []byte, dbi iterator.Iterator) uint64 {
 		var tf protocol.FileInfoTruncated
 		err := tf.UnmarshalXDR(dbi.Value())
 		if err != nil {
@@ -253,7 +253,7 @@ func ldbReplaceWithDelete(db *leveldb.DB, repo, node []byte, fs []protocol.FileI
 		}
 		if !tf.IsDeleted() {
 			if debug {
-				l.Debugf("mark deleted; repo=%q node=%v name=%q", repo, protocol.NodeIDFromBytes(node), name)
+				l.Debugf("mark deleted; folder=%q device=%v name=%q", folder, protocol.DeviceIDFromBytes(device), name)
 			}
 			ts := clock(tf.LocalVersion)
 			f := protocol.FileInfo{
@@ -264,14 +264,14 @@ func ldbReplaceWithDelete(db *leveldb.DB, repo, node []byte, fs []protocol.FileI
 				Modified:     tf.Modified,
 			}
 			batch.Put(dbi.Key(), f.MarshalXDR())
-			ldbUpdateGlobal(db, batch, repo, node, nodeKeyName(dbi.Key()), f.Version)
+			ldbUpdateGlobal(db, batch, folder, device, deviceKeyName(dbi.Key()), f.Version)
 			return ts
 		}
 		return 0
 	})
 }
 
-func ldbUpdate(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo) uint64 {
+func ldbUpdate(db *leveldb.DB, folder, device []byte, fs []protocol.FileInfo) uint64 {
 	runtime.GC()
 
 	batch := new(leveldb.Batch)
@@ -284,16 +284,16 @@ func ldbUpdate(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo) uint64
 	var maxLocalVer uint64
 	for _, f := range fs {
 		name := []byte(f.Name)
-		fk := nodeKey(repo, node, name)
+		fk := deviceKey(folder, device, name)
 		bs, err := snap.Get(fk, nil)
 		if err == leveldb.ErrNotFound {
-			if lv := ldbInsert(batch, repo, node, name, f); lv > maxLocalVer {
+			if lv := ldbInsert(batch, folder, device, name, f); lv > maxLocalVer {
 				maxLocalVer = lv
 			}
 			if f.IsInvalid() {
-				ldbRemoveFromGlobal(snap, batch, repo, node, name)
+				ldbRemoveFromGlobal(snap, batch, folder, device, name)
 			} else {
-				ldbUpdateGlobal(snap, batch, repo, node, name, f.Version)
+				ldbUpdateGlobal(snap, batch, folder, device, name, f.Version)
 			}
 			continue
 		}
@@ -306,13 +306,13 @@ func ldbUpdate(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo) uint64
 		// Flags might change without the version being bumped when we set the
 		// invalid flag on an existing file.
 		if ef.Version != f.Version || ef.Flags != f.Flags {
-			if lv := ldbInsert(batch, repo, node, name, f); lv > maxLocalVer {
+			if lv := ldbInsert(batch, folder, device, name, f); lv > maxLocalVer {
 				maxLocalVer = lv
 			}
 			if f.IsInvalid() {
-				ldbRemoveFromGlobal(snap, batch, repo, node, name)
+				ldbRemoveFromGlobal(snap, batch, folder, device, name)
 			} else {
-				ldbUpdateGlobal(snap, batch, repo, node, name, f.Version)
+				ldbUpdateGlobal(snap, batch, folder, device, name, f.Version)
 			}
 		}
 	}
@@ -325,29 +325,29 @@ func ldbUpdate(db *leveldb.DB, repo, node []byte, fs []protocol.FileInfo) uint64
 	return maxLocalVer
 }
 
-func ldbInsert(batch dbWriter, repo, node, name []byte, file protocol.FileInfo) uint64 {
+func ldbInsert(batch dbWriter, folder, device, name []byte, file protocol.FileInfo) uint64 {
 	if debug {
-		l.Debugf("insert; repo=%q node=%v %v", repo, protocol.NodeIDFromBytes(node), file)
+		l.Debugf("insert; folder=%q device=%v %v", folder, protocol.DeviceIDFromBytes(device), file)
 	}
 
 	if file.LocalVersion == 0 {
 		file.LocalVersion = clock(0)
 	}
 
-	nk := nodeKey(repo, node, name)
+	nk := deviceKey(folder, device, name)
 	batch.Put(nk, file.MarshalXDR())
 
 	return file.LocalVersion
 }
 
-// ldbUpdateGlobal adds this node+version to the version list for the given
-// file. If the node is already present in the list, the version is updated.
+// ldbUpdateGlobal adds this device+version to the version list for the given
+// file. If the device is already present in the list, the version is updated.
 // If the file does not have an entry in the global list, it is created.
-func ldbUpdateGlobal(db dbReader, batch dbWriter, repo, node, file []byte, version uint64) bool {
+func ldbUpdateGlobal(db dbReader, batch dbWriter, folder, device, file []byte, version uint64) bool {
 	if debug {
-		l.Debugf("update global; repo=%q node=%v file=%q version=%d", repo, protocol.NodeIDFromBytes(node), file, version)
+		l.Debugf("update global; folder=%q device=%v file=%q version=%d", folder, protocol.DeviceIDFromBytes(device), file, version)
 	}
-	gk := globalKey(repo, file)
+	gk := globalKey(folder, file)
 	svl, err := db.Get(gk, nil)
 	if err != nil && err != leveldb.ErrNotFound {
 		panic(err)
@@ -355,7 +355,7 @@ func ldbUpdateGlobal(db dbReader, batch dbWriter, repo, node, file []byte, versi
 
 	var fl versionList
 	nv := fileVersion{
-		node:    node,
+		device:    device,
 		version: version,
 	}
 	if svl != nil {
@@ -365,7 +365,7 @@ func ldbUpdateGlobal(db dbReader, batch dbWriter, repo, node, file []byte, versi
 		}
 
 		for i := range fl.versions {
-			if bytes.Compare(fl.versions[i].node, node) == 0 {
+			if bytes.Compare(fl.versions[i].device, device) == 0 {
 				if fl.versions[i].version == version {
 					// No need to do anything
 					return false
@@ -394,15 +394,15 @@ done:
 	return true
 }
 
-// ldbRemoveFromGlobal removes the node from the global version list for the
+// ldbRemoveFromGlobal removes the device from the global version list for the
 // given file. If the version list is empty after this, the file entry is
 // removed entirely.
-func ldbRemoveFromGlobal(db dbReader, batch dbWriter, repo, node, file []byte) {
+func ldbRemoveFromGlobal(db dbReader, batch dbWriter, folder, device, file []byte) {
 	if debug {
-		l.Debugf("remove from global; repo=%q node=%v file=%q", repo, protocol.NodeIDFromBytes(node), file)
+		l.Debugf("remove from global; folder=%q device=%v file=%q", folder, protocol.DeviceIDFromBytes(device), file)
 	}
 
-	gk := globalKey(repo, file)
+	gk := globalKey(folder, file)
 	svl, err := db.Get(gk, nil)
 	if err != nil {
 		// We might be called to "remove" a global version that doesn't exist
@@ -417,7 +417,7 @@ func ldbRemoveFromGlobal(db dbReader, batch dbWriter, repo, node, file []byte) {
 	}
 
 	for i := range fl.versions {
-		if bytes.Compare(fl.versions[i].node, node) == 0 {
+		if bytes.Compare(fl.versions[i].device, device) == 0 {
 			fl.versions = append(fl.versions[:i], fl.versions[i+1:]...)
 			break
 		}
@@ -430,9 +430,9 @@ func ldbRemoveFromGlobal(db dbReader, batch dbWriter, repo, node, file []byte) {
 	}
 }
 
-func ldbWithHave(db *leveldb.DB, repo, node []byte, truncate bool, fn fileIterator) {
-	start := nodeKey(repo, node, nil)                            // before all repo/node files
-	limit := nodeKey(repo, node, []byte{0xff, 0xff, 0xff, 0xff}) // after all repo/node files
+func ldbWithHave(db *leveldb.DB, folder, device []byte, truncate bool, fn fileIterator) {
+	start := deviceKey(folder, device, nil)                            // before all folder/device files
+	limit := deviceKey(folder, device, []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
 	snap, err := db.GetSnapshot()
 	if err != nil {
 		panic(err)
@@ -452,11 +452,11 @@ func ldbWithHave(db *leveldb.DB, repo, node []byte, truncate bool, fn fileIterat
 	}
 }
 
-func ldbWithAllRepoTruncated(db *leveldb.DB, repo []byte, fn func(node []byte, f protocol.FileInfoTruncated) bool) {
+func ldbWithAllFolderTruncated(db *leveldb.DB, folder []byte, fn func(device []byte, f protocol.FileInfoTruncated) bool) {
 	runtime.GC()
 
-	start := nodeKey(repo, nil, nil)                                                // before all repo/node files
-	limit := nodeKey(repo, protocol.LocalNodeID[:], []byte{0xff, 0xff, 0xff, 0xff}) // after all repo/node files
+	start := deviceKey(folder, nil, nil)                                                // before all folder/device files
+	limit := deviceKey(folder, protocol.LocalDeviceID[:], []byte{0xff, 0xff, 0xff, 0xff}) // after all folder/device files
 	snap, err := db.GetSnapshot()
 	if err != nil {
 		panic(err)
@@ -466,20 +466,20 @@ func ldbWithAllRepoTruncated(db *leveldb.DB, repo []byte, fn func(node []byte, f
 	defer dbi.Release()
 
 	for dbi.Next() {
-		node := nodeKeyNode(dbi.Key())
+		device := deviceKeyDevice(dbi.Key())
 		var f protocol.FileInfoTruncated
 		err := f.UnmarshalXDR(dbi.Value())
 		if err != nil {
 			panic(err)
 		}
-		if cont := fn(node, f); !cont {
+		if cont := fn(device, f); !cont {
 			return
 		}
 	}
 }
 
-func ldbGet(db *leveldb.DB, repo, node, file []byte) protocol.FileInfo {
-	nk := nodeKey(repo, node, file)
+func ldbGet(db *leveldb.DB, folder, device, file []byte) protocol.FileInfo {
+	nk := deviceKey(folder, device, file)
 	bs, err := db.Get(nk, nil)
 	if err == leveldb.ErrNotFound {
 		return protocol.FileInfo{}
@@ -496,8 +496,8 @@ func ldbGet(db *leveldb.DB, repo, node, file []byte) protocol.FileInfo {
 	return f
 }
 
-func ldbGetGlobal(db *leveldb.DB, repo, file []byte) protocol.FileInfo {
-	k := globalKey(repo, file)
+func ldbGetGlobal(db *leveldb.DB, folder, file []byte) protocol.FileInfo {
+	k := globalKey(folder, file)
 	snap, err := db.GetSnapshot()
 	if err != nil {
 		panic(err)
@@ -522,7 +522,7 @@ func ldbGetGlobal(db *leveldb.DB, repo, file []byte) protocol.FileInfo {
 		panic("no versions?")
 	}
 
-	k = nodeKey(repo, vl.versions[0].node, file)
+	k = deviceKey(folder, vl.versions[0].device, file)
 	bs, err = snap.Get(k, nil)
 	if err != nil {
 		panic(err)
@@ -536,11 +536,11 @@ func ldbGetGlobal(db *leveldb.DB, repo, file []byte) protocol.FileInfo {
 	return f
 }
 
-func ldbWithGlobal(db *leveldb.DB, repo []byte, truncate bool, fn fileIterator) {
+func ldbWithGlobal(db *leveldb.DB, folder []byte, truncate bool, fn fileIterator) {
 	runtime.GC()
 
-	start := globalKey(repo, nil)
-	limit := globalKey(repo, []byte{0xff, 0xff, 0xff, 0xff})
+	start := globalKey(folder, nil)
+	limit := globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff})
 	snap, err := db.GetSnapshot()
 	if err != nil {
 		panic(err)
@@ -559,7 +559,7 @@ func ldbWithGlobal(db *leveldb.DB, repo []byte, truncate bool, fn fileIterator)
 			l.Debugln(dbi.Key())
 			panic("no versions?")
 		}
-		fk := nodeKey(repo, vl.versions[0].node, globalKeyName(dbi.Key()))
+		fk := deviceKey(folder, vl.versions[0].device, globalKeyName(dbi.Key()))
 		bs, err := snap.Get(fk, nil)
 		if err != nil {
 			panic(err)
@@ -576,8 +576,8 @@ func ldbWithGlobal(db *leveldb.DB, repo []byte, truncate bool, fn fileIterator)
 	}
 }
 
-func ldbAvailability(db *leveldb.DB, repo, file []byte) []protocol.NodeID {
-	k := globalKey(repo, file)
+func ldbAvailability(db *leveldb.DB, folder, file []byte) []protocol.DeviceID {
+	k := globalKey(folder, file)
 	bs, err := db.Get(k, nil)
 	if err == leveldb.ErrNotFound {
 		return nil
@@ -592,23 +592,23 @@ func ldbAvailability(db *leveldb.DB, repo, file []byte) []protocol.NodeID {
 		panic(err)
 	}
 
-	var nodes []protocol.NodeID
+	var devices []protocol.DeviceID
 	for _, v := range vl.versions {
 		if v.version != vl.versions[0].version {
 			break
 		}
-		n := protocol.NodeIDFromBytes(v.node)
-		nodes = append(nodes, n)
+		n := protocol.DeviceIDFromBytes(v.device)
+		devices = append(devices, n)
 	}
 
-	return nodes
+	return devices
 }
 
-func ldbWithNeed(db *leveldb.DB, repo, node []byte, truncate bool, fn fileIterator) {
+func ldbWithNeed(db *leveldb.DB, folder, device []byte, truncate bool, fn fileIterator) {
 	runtime.GC()
 
-	start := globalKey(repo, nil)
-	limit := globalKey(repo, []byte{0xff, 0xff, 0xff, 0xff})
+	start := globalKey(folder, nil)
+	limit := globalKey(folder, []byte{0xff, 0xff, 0xff, 0xff})
 	snap, err := db.GetSnapshot()
 	if err != nil {
 		panic(err)
@@ -633,7 +633,7 @@ outer:
 		need := false // If we have a lower version of the file
 		var haveVersion uint64
 		for _, v := range vl.versions {
-			if bytes.Compare(v.node, node) == 0 {
+			if bytes.Compare(v.device, device) == 0 {
 				have = true
 				haveVersion = v.version
 				need = v.version < vl.versions[0].version
@@ -650,7 +650,7 @@ outer:
 					// We haven't found a valid copy of the file with the needed version.
 					continue outer
 				}
-				fk := nodeKey(repo, vl.versions[i].node, name)
+				fk := deviceKey(folder, vl.versions[i].device, name)
 				bs, err := snap.Get(fk, nil)
 				if err != nil {
 					panic(err)
@@ -672,7 +672,7 @@ outer:
 				}
 
 				if debug {
-					l.Debugf("need repo=%q node=%v name=%q need=%v have=%v haveV=%d globalV=%d", repo, protocol.NodeIDFromBytes(node), name, need, have, haveVersion, vl.versions[0].version)
+					l.Debugf("need folder=%q device=%v name=%q need=%v have=%v haveV=%d globalV=%d", folder, protocol.DeviceIDFromBytes(device), name, need, have, haveVersion, vl.versions[0].version)
 				}
 
 				if cont := fn(gf); !cont {
@@ -686,7 +686,7 @@ outer:
 	}
 }
 
-func ldbListRepos(db *leveldb.DB) []string {
+func ldbListFolders(db *leveldb.DB) []string {
 	runtime.GC()
 
 	start := []byte{keyTypeGlobal}
@@ -699,24 +699,24 @@ func ldbListRepos(db *leveldb.DB) []string {
 	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
 	defer dbi.Release()
 
-	repoExists := make(map[string]bool)
+	folderExists := make(map[string]bool)
 	for dbi.Next() {
-		repo := string(globalKeyRepo(dbi.Key()))
-		if !repoExists[repo] {
-			repoExists[repo] = true
+		folder := string(globalKeyFolder(dbi.Key()))
+		if !folderExists[folder] {
+			folderExists[folder] = true
 		}
 	}
 
-	repos := make([]string, 0, len(repoExists))
-	for k := range repoExists {
-		repos = append(repos, k)
+	folders := make([]string, 0, len(folderExists))
+	for k := range folderExists {
+		folders = append(folders, k)
 	}
 
-	sort.Strings(repos)
-	return repos
+	sort.Strings(folders)
+	return folders
 }
 
-func ldbDropRepo(db *leveldb.DB, repo []byte) {
+func ldbDropFolder(db *leveldb.DB, folder []byte) {
 	runtime.GC()
 
 	snap, err := db.GetSnapshot()
@@ -725,25 +725,25 @@ func ldbDropRepo(db *leveldb.DB, repo []byte) {
 	}
 	defer snap.Release()
 
-	// Remove all items related to the given repo from the node->file bucket
-	start := []byte{keyTypeNode}
-	limit := []byte{keyTypeNode + 1}
+	// Remove all items related to the given folder from the device->file bucket
+	start := []byte{keyTypeDevice}
+	limit := []byte{keyTypeDevice + 1}
 	dbi := snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
 	for dbi.Next() {
-		itemRepo := nodeKeyRepo(dbi.Key())
-		if bytes.Compare(repo, itemRepo) == 0 {
+		itemFolder := deviceKeyFolder(dbi.Key())
+		if bytes.Compare(folder, itemFolder) == 0 {
 			db.Delete(dbi.Key(), nil)
 		}
 	}
 	dbi.Release()
 
-	// Remove all items related to the given repo from the global bucket
+	// Remove all items related to the given folder from the global bucket
 	start = []byte{keyTypeGlobal}
 	limit = []byte{keyTypeGlobal + 1}
 	dbi = snap.NewIterator(&util.Range{Start: start, Limit: limit}, nil)
 	for dbi.Next() {
-		itemRepo := globalKeyRepo(dbi.Key())
-		if bytes.Compare(repo, itemRepo) == 0 {
+		itemFolder := globalKeyFolder(dbi.Key())
+		if bytes.Compare(folder, itemFolder) == 0 {
 			db.Delete(dbi.Key(), nil)
 		}
 	}

internal/files/leveldb_xdr.go

@@ -22,17 +22,17 @@ fileVersion Structure:
 +                       version (64 bits)                       +
 |                                                               |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                        Length of node                         |
+|                       Length of device                        |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 /                                                               /
-\                    node (variable length)                     \
+\                   device (variable length)                    \
 /                                                               /
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 
 struct fileVersion {
 	unsigned hyper version;
-	opaque node<>;
+	opaque device<>;
 }
 
 */
@@ -55,7 +55,7 @@ func (o fileVersion) AppendXDR(bs []byte) []byte {
 
 func (o fileVersion) encodeXDR(xw *xdr.Writer) (int, error) {
 	xw.WriteUint64(o.version)
-	xw.WriteBytes(o.node)
+	xw.WriteBytes(o.device)
 	return xw.Tot(), xw.Error()
 }
 
@@ -72,7 +72,7 @@ func (o *fileVersion) UnmarshalXDR(bs []byte) error {
 
 func (o *fileVersion) decodeXDR(xr *xdr.Reader) error {
 	o.version = xr.ReadUint64()
-	o.node = xr.ReadBytes()
+	o.device = xr.ReadBytes()
 	return xr.Error()
 }
 

internal/files/set.go

@@ -27,147 +27,147 @@ type fileRecord struct {
 type bitset uint64
 
 type Set struct {
-	localVersion map[protocol.NodeID]uint64
+	localVersion map[protocol.DeviceID]uint64
 	mutex        sync.Mutex
-	repo         string
+	folder         string
 	db           *leveldb.DB
 }
 
-func NewSet(repo string, db *leveldb.DB) *Set {
+func NewSet(folder string, db *leveldb.DB) *Set {
 	var s = Set{
-		localVersion: make(map[protocol.NodeID]uint64),
-		repo:         repo,
+		localVersion: make(map[protocol.DeviceID]uint64),
+		folder:         folder,
 		db:           db,
 	}
 
-	var nodeID protocol.NodeID
-	ldbWithAllRepoTruncated(db, []byte(repo), func(node []byte, f protocol.FileInfoTruncated) bool {
-		copy(nodeID[:], node)
-		if f.LocalVersion > s.localVersion[nodeID] {
-			s.localVersion[nodeID] = f.LocalVersion
+	var deviceID protocol.DeviceID
+	ldbWithAllFolderTruncated(db, []byte(folder), func(device []byte, f protocol.FileInfoTruncated) bool {
+		copy(deviceID[:], device)
+		if f.LocalVersion > s.localVersion[deviceID] {
+			s.localVersion[deviceID] = f.LocalVersion
 		}
 		lamport.Default.Tick(f.Version)
 		return true
 	})
 	if debug {
-		l.Debugf("loaded localVersion for %q: %#v", repo, s.localVersion)
+		l.Debugf("loaded localVersion for %q: %#v", folder, s.localVersion)
 	}
-	clock(s.localVersion[protocol.LocalNodeID])
+	clock(s.localVersion[protocol.LocalDeviceID])
 
 	return &s
 }
 
-func (s *Set) Replace(node protocol.NodeID, fs []protocol.FileInfo) {
+func (s *Set) Replace(device protocol.DeviceID, fs []protocol.FileInfo) {
 	if debug {
-		l.Debugf("%s Replace(%v, [%d])", s.repo, node, len(fs))
+		l.Debugf("%s Replace(%v, [%d])", s.folder, device, len(fs))
 	}
 	normalizeFilenames(fs)
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	s.localVersion[node] = ldbReplace(s.db, []byte(s.repo), node[:], fs)
+	s.localVersion[device] = ldbReplace(s.db, []byte(s.folder), device[:], fs)
 	if len(fs) == 0 {
 		// Reset the local version if all files were removed.
-		s.localVersion[node] = 0
+		s.localVersion[device] = 0
 	}
 }
 
-func (s *Set) ReplaceWithDelete(node protocol.NodeID, fs []protocol.FileInfo) {
+func (s *Set) ReplaceWithDelete(device protocol.DeviceID, fs []protocol.FileInfo) {
 	if debug {
-		l.Debugf("%s ReplaceWithDelete(%v, [%d])", s.repo, node, len(fs))
+		l.Debugf("%s ReplaceWithDelete(%v, [%d])", s.folder, device, len(fs))
 	}
 	normalizeFilenames(fs)
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	if lv := ldbReplaceWithDelete(s.db, []byte(s.repo), node[:], fs); lv > s.localVersion[node] {
-		s.localVersion[node] = lv
+	if lv := ldbReplaceWithDelete(s.db, []byte(s.folder), device[:], fs); lv > s.localVersion[device] {
+		s.localVersion[device] = lv
 	}
 }
 
-func (s *Set) Update(node protocol.NodeID, fs []protocol.FileInfo) {
+func (s *Set) Update(device protocol.DeviceID, fs []protocol.FileInfo) {
 	if debug {
-		l.Debugf("%s Update(%v, [%d])", s.repo, node, len(fs))
+		l.Debugf("%s Update(%v, [%d])", s.folder, device, len(fs))
 	}
 	normalizeFilenames(fs)
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	if lv := ldbUpdate(s.db, []byte(s.repo), node[:], fs); lv > s.localVersion[node] {
-		s.localVersion[node] = lv
+	if lv := ldbUpdate(s.db, []byte(s.folder), device[:], fs); lv > s.localVersion[device] {
+		s.localVersion[device] = lv
 	}
 }
 
-func (s *Set) WithNeed(node protocol.NodeID, fn fileIterator) {
+func (s *Set) WithNeed(device protocol.DeviceID, fn fileIterator) {
 	if debug {
-		l.Debugf("%s WithNeed(%v)", s.repo, node)
+		l.Debugf("%s WithNeed(%v)", s.folder, device)
 	}
-	ldbWithNeed(s.db, []byte(s.repo), node[:], false, nativeFileIterator(fn))
+	ldbWithNeed(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn))
 }
 
-func (s *Set) WithNeedTruncated(node protocol.NodeID, fn fileIterator) {
+func (s *Set) WithNeedTruncated(device protocol.DeviceID, fn fileIterator) {
 	if debug {
-		l.Debugf("%s WithNeedTruncated(%v)", s.repo, node)
+		l.Debugf("%s WithNeedTruncated(%v)", s.folder, device)
 	}
-	ldbWithNeed(s.db, []byte(s.repo), node[:], true, nativeFileIterator(fn))
+	ldbWithNeed(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn))
 }
 
-func (s *Set) WithHave(node protocol.NodeID, fn fileIterator) {
+func (s *Set) WithHave(device protocol.DeviceID, fn fileIterator) {
 	if debug {
-		l.Debugf("%s WithHave(%v)", s.repo, node)
+		l.Debugf("%s WithHave(%v)", s.folder, device)
 	}
-	ldbWithHave(s.db, []byte(s.repo), node[:], false, nativeFileIterator(fn))
+	ldbWithHave(s.db, []byte(s.folder), device[:], false, nativeFileIterator(fn))
 }
 
-func (s *Set) WithHaveTruncated(node protocol.NodeID, fn fileIterator) {
+func (s *Set) WithHaveTruncated(device protocol.DeviceID, fn fileIterator) {
 	if debug {
-		l.Debugf("%s WithHaveTruncated(%v)", s.repo, node)
+		l.Debugf("%s WithHaveTruncated(%v)", s.folder, device)
 	}
-	ldbWithHave(s.db, []byte(s.repo), node[:], true, nativeFileIterator(fn))
+	ldbWithHave(s.db, []byte(s.folder), device[:], true, nativeFileIterator(fn))
 }
 
 func (s *Set) WithGlobal(fn fileIterator) {
 	if debug {
-		l.Debugf("%s WithGlobal()", s.repo)
+		l.Debugf("%s WithGlobal()", s.folder)
 	}
-	ldbWithGlobal(s.db, []byte(s.repo), false, nativeFileIterator(fn))
+	ldbWithGlobal(s.db, []byte(s.folder), false, nativeFileIterator(fn))
 }
 
 func (s *Set) WithGlobalTruncated(fn fileIterator) {
 	if debug {
-		l.Debugf("%s WithGlobalTruncated()", s.repo)
+		l.Debugf("%s WithGlobalTruncated()", s.folder)
 	}
-	ldbWithGlobal(s.db, []byte(s.repo), true, nativeFileIterator(fn))
+	ldbWithGlobal(s.db, []byte(s.folder), true, nativeFileIterator(fn))
 }
 
-func (s *Set) Get(node protocol.NodeID, file string) protocol.FileInfo {
-	f := ldbGet(s.db, []byte(s.repo), node[:], []byte(normalizedFilename(file)))
+func (s *Set) Get(device protocol.DeviceID, file string) protocol.FileInfo {
+	f := ldbGet(s.db, []byte(s.folder), device[:], []byte(normalizedFilename(file)))
 	f.Name = nativeFilename(f.Name)
 	return f
 }
 
 func (s *Set) GetGlobal(file string) protocol.FileInfo {
-	f := ldbGetGlobal(s.db, []byte(s.repo), []byte(normalizedFilename(file)))
+	f := ldbGetGlobal(s.db, []byte(s.folder), []byte(normalizedFilename(file)))
 	f.Name = nativeFilename(f.Name)
 	return f
 }
 
-func (s *Set) Availability(file string) []protocol.NodeID {
-	return ldbAvailability(s.db, []byte(s.repo), []byte(normalizedFilename(file)))
+func (s *Set) Availability(file string) []protocol.DeviceID {
+	return ldbAvailability(s.db, []byte(s.folder), []byte(normalizedFilename(file)))
 }
 
-func (s *Set) LocalVersion(node protocol.NodeID) uint64 {
+func (s *Set) LocalVersion(device protocol.DeviceID) uint64 {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	return s.localVersion[node]
+	return s.localVersion[device]
 }
 
-// ListRepos returns the repository IDs seen in the database.
-func ListRepos(db *leveldb.DB) []string {
-	return ldbListRepos(db)
+// ListFolders returns the folder IDs seen in the database.
+func ListFolders(db *leveldb.DB) []string {
+	return ldbListFolders(db)
 }
 
-// DropRepo clears out all information related to the given repo from the
+// DropFolder clears out all information related to the given folder from the
 // database.
-func DropRepo(db *leveldb.DB, repo string) {
-	ldbDropRepo(db, []byte(repo))
+func DropFolder(db *leveldb.DB, folder string) {
+	ldbDropFolder(db, []byte(folder))
 }
 
 func normalizeFilenames(fs []protocol.FileInfo) {

internal/files/set_test.go

@@ -18,11 +18,11 @@ import (
 	"github.com/syndtr/goleveldb/leveldb/storage"
 )
 
-var remoteNode0, remoteNode1 protocol.NodeID
+var remoteDevice0, remoteDevice1 protocol.DeviceID
 
 func init() {
-	remoteNode0, _ = protocol.NodeIDFromString("AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR")
-	remoteNode1, _ = protocol.NodeIDFromString("I6KAH76-66SLLLB-5PFXSOA-UFJCDZC-YAOMLEK-CP2GB32-BV5RQST-3PSROAU")
+	remoteDevice0, _ = protocol.DeviceIDFromString("AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR")
+	remoteDevice1, _ = protocol.DeviceIDFromString("I6KAH76-66SLLLB-5PFXSOA-UFJCDZC-YAOMLEK-CP2GB32-BV5RQST-3PSROAU")
 }
 
 func genBlocks(n int) []protocol.BlockInfo {
@@ -48,7 +48,7 @@ func globalList(s *files.Set) []protocol.FileInfo {
 	return fs
 }
 
-func haveList(s *files.Set, n protocol.NodeID) []protocol.FileInfo {
+func haveList(s *files.Set, n protocol.DeviceID) []protocol.FileInfo {
 	var fs []protocol.FileInfo
 	s.WithHave(n, func(fi protocol.FileIntf) bool {
 		f := fi.(protocol.FileInfo)
@@ -58,7 +58,7 @@ func haveList(s *files.Set, n protocol.NodeID) []protocol.FileInfo {
 	return fs
 }
 
-func needList(s *files.Set, n protocol.NodeID) []protocol.FileInfo {
+func needList(s *files.Set, n protocol.DeviceID) []protocol.FileInfo {
 	var fs []protocol.FileInfo
 	s.WithNeed(n, func(fi protocol.FileIntf) bool {
 		f := fi.(protocol.FileInfo)
@@ -158,10 +158,10 @@ func TestGlobalSet(t *testing.T) {
 		local0[3],
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local0)
-	m.ReplaceWithDelete(protocol.LocalNodeID, local1)
-	m.Replace(remoteNode0, remote0)
-	m.Update(remoteNode0, remote1)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local0)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local1)
+	m.Replace(remoteDevice0, remote0)
+	m.Update(remoteDevice0, remote1)
 
 	g := fileList(globalList(m))
 	sort.Sort(g)
@@ -170,40 +170,40 @@ func TestGlobalSet(t *testing.T) {
 		t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal)
 	}
 
-	h := fileList(haveList(m, protocol.LocalNodeID))
+	h := fileList(haveList(m, protocol.LocalDeviceID))
 	sort.Sort(h)
 
 	if fmt.Sprint(h) != fmt.Sprint(localTot) {
 		t.Errorf("Have incorrect;\n A: %v !=\n E: %v", h, localTot)
 	}
 
-	h = fileList(haveList(m, remoteNode0))
+	h = fileList(haveList(m, remoteDevice0))
 	sort.Sort(h)
 
 	if fmt.Sprint(h) != fmt.Sprint(remoteTot) {
 		t.Errorf("Have incorrect;\n A: %v !=\n E: %v", h, remoteTot)
 	}
 
-	n := fileList(needList(m, protocol.LocalNodeID))
+	n := fileList(needList(m, protocol.LocalDeviceID))
 	sort.Sort(n)
 
 	if fmt.Sprint(n) != fmt.Sprint(expectedLocalNeed) {
 		t.Errorf("Need incorrect;\n A: %v !=\n E: %v", n, expectedLocalNeed)
 	}
 
-	n = fileList(needList(m, remoteNode0))
+	n = fileList(needList(m, remoteDevice0))
 	sort.Sort(n)
 
 	if fmt.Sprint(n) != fmt.Sprint(expectedRemoteNeed) {
 		t.Errorf("Need incorrect;\n A: %v !=\n E: %v", n, expectedRemoteNeed)
 	}
 
-	f := m.Get(protocol.LocalNodeID, "b")
+	f := m.Get(protocol.LocalDeviceID, "b")
 	if fmt.Sprint(f) != fmt.Sprint(localTot[1]) {
 		t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, localTot[1])
 	}
 
-	f = m.Get(remoteNode0, "b")
+	f = m.Get(remoteDevice0, "b")
 	if fmt.Sprint(f) != fmt.Sprint(remote1[0]) {
 		t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, remote1[0])
 	}
@@ -213,7 +213,7 @@ func TestGlobalSet(t *testing.T) {
 		t.Errorf("GetGlobal incorrect;\n A: %v !=\n E: %v", f, remote1[0])
 	}
 
-	f = m.Get(protocol.LocalNodeID, "zz")
+	f = m.Get(protocol.LocalDeviceID, "zz")
 	if f.Name != "" {
 		t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, protocol.FileInfo{})
 	}
@@ -223,18 +223,18 @@ func TestGlobalSet(t *testing.T) {
 		t.Errorf("GetGlobal incorrect;\n A: %v !=\n E: %v", f, protocol.FileInfo{})
 	}
 
-	av := []protocol.NodeID{protocol.LocalNodeID, remoteNode0}
+	av := []protocol.DeviceID{protocol.LocalDeviceID, remoteDevice0}
 	a := m.Availability("a")
 	if !(len(a) == 2 && (a[0] == av[0] && a[1] == av[1] || a[0] == av[1] && a[1] == av[0])) {
 		t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, av)
 	}
 	a = m.Availability("b")
-	if len(a) != 1 || a[0] != remoteNode0 {
-		t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, remoteNode0)
+	if len(a) != 1 || a[0] != remoteDevice0 {
+		t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, remoteDevice0)
 	}
 	a = m.Availability("d")
-	if len(a) != 1 || a[0] != protocol.LocalNodeID {
-		t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, protocol.LocalNodeID)
+	if len(a) != 1 || a[0] != protocol.LocalDeviceID {
+		t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, protocol.LocalDeviceID)
 	}
 }
 
@@ -268,11 +268,11 @@ func TestNeedWithInvalid(t *testing.T) {
 		protocol.FileInfo{Name: "d", Version: 1003, Blocks: genBlocks(7)},
 	}
 
-	s.ReplaceWithDelete(protocol.LocalNodeID, localHave)
-	s.Replace(remoteNode0, remote0Have)
-	s.Replace(remoteNode1, remote1Have)
+	s.ReplaceWithDelete(protocol.LocalDeviceID, localHave)
+	s.Replace(remoteDevice0, remote0Have)
+	s.Replace(remoteDevice1, remote1Have)
 
-	need := fileList(needList(s, protocol.LocalNodeID))
+	need := fileList(needList(s, protocol.LocalDeviceID))
 	sort.Sort(need)
 
 	if fmt.Sprint(need) != fmt.Sprint(expectedNeed) {
@@ -297,9 +297,9 @@ func TestUpdateToInvalid(t *testing.T) {
 		protocol.FileInfo{Name: "d", Version: 1003, Blocks: genBlocks(7)},
 	}
 
-	s.ReplaceWithDelete(protocol.LocalNodeID, localHave)
+	s.ReplaceWithDelete(protocol.LocalDeviceID, localHave)
 
-	have := fileList(haveList(s, protocol.LocalNodeID))
+	have := fileList(haveList(s, protocol.LocalDeviceID))
 	sort.Sort(have)
 
 	if fmt.Sprint(have) != fmt.Sprint(localHave) {
@@ -307,9 +307,9 @@ func TestUpdateToInvalid(t *testing.T) {
 	}
 
 	localHave[1] = protocol.FileInfo{Name: "b", Version: 1001, Flags: protocol.FlagInvalid}
-	s.Update(protocol.LocalNodeID, localHave[1:2])
+	s.Update(protocol.LocalDeviceID, localHave[1:2])
 
-	have = fileList(haveList(s, protocol.LocalNodeID))
+	have = fileList(haveList(s, protocol.LocalDeviceID))
 	sort.Sort(have)
 
 	if fmt.Sprint(have) != fmt.Sprint(localHave) {
@@ -340,18 +340,18 @@ func TestInvalidAvailability(t *testing.T) {
 		protocol.FileInfo{Name: "none", Version: 1004, Blocks: genBlocks(5), Flags: protocol.FlagInvalid},
 	}
 
-	s.Replace(remoteNode0, remote0Have)
-	s.Replace(remoteNode1, remote1Have)
+	s.Replace(remoteDevice0, remote0Have)
+	s.Replace(remoteDevice1, remote1Have)
 
 	if av := s.Availability("both"); len(av) != 2 {
 		t.Error("Incorrect availability for 'both':", av)
 	}
 
-	if av := s.Availability("r0only"); len(av) != 1 || av[0] != remoteNode0 {
+	if av := s.Availability("r0only"); len(av) != 1 || av[0] != remoteDevice0 {
 		t.Error("Incorrect availability for 'r0only':", av)
 	}
 
-	if av := s.Availability("r1only"); len(av) != 1 || av[0] != remoteNode1 {
+	if av := s.Availability("r1only"); len(av) != 1 || av[0] != remoteDevice1 {
 		t.Error("Incorrect availability for 'r1only':", av)
 	}
 
@@ -376,22 +376,22 @@ func TestLocalDeleted(t *testing.T) {
 		protocol.FileInfo{Name: "z", Version: 1000, Flags: protocol.FlagDirectory},
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local1)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local1)
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
+	m.ReplaceWithDelete(protocol.LocalDeviceID, []protocol.FileInfo{
 		local1[0],
 		// [1] removed
 		local1[2],
 		local1[3],
 		local1[4],
 	})
-	m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
+	m.ReplaceWithDelete(protocol.LocalDeviceID, []protocol.FileInfo{
 		local1[0],
 		local1[2],
 		// [3] removed
 		local1[4],
 	})
-	m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
+	m.ReplaceWithDelete(protocol.LocalDeviceID, []protocol.FileInfo{
 		local1[0],
 		local1[2],
 		// [4] removed
@@ -413,7 +413,7 @@ func TestLocalDeleted(t *testing.T) {
 		t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal1)
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
+	m.ReplaceWithDelete(protocol.LocalDeviceID, []protocol.FileInfo{
 		local1[0],
 		// [2] removed
 	})
@@ -449,7 +449,7 @@ func Benchmark10kReplace(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		m := files.NewSet("test", db)
-		m.ReplaceWithDelete(protocol.LocalNodeID, local)
+		m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 	}
 }
 
@@ -465,14 +465,14 @@ func Benchmark10kUpdateChg(b *testing.B) {
 	}
 
 	m := files.NewSet("test", db)
-	m.Replace(remoteNode0, remote)
+	m.Replace(remoteDevice0, remote)
 
 	var local []protocol.FileInfo
 	for i := 0; i < 10000; i++ {
 		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -481,7 +481,7 @@ func Benchmark10kUpdateChg(b *testing.B) {
 			local[j].Version++
 		}
 		b.StartTimer()
-		m.Update(protocol.LocalNodeID, local)
+		m.Update(protocol.LocalDeviceID, local)
 	}
 }
 
@@ -496,18 +496,18 @@ func Benchmark10kUpdateSme(b *testing.B) {
 		b.Fatal(err)
 	}
 	m := files.NewSet("test", db)
-	m.Replace(remoteNode0, remote)
+	m.Replace(remoteDevice0, remote)
 
 	var local []protocol.FileInfo
 	for i := 0; i < 10000; i++ {
 		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		m.Update(protocol.LocalNodeID, local)
+		m.Update(protocol.LocalDeviceID, local)
 	}
 }
 
@@ -523,7 +523,7 @@ func Benchmark10kNeed2k(b *testing.B) {
 	}
 
 	m := files.NewSet("test", db)
-	m.Replace(remoteNode0, remote)
+	m.Replace(remoteDevice0, remote)
 
 	var local []protocol.FileInfo
 	for i := 0; i < 8000; i++ {
@@ -533,11 +533,11 @@ func Benchmark10kNeed2k(b *testing.B) {
 		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 980})
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		fs := needList(m, protocol.LocalNodeID)
+		fs := needList(m, protocol.LocalDeviceID)
 		if l := len(fs); l != 2000 {
 			b.Errorf("wrong length %d != 2k", l)
 		}
@@ -556,7 +556,7 @@ func Benchmark10kHaveFullList(b *testing.B) {
 	}
 
 	m := files.NewSet("test", db)
-	m.Replace(remoteNode0, remote)
+	m.Replace(remoteDevice0, remote)
 
 	var local []protocol.FileInfo
 	for i := 0; i < 2000; i++ {
@@ -566,11 +566,11 @@ func Benchmark10kHaveFullList(b *testing.B) {
 		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 980})
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		fs := haveList(m, protocol.LocalNodeID)
+		fs := haveList(m, protocol.LocalDeviceID)
 		if l := len(fs); l != 10000 {
 			b.Errorf("wrong length %d != 10k", l)
 		}
@@ -589,7 +589,7 @@ func Benchmark10kGlobal(b *testing.B) {
 	}
 
 	m := files.NewSet("test", db)
-	m.Replace(remoteNode0, remote)
+	m.Replace(remoteDevice0, remote)
 
 	var local []protocol.FileInfo
 	for i := 0; i < 2000; i++ {
@@ -599,7 +599,7 @@ func Benchmark10kGlobal(b *testing.B) {
 		local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 980})
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -632,7 +632,7 @@ func TestGlobalReset(t *testing.T) {
 		protocol.FileInfo{Name: "e", Version: 1000},
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
 	g := globalList(m)
 	sort.Sort(fileList(g))
 
@@ -640,8 +640,8 @@ func TestGlobalReset(t *testing.T) {
 		t.Errorf("Global incorrect;\n%v !=\n%v", g, local)
 	}
 
-	m.Replace(remoteNode0, remote)
-	m.Replace(remoteNode0, nil)
+	m.Replace(remoteDevice0, remote)
+	m.Replace(remoteDevice0, nil)
 
 	g = globalList(m)
 	sort.Sort(fileList(g))
@@ -679,10 +679,10 @@ func TestNeed(t *testing.T) {
 		protocol.FileInfo{Name: "e", Version: 1000},
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local)
-	m.Replace(remoteNode0, remote)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local)
+	m.Replace(remoteDevice0, remote)
 
-	need := needList(m, protocol.LocalNodeID)
+	need := needList(m, protocol.LocalDeviceID)
 
 	sort.Sort(fileList(need))
 	sort.Sort(fileList(shouldNeed))
@@ -715,23 +715,23 @@ func TestLocalVersion(t *testing.T) {
 		protocol.FileInfo{Name: "e", Version: 1000},
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local1)
-	c0 := m.LocalVersion(protocol.LocalNodeID)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local1)
+	c0 := m.LocalVersion(protocol.LocalDeviceID)
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local2)
-	c1 := m.LocalVersion(protocol.LocalNodeID)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local2)
+	c1 := m.LocalVersion(protocol.LocalDeviceID)
 	if !(c1 > c0) {
 		t.Fatal("Local version number should have incremented")
 	}
 
-	m.ReplaceWithDelete(protocol.LocalNodeID, local2)
-	c2 := m.LocalVersion(protocol.LocalNodeID)
+	m.ReplaceWithDelete(protocol.LocalDeviceID, local2)
+	c2 := m.LocalVersion(protocol.LocalDeviceID)
 	if c2 != c1 {
 		t.Fatal("Local version number should be unchanged")
 	}
 }
 
-func TestListDropRepo(t *testing.T) {
+func TestListDropFolder(t *testing.T) {
 	db, err := leveldb.Open(storage.NewMemStorage(), nil)
 	if err != nil {
 		t.Fatal(err)
@@ -743,7 +743,7 @@ func TestListDropRepo(t *testing.T) {
 		protocol.FileInfo{Name: "b", Version: 1000},
 		protocol.FileInfo{Name: "c", Version: 1000},
 	}
-	s0.Replace(protocol.LocalNodeID, local1)
+	s0.Replace(protocol.LocalDeviceID, local1)
 
 	s1 := files.NewSet("test1", db)
 	local2 := []protocol.FileInfo{
@@ -751,13 +751,13 @@ func TestListDropRepo(t *testing.T) {
 		protocol.FileInfo{Name: "e", Version: 1002},
 		protocol.FileInfo{Name: "f", Version: 1002},
 	}
-	s1.Replace(remoteNode0, local2)
+	s1.Replace(remoteDevice0, local2)
 
-	// Check that we have both repos and their data is in the global list
+	// Check that we have both folders and their data is in the global list
 
-	expectedRepoList := []string{"test0", "test1"}
-	if actualRepoList := files.ListRepos(db); !reflect.DeepEqual(actualRepoList, expectedRepoList) {
-		t.Fatalf("RepoList mismatch\nE: %v\nA: %v", expectedRepoList, actualRepoList)
+	expectedFolderList := []string{"test0", "test1"}
+	if actualFolderList := files.ListFolders(db); !reflect.DeepEqual(actualFolderList, expectedFolderList) {
+		t.Fatalf("FolderList mismatch\nE: %v\nA: %v", expectedFolderList, actualFolderList)
 	}
 	if l := len(globalList(s0)); l != 3 {
 		t.Errorf("Incorrect global length %d != 3 for s0", l)
@@ -768,11 +768,11 @@ func TestListDropRepo(t *testing.T) {
 
 	// Drop one of them and check that it's gone.
 
-	files.DropRepo(db, "test1")
+	files.DropFolder(db, "test1")
 
-	expectedRepoList = []string{"test0"}
-	if actualRepoList := files.ListRepos(db); !reflect.DeepEqual(actualRepoList, expectedRepoList) {
-		t.Fatalf("RepoList mismatch\nE: %v\nA: %v", expectedRepoList, actualRepoList)
+	expectedFolderList = []string{"test0"}
+	if actualFolderList := files.ListFolders(db); !reflect.DeepEqual(actualFolderList, expectedFolderList) {
+		t.Fatalf("FolderList mismatch\nE: %v\nA: %v", expectedFolderList, actualFolderList)
 	}
 	if l := len(globalList(s0)); l != 3 {
 		t.Errorf("Incorrect global length %d != 3 for s0", l)
@@ -795,14 +795,14 @@ func TestGlobalNeedWithInvalid(t *testing.T) {
 		protocol.FileInfo{Name: "b", Version: 1002, Flags: protocol.FlagInvalid},
 		protocol.FileInfo{Name: "c", Version: 1002, Blocks: genBlocks(4)},
 	}
-	s.Replace(remoteNode0, rem0)
+	s.Replace(remoteDevice0, rem0)
 
 	rem1 := fileList{
 		protocol.FileInfo{Name: "a", Version: 1002, Blocks: genBlocks(4)},
 		protocol.FileInfo{Name: "b", Version: 1002, Blocks: genBlocks(4)},
 		protocol.FileInfo{Name: "c", Version: 1002, Flags: protocol.FlagInvalid},
 	}
-	s.Replace(remoteNode1, rem1)
+	s.Replace(remoteDevice1, rem1)
 
 	total := fileList{
 		// There's a valid copy of each file, so it should be merged
@@ -811,7 +811,7 @@ func TestGlobalNeedWithInvalid(t *testing.T) {
 		protocol.FileInfo{Name: "c", Version: 1002, Blocks: genBlocks(4)},
 	}
 
-	need := fileList(needList(s, protocol.LocalNodeID))
+	need := fileList(needList(s, protocol.LocalDeviceID))
 	if fmt.Sprint(need) != fmt.Sprint(total) {
 		t.Errorf("Need incorrect;\n A: %v !=\n E: %v", need, total)
 	}
@@ -840,7 +840,7 @@ func TestLongPath(t *testing.T) {
 		protocol.FileInfo{Name: string(name), Version: 1000},
 	}
 
-	s.ReplaceWithDelete(protocol.LocalNodeID, local)
+	s.ReplaceWithDelete(protocol.LocalDeviceID, local)
 
 	gf := globalList(s)
 	if l := len(gf); l != 1 {
@@ -877,8 +877,8 @@ func TestStressGlobalVersion(t *testing.T) {
 	m := files.NewSet("test", db)
 
 	done := make(chan struct{})
-	go stressWriter(m, remoteNode0, set1, nil, done)
-	go stressWriter(m, protocol.LocalNodeID, set2, nil, done)
+	go stressWriter(m, remoteDevice0, set1, nil, done)
+	go stressWriter(m, protocol.LocalDeviceID, set2, nil, done)
 
 	t0 := time.Now()
 	for time.Since(t0) < dur {
@@ -891,7 +891,7 @@ func TestStressGlobalVersion(t *testing.T) {
 	close(done)
 }
 
-func stressWriter(s *files.Set, id protocol.NodeID, set1, set2 []protocol.FileInfo, done chan struct{}) {
+func stressWriter(s *files.Set, id protocol.DeviceID, set1, set2 []protocol.FileInfo, done chan struct{}) {
 	one := true
 	i := 0
 	for {