chore(protocol): minor cleanup of ClusterConfig messages; remove DisableTempIndexes option (#10202)

This makes a couple of backwards compatible changes to the
ClusterConfig:

- Remove the `ignore_permissions` and `ignore_delete` booleans which
we've never read or used for anything
- Remove the `disable_temp_indexes` boolean and option entirely. We did
use this one, and about 1% of users have set the option. The only thing
it does is inhibits sending of periodical DownloadProgress messages
while downloading data, which is a minuscule bandwidth optimisation
given that we're already sending data at the time.
- Change the `read_only` boolean (which indicated send-only folders) to
an enum `FolderType`, where the values zero and one match the existing
usage. Again, we don't actually use this value, but I can see that we
might want to and then it makes more sense for it to be more
comprehensive.
- Change the `paused` boolean to an enum `StopReason`, where zero
indicates not stopped and one indicates paused, exactly the same wire
representation as previously but leaves space for additional stop
reasons (errors etc).

lib/protocol/bep_clusterconfig.go

@@ -12,12 +12,28 @@ import (
 	"github.com/syncthing/syncthing/internal/gen/bep"
 )
 
-type Compression = bep.Compression
+type Compression bep.Compression
 
 const (
-	CompressionMetadata = bep.Compression_COMPRESSION_METADATA
-	CompressionNever    = bep.Compression_COMPRESSION_NEVER
-	CompressionAlways   = bep.Compression_COMPRESSION_ALWAYS
+	CompressionMetadata = Compression(bep.Compression_COMPRESSION_METADATA)
+	CompressionNever    = Compression(bep.Compression_COMPRESSION_NEVER)
+	CompressionAlways   = Compression(bep.Compression_COMPRESSION_ALWAYS)
+)
+
+type FolderType bep.FolderType
+
+const (
+	FolderTypeSendReceive      = FolderType(bep.FolderType_FOLDER_TYPE_SEND_RECEIVE)
+	FolderTypeSendOnly         = FolderType(bep.FolderType_FOLDER_TYPE_SEND_ONLY)
+	FolderTypeReceiveOnly      = FolderType(bep.FolderType_FOLDER_TYPE_RECEIVE_ONLY)
+	FolderTypeReceiveEncrypted = FolderType(bep.FolderType_FOLDER_TYPE_RECEIVE_ENCRYPTED)
+)
+
+type FolderStopReason bep.FolderStopReason
+
+const (
+	FolderStopReasonRunning = FolderStopReason(bep.FolderStopReason_FOLDER_STOP_REASON_RUNNING)
+	FolderStopReasonPaused  = FolderStopReason(bep.FolderStopReason_FOLDER_STOP_REASON_PAUSED)
 )
 
 type ClusterConfig struct {
@@ -51,14 +67,11 @@ func clusterConfigFromWire(w *bep.ClusterConfig) *ClusterConfig {
 }
 
 type Folder struct {
-	ID                 string
-	Label              string
-	ReadOnly           bool
-	IgnorePermissions  bool
-	IgnoreDelete       bool
-	DisableTempIndexes bool
-	Paused             bool
-	Devices            []Device
+	ID         string
+	Label      string
+	Type       FolderType
+	StopReason FolderStopReason
+	Devices    []Device
 }
 
 func (f *Folder) toWire() *bep.Folder {
@@ -67,14 +80,11 @@ func (f *Folder) toWire() *bep.Folder {
 		devices[i] = d.toWire()
 	}
 	return &bep.Folder{
-		Id:                 f.ID,
-		Label:              f.Label,
-		ReadOnly:           f.ReadOnly,
-		IgnorePermissions:  f.IgnorePermissions,
-		IgnoreDelete:       f.IgnoreDelete,
-		DisableTempIndexes: f.DisableTempIndexes,
-		Paused:             f.Paused,
-		Devices:            devices,
+		Id:         f.ID,
+		Label:      f.Label,
+		Type:       bep.FolderType(f.Type),
+		StopReason: bep.FolderStopReason(f.StopReason),
+		Devices:    devices,
 	}
 }
 
@@ -84,14 +94,11 @@ func folderFromWire(w *bep.Folder) Folder {
 		devices[i] = deviceFromWire(d)
 	}
 	return Folder{
-		ID:                 w.Id,
-		Label:              w.Label,
-		ReadOnly:           w.ReadOnly,
-		IgnorePermissions:  w.IgnorePermissions,
-		IgnoreDelete:       w.IgnoreDelete,
-		DisableTempIndexes: w.DisableTempIndexes,
-		Paused:             w.Paused,
-		Devices:            devices,
+		ID:         w.Id,
+		Label:      w.Label,
+		Type:       FolderType(w.Type),
+		StopReason: FolderStopReason(w.StopReason),
+		Devices:    devices,
 	}
 }
 
@@ -103,6 +110,15 @@ func (f Folder) Description() string {
 	return fmt.Sprintf("%q (%s)", f.Label, f.ID)
 }
 
+func (f Folder) IsRunning() bool {
+	switch f.StopReason {
+	case FolderStopReasonPaused:
+		return false
+	default:
+		return true
+	}
+}
+
 type Device struct {
 	ID                       DeviceID
 	Name                     string
@@ -121,7 +137,7 @@ func (d *Device) toWire() *bep.Device {
 		Id:                       d.ID[:],
 		Name:                     d.Name,
 		Addresses:                d.Addresses,
-		Compression:              d.Compression,
+		Compression:              bep.Compression(d.Compression),
 		CertName:                 d.CertName,
 		MaxSequence:              d.MaxSequence,
 		Introducer:               d.Introducer,
@@ -136,7 +152,7 @@ func deviceFromWire(w *bep.Device) Device {
 		ID:                       DeviceID(w.Id),
 		Name:                     w.Name,
 		Addresses:                w.Addresses,
-		Compression:              w.Compression,
+		Compression:              Compression(w.Compression),
 		CertName:                 w.CertName,
 		MaxSequence:              w.MaxSequence,
 		Introducer:               w.Introducer,

lib/protocol/encryption.go

@@ -153,7 +153,9 @@ func (e encryptedModel) DownloadProgress(p *DownloadProgress) error {
 		return e.model.DownloadProgress(p)
 	}
 
-	// Encrypted devices shouldn't send these - ignore them.
+	// We currently ignore these, though we could in principle translate
+	// them and use partially downloaded encrypted files like we do normal
+	// files.
 	return nil
 }