From 1dc8bcd48cb8563045bb85270113f1a029809c19 Mon Sep 17 00:00:00 2001
From: Fionera <fionera@fionera.de>
Date: Mon, 23 Sep 2019 15:32:36 +0200
Subject: [PATCH] Remove backend dependency from fs/hash
---
backend/dropbox/dropbox.go | 9 +-
backend/local/local.go | 2 +-
backend/local/local_internal_test.go | 2 +-
backend/mailru/mailru.go | 14 ++-
backend/onedrive/onedrive.go | 9 +-
cmd/dbhashsum/dbhashsum.go | 5 +-
cmd/hashsum/hashsum.go | 2 +-
fs/hash/hash.go | 178 ++++++++++++++-------------
fs/hash/hash_test.go | 34 +++--
fs/object/object.go | 2 +-
fs/object/object_test.go | 2 +-
fs/operations/operations.go | 11 +-
fs/operations/operations_test.go | 18 ---
13 files changed, 138 insertions(+), 150 deletions(-)
diff --git a/backend/dropbox/dropbox.go b/backend/dropbox/dropbox.go
index 57ed90a83..9dbfa5c20 100644
--- a/backend/dropbox/dropbox.go
+++ b/backend/dropbox/dropbox.go
@@ -39,6 +39,7 @@ import (
"github.com/dropbox/dropbox-sdk-go-unofficial/dropbox/team"
"github.com/dropbox/dropbox-sdk-go-unofficial/dropbox/users"
"github.com/pkg/errors"
+ "github.com/rclone/rclone/backend/dropbox/dbhash"
"github.com/rclone/rclone/fs"
"github.com/rclone/rclone/fs/config"
"github.com/rclone/rclone/fs/config/configmap"
@@ -105,10 +106,14 @@ var (
// A regexp matching path names for files Dropbox ignores
// See https://www.dropbox.com/en/help/145 - Ignored files
ignoredFiles = regexp.MustCompile(`(?i)(^|/)(desktop\.ini|thumbs\.db|\.ds_store|icon\r|\.dropbox|\.dropbox.attr)$`)
+
+ // DbHashType is the hash.Type for Dropbox
+ DbHashType hash.Type
)
// Register with Fs
func init() {
+ DbHashType = hash.RegisterHash("Dropbox", 64, dbhash.New)
fs.Register(&fs.RegInfo{
Name: "dropbox",
Description: "Dropbox",
@@ -881,7 +886,7 @@ func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) {
// Hashes returns the supported hash sets.
func (f *Fs) Hashes() hash.Set {
- return hash.Set(hash.Dropbox)
+ return hash.Set(DbHashType)
}
// ------------------------------------------------------------
@@ -906,7 +911,7 @@ func (o *Object) Remote() string {
// Hash returns the dropbox special hash
func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) {
- if t != hash.Dropbox {
+ if t != DbHashType {
return "", hash.ErrUnsupported
}
err := o.readMetaData()
diff --git a/backend/local/local.go b/backend/local/local.go
index 0f40dfe8f..fe5f87a2c 100644
--- a/backend/local/local.go
+++ b/backend/local/local.go
@@ -686,7 +686,7 @@ func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string
// Hashes returns the supported hash sets.
func (f *Fs) Hashes() hash.Set {
- return hash.Supported
+ return hash.Supported()
}
// ------------------------------------------------------------
diff --git a/backend/local/local_internal_test.go b/backend/local/local_internal_test.go
index ca3eee788..abdd74dad 100644
--- a/backend/local/local_internal_test.go
+++ b/backend/local/local_internal_test.go
@@ -44,7 +44,7 @@ func TestUpdatingCheck(t *testing.T) {
require.NoError(t, err)
o := &Object{size: fi.Size(), modTime: fi.ModTime(), fs: &Fs{}}
wrappedFd := readers.NewLimitedReadCloser(fd, -1)
- hash, err := hash.NewMultiHasherTypes(hash.Supported)
+ hash, err := hash.NewMultiHasherTypes(hash.Supported())
require.NoError(t, err)
in := localOpenFile{
o: o,
diff --git a/backend/mailru/mailru.go b/backend/mailru/mailru.go
index 31820ccc8..f799aec3e 100644
--- a/backend/mailru/mailru.go
+++ b/backend/mailru/mailru.go
@@ -59,6 +59,9 @@ var (
ErrorDirAlreadyExists = errors.New("directory already exists")
ErrorDirSourceNotExists = errors.New("directory source does not exist")
ErrorInvalidName = errors.New("invalid characters in object name")
+
+ // MrHashType is the hash.Type for Mailru
+ MrHashType hash.Type
)
// Description of how to authorize
@@ -74,6 +77,7 @@ var oauthConfig = &oauth2.Config{
// Register with Fs
func init() {
+ MrHashType = hash.RegisterHash("MailruHash", 40, mrhash.New)
fs.Register(&fs.RegInfo{
Name: "mailru",
Description: "Mail.ru Cloud",
@@ -1591,7 +1595,7 @@ func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, op
// Skip an extra speedup request if file fits in hash.
if size > mrhash.Size {
// Request hash from source.
- if srcHash, err := src.Hash(ctx, hash.Mailru); err == nil && srcHash != "" {
+ if srcHash, err := src.Hash(ctx, MrHashType); err == nil && srcHash != "" {
fileHash, _ = mrhash.DecodeString(srcHash)
}
@@ -1762,7 +1766,7 @@ func makeTempFile(ctx context.Context, tmpFs fs.Fs, wrapIn io.Reader, src fs.Obj
hashType := hash.SHA1
// Calculate Mailru and spool verification hashes in transit
- hashSet := hash.NewHashSet(hash.Mailru, hashType)
+ hashSet := hash.NewHashSet(MrHashType, hashType)
hasher, err := hash.NewMultiHasherTypes(hashSet)
if err != nil {
return nil, nil, err
@@ -1784,7 +1788,7 @@ func makeTempFile(ctx context.Context, tmpFs fs.Fs, wrapIn io.Reader, src fs.Obj
return nil, nil, mrhash.ErrorInvalidHash
}
- mrHash, err = mrhash.DecodeString(sums[hash.Mailru])
+ mrHash, err = mrhash.DecodeString(sums[MrHashType])
return
}
@@ -1972,7 +1976,7 @@ func (o *Object) Size() int64 {
// Hash returns the MD5 or SHA1 sum of an object
// returning a lowercase hex string
func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) {
- if t == hash.Mailru {
+ if t == MrHashType {
return hex.EncodeToString(o.mrHash), nil
}
return "", hash.ErrUnsupported
@@ -2354,7 +2358,7 @@ func (f *Fs) Precision() time.Duration {
// Hashes returns the supported hash sets
func (f *Fs) Hashes() hash.Set {
- return hash.Set(hash.Mailru)
+ return hash.Set(MrHashType)
}
// Features returns the optional features of this Fs
diff --git a/backend/onedrive/onedrive.go b/backend/onedrive/onedrive.go
index c23af9b21..7ff407de4 100644
--- a/backend/onedrive/onedrive.go
+++ b/backend/onedrive/onedrive.go
@@ -17,6 +17,7 @@ import (
"github.com/pkg/errors"
"github.com/rclone/rclone/backend/onedrive/api"
+ "github.com/rclone/rclone/backend/onedrive/quickxorhash"
"github.com/rclone/rclone/fs"
"github.com/rclone/rclone/fs/config"
"github.com/rclone/rclone/fs/config/configmap"
@@ -65,10 +66,14 @@ var (
ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret),
RedirectURL: oauthutil.RedirectLocalhostURL,
}
+
+ // QuickXorHashType is the hash.Type for OneDrive
+ QuickXorHashType hash.Type
)
// Register with Fs
func init() {
+ QuickXorHashType = hash.RegisterHash("QuickXorHash", 40, quickxorhash.New)
fs.Register(&fs.RegInfo{
Name: "onedrive",
Description: "Microsoft OneDrive",
@@ -1194,7 +1199,7 @@ func (f *Fs) Hashes() hash.Set {
if f.driveType == driveTypePersonal {
return hash.Set(hash.SHA1)
}
- return hash.Set(hash.QuickXorHash)
+ return hash.Set(QuickXorHashType)
}
// PublicLink returns a link for downloading without accout.
@@ -1270,7 +1275,7 @@ func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) {
return o.sha1, nil
}
} else {
- if t == hash.QuickXorHash {
+ if t == QuickXorHashType {
return o.quickxorhash, nil
}
}
diff --git a/cmd/dbhashsum/dbhashsum.go b/cmd/dbhashsum/dbhashsum.go
index f83313861..61715b377 100644
--- a/cmd/dbhashsum/dbhashsum.go
+++ b/cmd/dbhashsum/dbhashsum.go
@@ -4,7 +4,9 @@ import (
"context"
"os"
+ "github.com/rclone/rclone/backend/dropbox/dbhash"
"github.com/rclone/rclone/cmd"
+ "github.com/rclone/rclone/fs/hash"
"github.com/rclone/rclone/fs/operations"
"github.com/spf13/cobra"
)
@@ -26,7 +28,8 @@ The output is in the same format as md5sum and sha1sum.
cmd.CheckArgs(1, 1, command, args)
fsrc := cmd.NewFsSrc(args)
cmd.Run(false, false, command, func() error {
- return operations.DropboxHashSum(context.Background(), fsrc, os.Stdout)
+ dbHashType := hash.RegisterHash("Dropbox", 64, dbhash.New)
+ return operations.HashLister(context.Background(), dbHashType, fsrc, os.Stdout)
})
},
}
diff --git a/cmd/hashsum/hashsum.go b/cmd/hashsum/hashsum.go
index 91e260472..e04c1bc05 100644
--- a/cmd/hashsum/hashsum.go
+++ b/cmd/hashsum/hashsum.go
@@ -41,7 +41,7 @@ Then
cmd.CheckArgs(0, 2, command, args)
if len(args) == 0 {
fmt.Printf("Supported hashes are:\n")
- for _, ht := range hash.Supported.Array() {
+ for _, ht := range hash.Supported().Array() {
fmt.Printf(" * %v\n", ht)
}
return nil
diff --git a/fs/hash/hash.go b/fs/hash/hash.go
index 39c8abfeb..feee5200c 100644
--- a/fs/hash/hash.go
+++ b/fs/hash/hash.go
@@ -12,64 +12,88 @@ import (
"github.com/jzelinskie/whirlpool"
"github.com/pkg/errors"
- "github.com/rclone/rclone/backend/dropbox/dbhash"
- "github.com/rclone/rclone/backend/mailru/mrhash"
- "github.com/rclone/rclone/backend/onedrive/quickxorhash"
)
// Type indicates a standard hashing algorithm
type Type int
+type hashDefinition struct {
+ width int
+ name string
+ newFunc func() hash.Hash
+ hashType Type
+}
+
+var hashes []*hashDefinition
+var highestType Type = 1
+
+// RegisterHash adds a new Hash to the list and returns it Type
+func RegisterHash(name string, width int, newFunc func() hash.Hash) Type {
+ definition := &hashDefinition{
+ name: name,
+ width: width,
+ newFunc: newFunc,
+ hashType: highestType,
+ }
+ hashes = append(hashes, definition)
+ highestType = highestType << 1
+
+ return definition.hashType
+}
+
// ErrUnsupported should be returned by filesystem,
// if it is requested to deliver an unsupported hash type.
var ErrUnsupported = errors.New("hash type not supported")
-const (
+var (
+ // None indicates no hashes are supported
+ None Type
+
// MD5 indicates MD5 support
- MD5 Type = 1 << iota
+ MD5 Type
// SHA1 indicates SHA-1 support
- SHA1
-
- // Dropbox indicates Dropbox special hash
- // https://www.dropbox.com/developers/reference/content-hash
- Dropbox
-
- // QuickXorHash indicates Microsoft onedrive hash
- // https://docs.microsoft.com/en-us/onedrive/developer/code-snippets/quickxorhash
- QuickXorHash
+ SHA1 Type
// Whirlpool indicates Whirlpool support
- Whirlpool
+ Whirlpool Type
// CRC32 indicates CRC-32 support
- CRC32
-
- // Mailru indicates Mailru special hash
- Mailru
-
- // None indicates no hashes are supported
- None Type = 0
+ CRC32 Type
)
+func init() {
+ MD5 = RegisterHash("MD5", 32, md5.New)
+ SHA1 = RegisterHash("SHA-1", 40, sha1.New)
+ Whirlpool = RegisterHash("Whirlpool", 128, whirlpool.New)
+ CRC32 = RegisterHash("CRC32", 8, func() hash.Hash { return crc32.NewIEEE() })
+}
+
// Supported returns a set of all the supported hashes by
// HashStream and MultiHasher.
-var Supported = NewHashSet(MD5, SHA1, Dropbox, QuickXorHash, Whirlpool, CRC32, Mailru)
+func Supported() Set {
+ var types []Type
+ for _, v := range hashes {
+ types = append(types, v.hashType)
+ }
+
+ return NewHashSet(types...)
+}
// Width returns the width in characters for any HashType
-var Width = map[Type]int{
- MD5: 32,
- SHA1: 40,
- Dropbox: 64,
- QuickXorHash: 40,
- Whirlpool: 128,
- CRC32: 8,
- Mailru: 40,
+func Width(hashType Type) int {
+ for _, v := range hashes {
+ if v.hashType == hashType {
+ return v.width
+ }
+ }
+
+ return 0
}
// Stream will calculate hashes of all supported hash types.
func Stream(r io.Reader) (map[Type]string, error) {
- return StreamTypes(r, Supported)
+ return StreamTypes(r, Supported())
}
// StreamTypes will calculate hashes of the requested hash types.
@@ -93,52 +117,34 @@ func StreamTypes(r io.Reader, set Set) (map[Type]string, error) {
// String returns a string representation of the hash type.
// The function will panic if the hash type is unknown.
func (h Type) String() string {
- switch h {
- case None:
+ if h == None {
return "None"
- case MD5:
- return "MD5"
- case SHA1:
- return "SHA-1"
- case Dropbox:
- return "DropboxHash"
- case QuickXorHash:
- return "QuickXorHash"
- case Whirlpool:
- return "Whirlpool"
- case CRC32:
- return "CRC-32"
- case Mailru:
- return "MailruHash"
- default:
- err := fmt.Sprintf("internal error: unknown hash type: 0x%x", int(h))
- panic(err)
}
+
+ for _, v := range hashes {
+ if v.hashType == h {
+ return v.name
+ }
+ }
+
+ err := fmt.Sprintf("internal error: unknown hash type: 0x%x", int(h))
+ panic(err)
}
// Set a Type from a flag
func (h *Type) Set(s string) error {
- switch s {
- case "None":
+ if s == "None" {
*h = None
- case "MD5":
- *h = MD5
- case "SHA-1":
- *h = SHA1
- case "DropboxHash":
- *h = Dropbox
- case "QuickXorHash":
- *h = QuickXorHash
- case "Whirlpool":
- *h = Whirlpool
- case "CRC-32":
- *h = CRC32
- case "MailruHash":
- *h = Mailru
- default:
- return errors.Errorf("Unknown hash type %q", s)
}
- return nil
+
+ for _, v := range hashes {
+ if v.name == s {
+ *h = v.hashType
+ return nil
+ }
+ }
+
+ return errors.Errorf("Unknown hash type %q", s)
}
// Type of the value
@@ -150,32 +156,28 @@ func (h Type) Type() string {
// The types must be a subset of SupportedHashes,
// and this function must support all types.
func fromTypes(set Set) (map[Type]hash.Hash, error) {
- if !set.SubsetOf(Supported) {
+ if !set.SubsetOf(Supported()) {
return nil, errors.Errorf("requested set %08x contains unknown hash types", int(set))
}
var hashers = make(map[Type]hash.Hash)
+
types := set.Array()
for _, t := range types {
- switch t {
- case MD5:
- hashers[t] = md5.New()
- case SHA1:
- hashers[t] = sha1.New()
- case Dropbox:
- hashers[t] = dbhash.New()
- case QuickXorHash:
- hashers[t] = quickxorhash.New()
- case Whirlpool:
- hashers[t] = whirlpool.New()
- case CRC32:
- hashers[t] = crc32.NewIEEE()
- case Mailru:
- hashers[t] = mrhash.New()
- default:
+ for _, v := range hashes {
+ if t != v.hashType {
+ continue
+ }
+
+ hashers[t] = v.newFunc()
+ break
+ }
+
+ if hashers[t] == nil {
err := fmt.Sprintf("internal error: Unsupported hash type %v", t)
panic(err)
}
}
+
return hashers, nil
}
@@ -202,7 +204,7 @@ type MultiHasher struct {
// NewMultiHasher will return a hash writer that will write all
// supported hash types.
func NewMultiHasher() *MultiHasher {
- h, err := NewMultiHasherTypes(Supported)
+ h, err := NewMultiHasherTypes(Supported())
if err != nil {
panic("internal error: could not create multihasher")
}
diff --git a/fs/hash/hash_test.go b/fs/hash/hash_test.go
index 8b149eed9..e7653dbb1 100644
--- a/fs/hash/hash_test.go
+++ b/fs/hash/hash_test.go
@@ -3,6 +3,7 @@ package hash_test
import (
"bytes"
"io"
+ "log"
"testing"
"github.com/rclone/rclone/fs/hash"
@@ -23,6 +24,7 @@ func TestHashSet(t *testing.T) {
assert.Len(t, a, 0)
h = h.Add(hash.MD5)
+ log.Println(h)
assert.Equal(t, 1, h.Count())
assert.Equal(t, hash.MD5, h.GetOne())
a = h.Array()
@@ -30,10 +32,10 @@ func TestHashSet(t *testing.T) {
assert.Equal(t, a[0], hash.MD5)
// Test overlap, with all hashes
- h = h.Overlap(hash.Supported)
+ h = h.Overlap(hash.Supported())
assert.Equal(t, 1, h.Count())
assert.Equal(t, hash.MD5, h.GetOne())
- assert.True(t, h.SubsetOf(hash.Supported))
+ assert.True(t, h.SubsetOf(hash.Supported()))
assert.True(t, h.SubsetOf(hash.NewHashSet(hash.MD5)))
h = h.Add(hash.SHA1)
@@ -42,7 +44,7 @@ func TestHashSet(t *testing.T) {
if !(one == hash.MD5 || one == hash.SHA1) {
t.Fatalf("expected to be either MD5 or SHA1, got %v", one)
}
- assert.True(t, h.SubsetOf(hash.Supported))
+ assert.True(t, h.SubsetOf(hash.Supported()))
assert.False(t, h.SubsetOf(hash.NewHashSet(hash.MD5)))
assert.False(t, h.SubsetOf(hash.NewHashSet(hash.SHA1)))
assert.True(t, h.SubsetOf(hash.NewHashSet(hash.MD5, hash.SHA1)))
@@ -69,26 +71,20 @@ var hashTestSet = []hashTest{
{
input: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14},
output: map[hash.Type]string{
- hash.MD5: "bf13fc19e5151ac57d4252e0e0f87abe",
- hash.SHA1: "3ab6543c08a75f292a5ecedac87ec41642d12166",
- hash.Dropbox: "214d2fcf3566e94c99ad2f59bd993daca46d8521a0c447adf4b324f53fddc0c7",
- hash.QuickXorHash: "0110c000085000031c0001095ec00218d0000700",
- hash.Whirlpool: "eddf52133d4566d763f716e853d6e4efbabd29e2c2e63f56747b1596172851d34c2df9944beb6640dbdbe3d9b4eb61180720a79e3d15baff31c91e43d63869a4",
- hash.CRC32: "a6041d7e",
- hash.Mailru: "0102030405060708090a0b0c0d0e000000000000",
+ hash.MD5: "bf13fc19e5151ac57d4252e0e0f87abe",
+ hash.SHA1: "3ab6543c08a75f292a5ecedac87ec41642d12166",
+ hash.Whirlpool: "eddf52133d4566d763f716e853d6e4efbabd29e2c2e63f56747b1596172851d34c2df9944beb6640dbdbe3d9b4eb61180720a79e3d15baff31c91e43d63869a4",
+ hash.CRC32: "a6041d7e",
},
},
// Empty data set
{
input: []byte{},
output: map[hash.Type]string{
- hash.MD5: "d41d8cd98f00b204e9800998ecf8427e",
- hash.SHA1: "da39a3ee5e6b4b0d3255bfef95601890afd80709",
- hash.Dropbox: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
- hash.QuickXorHash: "0000000000000000000000000000000000000000",
- hash.Whirlpool: "19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3",
- hash.CRC32: "00000000",
- hash.Mailru: "0000000000000000000000000000000000000000",
+ hash.MD5: "d41d8cd98f00b204e9800998ecf8427e",
+ hash.SHA1: "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+ hash.Whirlpool: "19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3",
+ hash.CRC32: "00000000",
},
},
}
@@ -159,8 +155,8 @@ func TestHashStreamTypes(t *testing.T) {
}
func TestHashSetStringer(t *testing.T) {
- h := hash.NewHashSet(hash.SHA1, hash.MD5, hash.Dropbox, hash.QuickXorHash)
- assert.Equal(t, h.String(), "[MD5, SHA-1, DropboxHash, QuickXorHash]")
+ h := hash.NewHashSet(hash.SHA1, hash.MD5)
+ assert.Equal(t, h.String(), "[MD5, SHA-1]")
h = hash.NewHashSet(hash.SHA1)
assert.Equal(t, h.String(), "[SHA-1]")
h = hash.NewHashSet()
diff --git a/fs/object/object.go b/fs/object/object.go
index 14b26daa2..c88b9da02 100644
--- a/fs/object/object.go
+++ b/fs/object/object.go
@@ -79,7 +79,7 @@ func (memoryFs) String() string { return "memory" }
func (memoryFs) Precision() time.Duration { return time.Nanosecond }
// Returns the supported hash types of the filesystem
-func (memoryFs) Hashes() hash.Set { return hash.Supported }
+func (memoryFs) Hashes() hash.Set { return hash.Supported() }
// Features returns the optional features of this Fs
func (memoryFs) Features() *fs.Features { return &fs.Features{} }
diff --git a/fs/object/object_test.go b/fs/object/object_test.go
index 5e4ae1c00..d5cdfe619 100644
--- a/fs/object/object_test.go
+++ b/fs/object/object_test.go
@@ -53,7 +53,7 @@ func TestMemoryFs(t *testing.T) {
assert.Equal(t, "", f.Root())
assert.Equal(t, "memory", f.String())
assert.Equal(t, time.Nanosecond, f.Precision())
- assert.Equal(t, hash.Supported, f.Hashes())
+ assert.Equal(t, hash.Supported(), f.Hashes())
assert.Equal(t, &fs.Features{}, f.Features())
entries, err := f.List(context.Background(), "")
diff --git a/fs/operations/operations.go b/fs/operations/operations.go
index 30ba3cd50..d0181e578 100644
--- a/fs/operations/operations.go
+++ b/fs/operations/operations.go
@@ -980,15 +980,6 @@ func Sha1sum(ctx context.Context, f fs.Fs, w io.Writer) error {
return HashLister(ctx, hash.SHA1, f, w)
}
-// DropboxHashSum list the Fs to the supplied writer
-//
-// Obeys includes and excludes
-//
-// Lists in parallel which may get them out of order
-func DropboxHashSum(ctx context.Context, f fs.Fs, w io.Writer) error {
- return HashLister(ctx, hash.Dropbox, f, w)
-}
-
// hashSum returns the human readable hash for ht passed in. This may
// be UNSUPPORTED or ERROR.
func hashSum(ctx context.Context, ht hash.Type, o fs.Object) string {
@@ -1011,7 +1002,7 @@ func hashSum(ctx context.Context, ht hash.Type, o fs.Object) string {
func HashLister(ctx context.Context, ht hash.Type, f fs.Fs, w io.Writer) error {
return ListFn(ctx, f, func(o fs.Object) {
sum := hashSum(ctx, ht, o)
- syncFprintf(w, "%*s %s\n", hash.Width[ht], sum, o.Remote())
+ syncFprintf(w, "%*s %s\n", hash.Width(ht), sum, o.Remote())
})
}
diff --git a/fs/operations/operations_test.go b/fs/operations/operations_test.go
index b0112683f..8826f3767 100644
--- a/fs/operations/operations_test.go
+++ b/fs/operations/operations_test.go
@@ -225,23 +225,6 @@ func TestHashSums(t *testing.T) {
!strings.Contains(res, " potato2\n") {
t.Errorf("potato2 missing: %q", res)
}
-
- // Dropbox Hash Sum
-
- buf.Reset()
- err = operations.DropboxHashSum(context.Background(), r.Fremote, &buf)
- require.NoError(t, err)
- res = buf.String()
- if !strings.Contains(res, "fc62b10ec59efa8041f5a6c924d7c91572c1bbda280d9e01312b660804df1d47 empty space\n") &&
- !strings.Contains(res, " UNSUPPORTED empty space\n") &&
- !strings.Contains(res, " empty space\n") {
- t.Errorf("empty space missing: %q", res)
- }
- if !strings.Contains(res, "a979481df794fed9c3990a6a422e0b1044ac802c15fab13af9c687f8bdbee01a potato2\n") &&
- !strings.Contains(res, " UNSUPPORTED potato2\n") &&
- !strings.Contains(res, " potato2\n") {
- t.Errorf("potato2 missing: %q", res)
- }
}
func TestSuffixName(t *testing.T) {
@@ -1260,7 +1243,6 @@ func TestListFormat(t *testing.T) {
}{
{hash.MD5, "0cc175b9c0f1b6a831c399e269772661"},
{hash.SHA1, "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8"},
- {hash.Dropbox, "bf5d3affb73efd2ec6c36ad3112dd933efed63c4e1cbffcfa88e2759c144f2d8"},
} {
list.SetOutput(nil)
list.AddHash(test.ht)