build: cache go build & test

Signed-off-by: Anagh Kumar Baranwal <6824881+darthShadow@users.noreply.github.com>

.github/workflows/build.yml

@@ -29,12 +29,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        job_name: ['linux', 'linux_386', 'mac_amd64', 'mac_arm64', 'windows', 'other_os', 'go1.24']
+        job_name: ['linux', 'linux_386', 'mac_amd64', 'mac_arm64', 'windows', 'other_os', 'go1.23']
 
         include:
           - job_name: linux
             os: ubuntu-latest
-            go: '>=1.25.0-rc.1'
+            go: '>=1.24.0-rc.1'
             gotags: cmount
             build_flags: '-include "^linux/"'
             check: true
@@ -45,14 +45,14 @@ jobs:
 
           - job_name: linux_386
             os: ubuntu-latest
-            go: '>=1.25.0-rc.1'
+            go: '>=1.24.0-rc.1'
             goarch: 386
             gotags: cmount
             quicktest: true
 
           - job_name: mac_amd64
             os: macos-latest
-            go: '>=1.25.0-rc.1'
+            go: '>=1.24.0-rc.1'
             gotags: 'cmount'
             build_flags: '-include "^darwin/amd64" -cgo'
             quicktest: true
@@ -61,14 +61,14 @@ jobs:
 
           - job_name: mac_arm64
             os: macos-latest
-            go: '>=1.25.0-rc.1'
+            go: '>=1.24.0-rc.1'
             gotags: 'cmount'
             build_flags: '-include "^darwin/arm64" -cgo -macos-arch arm64 -cgo-cflags=-I/usr/local/include -cgo-ldflags=-L/usr/local/lib'
             deploy: true
 
           - job_name: windows
             os: windows-latest
-            go: '>=1.25.0-rc.1'
+            go: '>=1.24.0-rc.1'
             gotags: cmount
             cgo: '0'
             build_flags: '-include "^windows/"'
@@ -78,14 +78,14 @@ jobs:
 
           - job_name: other_os
             os: ubuntu-latest
-            go: '>=1.25.0-rc.1'
+            go: '>=1.24.0-rc.1'
             build_flags: '-exclude "^(windows/|darwin/|linux/)"'
             compile_all: true
             deploy: true
 
-          - job_name: go1.24
+          - job_name: go1.23
             os: ubuntu-latest
-            go: '1.24'
+            go: '1.23'
             quicktest: true
             racequicktest: true
 
@@ -95,7 +95,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -216,7 +216,7 @@ jobs:
           echo "runner-os-version=$ImageOS" >> $GITHUB_OUTPUT
 
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
             fetch-depth: 0
 
@@ -224,7 +224,7 @@ jobs:
         id: setup-go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.24'
+          go-version: '>=1.23.0-rc.1'
           check-latest: true
           cache: false
 
@@ -282,16 +282,6 @@ jobs:
       - name: Scan for vulnerabilities
         run: govulncheck ./...
 
-      - name: Check Markdown format
-        uses: DavidAnson/markdownlint-cli2-action@v20
-        with:
-          globs: |
-            CONTRIBUTING.md
-            MAINTAINERS.md
-            README.md
-            RELEASE.md
-            docs/content/{authors,bugs,changelog,docs,downloads,faq,filtering,gui,install,licence,overview,privacy}.md
-
       - name: Scan edits of autogenerated files
         run: bin/check_autogenerated_edits.py 'origin/${{ github.base_ref }}'
         if: github.event_name == 'pull_request'
@@ -304,7 +294,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -312,7 +302,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: '>=1.25.0-rc.1'
+          go-version: '>=1.24.0-rc.1'
 
       - name: Set global environment variables
         run: |

.github/workflows/build_android.yml

@@ -0,0 +1,212 @@
+---
+# Github Actions build for rclone
+# -*- compile-command: "yamllint -f parsable build_android.yml" -*-
+
+name: Build & Push Android Builds
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
+  cancel-in-progress: true
+
+# Trigger the workflow on push or pull request
+on:
+  push:
+    branches:
+      - '**'
+    tags:
+      - '**'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      manual:
+        description: Manual run (bypass default conditions)
+        type: boolean
+        default: true
+
+jobs:
+  android:
+    if: inputs.manual || (github.repository == 'rclone/rclone' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name))
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - job_name: android-all
+            platform: linux/amd64/android/go1.24
+            os: ubuntu-latest
+            go: '>=1.24.0-rc.1'
+
+    name: ${{ matrix.job_name }}
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Upgrade together with NDK version
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go }}
+          check-latest: true
+          cache: false
+
+      - name: Set Environment Variables
+        shell: bash
+        run: |
+          echo "GOMODCACHE=$(go env GOMODCACHE)" >> $GITHUB_ENV
+          echo "GOCACHE=$(go env GOCACHE)" >> $GITHUB_ENV
+          echo "VERSION=$(make version)" >> $GITHUB_ENV
+
+      - name: Set PLATFORM Variable
+        shell: bash
+        run: |
+          platform=${{ matrix.platform }}
+          echo "PLATFORM=${platform//\//-}" >> $GITHUB_ENV
+
+      - name: Get ImageOS
+        # There's no way around this, because "ImageOS" is only available to
+        # processes, but the setup-go action uses it in its key.
+        id: imageos
+        uses: actions/github-script@v7
+        with:
+          result-encoding: string
+          script: |
+            return process.env.ImageOS
+
+      - name: Set CACHE_PREFIX Variable
+        shell: bash
+        run: |
+          cache_prefix=${{ runner.os }}-${{ steps.imageos.outputs.result }}-${{ env.PLATFORM }}
+          echo "CACHE_PREFIX=${cache_prefix}" >> $GITHUB_ENV
+
+      - name: Load Go Module Cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ${{ env.GOMODCACHE }}
+          key: ${{ env.CACHE_PREFIX }}-modcache-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ env.CACHE_PREFIX }}-modcache
+
+      # Both load & update the cache when on default branch
+      - name: Load Go Build & Test Cache
+        id: go-cache
+        uses: actions/cache@v4
+        if: github.ref_name == github.event.repository.default_branch && github.event_name != 'pull_request'
+        with:
+          path: |
+            ${{ env.GOCACHE }}
+          key: ${{ env.CACHE_PREFIX }}-cache-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}-${{ github.run_id }}
+          restore-keys: |
+            ${{ env.CACHE_PREFIX }}-cache
+
+      # Only load the cache when not on default branch
+      - name: Load Go Build & Test Cache
+        id: go-cache-restore
+        uses: actions/cache/restore@v4
+        if: github.ref_name != github.event.repository.default_branch || github.event_name == 'pull_request'
+        with:
+          path: |
+            ${{ env.GOCACHE }}
+          key: ${{ env.CACHE_PREFIX }}-cache-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}-${{ github.run_id }}
+          restore-keys: |
+            ${{ env.CACHE_PREFIX }}-cache
+
+      - name: Build Native rclone
+        shell: bash
+        run: |
+          make
+
+      - name: Install gomobile
+        shell: bash
+        run: |
+          go install golang.org/x/mobile/cmd/gobind@latest
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          env PATH=$PATH:~/go/bin gomobile init
+          echo "RCLONE_NDK_VERSION=21" >> $GITHUB_ENV
+
+      - name: arm-v7a - gomobile build
+        shell: bash
+        run: env PATH=$PATH:~/go/bin gomobile bind -androidapi ${RCLONE_NDK_VERSION} -v -target=android/arm -javapkg=org.rclone -ldflags '-s -X github.com/rclone/rclone/fs.Version='${VERSION} github.com/rclone/rclone/librclone/gomobile
+
+      - name: arm-v7a - Set Environment Variables
+        shell: bash
+        run: |
+          echo "CC=$(echo $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi${RCLONE_NDK_VERSION}-clang)" >> $GITHUB_ENV
+          echo "CC_FOR_TARGET=$CC" >> $GITHUB_ENV
+          echo 'GOOS=android' >> $GITHUB_ENV
+          echo 'GOARCH=arm' >> $GITHUB_ENV
+          echo 'GOARM=7' >> $GITHUB_ENV
+          echo 'CGO_ENABLED=1' >> $GITHUB_ENV
+          echo 'CGO_LDFLAGS=-fuse-ld=lld -s -w' >> $GITHUB_ENV
+
+      - name: arm-v7a - Build
+        shell: bash
+        run: go build -v -tags android -trimpath -ldflags '-s -X github.com/rclone/rclone/fs.Version='${VERSION} -o build/rclone-android-${RCLONE_NDK_VERSION}-armv7a .
+
+      - name: arm64-v8a - Set Environment Variables
+        shell: bash
+        run: |
+          echo "CC=$(echo $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android${RCLONE_NDK_VERSION}-clang)" >> $GITHUB_ENV
+          echo "CC_FOR_TARGET=$CC" >> $GITHUB_ENV
+          echo 'GOOS=android' >> $GITHUB_ENV
+          echo 'GOARCH=arm64' >> $GITHUB_ENV
+          echo 'CGO_ENABLED=1' >> $GITHUB_ENV
+          echo 'CGO_LDFLAGS=-fuse-ld=lld -s -w' >> $GITHUB_ENV
+
+      - name: arm64-v8a - Build
+        shell: bash
+        run: go build -v -tags android -trimpath -ldflags '-s -X github.com/rclone/rclone/fs.Version='${VERSION} -o build/rclone-android-${RCLONE_NDK_VERSION}-armv8a .
+
+      - name: x86 - Set Environment Variables
+        shell: bash
+        run: |
+          echo "CC=$(echo $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/i686-linux-android${RCLONE_NDK_VERSION}-clang)" >> $GITHUB_ENV
+          echo "CC_FOR_TARGET=$CC" >> $GITHUB_ENV
+          echo 'GOOS=android' >> $GITHUB_ENV
+          echo 'GOARCH=386' >> $GITHUB_ENV
+          echo 'CGO_ENABLED=1' >> $GITHUB_ENV
+          echo 'CGO_LDFLAGS=-fuse-ld=lld -s -w' >> $GITHUB_ENV
+
+      - name: x86 - Build
+        shell: bash
+        run: go build -v -tags android -trimpath -ldflags '-s -X github.com/rclone/rclone/fs.Version='${VERSION} -o build/rclone-android-${RCLONE_NDK_VERSION}-x86 .
+
+      - name: x64 - Set Environment Variables
+        shell: bash
+        run: |
+          echo "CC=$(echo $ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin/x86_64-linux-android${RCLONE_NDK_VERSION}-clang)" >> $GITHUB_ENV
+          echo "CC_FOR_TARGET=$CC" >> $GITHUB_ENV
+          echo 'GOOS=android' >> $GITHUB_ENV
+          echo 'GOARCH=amd64' >> $GITHUB_ENV
+          echo 'CGO_ENABLED=1' >> $GITHUB_ENV
+          echo 'CGO_LDFLAGS=-fuse-ld=lld -s -w' >> $GITHUB_ENV
+
+      - name: x64 - Build
+        shell: bash
+        run: go build -v -tags android -trimpath -ldflags '-s -X github.com/rclone/rclone/fs.Version='${VERSION} -o build/rclone-android-${RCLONE_NDK_VERSION}-x64 .
+
+      - name: Delete Existing Cache
+        continue-on-error: true
+        shell: bash
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          cache_ids=($(gh cache list --key "${{ env.CACHE_PREFIX }}-cache" --json id | jq '.[].id'))
+          for cache_id in "${cache_ids[@]}"; do
+            echo "Deleting Cache: $cache_id"
+            gh cache delete "$cache_id"
+          done
+        if: github.ref_name == github.event.repository.default_branch && github.event_name != 'pull_request' && steps.go-cache.outputs.cache-hit != 'true'
+
+      - name: Deploy Built Binaries
+        shell: bash
+        run: |
+          make ci_upload
+        env:
+          RCLONE_CONFIG_PASS: ${{ secrets.RCLONE_CONFIG_PASS }}
+        # Upload artifacts if not a PR && not a fork
+        if: env.RCLONE_CONFIG_PASS != '' && github.head_ref == '' && github.repository == 'rclone/rclone'

.github/workflows/build_publish_docker_image.yml

@@ -4,6 +4,10 @@
 
 name: Build & Push Docker Images
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
+  cancel-in-progress: true
+
 # Trigger the workflow on push or pull request
 on:
   push:
@@ -41,32 +45,26 @@ jobs:
     runs-on: ${{ matrix.runs-on }}
 
     steps:
-      - name: Free Space
-        shell: bash
-        run: |
-          df -h .
-          # Remove android SDK
-          sudo rm -rf /usr/local/lib/android || true
-          # Remove .net runtime
-          sudo rm -rf /usr/share/dotnet || true
-          df -h .
-
       - name: Checkout Repository
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Set REPO_NAME Variable
+        shell: bash
         run: |
           echo "REPO_NAME=`echo ${{github.repository}} | tr '[:upper:]' '[:lower:]'`" >> ${GITHUB_ENV}
 
       - name: Set PLATFORM Variable
+        shell: bash
         run: |
           platform=${{ matrix.platform }}
           echo "PLATFORM=${platform//\//-}" >> $GITHUB_ENV
 
       - name: Set CACHE_NAME Variable
         shell: python
+        env:
+          GITHUB_EVENT_REPOSITORY_DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
         run: |
           import os, re
 
@@ -82,8 +80,11 @@ jobs:
 
           ref_name_slug = "cache"
 
-          if os.environ.get("GITHUB_REF_NAME") and os.environ['GITHUB_EVENT_NAME'] == "pull_request":
-            ref_name_slug += "-pr-" + slugify(os.environ['GITHUB_REF_NAME'])
+          if os.environ.get("GITHUB_REF_NAME"):
+            if os.environ['GITHUB_EVENT_NAME'] == "pull_request":
+              ref_name_slug += "-pr-" + slugify(os.environ['GITHUB_REF_NAME'])
+            elif os.environ['GITHUB_REF_NAME'] != os.environ['GITHUB_EVENT_REPOSITORY_DEFAULT_BRANCH']:
+              ref_name_slug += "-ref-" + slugify(os.environ['GITHUB_REF_NAME'])
 
           with open(os.environ['GITHUB_ENV'], 'a') as env:
               env.write(f"CACHE_NAME={ref_name_slug}\n")
@@ -98,6 +99,12 @@ jobs:
           script: |
             return process.env.ImageOS
 
+      - name: Set CACHE_PREFIX Variable
+        shell: bash
+        run: |
+          cache_prefix=${{ runner.os }}-${{ steps.imageos.outputs.result }}-${{ env.PLATFORM }}-docker-go
+          echo "CACHE_PREFIX=${cache_prefix}" >> $GITHUB_ENV
+
       - name: Extract Metadata (tags, labels) for Docker
         id: meta
         uses: docker/metadata-action@v5
@@ -130,22 +137,35 @@ jobs:
       - name: Load Go Build Cache for Docker
         id: go-cache
         uses: actions/cache@v4
+        if: github.ref_name == github.event.repository.default_branch
         with:
-          key: ${{ runner.os }}-${{ steps.imageos.outputs.result }}-go-${{ env.CACHE_NAME }}-${{ env.PLATFORM }}-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-${{ steps.imageos.outputs.result }}-go-${{ env.CACHE_NAME }}-${{ env.PLATFORM }}
           # Cache only the go builds, the module download is cached via the docker layer caching
           path: |
-            go-build-cache
+            /tmp/go-build-cache
+          key: ${{ env.CACHE_PREFIX }}-cache-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}-${{ github.run_id }}
+          restore-keys: |
+            ${{ env.CACHE_PREFIX }}-cache
+
+      - name: Load Go Build Cache for Docker
+        id: go-cache-restore
+        uses: actions/cache/restore@v4
+        if: github.ref_name != github.event.repository.default_branch
+        with:
+          # Cache only the go builds, the module download is cached via the docker layer caching
+          path: |
+            /tmp/go-build-cache
+          key: ${{ env.CACHE_PREFIX }}-cache-${{ hashFiles('**/go.mod') }}-${{ hashFiles('**/go.sum') }}-${{ github.run_id }}
+          restore-keys: |
+            ${{ env.CACHE_PREFIX }}-cache
 
       - name: Inject Go Build Cache into Docker
         uses: reproducible-containers/buildkit-cache-dance@v3
         with:
           cache-map: |
             {
-              "go-build-cache": "/root/.cache/go-build"
+              "/tmp/go-build-cache": "/root/.cache/go-build"
             }
-          skip-extraction: ${{ steps.go-cache.outputs.cache-hit }}
+          skip-extraction: ${{ steps.go-cache.outputs.cache-hit || steps.go-cache-restore.outputs.cache-hit }}
 
       - name: Login to GitHub Container Registry
         uses: docker/login-action@v3
@@ -172,9 +192,10 @@ jobs:
           outputs: |
             type=image,name=ghcr.io/${{ env.REPO_NAME }},push-by-digest=true,name-canonical=true,push=true
           cache-from: |
-            type=registry,ref=ghcr.io/${{ env.REPO_NAME }}:build-${{ env.CACHE_NAME }}-${{ env.PLATFORM }}
+            type=registry,ref=ghcr.io/${{ env.REPO_NAME }}:build-${{ env.PLATFORM }}-${{ env.CACHE_NAME }}
+            type=registry,ref=ghcr.io/${{ env.REPO_NAME }}:build-${{ env.PLATFORM }}-cache
           cache-to: |
-            type=registry,ref=ghcr.io/${{ env.REPO_NAME }}:build-${{ env.CACHE_NAME }}-${{ env.PLATFORM }},image-manifest=true,mode=max,compression=zstd
+            type=registry,ref=ghcr.io/${{ env.REPO_NAME }}:build-${{ env.PLATFORM }}-${{ env.CACHE_NAME }},image-manifest=true,mode=max,compression=zstd
 
       - name: Export Image Digest
         run: |
@@ -190,6 +211,19 @@ jobs:
           retention-days: 1
           if-no-files-found: error
 
+      - name: Delete Existing Cache
+        if: github.ref_name == github.event.repository.default_branch && steps.go-cache.outputs.cache-hit != 'true'
+        continue-on-error: true
+        shell: bash
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          cache_ids=($(gh cache list --key "${{ env.CACHE_PREFIX }}-cache" --json id | jq '.[].id'))
+          for cache_id in "${cache_ids[@]}"; do
+            echo "Deleting Cache: $cache_id"
+            gh cache delete "$cache_id"
+          done
+
   merge-image:
     name: Merge & Push Final Docker Image
     runs-on: ubuntu-24.04
@@ -198,13 +232,14 @@ jobs:
 
     steps:
       - name: Download Image Digests
-        uses: actions/download-artifact@v5
+        uses: actions/download-artifact@v4
         with:
           path: /tmp/digests
           pattern: digests-*
           merge-multiple: true
 
       - name: Set REPO_NAME Variable
+        shell: bash
         run: |
           echo "REPO_NAME=`echo ${{github.repository}} | tr '[:upper:]' '[:lower:]'`" >> ${GITHUB_ENV}
 

.github/workflows/build_publish_docker_plugin.yml

@@ -30,7 +30,7 @@ jobs:
           sudo rm -rf /usr/share/dotnet || true
           df -h .
       - name: Checkout master
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
       - name: Build and publish docker plugin

.github/workflows/lint.yml

@@ -0,0 +1,104 @@
+---
+# Github Actions build for rclone
+# -*- compile-command: "yamllint -f parsable lint.yml" -*-
+
+name: Lint & Vulnerability Check
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
+  cancel-in-progress: true
+
+# Trigger the workflow on push or pull request
+on:
+  push:
+    branches:
+      - '**'
+    tags:
+      - '**'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      manual:
+        description: Manual run (bypass default conditions)
+        type: boolean
+        default: true
+
+jobs:
+  lint:
+    if: inputs.manual || (github.repository == 'rclone/rclone' && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.event.pull_request.base.repo.full_name))
+    timeout-minutes: 30
+    name: "lint"
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Get runner parameters
+        id: get-runner-parameters
+        shell: bash
+        run: |
+          echo "year-week=$(/bin/date -u "+%Y%V")" >> $GITHUB_OUTPUT
+          echo "runner-os-version=$ImageOS" >> $GITHUB_OUTPUT
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Go
+        id: setup-go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '>=1.23.0-rc.1'
+          check-latest: true
+          cache: false
+
+      - name: Cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+            ~/.cache/golangci-lint
+          key: golangci-lint-${{ steps.get-runner-parameters.outputs.runner-os-version }}-go${{ steps.setup-go.outputs.go-version }}-${{ steps.get-runner-parameters.outputs.year-week }}-${{ hashFiles('go.sum') }}
+          restore-keys: golangci-lint-${{ steps.get-runner-parameters.outputs.runner-os-version }}-go${{ steps.setup-go.outputs.go-version }}-${{ steps.get-runner-parameters.outputs.year-week }}-
+
+      - name: Code quality test (Linux)
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: latest
+          skip-cache: true
+
+      - name: Code quality test (Windows)
+        uses: golangci/golangci-lint-action@v6
+        env:
+          GOOS: "windows"
+        with:
+          version: latest
+          skip-cache: true
+
+      - name: Code quality test (macOS)
+        uses: golangci/golangci-lint-action@v6
+        env:
+          GOOS: "darwin"
+        with:
+          version: latest
+          skip-cache: true
+
+      - name: Code quality test (FreeBSD)
+        uses: golangci/golangci-lint-action@v6
+        env:
+          GOOS: "freebsd"
+        with:
+          version: latest
+          skip-cache: true
+
+      - name: Code quality test (OpenBSD)
+        uses: golangci/golangci-lint-action@v6
+        env:
+          GOOS: "openbsd"
+        with:
+          version: latest
+          skip-cache: true
+
+      - name: Install govulncheck
+        run: go install golang.org/x/vuln/cmd/govulncheck@latest
+
+      - name: Scan for vulnerabilities
+        run: govulncheck ./...

.markdownlint.yml

@@ -1,43 +0,0 @@
-default: true
-
-# Use specific styles, to be consistent accross all documents.
-# Default is to accept any as long as it is consistent within the same document.
-heading-style: # MD003
-  style: atx
-ul-style: # MD004
-  style: dash
-hr-style: # MD035
-  style: ---
-code-block-style: # MD046
-  style: fenced
-code-fence-style: # MD048
-  style: backtick
-emphasis-style: # MD049
-  style: asterisk
-strong-style: # MD050
-  style: asterisk
-
-# Allow multiple headers with same text as long as they are not siblings.
-no-duplicate-heading: # MD024
-  siblings_only: true
-
-# Allow long lines in code blocks and tables.
-line-length: # MD013
-  code_blocks: false
-  tables: false
-
-# The Markdown files used to generated docs with Hugo contain a top level
-# header, even though the YAML front matter has a title property (which is
-# used for the HTML document title only). Suppress Markdownlint warning:
-# Multiple top-level headings in the same document.
-single-title: # MD025
-  level: 1
-  front_matter_title:
-
-# The HTML docs generated by Hugo from Markdown files may have slightly
-# different header anchors than GitHub rendered Markdown, e.g. Hugo trims
-# leading dashes so "--config string" becomes "#config-string" while it is
-# "#--config-string" in GitHub preview. When writing links to headers in the
-# Markdown files we must use whatever works in the final HTML generated docs.
-# Suppress Markdownlint warning: Link fragments should be valid.
-link-fragments: false # MD051

CONTRIBUTING.md

@@ -15,81 +15,61 @@ with the [latest beta of rclone](https://beta.rclone.org/):
 - Rclone version (e.g. output from `rclone version`)
 - Which OS you are using and how many bits (e.g. Windows 10, 64 bit)
 - The command you were trying to run (e.g. `rclone copy /tmp remote:tmp`)
-- A log of the command with the `-vv` flag (e.g. output from
-  `rclone -vv copy /tmp remote:tmp`)
-  - if the log contains secrets then edit the file with a text editor first to
-    obscure them
+- A log of the command with the `-vv` flag (e.g. output from `rclone -vv copy /tmp remote:tmp`)
+    - if the log contains secrets then edit the file with a text editor first to obscure them
 
 ## Submitting a new feature or bug fix
 
 If you find a bug that you'd like to fix, or a new feature that you'd
 like to implement then please submit a pull request via GitHub.
 
-If it is a big feature, then [make an issue](https://github.com/rclone/rclone/issues)
-first so it can be discussed.
+If it is a big feature, then [make an issue](https://github.com/rclone/rclone/issues) first so it can be discussed.
 
 To prepare your pull request first press the fork button on [rclone's GitHub
 page](https://github.com/rclone/rclone).
 
-Then [install Git](https://git-scm.com/downloads) and set your public contribution
-[name](https://docs.github.com/en/github/getting-started-with-github/setting-your-username-in-git)
-and [email](https://docs.github.com/en/github/setting-up-and-managing-your-github-user-account/setting-your-commit-email-address#setting-your-commit-email-address-in-git).
+Then [install Git](https://git-scm.com/downloads) and set your public contribution [name](https://docs.github.com/en/github/getting-started-with-github/setting-your-username-in-git) and [email](https://docs.github.com/en/github/setting-up-and-managing-your-github-user-account/setting-your-commit-email-address#setting-your-commit-email-address-in-git).
 
-Next open your terminal, change directory to your preferred folder and initialise
-your local rclone project:
+Next open your terminal, change directory to your preferred folder and initialise your local rclone project:
 
-```sh
-git clone https://github.com/rclone/rclone.git
-cd rclone
-git remote rename origin upstream
-  # if you have SSH keys setup in your GitHub account:
-git remote add origin git@github.com:YOURUSER/rclone.git
-  # otherwise:
-git remote add origin https://github.com/YOURUSER/rclone.git
-```
+    git clone https://github.com/rclone/rclone.git
+    cd rclone
+    git remote rename origin upstream
+      # if you have SSH keys setup in your GitHub account:
+    git remote add origin git@github.com:YOURUSER/rclone.git
+      # otherwise:
+    git remote add origin https://github.com/YOURUSER/rclone.git
 
-Note that most of the terminal commands in the rest of this guide must be
-executed from the rclone folder created above.
+Note that most of the terminal commands in the rest of this guide must be executed from the rclone folder created above.
 
 Now [install Go](https://golang.org/doc/install) and verify your installation:
 
-```sh
-go version
-```
+    go version
 
 Great, you can now compile and execute your own version of rclone:
 
-```sh
-go build
-./rclone version
-```
+    go build
+    ./rclone version
 
 (Note that you can also replace `go build` with `make`, which will include a
 more accurate version number in the executable as well as enable you to specify
 more build options.) Finally make a branch to add your new feature
 
-```sh
-git checkout -b my-new-feature
-```
+    git checkout -b my-new-feature
 
 And get hacking.
 
-You may like one of the [popular editors/IDE's for Go](https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins)
-and a quick view on the rclone [code organisation](#code-organisation).
+You may like one of the [popular editors/IDE's for Go](https://github.com/golang/go/wiki/IDEsAndTextEditorPlugins) and a quick view on the rclone [code organisation](#code-organisation).
 
-When ready - test the affected functionality and run the unit tests for the
-code you changed
+When ready - test the affected functionality and run the unit tests for the code you changed
 
-```sh
-cd folder/with/changed/files
-go test -v
-```
+    cd folder/with/changed/files
+    go test -v
 
 Note that you may need to make a test remote, e.g. `TestSwift` for some
 of the unit tests.
 
-This is typically enough if you made a simple bug fix, otherwise please read
-the rclone [testing](#testing) section too.
+This is typically enough if you made a simple bug fix, otherwise please read the rclone [testing](#testing) section too.
 
 Make sure you
 
@@ -99,19 +79,14 @@ Make sure you
 
 When you are done with that push your changes to GitHub:
 
-```sh
-git push -u origin my-new-feature
-```
+    git push -u origin my-new-feature
 
 and open the GitHub website to [create your pull
 request](https://help.github.com/articles/creating-a-pull-request/).
 
-Your changes will then get reviewed and you might get asked to fix some stuff.
-If so, then make the changes in the same branch, commit and push your updates to
-GitHub.
+Your changes will then get reviewed and you might get asked to fix some stuff. If so, then make the changes in the same branch, commit and push your updates to GitHub.
 
-You may sometimes be asked to [base your changes on the latest master](#basing-your-changes-on-the-latest-master)
-or [squash your commits](#squashing-your-commits).
+You may sometimes be asked to [base your changes on the latest master](#basing-your-changes-on-the-latest-master) or [squash your commits](#squashing-your-commits).
 
 ## Using Git and GitHub
 
@@ -119,118 +94,87 @@ or [squash your commits](#squashing-your-commits).
 
 Follow the guideline for [commit messages](#commit-messages) and then:
 
-```sh
-git checkout my-new-feature      # To switch to your branch
-git status                       # To see the new and changed files
-git add FILENAME                 # To select FILENAME for the commit
-git status                       # To verify the changes to be committed
-git commit                       # To do the commit
-git log                          # To verify the commit. Use q to quit the log
-```
+    git checkout my-new-feature      # To switch to your branch
+    git status                       # To see the new and changed files
+    git add FILENAME                 # To select FILENAME for the commit
+    git status                       # To verify the changes to be committed
+    git commit                       # To do the commit
+    git log                          # To verify the commit. Use q to quit the log
 
 You can modify the message or changes in the latest commit using:
 
-```sh
-git commit --amend
-```
+    git commit --amend
 
-If you amend to commits that have been pushed to GitHub, then you will have to
-[replace your previously pushed commits](#replacing-your-previously-pushed-commits).
+If you amend to commits that have been pushed to GitHub, then you will have to [replace your previously pushed commits](#replacing-your-previously-pushed-commits).
 
 ### Replacing your previously pushed commits
 
-Note that you are about to rewrite the GitHub history of your branch. It is good
-practice to involve your collaborators before modifying commits that have been
-pushed to GitHub.
+Note that you are about to rewrite the GitHub history of your branch. It is good practice to involve your collaborators before modifying commits that have been pushed to GitHub.
 
 Your previously pushed commits are replaced by:
 
-```sh
-git push --force origin my-new-feature 
-```
+    git push --force origin my-new-feature 
 
 ### Basing your changes on the latest master
 
-To base your changes on the latest version of the
-[rclone master](https://github.com/rclone/rclone/tree/master) (upstream):
+To base your changes on the latest version of the [rclone master](https://github.com/rclone/rclone/tree/master) (upstream):
 
-```sh
-git checkout master
-git fetch upstream
-git merge --ff-only
-git push origin --follow-tags    # optional update of your fork in GitHub
-git checkout my-new-feature
-git rebase master
-```
+    git checkout master
+    git fetch upstream
+    git merge --ff-only
+    git push origin --follow-tags    # optional update of your fork in GitHub
+    git checkout my-new-feature
+    git rebase master
 
-If you rebase commits that have been pushed to GitHub, then you will have to
-[replace your previously pushed commits](#replacing-your-previously-pushed-commits).
+If you rebase commits that have been pushed to GitHub, then you will have to [replace your previously pushed commits](#replacing-your-previously-pushed-commits).
 
-### Squashing your commits
+### Squashing your commits ###
 
 To combine your commits into one commit:
 
-```sh
-git log                          # To count the commits to squash, e.g. the last 2
-git reset --soft HEAD~2          # To undo the 2 latest commits
-git status                       # To check everything is as expected
-```
+    git log                          # To count the commits to squash, e.g. the last 2
+    git reset --soft HEAD~2          # To undo the 2 latest commits
+    git status                       # To check everything is as expected
 
 If everything is fine, then make the new combined commit:
 
-```sh
-git commit                       # To commit the undone commits as one
-```
+    git commit                       # To commit the undone commits as one
 
 otherwise, you may roll back using:
 
-```sh
-git reflog                       # To check that HEAD{1} is your previous state
-git reset --soft 'HEAD@{1}'      # To roll back to your previous state
-```
+    git reflog                       # To check that HEAD{1} is your previous state
+    git reset --soft 'HEAD@{1}'      # To roll back to your previous state
 
-If you squash commits that have been pushed to GitHub, then you will have to
-[replace your previously pushed commits](#replacing-your-previously-pushed-commits).
+If you squash commits that have been pushed to GitHub, then you will have to [replace your previously pushed commits](#replacing-your-previously-pushed-commits).
 
-Tip: You may like to use `git rebase -i master` if you are experienced or have a
-more complex situation.
+Tip: You may like to use `git rebase -i master` if you are experienced or have a more complex situation.
 
 ### GitHub Continuous Integration
 
-rclone currently uses [GitHub Actions](https://github.com/rclone/rclone/actions)
-to build and test the project, which should be automatically available for your
-fork too from the `Actions` tab in your repository.
+rclone currently uses [GitHub Actions](https://github.com/rclone/rclone/actions) to build and test the project, which should be automatically available for your fork too from the `Actions` tab in your repository.
 
 ## Testing
 
 ### Code quality tests
 
-If you install [golangci-lint](https://github.com/golangci/golangci-lint) then
-you can run the same tests as get run in the CI which can be very helpful.
+If you install [golangci-lint](https://github.com/golangci/golangci-lint) then you can run the same tests as get run in the CI which can be very helpful.
 
 You can run them with `make check` or with `golangci-lint run ./...`.
 
-Using these tests ensures that the rclone codebase all uses the same coding
-standards. These tests also check for easy mistakes to make (like forgetting
-to check an error return).
+Using these tests ensures that the rclone codebase all uses the same coding standards. These tests also check for easy mistakes to make (like forgetting to check an error return).
 
 ### Quick testing
 
 rclone's tests are run from the go testing framework, so at the top
 level you can run this to run all the tests.
 
-```sh
-go test -v ./...
-```
+    go test -v ./...
 
 You can also use `make`, if supported by your platform
 
-```sh
-make quicktest
-```
+    make quicktest
 
-The quicktest is [automatically run by GitHub](#github-continuous-integration)
-when you push your branch to GitHub.
+The quicktest is [automatically run by GitHub](#github-continuous-integration) when you push your branch to GitHub.
 
 ### Backend testing
 
@@ -246,51 +190,41 @@ need to make a remote called `TestDrive`.
 You can then run the unit tests in the drive directory.  These tests
 are skipped if `TestDrive:` isn't defined.
 
-```sh
-cd backend/drive
-go test -v
-```
+    cd backend/drive
+    go test -v
 
 You can then run the integration tests which test all of rclone's
 operations.  Normally these get run against the local file system,
 but they can be run against any of the remotes.
 
-```sh
-cd fs/sync
-go test -v -remote TestDrive:
-go test -v -remote TestDrive: -fast-list
+    cd fs/sync
+    go test -v -remote TestDrive:
+    go test -v -remote TestDrive: -fast-list
 
-cd fs/operations
-go test -v -remote TestDrive:
-```
+    cd fs/operations
+    go test -v -remote TestDrive:
 
 If you want to use the integration test framework to run these tests
 altogether with an HTML report and test retries then from the
 project root:
 
-```sh
-go install github.com/rclone/rclone/fstest/test_all
-test_all -backends drive
-```
+    go install github.com/rclone/rclone/fstest/test_all
+    test_all -backends drive
 
 ### Full integration testing
 
 If you want to run all the integration tests against all the remotes,
 then change into the project root and run
 
-```sh
-make check
-make test
-```
+    make check
+    make test
 
 The commands may require some extra go packages which you can install with
 
-```sh
-make build_dep
-```
+    make build_dep
 
 The full integration tests are run daily on the integration test server. You can
-find the results at <https://pub.rclone.org/integration-tests/>
+find the results at https://pub.rclone.org/integration-tests/
 
 ## Code Organisation
 
@@ -298,48 +232,46 @@ Rclone code is organised into a small number of top level directories
 with modules beneath.
 
 - backend - the rclone backends for interfacing to cloud providers -
-  - all - import this to load all the cloud providers
-  - ...providers
+    - all - import this to load all the cloud providers
+    - ...providers
 - bin - scripts for use while building or maintaining rclone
 - cmd - the rclone commands
-  - all - import this to load all the commands
-  - ...commands
+    - all - import this to load all the commands
+    - ...commands
 - cmdtest - end-to-end tests of commands, flags, environment variables,...
 - docs - the documentation and website
-  - content - adjust these docs only, except those marked autogenerated
-    or portions marked autogenerated where the corresponding .go file must be
-    edited instead, and everything else is autogenerated
-    - commands - these are auto-generated, edit the corresponding .go file
+    - content - adjust these docs only - everything else is autogenerated
+    - command - these are auto-generated - edit the corresponding .go file
 - fs - main rclone definitions - minimal amount of code
-  - accounting - bandwidth limiting and statistics
-  - asyncreader - an io.Reader which reads ahead
-  - config - manage the config file and flags
-  - driveletter - detect if a name is a drive letter
-  - filter - implements include/exclude filtering
-  - fserrors - rclone specific error handling
-  - fshttp - http handling for rclone
-  - fspath - path handling for rclone
-  - hash - defines rclone's hash types and functions
-  - list - list a remote
-  - log - logging facilities
-  - march - iterates directories in lock step
-  - object - in memory Fs objects
-  - operations - primitives for sync, e.g. Copy, Move
-  - sync - sync directories
-  - walk - walk a directory
+    - accounting - bandwidth limiting and statistics
+    - asyncreader - an io.Reader which reads ahead
+    - config - manage the config file and flags
+    - driveletter - detect if a name is a drive letter
+    - filter - implements include/exclude filtering
+    - fserrors - rclone specific error handling
+    - fshttp - http handling for rclone
+    - fspath - path handling for rclone
+    - hash - defines rclone's hash types and functions
+    - list - list a remote
+    - log - logging facilities
+    - march - iterates directories in lock step
+    - object - in memory Fs objects
+    - operations - primitives for sync, e.g. Copy, Move
+    - sync - sync directories
+    - walk - walk a directory
 - fstest - provides integration test framework
-  - fstests - integration tests for the backends
-  - mockdir - mocks an fs.Directory
-  - mockobject - mocks an fs.Object
-  - test_all - Runs integration tests for everything
+    - fstests - integration tests for the backends
+    - mockdir - mocks an fs.Directory
+    - mockobject - mocks an fs.Object
+    - test_all - Runs integration tests for everything
 - graphics - the images used in the website, etc.
 - lib - libraries used by the backend
-  - atexit - register functions to run when rclone exits
-  - dircache - directory ID to name caching
-  - oauthutil - helpers for using oauth
-  - pacer - retries with backoff and paces operations
-  - readers - a selection of useful io.Readers
-  - rest - a thin abstraction over net/http for REST
+    - atexit - register functions to run when rclone exits
+    - dircache - directory ID to name caching
+    - oauthutil - helpers for using oauth
+    - pacer - retries with backoff and paces operations
+    - readers - a selection of useful io.Readers
+    - rest - a thin abstraction over net/http for REST
 - librclone - in memory interface to rclone's API for embedding rclone
 - vfs - Virtual FileSystem layer for implementing rclone mount and similar
 
@@ -347,36 +279,6 @@ with modules beneath.
 
 If you are adding a new feature then please update the documentation.
 
-The documentation sources are generally in Markdown format, in conformance
-with the CommonMark specification and compatible with GitHub Flavored
-Markdown (GFM). The markdown format is checked as part of the lint operation
-that runs automatically on pull requests, to enforce standards and consistency.
-This is based on the [markdownlint](https://github.com/DavidAnson/markdownlint)
-tool, which can also be integrated into editors so you can perform the same
-checks while writing.
-
-HTML pages, served as website <rclone.org>, are generated from the Markdown,
-using [Hugo](https://gohugo.io). Note that when generating the HTML pages,
-there is currently used a different algorithm for generating header anchors
-than what GitHub uses for its Markdown rendering. For example, in the HTML docs
-generated by Hugo any leading `-` characters are ignored, which means when
-linking to a header with text `--config string` we therefore need to use the
-link `#config-string` in our Markdown source, which will not work in GitHub's
-preview where `#--config-string` would be the correct link.
-
-Most of the documentation are written directly in text files with extension
-`.md`, mainly within folder `docs/content`. Note that several of such files
-are autogenerated (e.g. the command documentation, and `docs/content/flags.md`),
-or contain autogenerated portions (e.g. the backend documentation under
-`docs/content/commands`). These are marked with an `autogenerated` comment.
-The sources of the autogenerated text are usually Markdown formatted text
-embedded as string values in the Go source code, so you need to locate these
-and edit the `.go` file instead. The `MANUAL.*`, `rclone.1` and other text
-files in the root of the repository are also autogenerated. The autogeneration
-of files, and the website, will be done during the release process. See the
-`make doc` and `make website` targets in the Makefile if you are interested in
-how. You don't need to run these when adding a feature.
-
 If you add a new general flag (not for a backend), then document it in
 `docs/content/docs.md` - the flags there are supposed to be in
 alphabetical order.
@@ -385,40 +287,39 @@ If you add a new backend option/flag, then it should be documented in
 the source file in the `Help:` field.
 
 - Start with the most important information about the option,
-  as a single sentence on a single line.
-  - This text will be used for the command-line flag help.
-  - It will be combined with other information, such as any default value,
-    and the result will look odd if not written as a single sentence.
-  - It should end with a period/full stop character, which will be shown
-    in docs but automatically removed when producing the flag help.
-  - Try to keep it below 80 characters, to reduce text wrapping in the terminal.
+    as a single sentence on a single line.
+    - This text will be used for the command-line flag help.
+    - It will be combined with other information, such as any default value,
+      and the result will look odd if not written as a single sentence.
+    - It should end with a period/full stop character, which will be shown
+      in docs but automatically removed when producing the flag help.
+    - Try to keep it below 80 characters, to reduce text wrapping in the terminal.
 - More details can be added in a new paragraph, after an empty line (`"\n\n"`).
-  - Like with docs generated from Markdown, a single line break is ignored
-    and two line breaks creates a new paragraph.
-  - This text will be shown to the user in `rclone config`
-    and in the docs (where it will be added by `make backenddocs`,
-    normally run some time before next release).
+    - Like with docs generated from Markdown, a single line break is ignored
+      and two line breaks creates a new paragraph.
+    - This text will be shown to the user in `rclone config`
+      and in the docs (where it will be added by `make backenddocs`,
+      normally run some time before next release).
 - To create options of enumeration type use the `Examples:` field.
-  - Each example value have their own `Help:` field, but they are treated
-    a bit different than the main option help text. They will be shown
-    as an unordered list, therefore a single line break is enough to
-    create a new list item. Also, for enumeration texts like name of
-    countries, it looks better without an ending period/full stop character.
+    - Each example value have their own `Help:` field, but they are treated
+      a bit different than the main option help text. They will be shown
+      as an unordered list, therefore a single line break is enough to
+      create a new list item. Also, for enumeration texts like name of
+      countries, it looks better without an ending period/full stop character.
 
-When writing documentation for an entirely new backend,
-see [backend documentation](#backend-documentation).
+The only documentation you need to edit are the `docs/content/*.md`
+files.  The `MANUAL.*`, `rclone.1`, website, etc. are all auto-generated
+from those during the release process.  See the `make doc` and `make
+website` targets in the Makefile if you are interested in how.  You
+don't need to run these when adding a feature.
 
-If you are updating documentation for a command, you must do that in the
-command source code, e.g. `cmd/ls/ls.go`. Write flag help strings as a single
-sentence on a single line, without a period/full stop character at the end,
-as it will be combined unmodified with other information (such as any default
-value).
+Documentation for rclone sub commands is with their code, e.g.
+`cmd/ls/ls.go`. Write flag help strings as a single sentence on a single
+line, without a period/full stop character at the end, as it will be
+combined unmodified with other information (such as any default value).
 
-Note that you can use
-[GitHub's online editor](https://help.github.com/en/github/managing-files-in-a-repository/editing-files-in-another-users-repository)
-for small changes in the docs which makes it very easy. Just remember the
-caveat when linking to header anchors, noted above, which means that GitHub's
-Markdown preview may not be an entirely reliable verification of the results.
+Note that you can use [GitHub's online editor](https://help.github.com/en/github/managing-files-in-a-repository/editing-files-in-another-users-repository)
+for small changes in the docs which makes it very easy.
 
 ## Making a release
 
@@ -449,13 +350,13 @@ change will get linked into the issue.
 
 Here is an example of a short commit message:
 
-```text
+```
 drive: add team drive support - fixes #885
 ```
 
 And here is an example of a longer one:
 
-```text
+```
 mount: fix hang on errored upload
 
 In certain circumstances, if an upload failed then the mount could hang
@@ -478,9 +379,7 @@ To add a dependency `github.com/ncw/new_dependency` see the
 instructions below.  These will fetch the dependency and add it to
 `go.mod` and `go.sum`.
 
-```sh
-go get github.com/ncw/new_dependency
-```
+    go get github.com/ncw/new_dependency
 
 You can add constraints on that package when doing `go get` (see the
 go docs linked above), but don't unless you really need to.
@@ -492,9 +391,7 @@ and `go.sum` in the same commit as your other changes.
 
 If you need to update a dependency then run
 
-```sh
-go get golang.org/x/crypto
-```
+    go get golang.org/x/crypto
 
 Check in a single commit as above.
 
@@ -537,38 +434,25 @@ remote or an fs.
 ### Getting going
 
 - Create `backend/remote/remote.go` (copy this from a similar remote)
-  - box is a good one to start from if you have a directory-based remote (and
-    shows how to use the directory cache)
-  - b2 is a good one to start from if you have a bucket-based remote
+    - box is a good one to start from if you have a directory-based remote (and shows how to use the directory cache)
+    - b2 is a good one to start from if you have a bucket-based remote
 - Add your remote to the imports in `backend/all/all.go`
-- HTTP based remotes are easiest to maintain if they use rclone's
-  [lib/rest](https://pkg.go.dev/github.com/rclone/rclone/lib/rest) module, but
-  if there is a really good Go SDK from the provider then use that instead.
-- Try to implement as many optional methods as possible as it makes the remote
-  more usable.
-- Use [lib/encoder](https://pkg.go.dev/github.com/rclone/rclone/lib/encoder) to
-  make sure we can encode any path name and `rclone info` to help determine the
-  encodings needed
-  - `rclone purge -v TestRemote:rclone-info`
-  - `rclone test info --all --remote-encoding None -vv --write-json remote.json TestRemote:rclone-info`
-  - `go run cmd/test/info/internal/build_csv/main.go -o remote.csv remote.json`
-  - open `remote.csv` in a spreadsheet and examine
+- HTTP based remotes are easiest to maintain if they use rclone's [lib/rest](https://pkg.go.dev/github.com/rclone/rclone/lib/rest) module, but if there is a really good Go SDK from the provider then use that instead.
+- Try to implement as many optional methods as possible as it makes the remote more usable.
+- Use [lib/encoder](https://pkg.go.dev/github.com/rclone/rclone/lib/encoder) to make sure we can encode any path name and `rclone info` to help determine the encodings needed
+    - `rclone purge -v TestRemote:rclone-info`
+    - `rclone test info --all --remote-encoding None -vv --write-json remote.json TestRemote:rclone-info`
+    - `go run cmd/test/info/internal/build_csv/main.go -o remote.csv remote.json`
+    - open `remote.csv` in a spreadsheet and examine
 
 ### Guidelines for a speedy merge
 
-- **Do** use [lib/rest](https://pkg.go.dev/github.com/rclone/rclone/lib/rest)
-  if you are implementing a REST like backend and parsing XML/JSON in the backend.
-- **Do** use rclone's Client or Transport from [fs/fshttp](https://pkg.go.dev/github.com/rclone/rclone/fs/fshttp)
-  if your backend is HTTP based - this adds features like `--dump bodies`,
-  `--tpslimit`, `--user-agent` without you having to code anything!
-- **Do** follow your example backend exactly - use the same code order, function
-  names, layout, structure. **Don't** move stuff around and **Don't** delete the
-  comments.
-- **Do not** split your backend up into `fs.go` and `object.go` (there are a few
-  backends like that - don't follow them!)
+- **Do** use [lib/rest](https://pkg.go.dev/github.com/rclone/rclone/lib/rest) if you are implementing a REST like backend and parsing XML/JSON in the backend.
+- **Do** use rclone's Client or Transport from [fs/fshttp](https://pkg.go.dev/github.com/rclone/rclone/fs/fshttp) if your backend is HTTP based - this adds features like `--dump bodies`, `--tpslimit`, `--user-agent` without you having to code anything!
+- **Do** follow your example backend exactly - use the same code order, function names, layout, structure. **Don't** move stuff around and **Don't** delete the comments.
+- **Do not** split your backend up into `fs.go` and `object.go` (there are a few backends like that - don't follow them!)
 - **Do** put your API type definitions in a separate file - by preference `api/types.go`
-- **Remember** we have >50 backends to maintain so keeping them as similar as
-  possible to each other is a high priority!
+- **Remember** we have >50 backends to maintain so keeping them as similar as possible to each other is a high priority!
 
 ### Unit tests
 
@@ -579,20 +463,19 @@ remote or an fs.
 ### Integration tests
 
 - Add your backend to `fstest/test_all/config.yaml`
-  - Once you've done that then you can use the integration test framework from
-    the project root:
-  - go install ./...
-  - test_all -backends remote
+    - Once you've done that then you can use the integration test framework from the project root:
+    - go install ./...
+    - test_all -backends remote
 
 Or if you want to run the integration tests manually:
 
 - Make sure integration tests pass with
-  - `cd fs/operations`
-  - `go test -v -remote TestRemote:`
-  - `cd fs/sync`
-  - `go test -v -remote TestRemote:`
+    - `cd fs/operations`
+    - `go test -v -remote TestRemote:`
+    - `cd fs/sync`
+    - `go test -v -remote TestRemote:`
 - If your remote defines `ListR` check with this also
-  - `go test -v -remote TestRemote: -fast-list`
+    - `go test -v -remote TestRemote: -fast-list`
 
 See the [testing](#testing) section for more information on integration tests.
 
@@ -604,13 +487,10 @@ alphabetical order of full name of remote (e.g. `drive` is ordered as
 `Google Drive`) but with the local file system last.
 
 - `README.md` - main GitHub page
-- `docs/content/remote.md` - main docs page (note the backend options are
-  automatically added to this file with `make backenddocs`)
-  - make sure this has the `autogenerated options` comments in (see your
-    reference backend docs)
-  - update them in your backend with `bin/make_backend_docs.py remote`
-- `docs/content/overview.md` - overview docs - add an entry into the Features
-  table and the Optional Features table.
+- `docs/content/remote.md` - main docs page (note the backend options are automatically added to this file with `make backenddocs`)
+    - make sure this has the `autogenerated options` comments in (see your reference backend docs)
+    - update them in your backend with `bin/make_backend_docs.py remote`
+- `docs/content/overview.md` - overview docs - add an entry into the Features table and the Optional Features table.
 - `docs/content/docs.md` - list of remotes in config section
 - `docs/content/_index.md` - front page of rclone.org
 - `docs/layouts/chrome/navbar.html` - add it to the website navigation
@@ -626,22 +506,21 @@ It is quite easy to add a new S3 provider to rclone.
 You'll need to modify the following files
 
 - `backend/s3/s3.go`
-  - Add the provider to `providerOption` at the top of the file
-  - Add endpoints and other config for your provider gated on the provider in `fs.RegInfo`.
-  - Exclude your provider from generic config questions (eg `region` and `endpoint).
-  - Add the provider to the `setQuirks` function - see the documentation there.
+    - Add the provider to `providerOption` at the top of the file
+    - Add endpoints and other config for your provider gated on the provider in `fs.RegInfo`.
+    - Exclude your provider from generic config questions (eg `region` and `endpoint).
+    - Add the provider to the `setQuirks` function - see the documentation there.
 - `docs/content/s3.md`
-  - Add the provider at the top of the page.
-  - Add a section about the provider linked from there.
-    - Make sure this is in alphabetical order in the `Providers` section.
-  - Add a transcript of a trial `rclone config` session
-    - Edit the transcript to remove things which might change in subsequent versions
-  - **Do not** alter or add to the autogenerated parts of `s3.md`
-  - **Do not** run `make backenddocs` or `bin/make_backend_docs.py s3`
+    - Add the provider at the top of the page.
+    - Add a section about the provider linked from there.
+    - Add a transcript of a trial `rclone config` session
+        - Edit the transcript to remove things which might change in subsequent versions
+    - **Do not** alter or add to the autogenerated parts of `s3.md`
+    - **Do not** run `make backenddocs` or `bin/make_backend_docs.py s3`
 - `README.md` - this is the home page in github
-  - Add the provider and a link to the section you wrote in `docs/contents/s3.md`
+    - Add the provider and a link to the section you wrote in `docs/contents/s3.md`
 - `docs/content/_index.md` - this is the home page of rclone.org
-  - Add the provider and a link to the section you wrote in `docs/contents/s3.md`
+    - Add the provider and a link to the section you wrote in `docs/contents/s3.md`
 
 When adding the provider, endpoints, quirks, docs etc keep them in
 alphabetical order by `Provider` name, but with `AWS` first and
@@ -662,34 +541,31 @@ For an example of adding an s3 provider see [eb3082a1](https://github.com/rclone
 
 ## Writing a plugin
 
-New features (backends, commands) can also be added "out-of-tree", through Go
-plugins. Changes will be kept in a dynamically loaded file instead of being
-compiled into the main binary. This is useful if you can't merge your changes
-upstream or don't want to maintain a fork of rclone.
+New features (backends, commands) can also be added "out-of-tree", through Go plugins.
+Changes will be kept in a dynamically loaded file instead of being compiled into the main binary.
+This is useful if you can't merge your changes upstream or don't want to maintain a fork of rclone.
 
 ### Usage
 
-- Naming
-  - Plugins names must have the pattern `librcloneplugin_KIND_NAME.so`.
-  - `KIND` should be one of `backend`, `command` or `bundle`.
-  - Example: A plugin with backend support for PiFS would be called
-    `librcloneplugin_backend_pifs.so`.
-- Loading
-  - Supported on macOS & Linux as of now. ([Go issue for Windows support](https://github.com/golang/go/issues/19282))
-  - Supported on rclone v1.50 or greater.
-  - All plugins in the folder specified by variable `$RCLONE_PLUGIN_PATH` are loaded.
-  - If this variable doesn't exist, plugin support is disabled.
-  - Plugins must be compiled against the exact version of rclone to work.
-    (The rclone used during building the plugin must be the same as the source
-    of rclone)
+ - Naming
+   - Plugins names must have the pattern `librcloneplugin_KIND_NAME.so`.
+   - `KIND` should be one of `backend`, `command` or `bundle`.
+   - Example: A plugin with backend support for PiFS would be called
+     `librcloneplugin_backend_pifs.so`.
+ - Loading
+   - Supported on macOS & Linux as of now. ([Go issue for Windows support](https://github.com/golang/go/issues/19282))
+   - Supported on rclone v1.50 or greater.
+   - All plugins in the folder specified by variable `$RCLONE_PLUGIN_PATH` are loaded.
+   - If this variable doesn't exist, plugin support is disabled.
+   - Plugins must be compiled against the exact version of rclone to work.
+     (The rclone used during building the plugin must be the same as the source of rclone)
 
 ### Building
 
 To turn your existing additions into a Go plugin, move them to an external repository
 and change the top-level package name to `main`.
 
-Check `rclone --version` and make sure that the plugin's rclone dependency and
-host Go version match.
+Check `rclone --version` and make sure that the plugin's rclone dependency and host Go version match.
 
 Then, run `go build -buildmode=plugin -o PLUGIN_NAME.so .` to build the plugin.
 
@@ -707,6 +583,6 @@ add them out of tree.
 This may be easier than using a plugin and is supported on all
 platforms not just macOS and Linux.
 
-This is explained further in <https://github.com/rclone/rclone_out_of_tree_example>
+This is explained further in https://github.com/rclone/rclone_out_of_tree_example
 which has an example of an out of tree backend `ram` (which is a
 renamed version of the `memory` backend).

MAINTAINERS.md

@@ -1,4 +1,4 @@
-# Maintainers guide for rclone
+# Maintainers guide for rclone #
 
 Current active maintainers of rclone are:
 
@@ -24,108 +24,80 @@ Current active maintainers of rclone are:
 | Dan McArdle      | @dmcardle         | gitannex                     |
 | Sam Harrison     | @childish-sambino | filescom                     |
 
-## This is a work in progress draft
+**This is a work in progress Draft**
 
-This is a guide for how to be an rclone maintainer.  This is mostly a write-up
-of what I (@ncw) attempt to do.
+This is a guide for how to be an rclone maintainer.  This is mostly a write-up of what I (@ncw) attempt to do.
 
-## Triaging Tickets
+## Triaging Tickets ##
 
-When a ticket comes in it should be triaged.  This means it should be classified
-by adding labels and placed into a milestone. Quite a lot of tickets need a bit
-of back and forth to determine whether it is a valid ticket so tickets may
-remain without labels or milestone for a while.
+When a ticket comes in it should be triaged.  This means it should be classified by adding labels and placed into a milestone. Quite a lot of tickets need a bit of back and forth to determine whether it is a valid ticket so tickets may remain without labels or milestone for a while.
 
 Rclone uses the labels like this:
 
-- `bug` - a definitely verified bug
-- `can't reproduce` - a problem which we can't reproduce
-- `doc fix` - a bug in the documentation - if users need help understanding the
-  docs add this label
-- `duplicate` - normally close these and ask the user to subscribe to the original
-- `enhancement: new remote` - a new rclone backend
-- `enhancement` - a new feature
-- `FUSE` - to do with `rclone mount` command
-- `good first issue` - mark these if you find a small self-contained issue -
-  these get shown to new visitors to the project
-- `help` wanted - mark these if you find a self-contained issue - these get
-  shown to new visitors to the project
-- `IMPORTANT` - note to maintainers not to forget to fix this for the release
-- `maintenance` - internal enhancement, code re-organisation, etc.
-- `Needs Go 1.XX` - waiting for that version of Go to be released
-- `question` - not a `bug` or `enhancement` - direct to the forum for next time
-- `Remote: XXX` - which rclone backend this affects
-- `thinking` - not decided on the course of action yet
+* `bug` - a definitely verified bug
+* `can't reproduce` - a problem which we can't reproduce
+* `doc fix` - a bug in the documentation - if users need help understanding the docs add this label
+* `duplicate` - normally close these and ask the user to subscribe to the original
+* `enhancement: new remote` - a new rclone backend
+* `enhancement` - a new feature
+* `FUSE` - to do with `rclone mount` command
+* `good first issue` - mark these if you find a small self-contained issue - these get shown to new visitors to the project
+* `help` wanted - mark these if you find a self-contained issue - these get shown to new visitors to the project
+* `IMPORTANT` - note to maintainers not to forget to fix this for the release
+* `maintenance` - internal enhancement, code re-organisation, etc.
+* `Needs Go 1.XX` - waiting for that version of Go to be released
+* `question` - not a `bug` or `enhancement` - direct to the forum for next time
+* `Remote: XXX` - which rclone backend this affects
+* `thinking` - not decided on the course of action yet
 
-If it turns out to be a bug or an enhancement it should be tagged as such, with
-the appropriate other tags.  Don't forget the "good first issue" tag to give new
-contributors something easy to do to get going.
+If it turns out to be a bug or an enhancement it should be tagged as such, with the appropriate other tags.  Don't forget the "good first issue" tag to give new contributors something easy to do to get going.
 
-When a ticket is tagged it should be added to a milestone, either the next
-release, the one after, Soon or Help Wanted.  Bugs can be added to the
-"Known Bugs" milestone if they aren't planned to be fixed or need to wait for
-something (e.g. the next go release).
+When a ticket is tagged it should be added to a milestone, either the next release, the one after, Soon or Help Wanted.  Bugs can be added to the "Known Bugs" milestone if they aren't planned to be fixed or need to wait for something (e.g. the next go release).
 
 The milestones have these meanings:
 
-- v1.XX - stuff we would like to fit into this release
-- v1.XX+1 - stuff we are leaving until the next release
-- Soon - stuff we think is a good idea - waiting to be scheduled for a release
-- Help wanted - blue sky stuff that might get moved up, or someone could help with
-- Known bugs - bugs waiting on external factors or we aren't going to fix for
-  the moment
+* v1.XX - stuff we would like to fit into this release
+* v1.XX+1 - stuff we are leaving until the next release
+* Soon - stuff we think is a good idea - waiting to be scheduled for a release
+* Help wanted - blue sky stuff that might get moved up, or someone could help with
+* Known bugs - bugs waiting on external factors or we aren't going to fix for the moment
 
-Tickets [with no milestone](https://github.com/rclone/rclone/issues?utf8=✓&q=is%3Aissue%20is%3Aopen%20no%3Amile)
-are good candidates for ones that have slipped between the gaps and need
-following up.
+Tickets [with no milestone](https://github.com/rclone/rclone/issues?utf8=✓&q=is%3Aissue%20is%3Aopen%20no%3Amile) are good candidates for ones that have slipped between the gaps and need following up.
 
-## Closing Tickets
+## Closing Tickets ##
 
-Close tickets as soon as you can - make sure they are tagged with a release.
-Post a link to a beta in the ticket with the fix in, asking for feedback.
+Close tickets as soon as you can - make sure they are tagged with a release.  Post a link to a beta in the ticket with the fix in, asking for feedback.
 
-## Pull requests
+## Pull requests ##
 
 Try to process pull requests promptly!
 
-Merging pull requests on GitHub itself works quite well nowadays so you can
-squash and rebase or rebase pull requests. rclone doesn't use merge commits.
-Use the squash and rebase option if you need to edit the commit message.
+Merging pull requests on GitHub itself works quite well nowadays so you can squash and rebase or rebase pull requests.  rclone doesn't use merge commits.  Use the squash and rebase option if you need to edit the commit message.
 
-After merging the commit, in your local master branch, do `git pull` then run
-`bin/update-authors.py` to update the authors file then `git push`.
+After merging the commit, in your local master branch, do `git pull` then run `bin/update-authors.py` to update the authors file then `git push`.
 
-Sometimes pull requests need to be left open for a while - this especially true
-of contributions of new backends which take a long time to get right.
+Sometimes pull requests need to be left open for a while - this especially true of contributions of new backends which take a long time to get right.
 
-## Merges
+## Merges ##
 
-If you are merging a branch locally then do `git merge --ff-only branch-name` to
-avoid a merge commit.  You'll need to rebase the branch if it doesn't merge cleanly.
+If you are merging a branch locally then do `git merge --ff-only branch-name` to avoid a merge commit.  You'll need to rebase the branch if it doesn't merge cleanly.
 
-## Release cycle
+## Release cycle ##
 
-Rclone aims for a 6-8 week release cycle.  Sometimes release cycles take longer
-if there is something big to merge that didn't stabilize properly or for personal
-reasons.
+Rclone aims for a 6-8 week release cycle.  Sometimes release cycles take longer if there is something big to merge that didn't stabilize properly or for personal reasons.
 
 High impact regressions should be fixed before the next release.
 
-Near the start of the release cycle, the dependencies should be updated with
-`make update` to give time for bugs to surface.
+Near the start of the release cycle, the dependencies should be updated with `make update` to give time for bugs to surface.
 
-Towards the end of the release cycle try not to merge anything too big so let
-things settle down.
+Towards the end of the release cycle try not to merge anything too big so let things settle down.
 
-Follow the instructions in RELEASE.md for making the release. Note that the
-testing part is the most time-consuming often needing several rounds of test
-and fix depending on exactly how many new features rclone has gained.
+Follow the instructions in RELEASE.md for making the release. Note that the testing part is the most time-consuming often needing several rounds of test and fix depending on exactly how many new features rclone has gained.
 
-## Mailing list
+## Mailing list ##
 
-There is now an invite-only mailing list for rclone developers `rclone-dev` on
-google groups.
+There is now an invite-only mailing list for rclone developers `rclone-dev` on google groups.
 
-## TODO
+## TODO ##
 
-I should probably make a <dev@rclone.org> to register with cloud providers.
+I should probably make a dev@rclone.org to register with cloud providers.

Makefile

@@ -88,13 +88,13 @@ test:	rclone test_all
 
 # Quick test
 quicktest:
-	RCLONE_CONFIG="/notfound" go test $(LDFLAGS) $(BUILDTAGS) ./...
+	RCLONE_CONFIG="/notfound" go test $(BUILDTAGS) ./...
 
 racequicktest:
-	RCLONE_CONFIG="/notfound" go test $(LDFLAGS) $(BUILDTAGS) -cpu=2 -race ./...
+	RCLONE_CONFIG="/notfound" go test $(BUILDTAGS) -cpu=2 -race ./...
 
 compiletest:
-	RCLONE_CONFIG="/notfound" go test $(LDFLAGS) $(BUILDTAGS) -run XXX ./...
+	RCLONE_CONFIG="/notfound" go test $(BUILDTAGS) -run XXX ./...
 
 # Do source code quality checks
 check:	rclone
@@ -243,7 +243,7 @@ fetch_binaries:
 	rclone -P sync --exclude "/testbuilds/**" --delete-excluded $(BETA_UPLOAD) build/
 
 serve:	website
-	cd docs && hugo server --logLevel info -w --disableFastRender --ignoreCache
+	cd docs && hugo server --logLevel info -w --disableFastRender
 
 tag:	retag doc
 	bin/make_changelog.py $(LAST_TAG) $(VERSION) > docs/content/changelog.md.new

README.md

@@ -1,6 +1,6 @@
-<!-- markdownlint-disable-next-line first-line-heading no-inline-html -->
+
+
 [<img src="https://rclone.org/img/logo_on_light__horizontal_color.svg" width="50%" alt="rclone logo">](https://rclone.org/#gh-light-mode-only)
-<!-- markdownlint-disable-next-line no-inline-html -->
 [<img src="https://rclone.org/img/logo_on_dark__horizontal_color.svg" width="50%" alt="rclone logo">](https://rclone.org/#gh-dark-mode-only)
 
 [Website](https://rclone.org) |
@@ -18,105 +18,102 @@
 
 # Rclone
 
-Rclone *("rsync for cloud storage")* is a command-line program to sync files and
-directories to and from different cloud storage providers.
+Rclone *("rsync for cloud storage")* is a command-line program to sync files and directories to and from different cloud storage providers.
 
 ## Storage providers
 
-- 1Fichier [:page_facing_up:](https://rclone.org/fichier/)
-- Akamai Netstorage [:page_facing_up:](https://rclone.org/netstorage/)
-- Alibaba Cloud (Aliyun) Object Storage System (OSS) [:page_facing_up:](https://rclone.org/s3/#alibaba-oss)
-- Amazon S3 [:page_facing_up:](https://rclone.org/s3/)
-- ArvanCloud Object Storage (AOS) [:page_facing_up:](https://rclone.org/s3/#arvan-cloud-object-storage-aos)
-- Backblaze B2 [:page_facing_up:](https://rclone.org/b2/)
-- Box [:page_facing_up:](https://rclone.org/box/)
-- Ceph [:page_facing_up:](https://rclone.org/s3/#ceph)
-- China Mobile Ecloud Elastic Object Storage (EOS) [:page_facing_up:](https://rclone.org/s3/#china-mobile-ecloud-eos)
-- Cloudflare R2 [:page_facing_up:](https://rclone.org/s3/#cloudflare-r2)
-- Citrix ShareFile [:page_facing_up:](https://rclone.org/sharefile/)
-- DigitalOcean Spaces [:page_facing_up:](https://rclone.org/s3/#digitalocean-spaces)
-- Digi Storage [:page_facing_up:](https://rclone.org/koofr/#digi-storage)
-- Dreamhost [:page_facing_up:](https://rclone.org/s3/#dreamhost)
-- Dropbox [:page_facing_up:](https://rclone.org/dropbox/)
-- Enterprise File Fabric [:page_facing_up:](https://rclone.org/filefabric/)
-- Exaba [:page_facing_up:](https://rclone.org/s3/#exaba)
-- Fastmail Files [:page_facing_up:](https://rclone.org/webdav/#fastmail-files)
-- FileLu [:page_facing_up:](https://rclone.org/filelu/)
-- Files.com [:page_facing_up:](https://rclone.org/filescom/)
-- FlashBlade [:page_facing_up:](https://rclone.org/s3/#pure-storage-flashblade)
-- FTP [:page_facing_up:](https://rclone.org/ftp/)
-- GoFile [:page_facing_up:](https://rclone.org/gofile/)
-- Google Cloud Storage [:page_facing_up:](https://rclone.org/googlecloudstorage/)
-- Google Drive [:page_facing_up:](https://rclone.org/drive/)
-- Google Photos [:page_facing_up:](https://rclone.org/googlephotos/)
-- HDFS (Hadoop Distributed Filesystem) [:page_facing_up:](https://rclone.org/hdfs/)
-- Hetzner Storage Box [:page_facing_up:](https://rclone.org/sftp/#hetzner-storage-box)
-- HiDrive [:page_facing_up:](https://rclone.org/hidrive/)
-- HTTP [:page_facing_up:](https://rclone.org/http/)
-- Huawei Cloud Object Storage Service(OBS) [:page_facing_up:](https://rclone.org/s3/#huawei-obs)
-- iCloud Drive [:page_facing_up:](https://rclone.org/iclouddrive/)
-- ImageKit [:page_facing_up:](https://rclone.org/imagekit/)
-- Internet Archive [:page_facing_up:](https://rclone.org/internetarchive/)
-- Jottacloud [:page_facing_up:](https://rclone.org/jottacloud/)
-- IBM COS S3 [:page_facing_up:](https://rclone.org/s3/#ibm-cos-s3)
-- IONOS Cloud [:page_facing_up:](https://rclone.org/s3/#ionos)
-- Koofr [:page_facing_up:](https://rclone.org/koofr/)
-- Leviia Object Storage [:page_facing_up:](https://rclone.org/s3/#leviia)
-- Liara Object Storage [:page_facing_up:](https://rclone.org/s3/#liara-object-storage)
-- Linkbox [:page_facing_up:](https://rclone.org/linkbox)
-- Linode Object Storage [:page_facing_up:](https://rclone.org/s3/#linode)
-- Magalu Object Storage [:page_facing_up:](https://rclone.org/s3/#magalu)
-- Mail.ru Cloud [:page_facing_up:](https://rclone.org/mailru/)
-- Memset Memstore [:page_facing_up:](https://rclone.org/swift/)
-- MEGA [:page_facing_up:](https://rclone.org/mega/)
-- MEGA S4 Object Storage [:page_facing_up:](https://rclone.org/s3/#mega)
-- Memory [:page_facing_up:](https://rclone.org/memory/)
-- Microsoft Azure Blob Storage [:page_facing_up:](https://rclone.org/azureblob/)
-- Microsoft Azure Files Storage [:page_facing_up:](https://rclone.org/azurefiles/)
-- Microsoft OneDrive [:page_facing_up:](https://rclone.org/onedrive/)
-- Minio [:page_facing_up:](https://rclone.org/s3/#minio)
-- Nextcloud [:page_facing_up:](https://rclone.org/webdav/#nextcloud)
-- Blomp Cloud Storage [:page_facing_up:](https://rclone.org/swift/)
-- OpenDrive [:page_facing_up:](https://rclone.org/opendrive/)
-- OpenStack Swift [:page_facing_up:](https://rclone.org/swift/)
-- Oracle Cloud Storage [:page_facing_up:](https://rclone.org/swift/)
-- Oracle Object Storage [:page_facing_up:](https://rclone.org/oracleobjectstorage/)
-- Outscale [:page_facing_up:](https://rclone.org/s3/#outscale)
-- OVHcloud Object Storage (Swift) [:page_facing_up:](https://rclone.org/swift/)
-- OVHcloud Object Storage (S3-compatible) [:page_facing_up:](https://rclone.org/s3/#ovhcloud)
-- ownCloud [:page_facing_up:](https://rclone.org/webdav/#owncloud)
-- pCloud [:page_facing_up:](https://rclone.org/pcloud/)
-- Petabox [:page_facing_up:](https://rclone.org/s3/#petabox)
-- PikPak [:page_facing_up:](https://rclone.org/pikpak/)
-- Pixeldrain [:page_facing_up:](https://rclone.org/pixeldrain/)
-- premiumize.me [:page_facing_up:](https://rclone.org/premiumizeme/)
-- put.io [:page_facing_up:](https://rclone.org/putio/)
-- Proton Drive [:page_facing_up:](https://rclone.org/protondrive/)
-- QingStor [:page_facing_up:](https://rclone.org/qingstor/)
-- Qiniu Cloud Object Storage (Kodo) [:page_facing_up:](https://rclone.org/s3/#qiniu)
-- Quatrix [:page_facing_up:](https://rclone.org/quatrix/)
-- Rackspace Cloud Files [:page_facing_up:](https://rclone.org/swift/)
-- RackCorp Object Storage [:page_facing_up:](https://rclone.org/s3/#RackCorp)
-- rsync.net [:page_facing_up:](https://rclone.org/sftp/#rsync-net)
-- Scaleway [:page_facing_up:](https://rclone.org/s3/#scaleway)
-- Seafile [:page_facing_up:](https://rclone.org/seafile/)
-- Seagate Lyve Cloud [:page_facing_up:](https://rclone.org/s3/#lyve)
-- SeaweedFS [:page_facing_up:](https://rclone.org/s3/#seaweedfs)
-- Selectel Object Storage [:page_facing_up:](https://rclone.org/s3/#selectel)
-- SFTP [:page_facing_up:](https://rclone.org/sftp/)
-- SMB / CIFS [:page_facing_up:](https://rclone.org/smb/)
-- StackPath [:page_facing_up:](https://rclone.org/s3/#stackpath)
-- Storj [:page_facing_up:](https://rclone.org/storj/)
-- SugarSync [:page_facing_up:](https://rclone.org/sugarsync/)
-- Synology C2 Object Storage [:page_facing_up:](https://rclone.org/s3/#synology-c2)
-- Tencent Cloud Object Storage (COS) [:page_facing_up:](https://rclone.org/s3/#tencent-cos)
-- Uloz.to [:page_facing_up:](https://rclone.org/ulozto/)
-- Wasabi [:page_facing_up:](https://rclone.org/s3/#wasabi)
-- WebDAV [:page_facing_up:](https://rclone.org/webdav/)
-- Yandex Disk [:page_facing_up:](https://rclone.org/yandex/)
-- Zoho WorkDrive [:page_facing_up:](https://rclone.org/zoho/)
-- Zata.ai [:page_facing_up:](https://rclone.org/s3/#Zata)
-- The local filesystem [:page_facing_up:](https://rclone.org/local/)
+  * 1Fichier [:page_facing_up:](https://rclone.org/fichier/)
+  * Akamai Netstorage [:page_facing_up:](https://rclone.org/netstorage/)
+  * Alibaba Cloud (Aliyun) Object Storage System (OSS) [:page_facing_up:](https://rclone.org/s3/#alibaba-oss)
+  * Amazon S3 [:page_facing_up:](https://rclone.org/s3/)
+  * ArvanCloud Object Storage (AOS) [:page_facing_up:](https://rclone.org/s3/#arvan-cloud-object-storage-aos)
+  * Backblaze B2 [:page_facing_up:](https://rclone.org/b2/)
+  * Box [:page_facing_up:](https://rclone.org/box/)
+  * Ceph [:page_facing_up:](https://rclone.org/s3/#ceph)
+  * China Mobile Ecloud Elastic Object Storage (EOS) [:page_facing_up:](https://rclone.org/s3/#china-mobile-ecloud-eos)
+  * Cloudflare R2 [:page_facing_up:](https://rclone.org/s3/#cloudflare-r2)
+  * Citrix ShareFile [:page_facing_up:](https://rclone.org/sharefile/)
+  * DigitalOcean Spaces [:page_facing_up:](https://rclone.org/s3/#digitalocean-spaces)
+  * Digi Storage [:page_facing_up:](https://rclone.org/koofr/#digi-storage)
+  * Dreamhost [:page_facing_up:](https://rclone.org/s3/#dreamhost)
+  * Dropbox [:page_facing_up:](https://rclone.org/dropbox/)
+  * Enterprise File Fabric [:page_facing_up:](https://rclone.org/filefabric/)
+  * Fastmail Files [:page_facing_up:](https://rclone.org/webdav/#fastmail-files)
+  * FileLu [:page_facing_up:](https://rclone.org/filelu/)
+  * Files.com [:page_facing_up:](https://rclone.org/filescom/)
+  * FlashBlade [:page_facing_up:](https://rclone.org/s3/#pure-storage-flashblade)
+  * FTP [:page_facing_up:](https://rclone.org/ftp/)
+  * GoFile [:page_facing_up:](https://rclone.org/gofile/)
+  * Google Cloud Storage [:page_facing_up:](https://rclone.org/googlecloudstorage/)
+  * Google Drive [:page_facing_up:](https://rclone.org/drive/)
+  * Google Photos [:page_facing_up:](https://rclone.org/googlephotos/)
+  * HDFS (Hadoop Distributed Filesystem) [:page_facing_up:](https://rclone.org/hdfs/)
+  * Hetzner Storage Box [:page_facing_up:](https://rclone.org/sftp/#hetzner-storage-box)
+  * HiDrive [:page_facing_up:](https://rclone.org/hidrive/)
+  * HTTP [:page_facing_up:](https://rclone.org/http/)
+  * Huawei Cloud Object Storage Service(OBS) [:page_facing_up:](https://rclone.org/s3/#huawei-obs)
+  * iCloud Drive [:page_facing_up:](https://rclone.org/iclouddrive/)
+  * ImageKit [:page_facing_up:](https://rclone.org/imagekit/)
+  * Internet Archive [:page_facing_up:](https://rclone.org/internetarchive/)
+  * Jottacloud [:page_facing_up:](https://rclone.org/jottacloud/)
+  * IBM COS S3 [:page_facing_up:](https://rclone.org/s3/#ibm-cos-s3)
+  * IONOS Cloud [:page_facing_up:](https://rclone.org/s3/#ionos)
+  * Koofr [:page_facing_up:](https://rclone.org/koofr/)
+  * Leviia Object Storage [:page_facing_up:](https://rclone.org/s3/#leviia)
+  * Liara Object Storage [:page_facing_up:](https://rclone.org/s3/#liara-object-storage)
+  * Linkbox [:page_facing_up:](https://rclone.org/linkbox)
+  * Linode Object Storage [:page_facing_up:](https://rclone.org/s3/#linode)
+  * Magalu Object Storage [:page_facing_up:](https://rclone.org/s3/#magalu)
+  * Mail.ru Cloud [:page_facing_up:](https://rclone.org/mailru/)
+  * Memset Memstore [:page_facing_up:](https://rclone.org/swift/)
+  * MEGA [:page_facing_up:](https://rclone.org/mega/)
+  * MEGA S4 Object Storage [:page_facing_up:](https://rclone.org/s3/#mega)
+  * Memory [:page_facing_up:](https://rclone.org/memory/)
+  * Microsoft Azure Blob Storage [:page_facing_up:](https://rclone.org/azureblob/)
+  * Microsoft Azure Files Storage [:page_facing_up:](https://rclone.org/azurefiles/)
+  * Microsoft OneDrive [:page_facing_up:](https://rclone.org/onedrive/)
+  * Minio [:page_facing_up:](https://rclone.org/s3/#minio)
+  * Nextcloud [:page_facing_up:](https://rclone.org/webdav/#nextcloud)
+  * OVH [:page_facing_up:](https://rclone.org/swift/)
+  * Blomp Cloud Storage [:page_facing_up:](https://rclone.org/swift/)
+  * OpenDrive [:page_facing_up:](https://rclone.org/opendrive/)
+  * OpenStack Swift [:page_facing_up:](https://rclone.org/swift/)
+  * Oracle Cloud Storage [:page_facing_up:](https://rclone.org/swift/)
+  * Oracle Object Storage [:page_facing_up:](https://rclone.org/oracleobjectstorage/)
+  * Outscale [:page_facing_up:](https://rclone.org/s3/#outscale)
+  * ownCloud [:page_facing_up:](https://rclone.org/webdav/#owncloud)
+  * pCloud [:page_facing_up:](https://rclone.org/pcloud/)
+  * Petabox [:page_facing_up:](https://rclone.org/s3/#petabox)
+  * PikPak [:page_facing_up:](https://rclone.org/pikpak/)
+  * Pixeldrain [:page_facing_up:](https://rclone.org/pixeldrain/)
+  * premiumize.me [:page_facing_up:](https://rclone.org/premiumizeme/)
+  * put.io [:page_facing_up:](https://rclone.org/putio/)
+  * Proton Drive [:page_facing_up:](https://rclone.org/protondrive/)
+  * QingStor [:page_facing_up:](https://rclone.org/qingstor/)
+  * Qiniu Cloud Object Storage (Kodo) [:page_facing_up:](https://rclone.org/s3/#qiniu)
+  * Quatrix [:page_facing_up:](https://rclone.org/quatrix/)
+  * Rackspace Cloud Files [:page_facing_up:](https://rclone.org/swift/)
+  * RackCorp Object Storage [:page_facing_up:](https://rclone.org/s3/#RackCorp)
+  * rsync.net [:page_facing_up:](https://rclone.org/sftp/#rsync-net)
+  * Scaleway [:page_facing_up:](https://rclone.org/s3/#scaleway)
+  * Seafile [:page_facing_up:](https://rclone.org/seafile/)
+  * Seagate Lyve Cloud [:page_facing_up:](https://rclone.org/s3/#lyve)
+  * SeaweedFS [:page_facing_up:](https://rclone.org/s3/#seaweedfs)
+  * Selectel Object Storage [:page_facing_up:](https://rclone.org/s3/#selectel)
+  * SFTP [:page_facing_up:](https://rclone.org/sftp/)
+  * SMB / CIFS [:page_facing_up:](https://rclone.org/smb/)
+  * StackPath [:page_facing_up:](https://rclone.org/s3/#stackpath)
+  * Storj [:page_facing_up:](https://rclone.org/storj/)
+  * SugarSync [:page_facing_up:](https://rclone.org/sugarsync/)
+  * Synology C2 Object Storage [:page_facing_up:](https://rclone.org/s3/#synology-c2)
+  * Tencent Cloud Object Storage (COS) [:page_facing_up:](https://rclone.org/s3/#tencent-cos)
+  * Uloz.to [:page_facing_up:](https://rclone.org/ulozto/)
+  * Wasabi [:page_facing_up:](https://rclone.org/s3/#wasabi)
+  * WebDAV [:page_facing_up:](https://rclone.org/webdav/)
+  * Yandex Disk [:page_facing_up:](https://rclone.org/yandex/)
+  * Zoho WorkDrive [:page_facing_up:](https://rclone.org/zoho/)
+  * Zata.ai [:page_facing_up:](https://rclone.org/s3/#Zata)
+  * The local filesystem [:page_facing_up:](https://rclone.org/local/)
 
 Please see [the full list of all storage providers and their features](https://rclone.org/overview/)
 
@@ -124,54 +121,50 @@ Please see [the full list of all storage providers and their features](https://r
 
 These backends adapt or modify other storage providers
 
-- Alias: rename existing remotes [:page_facing_up:](https://rclone.org/alias/)
-- Cache: cache remotes (DEPRECATED) [:page_facing_up:](https://rclone.org/cache/)
-- Chunker: split large files [:page_facing_up:](https://rclone.org/chunker/)
-- Combine: combine multiple remotes into a directory tree [:page_facing_up:](https://rclone.org/combine/)
-- Compress: compress files [:page_facing_up:](https://rclone.org/compress/)
-- Crypt: encrypt files [:page_facing_up:](https://rclone.org/crypt/)
-- Hasher: hash files [:page_facing_up:](https://rclone.org/hasher/)
-- Union: join multiple remotes to work together [:page_facing_up:](https://rclone.org/union/)
+  * Alias: rename existing remotes [:page_facing_up:](https://rclone.org/alias/)
+  * Cache: cache remotes (DEPRECATED) [:page_facing_up:](https://rclone.org/cache/)
+  * Chunker: split large files [:page_facing_up:](https://rclone.org/chunker/)
+  * Combine: combine multiple remotes into a directory tree [:page_facing_up:](https://rclone.org/combine/)
+  * Compress: compress files [:page_facing_up:](https://rclone.org/compress/)
+  * Crypt: encrypt files [:page_facing_up:](https://rclone.org/crypt/)
+  * Hasher: hash files [:page_facing_up:](https://rclone.org/hasher/)
+  * Union: join multiple remotes to work together [:page_facing_up:](https://rclone.org/union/)
 
 ## Features
 
-- MD5/SHA-1 hashes checked at all times for file integrity
-- Timestamps preserved on files
-- Partial syncs supported on a whole file basis
-- [Copy](https://rclone.org/commands/rclone_copy/) mode to just copy new/changed
-  files
-- [Sync](https://rclone.org/commands/rclone_sync/) (one way) mode to make a directory
-  identical
-- [Bisync](https://rclone.org/bisync/) (two way) to keep two directories in sync
-  bidirectionally
-- [Check](https://rclone.org/commands/rclone_check/) mode to check for file hash
-  equality
-- Can sync to and from network, e.g. two different cloud accounts
-- Optional large file chunking ([Chunker](https://rclone.org/chunker/))
-- Optional transparent compression ([Compress](https://rclone.org/compress/))
-- Optional encryption ([Crypt](https://rclone.org/crypt/))
-- Optional FUSE mount ([rclone mount](https://rclone.org/commands/rclone_mount/))
-- Multi-threaded downloads to local disk
-- Can [serve](https://rclone.org/commands/rclone_serve/) local or remote files
-  over HTTP/WebDAV/FTP/SFTP/DLNA
+  * MD5/SHA-1 hashes checked at all times for file integrity
+  * Timestamps preserved on files
+  * Partial syncs supported on a whole file basis
+  * [Copy](https://rclone.org/commands/rclone_copy/) mode to just copy new/changed files
+  * [Sync](https://rclone.org/commands/rclone_sync/) (one way) mode to make a directory identical
+  * [Bisync](https://rclone.org/bisync/) (two way) to keep two directories in sync bidirectionally
+  * [Check](https://rclone.org/commands/rclone_check/) mode to check for file hash equality
+  * Can sync to and from network, e.g. two different cloud accounts
+  * Optional large file chunking ([Chunker](https://rclone.org/chunker/))
+  * Optional transparent compression ([Compress](https://rclone.org/compress/))
+  * Optional encryption ([Crypt](https://rclone.org/crypt/))
+  * Optional FUSE mount ([rclone mount](https://rclone.org/commands/rclone_mount/))
+  * Multi-threaded downloads to local disk
+  * Can [serve](https://rclone.org/commands/rclone_serve/) local or remote files over HTTP/WebDAV/FTP/SFTP/DLNA
 
 ## Installation & documentation
 
 Please see the [rclone website](https://rclone.org/) for:
 
-- [Installation](https://rclone.org/install/)
-- [Documentation & configuration](https://rclone.org/docs/)
-- [Changelog](https://rclone.org/changelog/)
-- [FAQ](https://rclone.org/faq/)
-- [Storage providers](https://rclone.org/overview/)
-- [Forum](https://forum.rclone.org/)
-- ...and more
+  * [Installation](https://rclone.org/install/)
+  * [Documentation & configuration](https://rclone.org/docs/)
+  * [Changelog](https://rclone.org/changelog/)
+  * [FAQ](https://rclone.org/faq/)
+  * [Storage providers](https://rclone.org/overview/)
+  * [Forum](https://forum.rclone.org/)
+  * ...and more
 
 ## Downloads
 
-- <https://rclone.org/downloads/>
+  * https://rclone.org/downloads/
 
-## License
+License
+-------
 
 This is free software under the terms of the MIT license (check the
 [COPYING file](/COPYING) included in this package).

RELEASE.md

@@ -4,55 +4,52 @@ This file describes how to make the various kinds of releases
 
 ## Extra required software for making a release
 
-- [gh the github cli](https://github.com/cli/cli) for uploading packages
-- pandoc for making the html and man pages
+  * [gh the github cli](https://github.com/cli/cli) for uploading packages
+  * pandoc for making the html and man pages
 
 ## Making a release
 
-- git checkout master # see below for stable branch
-- git pull # IMPORTANT
-- git status - make sure everything is checked in
-- Check GitHub actions build for master is Green
-- make test # see integration test server or run locally
-- make tag
-- edit docs/content/changelog.md # make sure to remove duplicate logs from point
-  releases
-- make tidy
-- make doc
-- git status - to check for new man pages - git add them
-- git commit -a -v -m "Version v1.XX.0"
-- make retag
-- git push origin # without --follow-tags so it doesn't push the tag if it fails
-- git push --follow-tags origin
-- \# Wait for the GitHub builds to complete then...
-- make fetch_binaries
-- make tarball
-- make vendorball
-- make sign_upload
-- make check_sign
-- make upload
-- make upload_website
-- make upload_github
-- make startdev # make startstable for stable branch
-- \# announce with forum post, twitter post, patreon post
+  * git checkout master # see below for stable branch
+  * git pull # IMPORTANT
+  * git status - make sure everything is checked in
+  * Check GitHub actions build for master is Green
+  * make test # see integration test server or run locally
+  * make tag
+  * edit docs/content/changelog.md # make sure to remove duplicate logs from point releases
+  * make tidy
+  * make doc
+  * git status - to check for new man pages - git add them
+  * git commit -a -v -m "Version v1.XX.0"
+  * make retag
+  * git push origin # without --follow-tags so it doesn't push the tag if it fails
+  * git push --follow-tags origin
+  * # Wait for the GitHub builds to complete then...
+  * make fetch_binaries
+  * make tarball
+  * make vendorball
+  * make sign_upload
+  * make check_sign
+  * make upload
+  * make upload_website
+  * make upload_github
+  * make startdev # make startstable for stable branch
+  * # announce with forum post, twitter post, patreon post
 
 ## Update dependencies
 
 Early in the next release cycle update the dependencies.
 
-- Review any pinned packages in go.mod and remove if possible
-- `make updatedirect`
-- `make GOTAGS=cmount`
-- `make compiletest`
-- Fix anything which doesn't compile at this point and commit changes here
-- `git commit -a -v -m "build: update all dependencies"`
+  * Review any pinned packages in go.mod and remove if possible
+  * `make updatedirect`
+  * `make GOTAGS=cmount`
+  * `make compiletest`
+  * Fix anything which doesn't compile at this point and commit changes here
+  * `git commit -a -v -m "build: update all dependencies"`
 
 If the `make updatedirect` upgrades the version of go in the `go.mod`
 
-```text
-go 1.22.0
-```
-
+    go 1.22.0
+    
 then go to manual mode. `go1.22` here is the lowest supported version
 in the `go.mod`.
 
@@ -60,7 +57,7 @@ If `make updatedirect` added a `toolchain` directive then remove it.
 We don't want to force a toolchain on our users. Linux packagers are
 often using a version of Go that is a few versions out of date.
 
-```sh
+```
 go list -m -f '{{if not (or .Main .Indirect)}}{{.Path}}{{end}}' all > /tmp/potential-upgrades
 go get -d $(cat /tmp/potential-upgrades)
 go mod tidy -go=1.22 -compat=1.22
@@ -70,7 +67,7 @@ If the `go mod tidy` fails use the output from it to remove the
 package which can't be upgraded from `/tmp/potential-upgrades` when
 done
 
-```sh
+```
 git co go.mod go.sum
 ```
 
@@ -80,12 +77,12 @@ Optionally upgrade the direct and indirect dependencies. This is very
 likely to fail if the manual method was used abve - in that case
 ignore it as it is too time consuming to fix.
 
-- `make update`
-- `make GOTAGS=cmount`
-- `make compiletest`
-- roll back any updates which didn't compile
-- `git commit -a -v --amend`
-- **NB** watch out for this changing the default go version in `go.mod`
+  * `make update`
+  * `make GOTAGS=cmount`
+  * `make compiletest`
+  * roll back any updates which didn't compile
+  * `git commit -a -v --amend`
+  * **NB** watch out for this changing the default go version in `go.mod`
 
 Note that `make update` updates all direct and indirect dependencies
 and there can occasionally be forwards compatibility problems with
@@ -102,9 +99,7 @@ The above procedure will not upgrade major versions, so v2 to v3.
 However this tool can show which major versions might need to be
 upgraded:
 
-```sh
-go run github.com/icholy/gomajor@latest list -major
-```
+    go run github.com/icholy/gomajor@latest list -major
 
 Expect API breakage when updating major versions.
 
@@ -112,9 +107,7 @@ Expect API breakage when updating major versions.
 
 At some point after the release run
 
-```sh
-bin/tidy-beta v1.55
-```
+    bin/tidy-beta v1.55
 
 where the version number is that of a couple ago to remove old beta binaries.
 
@@ -124,64 +117,54 @@ If rclone needs a point release due to some horrendous bug:
 
 Set vars
 
-- BASE_TAG=v1.XX          # e.g. v1.52
-- NEW_TAG=${BASE_TAG}.Y   # e.g. v1.52.1
-- echo $BASE_TAG $NEW_TAG # v1.52 v1.52.1
+  * BASE_TAG=v1.XX          # e.g. v1.52
+  * NEW_TAG=${BASE_TAG}.Y   # e.g. v1.52.1
+  * echo $BASE_TAG $NEW_TAG # v1.52 v1.52.1
 
 First make the release branch.  If this is a second point release then
 this will be done already.
 
-- git co -b ${BASE_TAG}-stable ${BASE_TAG}.0
-- make startstable
+  * git co -b ${BASE_TAG}-stable ${BASE_TAG}.0
+  * make startstable
 
 Now
 
-- git co ${BASE_TAG}-stable
-- git cherry-pick any fixes
-- make startstable
-- Do the steps as above
-- git co master
-- `#` cherry pick the changes to the changelog - check the diff to make sure it
-  is correct
-- git checkout ${BASE_TAG}-stable docs/content/changelog.md
-- git commit -a -v -m "Changelog updates from Version ${NEW_TAG}"
-- git push
+  * git co ${BASE_TAG}-stable
+  * git cherry-pick any fixes
+  * make startstable
+  * Do the steps as above
+  * git co master
+  * `#` cherry pick the changes to the changelog - check the diff to make sure it is correct
+  * git checkout ${BASE_TAG}-stable docs/content/changelog.md
+  * git commit -a -v -m "Changelog updates from Version ${NEW_TAG}"
+  * git push
 
 ## Sponsor logos
 
-If updating the website note that the sponsor logos have been moved out of the
-main repository.
+If updating the website note that the sponsor logos have been moved out of the main repository.
 
-You will need to checkout `/docs/static/img/logos` from <https://github.com/rclone/third-party-logos>
+You will need to checkout `/docs/static/img/logos` from https://github.com/rclone/third-party-logos
 which is a private repo containing artwork from sponsors.
 
 ## Update the website between releases
 
 Create an update website branch based off the last release
 
-```sh
-git co -b update-website
-```
+    git co -b update-website
 
 If the branch already exists, double check there are no commits that need saving.
 
 Now reset the branch to the last release
 
-```sh
-git reset --hard v1.64.0
-```
+    git reset --hard v1.64.0
 
 Create the changes, check them in, test with `make serve` then
 
-```sh
-make upload_test_website
-```
+    make upload_test_website
 
-Check out <https://test.rclone.org> and when happy
+Check out https://test.rclone.org and when happy
 
-```sh
-make upload_website
-```
+    make upload_website
 
 Cherry pick any changes back to master and the stable branch if it is active.
 
@@ -189,14 +172,14 @@ Cherry pick any changes back to master and the stable branch if it is active.
 
 To do a basic build of rclone's docker image to debug builds locally:
 
-```sh
+```
 docker buildx build --load -t rclone/rclone:testing --progress=plain .
 docker run --rm rclone/rclone:testing version
 ```
 
 To test the multipatform build
 
-```sh
+```
 docker buildx build -t rclone/rclone:testing --progress=plain --platform linux/amd64,linux/386,linux/arm64,linux/arm/v7,linux/arm/v6 .
 ```
 
@@ -204,6 +187,6 @@ To make a full build then set the tags correctly and add `--push`
 
 Note that you can't only build one architecture - you need to build them all.
 
-```sh
+```
 docker buildx build --platform linux/amd64,linux/386,linux/arm64,linux/arm/v7,linux/arm/v6 -t rclone/rclone:1.54.1 -t rclone/rclone:1.54 -t rclone/rclone:1 -t rclone/rclone:latest --push .
 ```

backend/azureblob/azureblob.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 // Package azureblob provides an interface to the Microsoft Azure blob object storage system
 package azureblob
@@ -51,7 +51,6 @@ import (
 	"github.com/rclone/rclone/lib/env"
 	"github.com/rclone/rclone/lib/multipart"
 	"github.com/rclone/rclone/lib/pacer"
-	"github.com/rclone/rclone/lib/pool"
 	"golang.org/x/sync/errgroup"
 )
 
@@ -2671,13 +2670,6 @@ func (w *azChunkWriter) WriteChunk(ctx context.Context, chunkNumber int, reader
 		return -1, err
 	}
 
-	// Only account after the checksum reads have been done
-	if do, ok := reader.(pool.DelayAccountinger); ok {
-		// To figure out this number, do a transfer and if the accounted size is 0 or a
-		// multiple of what it should be, increase or decrease this number.
-		do.DelayAccounting(2)
-	}
-
 	// Upload the block, with MD5 for check
 	m := md5.New()
 	currentChunkSize, err := io.Copy(m, reader)
@@ -2765,8 +2757,6 @@ func (o *Object) clearUncommittedBlocks(ctx context.Context) (err error) {
 		blockList    blockblob.GetBlockListResponse
 		properties   *blob.GetPropertiesResponse
 		options      *blockblob.CommitBlockListOptions
-		// Use temporary pacer as this can be called recursively which can cause a deadlock with --max-connections
-		pacer = fs.NewPacer(ctx, pacer.NewS3(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant)))
 	)
 
 	properties, err = o.readMetaDataAlways(ctx)
@@ -2778,7 +2768,7 @@ func (o *Object) clearUncommittedBlocks(ctx context.Context) (err error) {
 
 	if objectExists {
 		// Get the committed block list
-		err = pacer.Call(func() (bool, error) {
+		err = o.fs.pacer.Call(func() (bool, error) {
 			blockList, err = blockBlobSVC.GetBlockList(ctx, blockblob.BlockListTypeAll, nil)
 			return o.fs.shouldRetry(ctx, err)
 		})
@@ -2820,7 +2810,7 @@ func (o *Object) clearUncommittedBlocks(ctx context.Context) (err error) {
 
 	// Commit only the committed blocks
 	fs.Debugf(o, "Committing %d blocks to remove uncommitted blocks", len(blockIDs))
-	err = pacer.Call(func() (bool, error) {
+	err = o.fs.pacer.Call(func() (bool, error) {
 		_, err := blockBlobSVC.CommitBlockList(ctx, blockIDs, options)
 		return o.fs.shouldRetry(ctx, err)
 	})

backend/azureblob/azureblob_internal_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package azureblob
 

backend/azureblob/azureblob_test.go

@@ -1,6 +1,6 @@
 // Test AzureBlob filesystem interface
 
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package azureblob
 

backend/azureblob/azureblob_unsupported.go

@@ -1,7 +1,7 @@
 // Build for azureblob for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || solaris || js || wasm
+//go:build plan9 || solaris || js
 
 // Package azureblob provides an interface to the Microsoft Azure blob object storage system
 package azureblob

backend/azurefiles/azurefiles.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 // Package azurefiles provides an interface to Microsoft Azure Files
 package azurefiles
@@ -453,7 +453,7 @@ func newFsFromOptions(ctx context.Context, name, root string, opt *Options) (fs.
 			return nil, fmt.Errorf("create new shared key credential failed: %w", err)
 		}
 	case opt.UseAZ:
-		options := azidentity.AzureCLICredentialOptions{}
+		var options = azidentity.AzureCLICredentialOptions{}
 		cred, err = azidentity.NewAzureCLICredential(&options)
 		fmt.Println(cred)
 		if err != nil {
@@ -550,7 +550,7 @@ func newFsFromOptions(ctx context.Context, name, root string, opt *Options) (fs.
 	case opt.UseMSI:
 		// Specifying a user-assigned identity. Exactly one of the above IDs must be specified.
 		// Validate and ensure exactly one is set. (To do: better validation.)
-		b2i := map[bool]int{false: 0, true: 1}
+		var b2i = map[bool]int{false: 0, true: 1}
 		set := b2i[opt.MSIClientID != ""] + b2i[opt.MSIObjectID != ""] + b2i[opt.MSIResourceID != ""]
 		if set > 1 {
 			return nil, errors.New("more than one user-assigned identity ID is set")
@@ -583,6 +583,7 @@ func newFsFromOptions(ctx context.Context, name, root string, opt *Options) (fs.
 			token, err := msiCred.GetToken(context.Background(), policy.TokenRequestOptions{
 				Scopes: []string{"api://AzureADTokenExchange"},
 			})
+
 			if err != nil {
 				return "", fmt.Errorf("failed to acquire MSI token: %w", err)
 			}
@@ -854,7 +855,7 @@ func (f *Fs) List(ctx context.Context, dir string) (fs.DirEntries, error) {
 		return entries, err
 	}
 
-	opt := &directory.ListFilesAndDirectoriesOptions{
+	var opt = &directory.ListFilesAndDirectoriesOptions{
 		Include: directory.ListFilesInclude{
 			Timestamps: true,
 		},
@@ -1013,10 +1014,6 @@ func (o *Object) SetModTime(ctx context.Context, t time.Time) error {
 		SMBProperties: &file.SMBProperties{
 			LastWriteTime: &t,
 		},
-		HTTPHeaders: &file.HTTPHeaders{
-			ContentMD5:  o.md5,
-			ContentType: &o.contentType,
-		},
 	}
 	_, err := o.fileClient().SetHTTPHeaders(ctx, &opt)
 	if err != nil {

backend/azurefiles/azurefiles_internal_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package azurefiles
 

backend/azurefiles/azurefiles_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package azurefiles
 

backend/azurefiles/azurefiles_unsupported.go

@@ -1,7 +1,7 @@
 // Build for azurefiles for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || js || wasm
+//go:build plan9 || js
 
 // Package azurefiles provides an interface to Microsoft Azure Files
 package azurefiles

backend/box/api/types.go

@@ -271,9 +271,9 @@ type User struct {
 	ModifiedAt    time.Time `json:"modified_at"`
 	Language      string    `json:"language"`
 	Timezone      string    `json:"timezone"`
-	SpaceAmount   float64   `json:"space_amount"`
-	SpaceUsed     float64   `json:"space_used"`
-	MaxUploadSize float64   `json:"max_upload_size"`
+	SpaceAmount   int64     `json:"space_amount"`
+	SpaceUsed     int64     `json:"space_used"`
+	MaxUploadSize int64     `json:"max_upload_size"`
 	Status        string    `json:"status"`
 	JobTitle      string    `json:"job_title"`
 	Phone         string    `json:"phone"`

backend/cache/cache.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 // Package cache implements a virtual provider to cache existing remotes.
 package cache

backend/cache/cache_internal_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm && !race
+//go:build !plan9 && !js && !race
 
 package cache_test
 

backend/cache/cache_test.go

@@ -1,6 +1,6 @@
 // Test Cache filesystem interface
 
-//go:build !plan9 && !js && !wasm && !race
+//go:build !plan9 && !js && !race
 
 package cache_test
 

backend/cache/cache_unsupported.go

@@ -1,7 +1,7 @@
 // Build for cache for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || js || wasm
+//go:build plan9 || js
 
 // Package cache implements a virtual provider to cache existing remotes.
 package cache

backend/cache/cache_upload_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm && !race
+//go:build !plan9 && !js && !race
 
 package cache_test
 

backend/cache/directory.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package cache
 

backend/cache/handle.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package cache
 

backend/cache/object.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package cache
 

backend/cache/plex.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package cache
 

backend/cache/storage_memory.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package cache
 

backend/cache/storage_persistent.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package cache
 

backend/cache/utils_test.go

@@ -1,4 +1,5 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
+// +build !plan9,!js
 
 package cache
 

backend/dropbox/dropbox.go

@@ -1446,9 +1446,9 @@ func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) {
 		}
 	}
 	usage = &fs.Usage{
-		Total: fs.NewUsageValue(total),        // quota of bytes that can be used
-		Used:  fs.NewUsageValue(used),         // bytes in use
-		Free:  fs.NewUsageValue(total - used), // bytes which can be uploaded before reaching the quota
+		Total: fs.NewUsageValue(int64(total)),        // quota of bytes that can be used
+		Used:  fs.NewUsageValue(int64(used)),         // bytes in use
+		Free:  fs.NewUsageValue(int64(total - used)), // bytes which can be uploaded before reaching the quota
 	}
 	return usage, nil
 }

backend/ftp/ftp.go

@@ -163,16 +163,6 @@ Enabled by default. Use 0 to disable.`,
 			Help:     "Disable TLS 1.3 (workaround for FTP servers with buggy TLS)",
 			Default:  false,
 			Advanced: true,
-		}, {
-			Name: "allow_insecure_tls_ciphers",
-			Help: `Allow insecure TLS ciphers
-
-Setting this flag will allow the usage of the following TLS ciphers in addition to the secure defaults:
-
-- TLS_RSA_WITH_AES_128_GCM_SHA256
-`,
-			Default:  false,
-			Advanced: true,
 		}, {
 			Name:     "shut_timeout",
 			Help:     "Maximum time to wait for data connection closing status.",
@@ -246,30 +236,29 @@ a write only folder.
 
 // Options defines the configuration for this backend
 type Options struct {
-	Host                    string               `config:"host"`
-	User                    string               `config:"user"`
-	Pass                    string               `config:"pass"`
-	Port                    string               `config:"port"`
-	TLS                     bool                 `config:"tls"`
-	ExplicitTLS             bool                 `config:"explicit_tls"`
-	TLSCacheSize            int                  `config:"tls_cache_size"`
-	DisableTLS13            bool                 `config:"disable_tls13"`
-	AllowInsecureTLSCiphers bool                 `config:"allow_insecure_tls_ciphers"`
-	Concurrency             int                  `config:"concurrency"`
-	SkipVerifyTLSCert       bool                 `config:"no_check_certificate"`
-	DisableEPSV             bool                 `config:"disable_epsv"`
-	DisableMLSD             bool                 `config:"disable_mlsd"`
-	DisableUTF8             bool                 `config:"disable_utf8"`
-	WritingMDTM             bool                 `config:"writing_mdtm"`
-	ForceListHidden         bool                 `config:"force_list_hidden"`
-	IdleTimeout             fs.Duration          `config:"idle_timeout"`
-	CloseTimeout            fs.Duration          `config:"close_timeout"`
-	ShutTimeout             fs.Duration          `config:"shut_timeout"`
-	AskPassword             bool                 `config:"ask_password"`
-	Enc                     encoder.MultiEncoder `config:"encoding"`
-	SocksProxy              string               `config:"socks_proxy"`
-	HTTPProxy               string               `config:"http_proxy"`
-	NoCheckUpload           bool                 `config:"no_check_upload"`
+	Host              string               `config:"host"`
+	User              string               `config:"user"`
+	Pass              string               `config:"pass"`
+	Port              string               `config:"port"`
+	TLS               bool                 `config:"tls"`
+	ExplicitTLS       bool                 `config:"explicit_tls"`
+	TLSCacheSize      int                  `config:"tls_cache_size"`
+	DisableTLS13      bool                 `config:"disable_tls13"`
+	Concurrency       int                  `config:"concurrency"`
+	SkipVerifyTLSCert bool                 `config:"no_check_certificate"`
+	DisableEPSV       bool                 `config:"disable_epsv"`
+	DisableMLSD       bool                 `config:"disable_mlsd"`
+	DisableUTF8       bool                 `config:"disable_utf8"`
+	WritingMDTM       bool                 `config:"writing_mdtm"`
+	ForceListHidden   bool                 `config:"force_list_hidden"`
+	IdleTimeout       fs.Duration          `config:"idle_timeout"`
+	CloseTimeout      fs.Duration          `config:"close_timeout"`
+	ShutTimeout       fs.Duration          `config:"shut_timeout"`
+	AskPassword       bool                 `config:"ask_password"`
+	Enc               encoder.MultiEncoder `config:"encoding"`
+	SocksProxy        string               `config:"socks_proxy"`
+	HTTPProxy         string               `config:"http_proxy"`
+	NoCheckUpload     bool                 `config:"no_check_upload"`
 }
 
 // Fs represents a remote FTP server
@@ -418,14 +407,6 @@ func (f *Fs) tlsConfig() *tls.Config {
 		if f.opt.DisableTLS13 {
 			tlsConfig.MaxVersion = tls.VersionTLS12
 		}
-		if f.opt.AllowInsecureTLSCiphers {
-			var ids []uint16
-			// Read default ciphers
-			for _, cs := range tls.CipherSuites() {
-				ids = append(ids, cs.ID)
-			}
-			tlsConfig.CipherSuites = append(ids, tls.TLS_RSA_WITH_AES_128_GCM_SHA256)
-		}
 	}
 	return tlsConfig
 }

backend/hdfs/fs.go

@@ -371,9 +371,9 @@ func (f *Fs) About(ctx context.Context) (*fs.Usage, error) {
 		return nil, err
 	}
 	return &fs.Usage{
-		Total: fs.NewUsageValue(info.Capacity),
-		Used:  fs.NewUsageValue(info.Used),
-		Free:  fs.NewUsageValue(info.Remaining),
+		Total: fs.NewUsageValue(int64(info.Capacity)),
+		Used:  fs.NewUsageValue(int64(info.Used)),
+		Free:  fs.NewUsageValue(int64(info.Remaining)),
 	}, nil
 }
 

backend/internetarchive/internetarchive.go

@@ -1339,7 +1339,7 @@ func quotePath(s string) string {
 	seg := strings.Split(s, "/")
 	newValues := []string{}
 	for _, v := range seg {
-		newValues = append(newValues, url.QueryEscape(v))
+		newValues = append(newValues, url.PathEscape(v))
 	}
 	return strings.Join(newValues, "/")
 }

backend/local/lchmod.go

@@ -1,4 +1,4 @@
-//go:build windows || plan9 || js || wasm || linux
+//go:build windows || plan9 || js || linux
 
 package local
 

backend/local/lchmod_unix.go

@@ -1,4 +1,4 @@
-//go:build !windows && !plan9 && !js && !wasm && !linux
+//go:build !windows && !plan9 && !js && !linux
 
 package local
 

backend/local/lchtimes.go

@@ -1,4 +1,4 @@
-//go:build plan9 || js || wasm
+//go:build plan9 || js
 
 package local
 

backend/local/lchtimes_unix.go

@@ -1,4 +1,4 @@
-//go:build !windows && !plan9 && !js && !wasm
+//go:build !windows && !plan9 && !js
 
 package local
 

backend/local/local.go

@@ -671,12 +671,8 @@ func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err e
 			name := fi.Name()
 			mode := fi.Mode()
 			newRemote := f.cleanRemote(dir, name)
-			symlinkFlag := os.ModeSymlink
-			if runtime.GOOS == "windows" {
-				symlinkFlag |= os.ModeIrregular
-			}
 			// Follow symlinks if required
-			if f.opt.FollowSymlinks && (mode&symlinkFlag) != 0 {
+			if f.opt.FollowSymlinks && (mode&os.ModeSymlink) != 0 {
 				localPath := filepath.Join(fsDirPath, name)
 				fi, err = os.Stat(localPath)
 				// Quietly skip errors on excluded files and directories
@@ -698,13 +694,13 @@ func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err e
 			if fi.IsDir() {
 				// Ignore directories which are symlinks.  These are junction points under windows which
 				// are kind of a souped up symlink. Unix doesn't have directories which are symlinks.
-				if (mode&symlinkFlag) == 0 && f.dev == readDevice(fi, f.opt.OneFileSystem) {
+				if (mode&os.ModeSymlink) == 0 && f.dev == readDevice(fi, f.opt.OneFileSystem) {
 					d := f.newDirectory(newRemote, fi)
 					entries = append(entries, d)
 				}
 			} else {
 				// Check whether this link should be translated
-				if f.opt.TranslateSymlinks && fi.Mode()&symlinkFlag != 0 {
+				if f.opt.TranslateSymlinks && fi.Mode()&os.ModeSymlink != 0 {
 					newRemote += fs.LinkSuffix
 				}
 				// Don't include non directory if not included

backend/local/metadata_other.go

@@ -1,4 +1,4 @@
-//go:build dragonfly || plan9 || js || wasm
+//go:build dragonfly || plan9 || js
 
 package local
 

backend/local/symlink.go

@@ -1,4 +1,4 @@
-//go:build !windows && !plan9 && !js && !wasm
+//go:build !windows && !plan9 && !js
 
 package local
 

backend/local/symlink_other.go

@@ -1,4 +1,4 @@
-//go:build windows || plan9 || js || wasm
+//go:build windows || plan9 || js
 
 package local
 

backend/mega/mega.go

@@ -946,9 +946,9 @@ func (f *Fs) About(ctx context.Context) (*fs.Usage, error) {
 		return nil, fmt.Errorf("failed to get Mega Quota: %w", err)
 	}
 	usage := &fs.Usage{
-		Total: fs.NewUsageValue(q.Mstrg),           // quota of bytes that can be used
-		Used:  fs.NewUsageValue(q.Cstrg),           // bytes in use
-		Free:  fs.NewUsageValue(q.Mstrg - q.Cstrg), // bytes which can be uploaded before reaching the quota
+		Total: fs.NewUsageValue(int64(q.Mstrg)),           // quota of bytes that can be used
+		Used:  fs.NewUsageValue(int64(q.Cstrg)),           // bytes in use
+		Free:  fs.NewUsageValue(int64(q.Mstrg - q.Cstrg)), // bytes which can be uploaded before reaching the quota
 	}
 	return usage, nil
 }

backend/oracleobjectstorage/byok.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/client.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/command.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/copy.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/multipart.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/object.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/options.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/oracleobjectstorage.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 // Package oracleobjectstorage provides an interface to the OCI object storage system.
 package oracleobjectstorage
@@ -12,7 +12,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ncw/swift/v2"
 	"github.com/oracle/oci-go-sdk/v65/common"
 	"github.com/oracle/oci-go-sdk/v65/objectstorage"
 	"github.com/rclone/rclone/fs"
@@ -34,46 +33,9 @@ func init() {
 		NewFs:       NewFs,
 		CommandHelp: commandHelp,
 		Options:     newOptions(),
-		MetadataInfo: &fs.MetadataInfo{
-			System: systemMetadataInfo,
-			Help:   `User metadata is stored as opc-meta- keys.`,
-		},
 	})
 }
 
-var systemMetadataInfo = map[string]fs.MetadataHelp{
-	"opc-meta-mode": {
-		Help:    "File type and mode",
-		Type:    "octal, unix style",
-		Example: "0100664",
-	},
-	"opc-meta-uid": {
-		Help:    "User ID of owner",
-		Type:    "decimal number",
-		Example: "500",
-	},
-	"opc-meta-gid": {
-		Help:    "Group ID of owner",
-		Type:    "decimal number",
-		Example: "500",
-	},
-	"opc-meta-atime": {
-		Help:    "Time of last access",
-		Type:    "ISO 8601",
-		Example: "2025-06-30T22:27:43-04:00",
-	},
-	"opc-meta-mtime": {
-		Help:    "Time of last modification",
-		Type:    "ISO 8601",
-		Example: "2025-06-30T22:27:43-04:00",
-	},
-	"opc-meta-btime": {
-		Help:    "Time of file birth (creation)",
-		Type:    "ISO 8601",
-		Example: "2025-06-30T22:27:43-04:00",
-	},
-}
-
 // Fs represents a remote object storage server
 type Fs struct {
 	name          string                             // name of this remote
@@ -120,7 +82,6 @@ func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, e
 	}
 	f.setRoot(root)
 	f.features = (&fs.Features{
-		ReadMetadata:      true,
 		ReadMimeType:      true,
 		WriteMimeType:     true,
 		BucketBased:       true,
@@ -727,38 +688,6 @@ func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (
 	return list.Flush()
 }
 
-// Metadata returns metadata for an object
-//
-// It should return nil if there is no Metadata
-func (o *Object) Metadata(ctx context.Context) (metadata fs.Metadata, err error) {
-	err = o.readMetaData(ctx)
-	if err != nil {
-		return nil, err
-	}
-	metadata = make(fs.Metadata, len(o.meta)+7)
-	for k, v := range o.meta {
-		switch k {
-		case metaMtime:
-			if modTime, err := swift.FloatStringToTime(v); err == nil {
-				metadata["mtime"] = modTime.Format(time.RFC3339Nano)
-			}
-		case metaMD5Hash:
-			// don't write hash metadata
-		default:
-			metadata[k] = v
-		}
-	}
-	if o.mimeType != "" {
-		metadata["content-type"] = o.mimeType
-	}
-
-	if !o.lastModified.IsZero() {
-		metadata["btime"] = o.lastModified.Format(time.RFC3339Nano)
-	}
-
-	return metadata, nil
-}
-
 // Check the interfaces are satisfied
 var (
 	_ fs.Fs              = &Fs{}

backend/oracleobjectstorage/oracleobjectstorage_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/oracleobjectstorage/oracleobjectstorage_unsupported.go

@@ -1,7 +1,7 @@
 // Build for oracleobjectstorage for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || solaris || js || wasm
+//go:build plan9 || solaris || js
 
 // Package oracleobjectstorage provides an interface to the OCI object storage system.
 package oracleobjectstorage

backend/oracleobjectstorage/waiter.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !solaris && !js && !wasm
+//go:build !plan9 && !solaris && !js
 
 package oracleobjectstorage
 

backend/pikpak/pikpak.go

@@ -979,24 +979,6 @@ func (f *Fs) deleteObjects(ctx context.Context, IDs []string, useTrash bool) (er
 	return nil
 }
 
-// untrash a file or directory by ID
-//
-// If a name collision occurs in the destination folder, PikPak might automatically
-// rename the restored item(s) by appending a numbered suffix. For example,
-// foo.txt -> foo(1).txt or foo(2).txt if foo(1).txt already exists
-func (f *Fs) untrashObjects(ctx context.Context, IDs []string) (err error) {
-	if len(IDs) == 0 {
-		return nil
-	}
-	req := api.RequestBatch{
-		IDs: IDs,
-	}
-	if err := f.requestBatchAction(ctx, "batchUntrash", &req); err != nil {
-		return fmt.Errorf("untrash object failed: %w", err)
-	}
-	return nil
-}
-
 // purgeCheck removes the root directory, if check is set then it
 // refuses to do so if it has anything in
 func (f *Fs) purgeCheck(ctx context.Context, dir string, check bool) error {
@@ -1081,14 +1063,7 @@ func (f *Fs) CleanUp(ctx context.Context) (err error) {
 	return f.waitTask(ctx, info.TaskID)
 }
 
-// Move the object to a new parent folder
-//
-// Objects cannot be moved to their current folder.
-// "file_move_or_copy_to_cur" (9): Please don't move or copy to current folder or sub folder
-//
-// If a name collision occurs in the destination folder, PikPak might automatically
-// rename the moved item(s) by appending a numbered suffix. For example,
-// foo.txt -> foo(1).txt or foo(2).txt if foo(1).txt already exists
+// Move the object
 func (f *Fs) moveObjects(ctx context.Context, IDs []string, dirID string) (err error) {
 	if len(IDs) == 0 {
 		return nil
@@ -1104,12 +1079,6 @@ func (f *Fs) moveObjects(ctx context.Context, IDs []string, dirID string) (err e
 }
 
 // renames the object
-//
-// The new name must be different from the current name.
-// "file_rename_to_same_name" (3): Name of file or folder is not changed
-//
-// Within the same folder, object names must be unique.
-// "file_duplicated_name" (3): File name cannot be repeated
 func (f *Fs) renameObject(ctx context.Context, ID, newName string) (info *api.File, err error) {
 	req := api.File{
 		Name: f.opt.Enc.FromStandardName(newName),
@@ -1194,13 +1163,18 @@ func (f *Fs) createObject(ctx context.Context, remote string, modTime time.Time,
 // Will only be called if src.Fs().Name() == f.Name()
 //
 // If it isn't possible then return fs.ErrorCantMove
-func (f *Fs) Move(ctx context.Context, src fs.Object, remote string) (dst fs.Object, err error) {
+func (f *Fs) Move(ctx context.Context, src fs.Object, remote string) (fs.Object, error) {
 	srcObj, ok := src.(*Object)
 	if !ok {
 		fs.Debugf(src, "Can't move - not same remote type")
 		return nil, fs.ErrorCantMove
 	}
-	err = srcObj.readMetaData(ctx)
+	err := srcObj.readMetaData(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	srcLeaf, srcParentID, err := srcObj.fs.dirCache.FindPath(ctx, srcObj.remote, false)
 	if err != nil {
 		return nil, err
 	}
@@ -1211,74 +1185,31 @@ func (f *Fs) Move(ctx context.Context, src fs.Object, remote string) (dst fs.Obj
 		return nil, err
 	}
 
-	if srcObj.parent != dstParentID {
-		// Perform the move. A numbered copy might be generated upon name collision.
+	if srcParentID != dstParentID {
+		// Do the move
 		if err = f.moveObjects(ctx, []string{srcObj.id}, dstParentID); err != nil {
-			return nil, fmt.Errorf("move: failed to move object %s to new parent %s: %w", srcObj.id, dstParentID, err)
+			return nil, err
 		}
-		defer func() {
-			if err != nil {
-				// FIXME: Restored file might have a numbered name if a conflict occurs
-				if mvErr := f.moveObjects(ctx, []string{srcObj.id}, srcObj.parent); mvErr != nil {
-					fs.Logf(f, "move: couldn't restore original object %q to %q after move failure: %v", dstObj.id, src.Remote(), mvErr)
-				}
-			}
-		}()
 	}
+	// Manually update info of moved object to save API calls
+	dstObj.id = srcObj.id
+	dstObj.mimeType = srcObj.mimeType
+	dstObj.gcid = srcObj.gcid
+	dstObj.md5sum = srcObj.md5sum
+	dstObj.hasMetaData = true
 
-	// Find the moved object and any conflict object with the same name.
-	var moved, conflict *api.File
-	_, err = f.listAll(ctx, dstParentID, api.KindOfFile, "false", func(item *api.File) bool {
-		if item.ID == srcObj.id {
-			moved = item
-			if item.Name == dstLeaf {
-				return true
-			}
-		} else if item.Name == dstLeaf {
-			conflict = item
+	if srcLeaf != dstLeaf {
+		// Rename
+		info, err := f.renameObject(ctx, srcObj.id, dstLeaf)
+		if err != nil {
+			return nil, fmt.Errorf("move: couldn't rename moved file: %w", err)
 		}
-		// Stop early if both found
-		return moved != nil && conflict != nil
-	})
-	if err != nil {
-		return nil, fmt.Errorf("move: couldn't locate moved file %q in destination directory %q: %w", srcObj.id, dstParentID, err)
+		return dstObj, dstObj.setMetaData(info)
 	}
-	if moved == nil {
-		return nil, fmt.Errorf("move: moved file %q not found in destination", srcObj.id)
-	}
-
-	// If moved object already has the correct name, return
-	if moved.Name == dstLeaf {
-		return dstObj, dstObj.setMetaData(moved)
-	}
-	// If name collision, delete conflicting file first
-	if conflict != nil {
-		if err = f.deleteObjects(ctx, []string{conflict.ID}, true); err != nil {
-			return nil, fmt.Errorf("move: couldn't delete conflicting file: %w", err)
-		}
-		defer func() {
-			if err != nil {
-				if restoreErr := f.untrashObjects(ctx, []string{conflict.ID}); restoreErr != nil {
-					fs.Logf(f, "move: couldn't restore conflicting file: %v", restoreErr)
-				}
-			}
-		}()
-	}
-	info, err := f.renameObject(ctx, srcObj.id, dstLeaf)
-	if err != nil {
-		return nil, fmt.Errorf("move: couldn't rename moved file %q to %q: %w", dstObj.id, dstLeaf, err)
-	}
-	return dstObj, dstObj.setMetaData(info)
+	return dstObj, nil
 }
 
 // copy objects
-//
-// Objects cannot be copied to their current folder.
-// "file_move_or_copy_to_cur" (9): Please don't move or copy to current folder or sub folder
-//
-// If a name collision occurs in the destination folder, PikPak might automatically
-// rename the copied item(s) by appending a numbered suffix. For example,
-// foo.txt -> foo(1).txt or foo(2).txt if foo(1).txt already exists
 func (f *Fs) copyObjects(ctx context.Context, IDs []string, dirID string) (err error) {
 	if len(IDs) == 0 {
 		return nil
@@ -1302,13 +1233,13 @@ func (f *Fs) copyObjects(ctx context.Context, IDs []string, dirID string) (err e
 // Will only be called if src.Fs().Name() == f.Name()
 //
 // If it isn't possible then return fs.ErrorCantCopy
-func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (dst fs.Object, err error) {
+func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (fs.Object, error) {
 	srcObj, ok := src.(*Object)
 	if !ok {
 		fs.Debugf(src, "Can't copy - not same remote type")
 		return nil, fs.ErrorCantCopy
 	}
-	err = srcObj.readMetaData(ctx)
+	err := srcObj.readMetaData(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -1323,55 +1254,31 @@ func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (dst fs.Obj
 		fs.Debugf(src, "Can't copy - same parent")
 		return nil, fs.ErrorCantCopy
 	}
-
-	// Check for possible conflicts: Pikpak creates numbered copies on name collision.
-	var conflict *api.File
-	_, srcLeaf := dircache.SplitPath(srcObj.remote)
-	if srcLeaf == dstLeaf {
-		if conflict, err = f.readMetaDataForPath(ctx, remote); err == nil {
-			// delete conflicting file
-			if err = f.deleteObjects(ctx, []string{conflict.ID}, true); err != nil {
-				return nil, fmt.Errorf("copy: couldn't delete conflicting file: %w", err)
-			}
-			defer func() {
-				if err != nil {
-					if restoreErr := f.untrashObjects(ctx, []string{conflict.ID}); restoreErr != nil {
-						fs.Logf(f, "copy: couldn't restore conflicting file: %v", restoreErr)
-					}
-				}
-			}()
-		} else if err != fs.ErrorObjectNotFound {
-			return nil, err
-		}
-	} else {
-		dstDir, _ := dircache.SplitPath(remote)
-		dstObj.remote = path.Join(dstDir, srcLeaf)
-		if conflict, err = f.readMetaDataForPath(ctx, dstObj.remote); err == nil {
-			tmpName := conflict.Name + "-rclone-copy-" + random.String(8)
-			if _, err = f.renameObject(ctx, conflict.ID, tmpName); err != nil {
-				return nil, fmt.Errorf("copy: couldn't rename conflicting file: %w", err)
-			}
-			defer func() {
-				if _, renameErr := f.renameObject(ctx, conflict.ID, conflict.Name); renameErr != nil {
-					fs.Logf(f, "copy: couldn't rename conflicting file back to original: %v", renameErr)
-				}
-			}()
-		} else if err != fs.ErrorObjectNotFound {
-			return nil, err
-		}
-	}
-
 	// Copy the object
 	if err := f.copyObjects(ctx, []string{srcObj.id}, dstParentID); err != nil {
 		return nil, fmt.Errorf("couldn't copy file: %w", err)
 	}
-	err = dstObj.readMetaData(ctx)
-	if err != nil {
+	// Update info of the copied object with new parent but source name
+	if info, err := dstObj.fs.readMetaDataForPath(ctx, srcObj.remote); err != nil {
 		return nil, fmt.Errorf("copy: couldn't locate copied file: %w", err)
+	} else if err = dstObj.setMetaData(info); err != nil {
+		return nil, err
+	}
+
+	// Can't copy and change name in one step so we have to check if we have
+	// the correct name after copy
+	srcLeaf, _, err := srcObj.fs.dirCache.FindPath(ctx, srcObj.remote, false)
+	if err != nil {
+		return nil, err
 	}
 
 	if srcLeaf != dstLeaf {
-		return f.Move(ctx, dstObj, remote)
+		// Rename
+		info, err := f.renameObject(ctx, dstObj.id, dstLeaf)
+		if err != nil {
+			return nil, fmt.Errorf("copy: couldn't rename copied file: %w", err)
+		}
+		return dstObj, dstObj.setMetaData(info)
 	}
 	return dstObj, nil
 }
@@ -1508,30 +1415,8 @@ func (f *Fs) upload(ctx context.Context, in io.Reader, leaf, dirID, gcid string,
 	}
 	if new.File == nil {
 		return nil, fmt.Errorf("invalid response: %+v", new)
-	}
-
-	defer atexit.OnError(&err, func() {
-		fs.Debugf(leaf, "canceling upload: %v", err)
-		if cancelErr := f.deleteObjects(ctx, []string{new.File.ID}, false); cancelErr != nil {
-			fs.Logf(leaf, "failed to cancel upload: %v", cancelErr)
-		}
-		if new.Task != nil {
-			if cancelErr := f.deleteTask(ctx, new.Task.ID, false); cancelErr != nil {
-				fs.Logf(leaf, "failed to cancel upload: %v", cancelErr)
-			}
-			fs.Debugf(leaf, "waiting %v for the cancellation to be effective", taskWaitTime)
-			time.Sleep(taskWaitTime)
-		}
-	})()
-
-	// Note: The API might automatically append a numbered suffix to the filename,
-	// even if a file with the same name does not exist in the target directory.
-	if upName := f.opt.Enc.ToStandardName(new.File.Name); leaf != upName {
-		return nil, fserrors.NoRetryError(fmt.Errorf("uploaded file name mismatch: expected %q, got %q", leaf, upName))
-	}
-
-	// early return; in case of zero-byte objects or uploaded by matched gcid
-	if new.File.Phase == api.PhaseTypeComplete {
+	} else if new.File.Phase == api.PhaseTypeComplete {
+		// early return; in case of zero-byte objects
 		if acc, ok := in.(*accounting.Account); ok && acc != nil {
 			// if `in io.Reader` is still in type of `*accounting.Account` (meaning that it is unused)
 			// it is considered as a server side copy as no incoming/outgoing traffic occur at all
@@ -1541,6 +1426,18 @@ func (f *Fs) upload(ctx context.Context, in io.Reader, leaf, dirID, gcid string,
 		return new.File, nil
 	}
 
+	defer atexit.OnError(&err, func() {
+		fs.Debugf(leaf, "canceling upload: %v", err)
+		if cancelErr := f.deleteObjects(ctx, []string{new.File.ID}, false); cancelErr != nil {
+			fs.Logf(leaf, "failed to cancel upload: %v", cancelErr)
+		}
+		if cancelErr := f.deleteTask(ctx, new.Task.ID, false); cancelErr != nil {
+			fs.Logf(leaf, "failed to cancel upload: %v", cancelErr)
+		}
+		fs.Debugf(leaf, "waiting %v for the cancellation to be effective", taskWaitTime)
+		time.Sleep(taskWaitTime)
+	})()
+
 	if uploadType == api.UploadTypeForm && new.Form != nil {
 		err = f.uploadByForm(ctx, in, req.Name, size, new.Form, options...)
 	} else if uploadType == api.UploadTypeResumable && new.Resumable != nil {
@@ -1552,9 +1449,6 @@ func (f *Fs) upload(ctx context.Context, in io.Reader, leaf, dirID, gcid string,
 	if err != nil {
 		return nil, fmt.Errorf("failed to upload: %w", err)
 	}
-	if new.Task == nil {
-		return new.File, nil
-	}
 	return new.File, f.waitTask(ctx, new.Task.ID)
 }
 

backend/premiumizeme/premiumizeme.go

@@ -793,7 +793,7 @@ func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) {
 		return nil, err
 	}
 	usage = &fs.Usage{
-		Used: fs.NewUsageValue(info.SpaceUsed),
+		Used: fs.NewUsageValue(int64(info.SpaceUsed)),
 	}
 	return usage, nil
 }

backend/protondrive/protondrive.go

@@ -1,5 +1,3 @@
-//go:build !wasm
-
 // Package protondrive implements the Proton Drive backend
 package protondrive
 

backend/protondrive/protondrive_test.go

@@ -1,5 +1,3 @@
-//go:build !wasm
-
 package protondrive_test
 
 import (

backend/protondrive/protondrive_unsupported.go

@@ -1,7 +0,0 @@
-// Build for sftp for unsupported platforms to stop go complaining
-// about "no buildable Go source files "
-
-//go:build wasm
-
-// Package protondrive implements the Proton Drive backend
-package protondrive

backend/qingstor/qingstor.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 // Package qingstor provides an interface to QingStor object storage
 // Home: https://www.qingcloud.com/

backend/qingstor/qingstor_test.go

@@ -1,6 +1,6 @@
 // Test QingStor filesystem interface
 
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package qingstor
 

backend/qingstor/qingstor_unsupported.go

@@ -1,7 +1,7 @@
 // Build for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || js || wasm
+//go:build plan9 || js
 
 // Package qingstor provides an interface to QingStor object storage
 // Home: https://www.qingcloud.com/

backend/qingstor/upload.go

@@ -1,6 +1,6 @@
 // Upload object to QingStor
 
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 package qingstor
 

backend/s3/s3.go

@@ -149,9 +149,6 @@ var providerOption = fs.Option{
 	}, {
 		Value: "Outscale",
 		Help:  "OUTSCALE Object Storage (OOS)",
-	}, {
-		Value: "OVHcloud",
-		Help:  "OVHcloud Object Storage",
 	}, {
 		Value: "Petabox",
 		Help:  "Petabox Object Storage",
@@ -538,59 +535,6 @@ func init() {
 				Value: "ap-northeast-1",
 				Help:  "Tokyo, Japan",
 			}},
-		}, {
-			// References:
-			// https://help.ovhcloud.com/csm/en-public-cloud-storage-s3-location?id=kb_article_view&sysparm_article=KB0047384
-			// https://support.us.ovhcloud.com/hc/en-us/articles/10667991081107-Endpoints-and-Object-Storage-Geoavailability
-			Name:     "region",
-			Help:     "Region where your bucket will be created and your data stored.\n",
-			Provider: "OVHcloud",
-			Examples: []fs.OptionExample{{
-				Value: "gra",
-				Help:  "Gravelines, France",
-			}, {
-				Value: "rbx",
-				Help:  "Roubaix, France",
-			}, {
-				Value: "sbg",
-				Help:  "Strasbourg, France",
-			}, {
-				Value: "eu-west-par",
-				Help:  "Paris, France (3AZ)",
-			}, {
-				Value: "de",
-				Help:  "Frankfurt, Germany",
-			}, {
-				Value: "uk",
-				Help:  "London, United Kingdom",
-			}, {
-				Value: "waw",
-				Help:  "Warsaw, Poland",
-			}, {
-				Value: "bhs",
-				Help:  "Beauharnois, Canada",
-			}, {
-				Value: "ca-east-tor",
-				Help:  "Toronto, Canada",
-			}, {
-				Value: "sgp",
-				Help:  "Singapore",
-			}, {
-				Value: "ap-southeast-syd",
-				Help:  "Sydney, Australia",
-			}, {
-				Value: "ap-south-mum",
-				Help:  "Mumbai, India",
-			}, {
-				Value: "us-east-va",
-				Help:  "Vint Hill, Virginia, USA",
-			}, {
-				Value: "us-west-or",
-				Help:  "Hillsboro, Oregon, USA",
-			}, {
-				Value: "rbx-archive",
-				Help:  "Roubaix, France (Cold Archive)",
-			}},
 		}, {
 			Name:     "region",
 			Help:     "Region where your bucket will be created and your data stored.\n",
@@ -643,7 +587,7 @@ func init() {
 		}, {
 			Name:     "region",
 			Help:     "Region to connect to.\n\nLeave blank if you are using an S3 clone and you don't have a region.",
-			Provider: "!AWS,Alibaba,ArvanCloud,ChinaMobile,Cloudflare,FlashBlade,IONOS,Petabox,Liara,Linode,Magalu,OVHcloud,Qiniu,RackCorp,Scaleway,Selectel,Storj,Synology,TencentCOS,HuaweiOBS,IDrive,Mega,Zata",
+			Provider: "!AWS,Alibaba,ArvanCloud,ChinaMobile,Cloudflare,FlashBlade,IONOS,Petabox,Liara,Linode,Magalu,Qiniu,RackCorp,Scaleway,Selectel,Storj,Synology,TencentCOS,HuaweiOBS,IDrive,Mega,Zata",
 			Examples: []fs.OptionExample{{
 				Value: "",
 				Help:  "Use this if unsure.\nWill use v4 signatures and an empty region.",
@@ -1230,71 +1174,6 @@ func init() {
 				Value: "obs.ru-northwest-2.myhuaweicloud.com",
 				Help:  "RU-Moscow2",
 			}},
-		}, {
-			Name:     "endpoint",
-			Help:     "Endpoint for OVHcloud Object Storage.",
-			Provider: "OVHcloud",
-			Examples: []fs.OptionExample{{
-				Value:    "s3.gra.io.cloud.ovh.net",
-				Help:     "OVHcloud Gravelines, France",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.rbx.io.cloud.ovh.net",
-				Help:     "OVHcloud Roubaix, France",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.sbg.io.cloud.ovh.net",
-				Help:     "OVHcloud Strasbourg, France",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.eu-west-par.io.cloud.ovh.net",
-				Help:     "OVHcloud Paris, France (3AZ)",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.de.io.cloud.ovh.net",
-				Help:     "OVHcloud Frankfurt, Germany",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.uk.io.cloud.ovh.net",
-				Help:     "OVHcloud London, United Kingdom",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.waw.io.cloud.ovh.net",
-				Help:     "OVHcloud Warsaw, Poland",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.bhs.io.cloud.ovh.net",
-				Help:     "OVHcloud Beauharnois, Canada",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.ca-east-tor.io.cloud.ovh.net",
-				Help:     "OVHcloud Toronto, Canada",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.sgp.io.cloud.ovh.net",
-				Help:     "OVHcloud Singapore",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.ap-southeast-syd.io.cloud.ovh.net",
-				Help:     "OVHcloud Sydney, Australia",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.ap-south-mum.io.cloud.ovh.net",
-				Help:     "OVHcloud Mumbai, India",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.us-east-va.io.cloud.ovh.us",
-				Help:     "OVHcloud Vint Hill, Virginia, USA",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.us-west-or.io.cloud.ovh.us",
-				Help:     "OVHcloud Hillsboro, Oregon, USA",
-				Provider: "OVHcloud",
-			}, {
-				Value:    "s3.rbx-archive.io.cloud.ovh.net",
-				Help:     "OVHcloud Roubaix, France (Cold Archive)",
-				Provider: "OVHcloud",
-			}},
 		}, {
 			Name:     "endpoint",
 			Help:     "Endpoint for Scaleway Object Storage.",
@@ -1532,7 +1411,7 @@ func init() {
 		}, {
 			Name:     "endpoint",
 			Help:     "Endpoint for S3 API.\n\nRequired when using an S3 clone.",
-			Provider: "!AWS,ArvanCloud,IBMCOS,IDrive,IONOS,TencentCOS,HuaweiOBS,Alibaba,ChinaMobile,GCS,Liara,Linode,LyveCloud,Magalu,OVHcloud,Scaleway,Selectel,StackPath,Storj,Synology,RackCorp,Qiniu,Petabox,Zata",
+			Provider: "!AWS,ArvanCloud,IBMCOS,IDrive,IONOS,TencentCOS,HuaweiOBS,Alibaba,ChinaMobile,GCS,Liara,Linode,LyveCloud,Magalu,Scaleway,Selectel,StackPath,Storj,Synology,RackCorp,Qiniu,Petabox,Zata",
 			Examples: []fs.OptionExample{{
 				Value:    "objects-us-east-1.dream.io",
 				Help:     "Dream Objects endpoint",
@@ -2067,7 +1946,7 @@ func init() {
 		}, {
 			Name:     "location_constraint",
 			Help:     "Location constraint - must be set to match the Region.\n\nLeave blank if not sure. Used when creating buckets only.",
-			Provider: "!AWS,Alibaba,ArvanCloud,HuaweiOBS,ChinaMobile,Cloudflare,FlashBlade,IBMCOS,IDrive,IONOS,Leviia,Liara,Linode,Magalu,Outscale,OVHcloud,Qiniu,RackCorp,Scaleway,Selectel,StackPath,Storj,TencentCOS,Petabox,Mega",
+			Provider: "!AWS,Alibaba,ArvanCloud,HuaweiOBS,ChinaMobile,Cloudflare,FlashBlade,IBMCOS,IDrive,IONOS,Leviia,Liara,Linode,Magalu,Outscale,Qiniu,RackCorp,Scaleway,Selectel,StackPath,Storj,TencentCOS,Petabox,Mega",
 		}, {
 			Name: "acl",
 			Help: `Canned ACL used when creating buckets and storing or copying objects.
@@ -2549,11 +2428,6 @@ See [AWS Docs on Dualstack Endpoints](https://docs.aws.amazon.com/AmazonS3/lates
 See: [AWS S3 Transfer acceleration](https://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration-examples.html)`,
 			Default:  false,
 			Advanced: true,
-		}, {
-			Name:     "use_arn_region",
-			Help:     `If true, enables arn region support for the service.`,
-			Default:  false,
-			Advanced: true,
 		}, {
 			Name:     "leave_parts_on_error",
 			Provider: "AWS",
@@ -3101,7 +2975,6 @@ type Options struct {
 	ForcePathStyle        bool                 `config:"force_path_style"`
 	V2Auth                bool                 `config:"v2_auth"`
 	UseAccelerateEndpoint bool                 `config:"use_accelerate_endpoint"`
-	UseARNRegion          bool                 `config:"use_arn_region"`
 	LeavePartsOnError     bool                 `config:"leave_parts_on_error"`
 	ListChunk             int32                `config:"list_chunk"`
 	ListVersion           int                  `config:"list_version"`
@@ -3466,7 +3339,6 @@ func s3Connection(ctx context.Context, opt *Options, client *http.Client) (s3Cli
 	options = append(options, func(s3Opt *s3.Options) {
 		s3Opt.UsePathStyle = opt.ForcePathStyle
 		s3Opt.UseAccelerate = opt.UseAccelerateEndpoint
-		s3Opt.UseARNRegion = opt.UseARNRegion
 		// FIXME maybe this should be a tristate so can default to DualStackEndpointStateUnset?
 		if opt.UseDualStack {
 			s3Opt.EndpointOptions.UseDualStackEndpoint = aws.DualStackEndpointStateEnabled
@@ -3717,8 +3589,6 @@ func setQuirks(opt *Options) {
 		useAlreadyExists = false // untested
 	case "Outscale":
 		virtualHostStyle = false
-	case "OVHcloud":
-		// No quirks
 	case "RackCorp":
 		// No quirks
 		useMultipartEtag = false // untested
@@ -6093,7 +5963,7 @@ func (o *Object) setMetaData(resp *s3.HeadObjectOutput) {
 	o.storageClass = stringClone(string(resp.StorageClass))
 	o.cacheControl = stringClonePointer(resp.CacheControl)
 	o.contentDisposition = stringClonePointer(resp.ContentDisposition)
-	o.contentEncoding = stringClonePointer(removeAWSChunked(resp.ContentEncoding))
+	o.contentEncoding = stringClonePointer(resp.ContentEncoding)
 	o.contentLanguage = stringClonePointer(resp.ContentLanguage)
 
 	// If decompressing then size and md5sum are unknown
@@ -6161,36 +6031,6 @@ func (o *Object) Storable() bool {
 	return true
 }
 
-// removeAWSChunked removes the "aws-chunked" content-coding from a
-// Content-Encoding field value (RFC 9110). Comparison is case-insensitive.
-// Returns nil if encoding is empty after removal.
-func removeAWSChunked(pv *string) *string {
-	if pv == nil {
-		return nil
-	}
-	v := *pv
-	if v == "" {
-		return nil
-	}
-	if !strings.Contains(strings.ToLower(v), "aws-chunked") {
-		return pv
-	}
-	parts := strings.Split(v, ",")
-	out := make([]string, 0, len(parts))
-	for _, p := range parts {
-		tok := strings.TrimSpace(p)
-		if tok == "" || strings.EqualFold(tok, "aws-chunked") {
-			continue
-		}
-		out = append(out, tok)
-	}
-	if len(out) == 0 {
-		return nil
-	}
-	v = strings.Join(out, ",")
-	return &v
-}
-
 func (o *Object) downloadFromURL(ctx context.Context, bucketPath string, options ...fs.OpenOption) (in io.ReadCloser, err error) {
 	url := o.fs.opt.DownloadURL + bucketPath
 	var resp *http.Response
@@ -6359,7 +6199,7 @@ func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.Read
 	o.setMetaData(&head)
 
 	// Decompress body if necessary
-	if deref(removeAWSChunked(resp.ContentEncoding)) == "gzip" {
+	if deref(resp.ContentEncoding) == "gzip" {
 		if o.fs.opt.Decompress || (resp.ContentLength == nil && o.fs.opt.MightGzip.Value) {
 			return readers.NewGzipReader(resp.Body)
 		}
@@ -6783,7 +6623,7 @@ func (o *Object) prepareUpload(ctx context.Context, src fs.ObjectInfo, options [
 		case "content-disposition":
 			ui.req.ContentDisposition = pv
 		case "content-encoding":
-			ui.req.ContentEncoding = removeAWSChunked(pv)
+			ui.req.ContentEncoding = pv
 		case "content-language":
 			ui.req.ContentLanguage = pv
 		case "content-type":
@@ -6880,7 +6720,7 @@ func (o *Object) prepareUpload(ctx context.Context, src fs.ObjectInfo, options [
 		case "content-disposition":
 			ui.req.ContentDisposition = aws.String(value)
 		case "content-encoding":
-			ui.req.ContentEncoding = removeAWSChunked(aws.String(value))
+			ui.req.ContentEncoding = aws.String(value)
 		case "content-language":
 			ui.req.ContentLanguage = aws.String(value)
 		case "content-type":

backend/s3/s3_internal_test.go

@@ -248,47 +248,6 @@ func TestMergeDeleteMarkers(t *testing.T) {
 	}
 }
 
-func TestRemoveAWSChunked(t *testing.T) {
-	ps := func(s string) *string {
-		return &s
-	}
-	tests := []struct {
-		name string
-		in   *string
-		want *string
-	}{
-		{"nil", nil, nil},
-		{"empty", ps(""), nil},
-		{"only aws", ps("aws-chunked"), nil},
-		{"leading aws", ps("aws-chunked, gzip"), ps("gzip")},
-		{"trailing aws", ps("gzip, aws-chunked"), ps("gzip")},
-		{"middle aws", ps("gzip, aws-chunked, br"), ps("gzip,br")},
-		{"case insensitive", ps("GZip, AwS-ChUnKeD, Br"), ps("GZip,Br")},
-		{"duplicates", ps("aws-chunked , aws-chunked"), nil},
-		{"no aws normalize spaces", ps(" gzip ,  br "), ps(" gzip ,  br ")},
-		{"surrounding spaces", ps("  aws-chunked  "), nil},
-		{"no change", ps("gzip, br"), ps("gzip, br")},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			got := removeAWSChunked(tc.in)
-			check := func(want, got *string) {
-				t.Helper()
-				if tc.want == nil {
-					assert.Nil(t, got)
-				} else {
-					require.NotNil(t, got)
-					assert.Equal(t, *tc.want, *got)
-				}
-			}
-			check(tc.want, got)
-			// Idempotent
-			got2 := removeAWSChunked(got)
-			check(got, got2)
-		})
-	}
-}
-
 func (f *Fs) InternalTestVersions(t *testing.T) {
 	ctx := context.Background()
 

backend/sftp/sftp.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 // Package sftp provides a filesystem interface using github.com/pkg/sftp
 package sftp
@@ -1863,9 +1863,9 @@ func (f *Fs) About(ctx context.Context) (*fs.Usage, error) {
 		free := vfsStats.FreeSpace()
 		used := total - free
 		return &fs.Usage{
-			Total: fs.NewUsageValue(total),
-			Used:  fs.NewUsageValue(used),
-			Free:  fs.NewUsageValue(free),
+			Total: fs.NewUsageValue(int64(total)),
+			Used:  fs.NewUsageValue(int64(used)),
+			Free:  fs.NewUsageValue(int64(free)),
 		}, nil
 	} else if err != nil {
 		if errors.Is(err, os.ErrNotExist) {

backend/sftp/sftp_internal_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp
 

backend/sftp/sftp_test.go

@@ -1,6 +1,6 @@
 // Test Sftp filesystem interface
 
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp_test
 

backend/sftp/sftp_unsupported.go

@@ -1,7 +1,7 @@
 // Build for sftp for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || wasm
+//go:build plan9
 
 // Package sftp provides a filesystem interface using github.com/pkg/sftp
 package sftp

backend/sftp/ssh.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp
 

backend/sftp/ssh_external.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp
 

backend/sftp/ssh_internal.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp
 

backend/sftp/stringlock.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp
 

backend/sftp/stringlock_test.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !wasm
+//go:build !plan9
 
 package sftp
 

backend/smb/filepool.go

@@ -1,99 +0,0 @@
-package smb
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sync"
-
-	"github.com/cloudsoda/go-smb2"
-	"golang.org/x/sync/errgroup"
-)
-
-// FsInterface defines the methods that filePool needs from Fs
-type FsInterface interface {
-	getConnection(ctx context.Context, share string) (*conn, error)
-	putConnection(pc **conn, err error)
-	removeSession()
-}
-
-type file struct {
-	*smb2.File
-	c *conn
-}
-
-type filePool struct {
-	ctx   context.Context
-	fs    FsInterface
-	share string
-	path  string
-
-	mu   sync.Mutex
-	pool []*file
-}
-
-func newFilePool(ctx context.Context, fs FsInterface, share, path string) *filePool {
-	return &filePool{
-		ctx:   ctx,
-		fs:    fs,
-		share: share,
-		path:  path,
-	}
-}
-
-func (p *filePool) get() (*file, error) {
-	p.mu.Lock()
-	if len(p.pool) > 0 {
-		f := p.pool[len(p.pool)-1]
-		p.pool = p.pool[:len(p.pool)-1]
-		p.mu.Unlock()
-		return f, nil
-	}
-	p.mu.Unlock()
-
-	c, err := p.fs.getConnection(p.ctx, p.share)
-	if err != nil {
-		return nil, err
-	}
-
-	fl, err := c.smbShare.OpenFile(p.path, os.O_WRONLY, 0o644)
-	if err != nil {
-		p.fs.putConnection(&c, err)
-		return nil, fmt.Errorf("failed to open: %w", err)
-	}
-
-	return &file{File: fl, c: c}, nil
-}
-
-func (p *filePool) put(f *file, err error) {
-	if f == nil {
-		return
-	}
-
-	if err != nil {
-		_ = f.Close()
-		p.fs.putConnection(&f.c, err)
-		return
-	}
-
-	p.mu.Lock()
-	p.pool = append(p.pool, f)
-	p.mu.Unlock()
-}
-
-func (p *filePool) drain() error {
-	p.mu.Lock()
-	files := p.pool
-	p.pool = nil
-	p.mu.Unlock()
-
-	g, _ := errgroup.WithContext(p.ctx)
-	for _, f := range files {
-		g.Go(func() error {
-			err := f.Close()
-			p.fs.putConnection(&f.c, err)
-			return err
-		})
-	}
-	return g.Wait()
-}

backend/smb/filepool_test.go

@@ -1,228 +0,0 @@
-package smb
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"testing"
-
-	"github.com/cloudsoda/go-smb2"
-	"github.com/stretchr/testify/assert"
-)
-
-// Mock Fs that implements FsInterface
-type mockFs struct {
-	mu                  sync.Mutex
-	putConnectionCalled bool
-	putConnectionErr    error
-	getConnectionCalled bool
-	getConnectionErr    error
-	getConnectionResult *conn
-	removeSessionCalled bool
-}
-
-func (m *mockFs) putConnection(pc **conn, err error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.putConnectionCalled = true
-	m.putConnectionErr = err
-}
-
-func (m *mockFs) getConnection(ctx context.Context, share string) (*conn, error) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.getConnectionCalled = true
-	if m.getConnectionErr != nil {
-		return nil, m.getConnectionErr
-	}
-	if m.getConnectionResult != nil {
-		return m.getConnectionResult, nil
-	}
-	return &conn{}, nil
-}
-
-func (m *mockFs) removeSession() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	m.removeSessionCalled = true
-}
-
-func (m *mockFs) isPutConnectionCalled() bool {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.putConnectionCalled
-}
-
-func (m *mockFs) getPutConnectionErr() error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.putConnectionErr
-}
-
-func (m *mockFs) isGetConnectionCalled() bool {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.getConnectionCalled
-}
-
-func newMockFs() *mockFs {
-	return &mockFs{}
-}
-
-// Helper function to create a mock file
-func newMockFile() *file {
-	return &file{
-		File: &smb2.File{},
-		c:    &conn{},
-	}
-}
-
-// Test filePool creation
-func TestNewFilePool(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	share := "testshare"
-	path := "/test/path"
-
-	pool := newFilePool(ctx, fs, share, path)
-
-	assert.NotNil(t, pool)
-	assert.Equal(t, ctx, pool.ctx)
-	assert.Equal(t, fs, pool.fs)
-	assert.Equal(t, share, pool.share)
-	assert.Equal(t, path, pool.path)
-	assert.Empty(t, pool.pool)
-}
-
-// Test getting file from pool when pool has files
-func TestFilePool_Get_FromPool(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	pool := newFilePool(ctx, fs, "testshare", "/test/path")
-
-	// Add a mock file to the pool
-	mockFile := newMockFile()
-	pool.pool = append(pool.pool, mockFile)
-
-	// Get file from pool
-	f, err := pool.get()
-
-	assert.NoError(t, err)
-	assert.NotNil(t, f)
-	assert.Equal(t, mockFile, f)
-	assert.Empty(t, pool.pool)
-}
-
-// Test getting file when pool is empty
-func TestFilePool_Get_EmptyPool(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-
-	// Set up the mock to return an error from getConnection
-	// This tests that the pool calls getConnection when empty
-	fs.getConnectionErr = errors.New("connection failed")
-
-	pool := newFilePool(ctx, fs, "testshare", "test/path")
-
-	// This should call getConnection and return the error
-	f, err := pool.get()
-	assert.Error(t, err)
-	assert.Nil(t, f)
-	assert.True(t, fs.isGetConnectionCalled())
-	assert.Equal(t, "connection failed", err.Error())
-}
-
-// Test putting file successfully
-func TestFilePool_Put_Success(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	pool := newFilePool(ctx, fs, "testshare", "/test/path")
-
-	mockFile := newMockFile()
-
-	pool.put(mockFile, nil)
-
-	assert.Len(t, pool.pool, 1)
-	assert.Equal(t, mockFile, pool.pool[0])
-}
-
-// Test putting file with error
-func TestFilePool_Put_WithError(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	pool := newFilePool(ctx, fs, "testshare", "/test/path")
-
-	mockFile := newMockFile()
-
-	pool.put(mockFile, errors.New("write error"))
-
-	// Should call putConnection with error
-	assert.True(t, fs.isPutConnectionCalled())
-	assert.Equal(t, errors.New("write error"), fs.getPutConnectionErr())
-	assert.Empty(t, pool.pool)
-}
-
-// Test putting nil file
-func TestFilePool_Put_NilFile(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	pool := newFilePool(ctx, fs, "testshare", "/test/path")
-
-	// Should not panic
-	pool.put(nil, nil)
-	pool.put(nil, errors.New("some error"))
-
-	assert.Empty(t, pool.pool)
-}
-
-// Test draining pool with files
-func TestFilePool_Drain_WithFiles(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	pool := newFilePool(ctx, fs, "testshare", "/test/path")
-
-	// Add mock files to pool
-	mockFile1 := newMockFile()
-	mockFile2 := newMockFile()
-	pool.pool = append(pool.pool, mockFile1, mockFile2)
-
-	// Before draining
-	assert.Len(t, pool.pool, 2)
-
-	_ = pool.drain()
-	assert.Empty(t, pool.pool)
-}
-
-// Test concurrent access to pool
-func TestFilePool_ConcurrentAccess(t *testing.T) {
-	ctx := context.Background()
-	fs := newMockFs()
-	pool := newFilePool(ctx, fs, "testshare", "/test/path")
-
-	const numGoroutines = 10
-	for i := 0; i < numGoroutines; i++ {
-		mockFile := newMockFile()
-		pool.pool = append(pool.pool, mockFile)
-	}
-
-	// Test concurrent get operations
-	done := make(chan bool, numGoroutines)
-
-	for i := 0; i < numGoroutines; i++ {
-		go func() {
-			defer func() { done <- true }()
-
-			f, err := pool.get()
-			if err == nil {
-				pool.put(f, nil)
-			}
-		}()
-	}
-
-	for i := 0; i < numGoroutines; i++ {
-		<-done
-	}
-
-	// Pool should be in a consistent after the concurrence access
-	assert.Len(t, pool.pool, numGoroutines)
-}

backend/smb/smb.go

@@ -3,7 +3,6 @@ package smb
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -495,82 +494,22 @@ func (f *Fs) About(ctx context.Context) (_ *fs.Usage, err error) {
 		return nil, err
 	}
 
-	bs := stat.BlockSize()
+	bs := int64(stat.BlockSize())
 	usage := &fs.Usage{
-		Total: fs.NewUsageValue(bs * stat.TotalBlockCount()),
-		Used:  fs.NewUsageValue(bs * (stat.TotalBlockCount() - stat.FreeBlockCount())),
-		Free:  fs.NewUsageValue(bs * stat.AvailableBlockCount()),
+		Total: fs.NewUsageValue(bs * int64(stat.TotalBlockCount())),
+		Used:  fs.NewUsageValue(bs * int64(stat.TotalBlockCount()-stat.FreeBlockCount())),
+		Free:  fs.NewUsageValue(bs * int64(stat.AvailableBlockCount())),
 	}
 	return usage, nil
 }
 
-type smbWriterAt struct {
-	pool    *filePool
-	closed  bool
-	closeMu sync.Mutex
-	wg      sync.WaitGroup
-}
-
-func (w *smbWriterAt) WriteAt(p []byte, off int64) (int, error) {
-	w.closeMu.Lock()
-	if w.closed {
-		w.closeMu.Unlock()
-		return 0, errors.New("writer already closed")
-	}
-	w.wg.Add(1)
-	w.closeMu.Unlock()
-	defer w.wg.Done()
-
-	f, err := w.pool.get()
-	if err != nil {
-		return 0, fmt.Errorf("failed to get file from pool: %w", err)
-	}
-
-	n, writeErr := f.WriteAt(p, off)
-	w.pool.put(f, writeErr)
-
-	if writeErr != nil {
-		return n, fmt.Errorf("failed to write at offset %d: %w", off, writeErr)
-	}
-
-	return n, writeErr
-}
-
-func (w *smbWriterAt) Close() error {
-	w.closeMu.Lock()
-	defer w.closeMu.Unlock()
-
-	if w.closed {
-		return nil
-	}
-	w.closed = true
-
-	// Wait for all pending writes to finish
-	w.wg.Wait()
-
-	var errs []error
-
-	// Drain the pool
-	if err := w.pool.drain(); err != nil {
-		errs = append(errs, fmt.Errorf("failed to drain file pool: %w", err))
-	}
-
-	// Remove session
-	w.pool.fs.removeSession()
-
-	if len(errs) > 0 {
-		return errors.Join(errs...)
-	}
-
-	return nil
-}
-
 // OpenWriterAt opens with a handle for random access writes
 //
 // Pass in the remote desired and the size if known.
 //
 // It truncates any existing object
 func (f *Fs) OpenWriterAt(ctx context.Context, remote string, size int64) (fs.WriterAtCloser, error) {
+	var err error
 	o := &Object{
 		fs:     f,
 		remote: remote,
@@ -580,42 +519,27 @@ func (f *Fs) OpenWriterAt(ctx context.Context, remote string, size int64) (fs.Wr
 		return nil, fs.ErrorIsDir
 	}
 
-	err := o.fs.ensureDirectory(ctx, share, filename)
+	err = o.fs.ensureDirectory(ctx, share, filename)
 	if err != nil {
 		return nil, fmt.Errorf("failed to make parent directories: %w", err)
 	}
 
-	smbPath := o.fs.toSambaPath(filename)
+	filename = o.fs.toSambaPath(filename)
+
+	o.fs.addSession() // Show session in use
+	defer o.fs.removeSession()
 
-	// One-time truncate
 	cn, err := o.fs.getConnection(ctx, share)
 	if err != nil {
 		return nil, err
 	}
-	file, err := cn.smbShare.OpenFile(smbPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
+
+	fl, err := cn.smbShare.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
 	if err != nil {
-		o.fs.putConnection(&cn, err)
-		return nil, err
+		return nil, fmt.Errorf("failed to open: %w", err)
 	}
-	if size > 0 {
-		if truncateErr := file.Truncate(size); truncateErr != nil {
-			_ = file.Close()
-			o.fs.putConnection(&cn, truncateErr)
-			return nil, fmt.Errorf("failed to truncate file: %w", truncateErr)
-		}
-	}
-	if closeErr := file.Close(); closeErr != nil {
-		o.fs.putConnection(&cn, closeErr)
-		return nil, fmt.Errorf("failed to close file after truncate: %w", closeErr)
-	}
-	o.fs.putConnection(&cn, nil)
 
-	// Add a new session
-	o.fs.addSession()
-
-	return &smbWriterAt{
-		pool: newFilePool(ctx, o.fs, share, smbPath),
-	}, nil
+	return fl, nil
 }
 
 // Shutdown the backend, closing any background tasks and any

bin/cross-compile.go

@@ -73,8 +73,7 @@ var osarches = []string{
 	"plan9/386",
 	"plan9/amd64",
 	"solaris/amd64",
-	"js/wasm",
-	"wasip1/wasm",
+	// "js/wasm", // Rclone is too big for js/wasm until https://github.com/golang/go/issues/64856 is fixed
 }
 
 // Special environment flags for a given arch

bin/go-test-cache/go.mod

@@ -0,0 +1,3 @@
+module go-test-cache
+
+go 1.24

bin/go-test-cache/main.go

@@ -0,0 +1,123 @@
+// This code was copied from:
+// https://github.com/fastly/cli/blob/main/scripts/go-test-cache/main.go
+// which in turn is based on the following script and was generated using AI.
+// https://github.com/airplanedev/blog-examples/blob/main/go-test-caching/update_file_timestamps.py?ref=airplane.ghost.io
+//
+// REFERENCE ARTICLE:
+// https://web.archive.org/web/20240308061717/https://www.airplane.dev/blog/caching-golang-tests-in-ci
+//
+// It updates the mtime of the files to a mtime dervived from the sha1 hash of their contents.
+package main
+
+import (
+	"crypto/sha1"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+const (
+	bufSize    = 65536
+	baseDate   = 1684178360
+	timeFormat = "2006-01-02 15:04:05"
+)
+
+func main() {
+	repoRoot := "."
+	allDirs := make([]string, 0)
+
+	err := filepath.Walk(repoRoot, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() {
+			dirPath := filepath.Join(repoRoot, path)
+			relPath, _ := filepath.Rel(repoRoot, dirPath)
+
+			if strings.HasPrefix(relPath, ".") {
+				return nil
+			}
+
+			allDirs = append(allDirs, dirPath)
+		} else {
+			filePath := filepath.Join(repoRoot, path)
+			relPath, _ := filepath.Rel(repoRoot, filePath)
+
+			if strings.HasPrefix(relPath, ".") {
+				return nil
+			}
+
+			sha1Hash, err := getFileSHA1(filePath)
+			if err != nil {
+				return err
+			}
+
+			modTime := getModifiedTime(sha1Hash)
+
+			log.Printf("Setting modified time of file %s to %s\n", relPath, modTime.Format(timeFormat))
+			err = os.Chtimes(filePath, modTime, modTime)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+	if err != nil {
+		log.Fatal("Error:", err)
+	}
+
+	sort.Slice(allDirs, func(i, j int) bool {
+		return len(allDirs[i]) > len(allDirs[j]) || (len(allDirs[i]) == len(allDirs[j]) && allDirs[i] < allDirs[j])
+	})
+
+	for _, dirPath := range allDirs {
+		relPath, _ := filepath.Rel(repoRoot, dirPath)
+
+		log.Printf("Setting modified time of directory %s to %s\n", relPath, time.Unix(baseDate, 0).Format(timeFormat))
+		err := os.Chtimes(dirPath, time.Unix(baseDate, 0), time.Unix(baseDate, 0))
+		if err != nil {
+			log.Fatal("Error:", err)
+		}
+	}
+
+	log.Println("Done")
+}
+
+func getFileSHA1(filePath string) (string, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	// G401: Use of weak cryptographic primitive
+	// Disabling as the hash is used not for security reasons.
+	// The hash is used as a cache key to improve test run times.
+	// #nosec
+	// nosemgrep: go.lang.security.audit.crypto.use_of_weak_crypto.use-of-sha1
+	hash := sha1.New()
+	if _, err := io.CopyBuffer(hash, file, make([]byte, bufSize)); err != nil {
+		return "", err
+	}
+
+	return string(hash.Sum(nil)), nil
+}
+
+func getModifiedTime(sha1Hash string) time.Time {
+	hashBytes := []byte(sha1Hash)
+	lastFiveBytes := hashBytes[:5]
+	lastFiveValue := int64(0)
+
+	for _, b := range lastFiveBytes {
+		lastFiveValue = (lastFiveValue << 8) + int64(b)
+	}
+
+	modTime := baseDate - (lastFiveValue % 10000)
+	return time.Unix(modTime, 0)
+}

bin/make_changelog.py

@@ -57,11 +57,11 @@ def make_out(data, indent=""):
             return
         del(data[category])
         if indent != "" and len(lines) == 1:
-            out_lines.append(indent+"- " + title+": " + lines[0])
+            out_lines.append(indent+"* " + title+": " + lines[0])
             return
-        out_lines.append(indent+"- " + title)
+        out_lines.append(indent+"* " + title)
         for line in lines:
-            out_lines.append(indent+"  - " + line)
+            out_lines.append(indent+"    * " + line)
     return out, out_lines
 
 
@@ -129,12 +129,12 @@ def main():
                 new_features[name].append(message)
 
     # Output new features
-    out, new_features_lines = make_out(new_features, indent="  ")
+    out, new_features_lines = make_out(new_features, indent="    ")
     for name in sorted(new_features.keys()):
         out(name)
 
     # Output bugfixes
-    out, bugfix_lines = make_out(bugfixes, indent="  ")
+    out, bugfix_lines = make_out(bugfixes, indent="    ")
     for name in sorted(bugfixes.keys()):
         out(name)
 
@@ -163,15 +163,15 @@ def main():
 
 [See commits](https://github.com/rclone/rclone/compare/%(version)s...%(next_version)s)
 
-- New backends
-- New commands
-- New Features
+* New backends
+* New commands
+* New Features
 %(new_features)s
-- Bug Fixes
+* Bug Fixes
 %(bugfixes)s
 %(backend_changes)s""" % locals())
     sys.stdout.write(old_tail)
-
+                
 
 if __name__ == "__main__":
     main()

bin/update-authors.py

@@ -23,7 +23,7 @@ def add_email(name, email):
     """
     print("Adding %s <%s>" % (name, email))
     with open(AUTHORS, "a+") as fd:
-        print("- %s <%s>" % (name, email), file=fd)
+        print("  * %s <%s>" % (name, email), file=fd)
     subprocess.check_call(["git", "commit", "-m", "Add %s to contributors" % name, AUTHORS])
     
 def main():

cmd/bisync/bisync_test.go

@@ -176,7 +176,6 @@ var (
 	// Flag -refresh-times helps with Dropbox tests failing with message
 	// "src and dst identical but can't set mod time without deleting and re-uploading"
 	argRefreshTimes = flag.Bool("refresh-times", false, "Force refreshing the target modtime, useful for Dropbox (default: false)")
-	ignoreLogs      = flag.Bool("ignore-logs", false, "skip comparing log lines but still compare listings")
 )
 
 // bisyncTest keeps all test data in a single place
@@ -227,18 +226,6 @@ var color = bisync.Color
 
 // TestMain drives the tests
 func TestMain(m *testing.M) {
-	bisync.LogTZ = time.UTC
-	ci := fs.GetConfig(context.TODO())
-	ciSave := *ci
-	defer func() {
-		*ci = ciSave
-	}()
-	// need to set context.TODO() here as we cannot pass a ctx to fs.LogLevelPrintf
-	ci.LogLevel = fs.LogLevelInfo
-	if *argDebug {
-		ci.LogLevel = fs.LogLevelDebug
-	}
-	fstest.Initialise()
 	fstest.TestMain(m)
 }
 
@@ -251,8 +238,7 @@ func TestBisyncRemoteLocal(t *testing.T) {
 	fs.Logf(nil, "remote: %v", remote)
 	require.NoError(t, err)
 	defer cleanup()
-	ctx, _ := fs.AddConfig(context.TODO())
-	testBisync(ctx, t, remote, *argRemote2)
+	testBisync(t, remote, *argRemote2)
 }
 
 // Path1 is local, Path2 is remote
@@ -264,8 +250,7 @@ func TestBisyncLocalRemote(t *testing.T) {
 	fs.Logf(nil, "remote: %v", remote)
 	require.NoError(t, err)
 	defer cleanup()
-	ctx, _ := fs.AddConfig(context.TODO())
-	testBisync(ctx, t, *argRemote2, remote)
+	testBisync(t, *argRemote2, remote)
 }
 
 // Path1 and Path2 are both different directories on remote
@@ -275,34 +260,14 @@ func TestBisyncRemoteRemote(t *testing.T) {
 	fs.Logf(nil, "remote: %v", remote)
 	require.NoError(t, err)
 	defer cleanup()
-	ctx, _ := fs.AddConfig(context.TODO())
-	testBisync(ctx, t, remote, remote)
-}
-
-// make sure rc can cope with running concurrent jobs
-func TestBisyncConcurrent(t *testing.T) {
-	if !isLocal(*fstest.RemoteName) {
-		t.Skip("TestBisyncConcurrent is skipped on non-local")
-	}
-	oldArgTestCase := argTestCase
-	*argTestCase = "basic"
-	*ignoreLogs = true // not useful to compare logs here because both runs will be logging at once
-	t.Cleanup(func() {
-		argTestCase = oldArgTestCase
-		*ignoreLogs = false
-	})
-
-	t.Run("test1", testParallel)
-	t.Run("test2", testParallel)
-}
-
-func testParallel(t *testing.T) {
-	t.Parallel()
-	TestBisyncRemoteRemote(t)
+	testBisync(t, remote, remote)
 }
 
 // TestBisync is a test engine for bisync test cases.
-func testBisync(ctx context.Context, t *testing.T, path1, path2 string) {
+func testBisync(t *testing.T, path1, path2 string) {
+	ctx := context.Background()
+	fstest.Initialise()
+
 	ci := fs.GetConfig(ctx)
 	ciSave := *ci
 	defer func() {
@@ -311,9 +276,8 @@ func testBisync(ctx context.Context, t *testing.T, path1, path2 string) {
 	if *argRefreshTimes {
 		ci.RefreshTimes = true
 	}
-	bisync.ColorsLock.Lock()
 	bisync.Colors = true
-	bisync.ColorsLock.Unlock()
+	time.Local = bisync.TZ
 	ci.FsCacheExpireDuration = fs.Duration(5 * time.Hour)
 
 	baseDir, err := os.Getwd()
@@ -599,15 +563,11 @@ func (b *bisyncTest) runTestCase(ctx context.Context, t *testing.T, testCase str
 	}
 }
 
-func isLocal(remote string) bool {
-	return bilib.IsLocalPath(remote) && !strings.HasPrefix(remote, ":") && !strings.Contains(remote, ",")
-}
-
 // makeTempRemote creates temporary folder and makes a filesystem
 // if a local path is provided, it's ignored (the test will run under system temp)
 func (b *bisyncTest) makeTempRemote(ctx context.Context, remote, subdir string) (f, parent fs.Fs, path, canon string) {
 	var err error
-	if isLocal(remote) {
+	if bilib.IsLocalPath(remote) && !strings.HasPrefix(remote, ":") && !strings.Contains(remote, ",") {
 		if remote != "" && !strings.HasPrefix(remote, "local") && *fstest.RemoteName != "" {
 			b.t.Fatalf(`Missing ":" in remote %q. Use "local" to test with local filesystem.`, remote)
 		}
@@ -638,8 +598,13 @@ func (b *bisyncTest) makeTempRemote(ctx context.Context, remote, subdir string)
 }
 
 func (b *bisyncTest) cleanupCase(ctx context.Context) {
-	_ = operations.Purge(ctx, b.fs1, "")
-	_ = operations.Purge(ctx, b.fs2, "")
+	// Silence "directory not found" errors from the ftp backend
+	_ = bilib.CaptureOutput(func() {
+		_ = operations.Purge(ctx, b.fs1, "")
+	})
+	_ = bilib.CaptureOutput(func() {
+		_ = operations.Purge(ctx, b.fs2, "")
+	})
 	_ = os.RemoveAll(b.workDir)
 	accounting.Stats(ctx).ResetCounters()
 }
@@ -654,6 +619,11 @@ func (b *bisyncTest) runTestStep(ctx context.Context, line string) (err error) {
 	defer func() {
 		*ci = ciSave
 	}()
+	ci.LogLevel = fs.LogLevelInfo
+	if b.debug {
+		ci.LogLevel = fs.LogLevelDebug
+	}
+
 	testFunc := func() {
 		src := filepath.Join(b.dataDir, "file7.txt")
 
@@ -983,12 +953,6 @@ func (b *bisyncTest) checkPreReqs(ctx context.Context, opt *bisync.Options) (con
 		b.fs2.Features().Disable("Copy") // API has longstanding bug for conflictBehavior=replace https://github.com/rclone/rclone/issues/4590
 		b.fs2.Features().Disable("Move")
 	}
-	if strings.HasPrefix(b.fs1.String(), "sftp") {
-		b.fs1.Features().Disable("Copy") // disable --sftp-copy-is-hardlink as hardlinks are not truly copies
-	}
-	if strings.HasPrefix(b.fs2.String(), "sftp") {
-		b.fs2.Features().Disable("Copy") // disable --sftp-copy-is-hardlink as hardlinks are not truly copies
-	}
 	if strings.Contains(strings.ToLower(fs.ConfigString(b.fs1)), "mailru") || strings.Contains(strings.ToLower(fs.ConfigString(b.fs2)), "mailru") {
 		fs.GetConfig(ctx).TPSLimit = 10 // https://github.com/rclone/rclone/issues/7768#issuecomment-2060888980
 	}
@@ -1011,23 +975,17 @@ func (b *bisyncTest) checkPreReqs(ctx context.Context, opt *bisync.Options) (con
 		objinfo := object.NewStaticObjectInfo("modtime_write_test", initDate, int64(len("modtime_write_test")), true, nil, nil)
 		obj, err := f.Put(ctx, in, objinfo)
 		require.NoError(b.t, err)
-		if !f.Features().IsLocal {
-			time.Sleep(time.Second) // avoid GoogleCloudStorage Error 429 rateLimitExceeded
-		}
 		err = obj.SetModTime(ctx, initDate)
 		if err == fs.ErrorCantSetModTime {
-			b.t.Skip("skipping test as at least one remote does not support setting modtime")
-		}
-		if !f.Features().IsLocal {
-			time.Sleep(time.Second) // avoid GoogleCloudStorage Error 429 rateLimitExceeded
+			if b.testCase != "nomodtime" {
+				b.t.Skip("skipping test as at least one remote does not support setting modtime")
+			}
 		}
 		err = obj.Remove(ctx)
 		require.NoError(b.t, err)
 	}
-	if b.testCase != "nomodtime" {
-		testSetModtime(b.fs1)
-		testSetModtime(b.fs2)
-	}
+	testSetModtime(b.fs1)
+	testSetModtime(b.fs2)
 
 	if b.testCase == "normalization" || b.testCase == "extended_char_paths" || b.testCase == "extended_filenames" {
 		// test whether remote is capable of running test
@@ -1471,9 +1429,6 @@ func (b *bisyncTest) compareResults() int {
 		resultText := b.mangleResult(b.workDir, file, false)
 
 		if fileType(file) == "log" {
-			if *ignoreLogs {
-				continue
-			}
 			// save mangled logs so difference is easier on eyes
 			goldenFile := filepath.Join(b.logDir, "mangled.golden.log")
 			resultFile := filepath.Join(b.logDir, "mangled.result.log")

cmd/bisync/checkfn.go

@@ -16,17 +16,15 @@ import (
 	"github.com/rclone/rclone/fs/operations"
 )
 
-type bisyncCheck = struct {
-	hashType   hash.Type
-	fsrc, fdst fs.Fs
-	fcrypt     *crypt.Fs
-}
+var hashType hash.Type
+var fsrc, fdst fs.Fs
+var fcrypt *crypt.Fs
 
 // WhichCheck determines which CheckFn we should use based on the Fs types
 // It is more robust and accurate than Check because
 // it will fallback to CryptCheck or DownloadCheck instead of --size-only!
 // it returns the *operations.CheckOpt with the CheckFn set.
-func (b *bisyncRun) WhichCheck(ctx context.Context, opt *operations.CheckOpt) *operations.CheckOpt {
+func WhichCheck(ctx context.Context, opt *operations.CheckOpt) *operations.CheckOpt {
 	ci := fs.GetConfig(ctx)
 	common := opt.Fsrc.Hashes().Overlap(opt.Fdst.Hashes())
 
@@ -42,32 +40,32 @@ func (b *bisyncRun) WhichCheck(ctx context.Context, opt *operations.CheckOpt) *o
 
 	if (srcIsCrypt && dstIsCrypt) || (!srcIsCrypt && dstIsCrypt) {
 		// if both are crypt or only dst is crypt
-		b.check.hashType = FdstCrypt.UnWrap().Hashes().GetOne()
-		if b.check.hashType != hash.None {
+		hashType = FdstCrypt.UnWrap().Hashes().GetOne()
+		if hashType != hash.None {
 			// use cryptcheck
-			b.check.fsrc = opt.Fsrc
-			b.check.fdst = opt.Fdst
-			b.check.fcrypt = FdstCrypt
-			fs.Infof(b.check.fdst, "Crypt detected! Using cryptcheck instead of check. (Use --size-only or --ignore-checksum to disable)")
-			opt.Check = b.CryptCheckFn
+			fsrc = opt.Fsrc
+			fdst = opt.Fdst
+			fcrypt = FdstCrypt
+			fs.Infof(fdst, "Crypt detected! Using cryptcheck instead of check. (Use --size-only or --ignore-checksum to disable)")
+			opt.Check = CryptCheckFn
 			return opt
 		}
 	} else if srcIsCrypt && !dstIsCrypt {
 		// if only src is crypt
-		b.check.hashType = FsrcCrypt.UnWrap().Hashes().GetOne()
-		if b.check.hashType != hash.None {
+		hashType = FsrcCrypt.UnWrap().Hashes().GetOne()
+		if hashType != hash.None {
 			// use reverse cryptcheck
-			b.check.fsrc = opt.Fdst
-			b.check.fdst = opt.Fsrc
-			b.check.fcrypt = FsrcCrypt
-			fs.Infof(b.check.fdst, "Crypt detected! Using cryptcheck instead of check. (Use --size-only or --ignore-checksum to disable)")
-			opt.Check = b.ReverseCryptCheckFn
+			fsrc = opt.Fdst
+			fdst = opt.Fsrc
+			fcrypt = FsrcCrypt
+			fs.Infof(fdst, "Crypt detected! Using cryptcheck instead of check. (Use --size-only or --ignore-checksum to disable)")
+			opt.Check = ReverseCryptCheckFn
 			return opt
 		}
 	}
 
 	// if we've gotten this far, neither check or cryptcheck will work, so use --download
-	fs.Infof(b.check.fdst, "Can't compare hashes, so using check --download for safety. (Use --size-only or --ignore-checksum to disable)")
+	fs.Infof(fdst, "Can't compare hashes, so using check --download for safety. (Use --size-only or --ignore-checksum to disable)")
 	opt.Check = DownloadCheckFn
 	return opt
 }
@@ -90,17 +88,17 @@ func CheckFn(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool,
 }
 
 // CryptCheckFn is a slightly modified version of CryptCheck
-func (b *bisyncRun) CryptCheckFn(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool, err error) {
+func CryptCheckFn(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool, err error) {
 	cryptDst := dst.(*crypt.Object)
 	underlyingDst := cryptDst.UnWrap()
-	underlyingHash, err := underlyingDst.Hash(ctx, b.check.hashType)
+	underlyingHash, err := underlyingDst.Hash(ctx, hashType)
 	if err != nil {
 		return true, false, fmt.Errorf("error reading hash from underlying %v: %w", underlyingDst, err)
 	}
 	if underlyingHash == "" {
 		return false, true, nil
 	}
-	cryptHash, err := b.check.fcrypt.ComputeHash(ctx, cryptDst, src, b.check.hashType)
+	cryptHash, err := fcrypt.ComputeHash(ctx, cryptDst, src, hashType)
 	if err != nil {
 		return true, false, fmt.Errorf("error computing hash: %w", err)
 	}
@@ -108,10 +106,10 @@ func (b *bisyncRun) CryptCheckFn(ctx context.Context, dst, src fs.Object) (diffe
 		return false, true, nil
 	}
 	if cryptHash != underlyingHash {
-		err = fmt.Errorf("hashes differ (%s:%s) %q vs (%s:%s) %q", b.check.fdst.Name(), b.check.fdst.Root(), cryptHash, b.check.fsrc.Name(), b.check.fsrc.Root(), underlyingHash)
+		err = fmt.Errorf("hashes differ (%s:%s) %q vs (%s:%s) %q", fdst.Name(), fdst.Root(), cryptHash, fsrc.Name(), fsrc.Root(), underlyingHash)
 		fs.Debugf(src, "%s", err.Error())
 		// using same error msg as CheckFn so integration tests match
-		err = fmt.Errorf("%v differ", b.check.hashType)
+		err = fmt.Errorf("%v differ", hashType)
 		fs.Errorf(src, "%s", err.Error())
 		return true, false, nil
 	}
@@ -120,8 +118,8 @@ func (b *bisyncRun) CryptCheckFn(ctx context.Context, dst, src fs.Object) (diffe
 
 // ReverseCryptCheckFn is like CryptCheckFn except src and dst are switched
 // result: src is crypt, dst is non-crypt
-func (b *bisyncRun) ReverseCryptCheckFn(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool, err error) {
-	return b.CryptCheckFn(ctx, src, dst)
+func ReverseCryptCheckFn(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool, err error) {
+	return CryptCheckFn(ctx, src, dst)
 }
 
 // DownloadCheckFn is a slightly modified version of Check with --download
@@ -139,7 +137,7 @@ func (b *bisyncRun) checkconflicts(ctxCheck context.Context, filterCheck *filter
 	if filterCheck.HaveFilesFrom() {
 		fs.Debugf(nil, "There are potential conflicts to check.")
 
-		opt, close, checkopterr := check.GetCheckOpt(fs1, fs2)
+		opt, close, checkopterr := check.GetCheckOpt(b.fs1, b.fs2)
 		if checkopterr != nil {
 			b.critical = true
 			b.retryable = true
@@ -150,16 +148,16 @@ func (b *bisyncRun) checkconflicts(ctxCheck context.Context, filterCheck *filter
 
 		opt.Match = new(bytes.Buffer)
 
-		opt = b.WhichCheck(ctxCheck, opt)
+		opt = WhichCheck(ctxCheck, opt)
 
 		fs.Infof(nil, "Checking potential conflicts...")
 		check := operations.CheckFn(ctxCheck, opt)
 		fs.Infof(nil, "Finished checking the potential conflicts. %s", check)
 
-		// reset error count, because we don't want to count check errors as bisync errors
+		//reset error count, because we don't want to count check errors as bisync errors
 		accounting.Stats(ctxCheck).ResetErrors()
 
-		// return the list of identical files to check against later
+		//return the list of identical files to check against later
 		if len(fmt.Sprint(opt.Match)) > 0 {
 			matches = bilib.ToNames(strings.Split(fmt.Sprint(opt.Match), "\n"))
 		}
@@ -175,14 +173,14 @@ func (b *bisyncRun) checkconflicts(ctxCheck context.Context, filterCheck *filter
 
 // WhichEqual is similar to WhichCheck, but checks a single object.
 // Returns true if the objects are equal, false if they differ or if we don't know
-func (b *bisyncRun) WhichEqual(ctx context.Context, src, dst fs.Object, Fsrc, Fdst fs.Fs) bool {
+func WhichEqual(ctx context.Context, src, dst fs.Object, Fsrc, Fdst fs.Fs) bool {
 	opt, close, checkopterr := check.GetCheckOpt(Fsrc, Fdst)
 	if checkopterr != nil {
 		fs.Debugf(nil, "GetCheckOpt error: %v", checkopterr)
 	}
 	defer close()
 
-	opt = b.WhichCheck(ctx, opt)
+	opt = WhichCheck(ctx, opt)
 	differ, noHash, err := opt.Check(ctx, dst, src)
 	if err != nil {
 		fs.Errorf(src, "failed to check: %v", err)
@@ -219,7 +217,7 @@ func (b *bisyncRun) EqualFn(ctx context.Context) context.Context {
 		equal, skipHash = timeSizeEqualFn()
 		if equal && !skipHash {
 			whichHashType := func(f fs.Info) hash.Type {
-				ht := b.getHashType(f.Name())
+				ht := getHashType(f.Name())
 				if ht == hash.None && b.opt.Compare.SlowHashSyncOnly && !b.opt.Resync {
 					ht = f.Hashes().GetOne()
 				}
@@ -227,9 +225,9 @@ func (b *bisyncRun) EqualFn(ctx context.Context) context.Context {
 			}
 			srcHash, _ := src.Hash(ctx, whichHashType(src.Fs()))
 			dstHash, _ := dst.Hash(ctx, whichHashType(dst.Fs()))
-			srcHash, _ = b.tryDownloadHash(ctx, src, srcHash)
-			dstHash, _ = b.tryDownloadHash(ctx, dst, dstHash)
-			equal = !b.hashDiffers(srcHash, dstHash, whichHashType(src.Fs()), whichHashType(dst.Fs()), src.Size(), dst.Size())
+			srcHash, _ = tryDownloadHash(ctx, src, srcHash)
+			dstHash, _ = tryDownloadHash(ctx, dst, dstHash)
+			equal = !hashDiffers(srcHash, dstHash, whichHashType(src.Fs()), whichHashType(dst.Fs()), src.Size(), dst.Size())
 		}
 		if equal {
 			logger(ctx, operations.Match, src, dst, nil)
@@ -249,7 +247,7 @@ func (b *bisyncRun) resyncTimeSizeEqual(ctxNoLogger context.Context, src fs.Obje
 		// note that arg order is path1, path2, regardless of src/dst
 		path1, path2 := b.resyncWhichIsWhich(src, dst)
 		if sizeDiffers(path1.Size(), path2.Size()) {
-			winningPath := b.resolveLargerSmaller(path1.Size(), path2.Size(), path1.Remote(), b.opt.ResyncMode)
+			winningPath := b.resolveLargerSmaller(path1.Size(), path2.Size(), path1.Remote(), path2.Remote(), b.opt.ResyncMode)
 			// don't need to check/update modtime here, as sizes definitely differ and something will be transferred
 			return b.resyncWinningPathToEqual(winningPath), b.resyncWinningPathToEqual(winningPath) // skip hash check if true
 		}
@@ -259,7 +257,7 @@ func (b *bisyncRun) resyncTimeSizeEqual(ctxNoLogger context.Context, src fs.Obje
 		// note that arg order is path1, path2, regardless of src/dst
 		path1, path2 := b.resyncWhichIsWhich(src, dst)
 		if timeDiffers(ctxNoLogger, path1.ModTime(ctxNoLogger), path2.ModTime(ctxNoLogger), path1.Fs(), path2.Fs()) {
-			winningPath := b.resolveNewerOlder(path1.ModTime(ctxNoLogger), path2.ModTime(ctxNoLogger), path1.Remote(), b.opt.ResyncMode)
+			winningPath := b.resolveNewerOlder(path1.ModTime(ctxNoLogger), path2.ModTime(ctxNoLogger), path1.Remote(), path2.Remote(), b.opt.ResyncMode)
 			// if src is winner, proceed with equal to check size/hash and possibly just update dest modtime instead of transferring
 			if !b.resyncWinningPathToEqual(winningPath) {
 				return operations.Equal(ctxNoLogger, src, dst), false // note we're back to src/dst, not path1/path2

cmd/bisync/cmd.go

@@ -115,7 +115,6 @@ func (x *CheckSyncMode) Type() string {
 }
 
 // Opt keeps command line options
-// internal functions should use b.opt instead
 var Opt Options
 
 func init() {

cmd/bisync/compare.go

@@ -28,7 +28,7 @@ type CompareOpt = struct {
 	DownloadHash     bool
 }
 
-func (b *bisyncRun) setCompareDefaults(ctx context.Context) (err error) {
+func (b *bisyncRun) setCompareDefaults(ctx context.Context) error {
 	ci := fs.GetConfig(ctx)
 
 	// defaults
@@ -120,25 +120,25 @@ func sizeDiffers(a, b int64) bool {
 
 // returns true if the hashes are definitely different.
 // returns false if equal, or if either is unknown.
-func (b *bisyncRun) hashDiffers(stringA, stringB string, ht1, ht2 hash.Type, size1, size2 int64) bool {
-	if stringA == "" || stringB == "" {
+func hashDiffers(a, b string, ht1, ht2 hash.Type, size1, size2 int64) bool {
+	if a == "" || b == "" {
 		if ht1 != hash.None && ht2 != hash.None && !(size1 <= 0 || size2 <= 0) {
-			fs.Logf(nil, Color(terminal.YellowFg, "WARNING: hash unexpectedly blank despite Fs support (%s, %s) (you may need to --resync!)"), stringA, stringB)
+			fs.Logf(nil, Color(terminal.YellowFg, "WARNING: hash unexpectedly blank despite Fs support (%s, %s) (you may need to --resync!)"), a, b)
 		}
 		return false
 	}
 	if ht1 != ht2 {
-		if !(b.downloadHashOpt.downloadHash && ((ht1 == hash.MD5 && ht2 == hash.None) || (ht1 == hash.None && ht2 == hash.MD5))) {
+		if !(downloadHash && ((ht1 == hash.MD5 && ht2 == hash.None) || (ht1 == hash.None && ht2 == hash.MD5))) {
 			fs.Infof(nil, Color(terminal.YellowFg, "WARNING: Can't compare hashes of different types (%s, %s)"), ht1.String(), ht2.String())
 			return false
 		}
 	}
-	return stringA != stringB
+	return a != b
 }
 
 // chooses hash type, giving priority to types both sides have in common
 func (b *bisyncRun) setHashType(ci *fs.ConfigInfo) {
-	b.downloadHashOpt.downloadHash = b.opt.Compare.DownloadHash
+	downloadHash = b.opt.Compare.DownloadHash
 	if b.opt.Compare.NoSlowHash && b.opt.Compare.SlowHashDetected {
 		fs.Infof(nil, "Not checking for common hash as at least one slow hash detected.")
 	} else {
@@ -268,15 +268,13 @@ func (b *bisyncRun) setFromCompareFlag(ctx context.Context) error {
 	return nil
 }
 
-// b.downloadHashOpt.downloadHash is true if we should attempt to compute hash by downloading when otherwise unavailable
-type downloadHashOpt struct {
-	downloadHash      bool
-	downloadHashWarn  mutex.Once
-	firstDownloadHash mutex.Once
-}
+// downloadHash is true if we should attempt to compute hash by downloading when otherwise unavailable
+var downloadHash bool
+var downloadHashWarn mutex.Once
+var firstDownloadHash mutex.Once
 
-func (b *bisyncRun) tryDownloadHash(ctx context.Context, o fs.DirEntry, hashVal string) (string, error) {
-	if hashVal != "" || !b.downloadHashOpt.downloadHash {
+func tryDownloadHash(ctx context.Context, o fs.DirEntry, hashVal string) (string, error) {
+	if hashVal != "" || !downloadHash {
 		return hashVal, nil
 	}
 	obj, ok := o.(fs.Object)
@@ -285,14 +283,14 @@ func (b *bisyncRun) tryDownloadHash(ctx context.Context, o fs.DirEntry, hashVal
 		return hashVal, fs.ErrorObjectNotFound
 	}
 	if o.Size() < 0 {
-		b.downloadHashOpt.downloadHashWarn.Do(func() {
+		downloadHashWarn.Do(func() {
 			fs.Log(o, Color(terminal.YellowFg, "Skipping hash download as checksum not reliable with files of unknown length."))
 		})
 		fs.Debugf(o, "Skipping hash download as checksum not reliable with files of unknown length.")
 		return hashVal, hash.ErrUnsupported
 	}
 
-	b.downloadHashOpt.firstDownloadHash.Do(func() {
+	firstDownloadHash.Do(func() {
 		fs.Infoc(obj.Fs().Name(), Color(terminal.Dim, "Downloading hashes..."))
 	})
 	tr := accounting.Stats(ctx).NewCheckingTransfer(o, "computing hash with --download-hash")

cmd/bisync/deltas.go

@@ -219,7 +219,7 @@ func (b *bisyncRun) findDeltas(fctx context.Context, f fs.Fs, oldListing string,
 				}
 			}
 			if b.opt.Compare.Checksum {
-				if b.hashDiffers(old.getHash(file), now.getHash(file), old.hash, now.hash, old.getSize(file), now.getSize(file)) {
+				if hashDiffers(old.getHash(file), now.getHash(file), old.hash, now.hash, old.getSize(file), now.getSize(file)) {
 					fs.Debugf(file, "(old: %v current: %v)", old.getHash(file), now.getHash(file))
 					whatchanged = append(whatchanged, Color(terminal.MagentaFg, "hash"))
 					d |= deltaHash
@@ -346,7 +346,7 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (result
 			if d2.is(deltaOther) {
 				// if size or hash differ, skip this, as we already know they're not equal
 				if (b.opt.Compare.Size && sizeDiffers(ds1.size[file], ds2.size[file2])) ||
-					(b.opt.Compare.Checksum && b.hashDiffers(ds1.hash[file], ds2.hash[file2], b.opt.Compare.HashType1, b.opt.Compare.HashType2, ds1.size[file], ds2.size[file2])) {
+					(b.opt.Compare.Checksum && hashDiffers(ds1.hash[file], ds2.hash[file2], b.opt.Compare.HashType1, b.opt.Compare.HashType2, ds1.size[file], ds2.size[file2])) {
 					fs.Debugf(file, "skipping equality check as size/hash definitely differ")
 				} else {
 					checkit := func(filename string) {
@@ -393,10 +393,10 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (result
 				// if files are identical, leave them alone instead of renaming
 				if (dirs1.has(file) || dirs1.has(alias)) && (dirs2.has(file) || dirs2.has(alias)) {
 					fs.Infof(nil, "This is a directory, not a file. Skipping equality check and will not rename: %s", file)
-					b.march.ls1.getPut(file, skippedDirs1)
-					b.march.ls2.getPut(file, skippedDirs2)
+					ls1.getPut(file, skippedDirs1)
+					ls2.getPut(file, skippedDirs2)
 					b.debugFn(file, func() {
-						b.debug(file, fmt.Sprintf("deltas dir: %s, ls1 has name?: %v, ls2 has name?: %v", file, b.march.ls1.has(b.DebugName), b.march.ls2.has(b.DebugName)))
+						b.debug(file, fmt.Sprintf("deltas dir: %s, ls1 has name?: %v, ls2 has name?: %v", file, ls1.has(b.DebugName), ls2.has(b.DebugName)))
 					})
 				} else {
 					equal := matches.Has(file)
@@ -409,16 +409,16 @@ func (b *bisyncRun) applyDeltas(ctx context.Context, ds1, ds2 *deltaSet) (result
 							// the Path1 version is deemed "correct" in this scenario
 							fs.Infof(alias, "Files are equal but will copy anyway to fix case to %s", file)
 							copy1to2.Add(file)
-						} else if b.opt.Compare.Modtime && timeDiffers(ctx, b.march.ls1.getTime(b.march.ls1.getTryAlias(file, alias)), b.march.ls2.getTime(b.march.ls2.getTryAlias(file, alias)), b.fs1, b.fs2) {
+						} else if b.opt.Compare.Modtime && timeDiffers(ctx, ls1.getTime(ls1.getTryAlias(file, alias)), ls2.getTime(ls2.getTryAlias(file, alias)), b.fs1, b.fs2) {
 							fs.Infof(file, "Files are equal but will copy anyway to update modtime (will not rename)")
-							if b.march.ls1.getTime(b.march.ls1.getTryAlias(file, alias)).Before(b.march.ls2.getTime(b.march.ls2.getTryAlias(file, alias))) {
+							if ls1.getTime(ls1.getTryAlias(file, alias)).Before(ls2.getTime(ls2.getTryAlias(file, alias))) {
 								// Path2 is newer
 								b.indent("Path2", p1, "Queue copy to Path1")
-								copy2to1.Add(b.march.ls2.getTryAlias(file, alias))
+								copy2to1.Add(ls2.getTryAlias(file, alias))
 							} else {
 								// Path1 is newer
 								b.indent("Path1", p2, "Queue copy to Path2")
-								copy1to2.Add(b.march.ls1.getTryAlias(file, alias))
+								copy1to2.Add(ls1.getTryAlias(file, alias))
 							}
 						} else {
 							fs.Infof(nil, "Files are equal! Skipping: %s", file)
@@ -590,10 +590,10 @@ func (b *bisyncRun) updateAliases(ctx context.Context, ds1, ds2 *deltaSet) {
 	fullMap1 := map[string]string{} // [transformedname]originalname
 	fullMap2 := map[string]string{} // [transformedname]originalname
 
-	for _, name := range b.march.ls1.list {
+	for _, name := range ls1.list {
 		fullMap1[transform(name)] = name
 	}
-	for _, name := range b.march.ls2.list {
+	for _, name := range ls2.list {
 		fullMap2[transform(name)] = name
 	}
 

cmd/bisync/listing.go

@@ -42,14 +42,10 @@ var lineRegex = regexp.MustCompile(`^(\S) +(-?\d+) (\S+) (\S+) (\d{4}-\d\d-\d\dT
 // timeFormat defines time format used in listings
 const timeFormat = "2006-01-02T15:04:05.000000000-0700"
 
+// TZ defines time zone used in listings
 var (
-	// TZ defines time zone used in listings
 	TZ      = time.UTC
 	tzLocal = false
-
-	// LogTZ defines time zone used in logs (which may be different than that used in listings).
-	// time.Local by default, but we force UTC on tests to make them deterministic regardless of tester's location.
-	LogTZ = time.Local
 )
 
 // fileInfo describes a file
@@ -202,8 +198,8 @@ func (b *bisyncRun) fileInfoEqual(file1, file2 string, ls1, ls2 *fileList) bool
 			equal = false
 		}
 	}
-	if b.opt.Compare.Checksum && !b.queueOpt.ignoreListingChecksum {
-		if b.hashDiffers(ls1.getHash(file1), ls2.getHash(file2), b.opt.Compare.HashType1, b.opt.Compare.HashType2, ls1.getSize(file1), ls2.getSize(file2)) {
+	if b.opt.Compare.Checksum && !ignoreListingChecksum {
+		if hashDiffers(ls1.getHash(file1), ls2.getHash(file2), b.opt.Compare.HashType1, b.opt.Compare.HashType2, ls1.getSize(file1), ls2.getSize(file2)) {
 			b.indent("ERROR", file1, fmt.Sprintf("Checksum not equal in listing. Path1: %v, Path2: %v", ls1.getHash(file1), ls2.getHash(file2)))
 			equal = false
 		}
@@ -247,7 +243,7 @@ func (ls *fileList) sort() {
 }
 
 // save will save listing to a file.
-func (ls *fileList) save(listing string) error {
+func (ls *fileList) save(ctx context.Context, listing string) error {
 	file, err := os.Create(listing)
 	if err != nil {
 		return err
@@ -712,9 +708,9 @@ func (b *bisyncRun) modifyListing(ctx context.Context, src fs.Fs, dst fs.Fs, res
 		b.debug(b.DebugName, fmt.Sprintf("%s pre-save dstList has it?: %v", direction, dstList.has(b.DebugName)))
 	}
 	// update files
-	err = srcList.save(srcListing)
+	err = srcList.save(ctx, srcListing)
 	b.handleErr(srcList, "error saving srcList from modifyListing", err, true, true)
-	err = dstList.save(dstListing)
+	err = dstList.save(ctx, dstListing)
 	b.handleErr(dstList, "error saving dstList from modifyListing", err, true, true)
 
 	return err
@@ -745,7 +741,7 @@ func (b *bisyncRun) recheck(ctxRecheck context.Context, src, dst fs.Fs, srcList,
 			if hashType != hash.None {
 				hashVal, _ = obj.Hash(ctxRecheck, hashType)
 			}
-			hashVal, _ = b.tryDownloadHash(ctxRecheck, obj, hashVal)
+			hashVal, _ = tryDownloadHash(ctxRecheck, obj, hashVal)
 		}
 		var modtime time.Time
 		if b.opt.Compare.Modtime {
@@ -759,7 +755,7 @@ func (b *bisyncRun) recheck(ctxRecheck context.Context, src, dst fs.Fs, srcList,
 		for _, dstObj := range dstObjs {
 			if srcObj.Remote() == dstObj.Remote() || srcObj.Remote() == b.aliases.Alias(dstObj.Remote()) {
 				// note: unlike Equal(), WhichEqual() does not update the modtime in dest if sums match but modtimes don't.
-				if b.opt.DryRun || b.WhichEqual(ctxRecheck, srcObj, dstObj, src, dst) {
+				if b.opt.DryRun || WhichEqual(ctxRecheck, srcObj, dstObj, src, dst) {
 					putObj(srcObj, srcList)
 					putObj(dstObj, dstList)
 					resolved = append(resolved, srcObj.Remote())
@@ -773,7 +769,7 @@ func (b *bisyncRun) recheck(ctxRecheck context.Context, src, dst fs.Fs, srcList,
 		// skip and error during --resync, as rollback is not possible
 		if !slices.Contains(resolved, srcObj.Remote()) && !b.opt.DryRun {
 			if b.opt.Resync {
-				err := errors.New("no dstObj match or files not equal")
+				err = errors.New("no dstObj match or files not equal")
 				b.handleErr(srcObj, "Unable to rollback during --resync", err, true, false)
 			} else {
 				toRollback = append(toRollback, srcObj.Remote())

cmd/bisync/lockfile.go

@@ -16,17 +16,16 @@ import (
 
 const basicallyforever = fs.Duration(200 * 365 * 24 * time.Hour)
 
-type lockFileOpt struct {
-	stopRenewal func()
-	data        struct {
-		Session     string
-		PID         string
-		TimeRenewed time.Time
-		TimeExpires time.Time
-	}
-}
+var stopRenewal func()
 
-func (b *bisyncRun) setLockFile() (err error) {
+var data = struct {
+	Session     string
+	PID         string
+	TimeRenewed time.Time
+	TimeExpires time.Time
+}{}
+
+func (b *bisyncRun) setLockFile() error {
 	b.lockFile = ""
 	b.setLockFileExpiration()
 	if !b.opt.DryRun {
@@ -46,23 +45,24 @@ func (b *bisyncRun) setLockFile() (err error) {
 		}
 		fs.Debugf(nil, "Lock file created: %s", b.lockFile)
 		b.renewLockFile()
-		b.lockFileOpt.stopRenewal = b.startLockRenewal()
+		stopRenewal = b.startLockRenewal()
 	}
 	return nil
 }
 
-func (b *bisyncRun) removeLockFile() (err error) {
+func (b *bisyncRun) removeLockFile() {
 	if b.lockFile != "" {
-		b.lockFileOpt.stopRenewal()
-		err = os.Remove(b.lockFile)
-		if err == nil {
+		stopRenewal()
+		errUnlock := os.Remove(b.lockFile)
+		if errUnlock == nil {
 			fs.Debugf(nil, "Lock file removed: %s", b.lockFile)
+		} else if err == nil {
+			err = errUnlock
 		} else {
-			fs.Errorf(nil, "cannot remove lockfile %s: %v", b.lockFile, err)
+			fs.Errorf(nil, "cannot remove lockfile %s: %v", b.lockFile, errUnlock)
 		}
 		b.lockFile = "" // block removing it again
 	}
-	return err
 }
 
 func (b *bisyncRun) setLockFileExpiration() {
@@ -77,18 +77,18 @@ func (b *bisyncRun) setLockFileExpiration() {
 func (b *bisyncRun) renewLockFile() {
 	if b.lockFile != "" && bilib.FileExists(b.lockFile) {
 
-		b.lockFileOpt.data.Session = b.basePath
-		b.lockFileOpt.data.PID = strconv.Itoa(os.Getpid())
-		b.lockFileOpt.data.TimeRenewed = time.Now()
-		b.lockFileOpt.data.TimeExpires = time.Now().Add(time.Duration(b.opt.MaxLock))
+		data.Session = b.basePath
+		data.PID = strconv.Itoa(os.Getpid())
+		data.TimeRenewed = time.Now()
+		data.TimeExpires = time.Now().Add(time.Duration(b.opt.MaxLock))
 
 		// save data file
 		df, err := os.Create(b.lockFile)
 		b.handleErr(b.lockFile, "error renewing lock file", err, true, true)
-		b.handleErr(b.lockFile, "error encoding JSON to lock file", json.NewEncoder(df).Encode(b.lockFileOpt.data), true, true)
+		b.handleErr(b.lockFile, "error encoding JSON to lock file", json.NewEncoder(df).Encode(data), true, true)
 		b.handleErr(b.lockFile, "error closing lock file", df.Close(), true, true)
 		if b.opt.MaxLock < basicallyforever {
-			fs.Infof(nil, Color(terminal.HiBlueFg, "lock file renewed for %v. New expiration: %v"), b.opt.MaxLock, b.lockFileOpt.data.TimeExpires)
+			fs.Infof(nil, Color(terminal.HiBlueFg, "lock file renewed for %v. New expiration: %v"), b.opt.MaxLock, data.TimeExpires)
 		}
 	}
 }
@@ -99,7 +99,7 @@ func (b *bisyncRun) lockFileIsExpired() bool {
 		b.handleErr(b.lockFile, "error reading lock file", err, true, true)
 		dec := json.NewDecoder(rdf)
 		for {
-			if err := dec.Decode(&b.lockFileOpt.data); err != nil {
+			if err := dec.Decode(&data); err != nil {
 				if err != io.EOF {
 					fs.Errorf(b.lockFile, "err: %v", err)
 				}
@@ -107,14 +107,14 @@ func (b *bisyncRun) lockFileIsExpired() bool {
 			}
 		}
 		b.handleErr(b.lockFile, "error closing file", rdf.Close(), true, true)
-		if !b.lockFileOpt.data.TimeExpires.IsZero() && b.lockFileOpt.data.TimeExpires.Before(time.Now()) {
-			fs.Infof(b.lockFile, Color(terminal.GreenFg, "Lock file found, but it expired at %v. Will delete it and proceed."), b.lockFileOpt.data.TimeExpires)
+		if !data.TimeExpires.IsZero() && data.TimeExpires.Before(time.Now()) {
+			fs.Infof(b.lockFile, Color(terminal.GreenFg, "Lock file found, but it expired at %v. Will delete it and proceed."), data.TimeExpires)
 			markFailed(b.listing1) // listing is untrusted so force revert to prior (if --recover) or create new ones (if --resync)
 			markFailed(b.listing2)
 			return true
 		}
-		fs.Infof(b.lockFile, Color(terminal.RedFg, "Valid lock file found. Expires at %v. (%v from now)"), b.lockFileOpt.data.TimeExpires, time.Since(b.lockFileOpt.data.TimeExpires).Abs().Round(time.Second))
-		prettyprint(b.lockFileOpt.data, "Lockfile info", fs.LogLevelInfo)
+		fs.Infof(b.lockFile, Color(terminal.RedFg, "Valid lock file found. Expires at %v. (%v from now)"), data.TimeExpires, time.Since(data.TimeExpires).Abs().Round(time.Second))
+		prettyprint(data, "Lockfile info", fs.LogLevelInfo)
 	}
 	return false
 }

cmd/bisync/log.go

@@ -6,7 +6,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/rclone/rclone/fs"
 	"github.com/rclone/rclone/lib/encoder"
@@ -68,15 +67,10 @@ func quotePath(path string) string {
 }
 
 // Colors controls whether terminal colors are enabled
-var (
-	Colors     bool
-	ColorsLock sync.Mutex
-)
+var Colors bool
 
 // Color handles terminal colors for bisync
 func Color(style string, s string) string {
-	ColorsLock.Lock()
-	defer ColorsLock.Unlock()
 	if !Colors {
 		return s
 	}
@@ -86,8 +80,6 @@ func Color(style string, s string) string {
 
 // ColorX handles terminal colors for bisync
 func ColorX(style string, s string) string {
-	ColorsLock.Lock()
-	defer ColorsLock.Unlock()
 	if !Colors {
 		return s
 	}

cmd/bisync/march.go

@@ -12,20 +12,18 @@ import (
 	"github.com/rclone/rclone/fs/march"
 )
 
-type bisyncMarch struct {
-	ls1            *fileList
-	ls2            *fileList
-	err            error
-	firstErr       error
-	marchAliasLock sync.Mutex
-	marchLsLock    sync.Mutex
-	marchErrLock   sync.Mutex
-	marchCtx       context.Context
-}
+var ls1 = newFileList()
+var ls2 = newFileList()
+var err error
+var firstErr error
+var marchAliasLock sync.Mutex
+var marchLsLock sync.Mutex
+var marchErrLock sync.Mutex
+var marchCtx context.Context
 
 func (b *bisyncRun) makeMarchListing(ctx context.Context) (*fileList, *fileList, error) {
 	ci := fs.GetConfig(ctx)
-	b.march.marchCtx = ctx
+	marchCtx = ctx
 	b.setupListing()
 	fs.Debugf(b, "starting to march!")
 
@@ -41,31 +39,31 @@ func (b *bisyncRun) makeMarchListing(ctx context.Context) (*fileList, *fileList,
 		NoCheckDest:            false,
 		NoUnicodeNormalization: ci.NoUnicodeNormalization,
 	}
-	b.march.err = m.Run(ctx)
+	err = m.Run(ctx)
 
-	fs.Debugf(b, "march completed. err: %v", b.march.err)
-	if b.march.err == nil {
-		b.march.err = b.march.firstErr
+	fs.Debugf(b, "march completed. err: %v", err)
+	if err == nil {
+		err = firstErr
 	}
-	if b.march.err != nil {
-		b.handleErr("march", "error during march", b.march.err, true, true)
+	if err != nil {
+		b.handleErr("march", "error during march", err, true, true)
 		b.abort = true
-		return b.march.ls1, b.march.ls2, b.march.err
+		return ls1, ls2, err
 	}
 
 	// save files
-	if b.opt.Compare.DownloadHash && b.march.ls1.hash == hash.None {
-		b.march.ls1.hash = hash.MD5
+	if b.opt.Compare.DownloadHash && ls1.hash == hash.None {
+		ls1.hash = hash.MD5
 	}
-	if b.opt.Compare.DownloadHash && b.march.ls2.hash == hash.None {
-		b.march.ls2.hash = hash.MD5
+	if b.opt.Compare.DownloadHash && ls2.hash == hash.None {
+		ls2.hash = hash.MD5
 	}
-	b.march.err = b.march.ls1.save(b.newListing1)
-	b.handleErr(b.march.ls1, "error saving b.march.ls1 from march", b.march.err, true, true)
-	b.march.err = b.march.ls2.save(b.newListing2)
-	b.handleErr(b.march.ls2, "error saving b.march.ls2 from march", b.march.err, true, true)
+	err = ls1.save(ctx, b.newListing1)
+	b.handleErr(ls1, "error saving ls1 from march", err, true, true)
+	err = ls2.save(ctx, b.newListing2)
+	b.handleErr(ls2, "error saving ls2 from march", err, true, true)
 
-	return b.march.ls1, b.march.ls2, b.march.err
+	return ls1, ls2, err
 }
 
 // SrcOnly have an object which is on path1 only
@@ -85,9 +83,9 @@ func (b *bisyncRun) DstOnly(o fs.DirEntry) (recurse bool) {
 // Match is called when object exists on both path1 and path2 (whether equal or not)
 func (b *bisyncRun) Match(ctx context.Context, o2, o1 fs.DirEntry) (recurse bool) {
 	fs.Debugf(o1, "both path1 and path2")
-	b.march.marchAliasLock.Lock()
+	marchAliasLock.Lock()
 	b.aliases.Add(o1.Remote(), o2.Remote())
-	b.march.marchAliasLock.Unlock()
+	marchAliasLock.Unlock()
 	b.parse(o1, true)
 	b.parse(o2, false)
 	return isDir(o1)
@@ -121,76 +119,76 @@ func (b *bisyncRun) parse(e fs.DirEntry, isPath1 bool) {
 }
 
 func (b *bisyncRun) setupListing() {
-	b.march.ls1 = newFileList()
-	b.march.ls2 = newFileList()
+	ls1 = newFileList()
+	ls2 = newFileList()
 
 	// note that --ignore-listing-checksum is different from --ignore-checksum
 	// and we already checked it when we set b.opt.Compare.HashType1 and 2
-	b.march.ls1.hash = b.opt.Compare.HashType1
-	b.march.ls2.hash = b.opt.Compare.HashType2
+	ls1.hash = b.opt.Compare.HashType1
+	ls2.hash = b.opt.Compare.HashType2
 }
 
 func (b *bisyncRun) ForObject(o fs.Object, isPath1 bool) {
-	tr := accounting.Stats(b.march.marchCtx).NewCheckingTransfer(o, "listing file - "+whichPath(isPath1))
+	tr := accounting.Stats(marchCtx).NewCheckingTransfer(o, "listing file - "+whichPath(isPath1))
 	defer func() {
-		tr.Done(b.march.marchCtx, nil)
+		tr.Done(marchCtx, nil)
 	}()
 	var (
 		hashVal string
 		hashErr error
 	)
-	ls := b.whichLs(isPath1)
+	ls := whichLs(isPath1)
 	hashType := ls.hash
 	if hashType != hash.None {
-		hashVal, hashErr = o.Hash(b.march.marchCtx, hashType)
-		b.march.marchErrLock.Lock()
-		if b.march.firstErr == nil {
-			b.march.firstErr = hashErr
+		hashVal, hashErr = o.Hash(marchCtx, hashType)
+		marchErrLock.Lock()
+		if firstErr == nil {
+			firstErr = hashErr
 		}
-		b.march.marchErrLock.Unlock()
+		marchErrLock.Unlock()
 	}
-	hashVal, hashErr = b.tryDownloadHash(b.march.marchCtx, o, hashVal)
-	b.march.marchErrLock.Lock()
-	if b.march.firstErr == nil {
-		b.march.firstErr = hashErr
+	hashVal, hashErr = tryDownloadHash(marchCtx, o, hashVal)
+	marchErrLock.Lock()
+	if firstErr == nil {
+		firstErr = hashErr
 	}
-	if b.march.firstErr != nil {
-		b.handleErr(hashType, "error hashing during march", b.march.firstErr, false, true)
+	if firstErr != nil {
+		b.handleErr(hashType, "error hashing during march", firstErr, false, true)
 	}
-	b.march.marchErrLock.Unlock()
+	marchErrLock.Unlock()
 
 	var modtime time.Time
 	if b.opt.Compare.Modtime {
-		modtime = o.ModTime(b.march.marchCtx).In(TZ)
+		modtime = o.ModTime(marchCtx).In(TZ)
 	}
 	id := ""     // TODO: ID(o)
 	flags := "-" // "-" for a file and "d" for a directory
-	b.march.marchLsLock.Lock()
+	marchLsLock.Lock()
 	ls.put(o.Remote(), o.Size(), modtime, hashVal, id, flags)
-	b.march.marchLsLock.Unlock()
+	marchLsLock.Unlock()
 }
 
 func (b *bisyncRun) ForDir(o fs.Directory, isPath1 bool) {
-	tr := accounting.Stats(b.march.marchCtx).NewCheckingTransfer(o, "listing dir - "+whichPath(isPath1))
+	tr := accounting.Stats(marchCtx).NewCheckingTransfer(o, "listing dir - "+whichPath(isPath1))
 	defer func() {
-		tr.Done(b.march.marchCtx, nil)
+		tr.Done(marchCtx, nil)
 	}()
-	ls := b.whichLs(isPath1)
+	ls := whichLs(isPath1)
 	var modtime time.Time
 	if b.opt.Compare.Modtime {
-		modtime = o.ModTime(b.march.marchCtx).In(TZ)
+		modtime = o.ModTime(marchCtx).In(TZ)
 	}
 	id := ""     // TODO
 	flags := "d" // "-" for a file and "d" for a directory
-	b.march.marchLsLock.Lock()
+	marchLsLock.Lock()
 	ls.put(o.Remote(), -1, modtime, "", id, flags)
-	b.march.marchLsLock.Unlock()
+	marchLsLock.Unlock()
 }
 
-func (b *bisyncRun) whichLs(isPath1 bool) *fileList {
-	ls := b.march.ls1
+func whichLs(isPath1 bool) *fileList {
+	ls := ls1
 	if !isPath1 {
-		ls = b.march.ls2
+		ls = ls2
 	}
 	return ls
 }
@@ -208,7 +206,7 @@ func (b *bisyncRun) findCheckFiles(ctx context.Context) (*fileList, *fileList, e
 	b.handleErr(b.opt.CheckFilename, "error adding CheckFilename to filter", filterCheckFile.Add(true, b.opt.CheckFilename), true, true)
 	b.handleErr(b.opt.CheckFilename, "error adding ** exclusion to filter", filterCheckFile.Add(false, "**"), true, true)
 	ci := fs.GetConfig(ctxCheckFile)
-	b.march.marchCtx = ctxCheckFile
+	marchCtx = ctxCheckFile
 
 	b.setupListing()
 	fs.Debugf(b, "starting to march!")
@@ -225,18 +223,18 @@ func (b *bisyncRun) findCheckFiles(ctx context.Context) (*fileList, *fileList, e
 		NoCheckDest:            false,
 		NoUnicodeNormalization: ci.NoUnicodeNormalization,
 	}
-	b.march.err = m.Run(ctxCheckFile)
+	err = m.Run(ctxCheckFile)
 
-	fs.Debugf(b, "march completed. err: %v", b.march.err)
-	if b.march.err == nil {
-		b.march.err = b.march.firstErr
+	fs.Debugf(b, "march completed. err: %v", err)
+	if err == nil {
+		err = firstErr
 	}
-	if b.march.err != nil {
-		b.handleErr("march", "error during findCheckFiles", b.march.err, true, true)
+	if err != nil {
+		b.handleErr("march", "error during findCheckFiles", err, true, true)
 		b.abort = true
 	}
 
-	return b.march.ls1, b.march.ls2, b.march.err
+	return ls1, ls2, err
 }
 
 // ID returns the ID of the Object if known, or "" if not

cmd/bisync/operations.go

@@ -51,11 +51,6 @@ type bisyncRun struct {
 	lockFile           string
 	renames            renames
 	resyncIs1to2       bool
-	march              bisyncMarch
-	check              bisyncCheck
-	queueOpt           bisyncQueueOpt
-	downloadHashOpt    downloadHashOpt
-	lockFileOpt        lockFileOpt
 }
 
 type queues struct {
@@ -69,6 +64,7 @@ type queues struct {
 
 // Bisync handles lock file, performs bisync run and checks exit status
 func Bisync(ctx context.Context, fs1, fs2 fs.Fs, optArg *Options) (err error) {
+	defer resetGlobals()
 	opt := *optArg // ensure that input is never changed
 	b := &bisyncRun{
 		fs1:       fs1,
@@ -87,9 +83,7 @@ func Bisync(ctx context.Context, fs1, fs2 fs.Fs, optArg *Options) (err error) {
 	opt.OrigBackupDir = ci.BackupDir
 
 	if ci.TerminalColorMode == fs.TerminalColorModeAlways || (ci.TerminalColorMode == fs.TerminalColorModeAuto && !log.Redirected()) {
-		ColorsLock.Lock()
 		Colors = true
-		ColorsLock.Unlock()
 	}
 
 	err = b.setCompareDefaults(ctx)
@@ -99,7 +93,7 @@ func Bisync(ctx context.Context, fs1, fs2 fs.Fs, optArg *Options) (err error) {
 
 	b.setResyncDefaults()
 
-	err = b.setResolveDefaults()
+	err = b.setResolveDefaults(ctx)
 	if err != nil {
 		return err
 	}
@@ -130,8 +124,6 @@ func Bisync(ctx context.Context, fs1, fs2 fs.Fs, optArg *Options) (err error) {
 		return err
 	}
 
-	b.queueOpt.logger = operations.NewLoggerOpt()
-
 	// Handle SIGINT
 	var finaliseOnce gosync.Once
 
@@ -169,7 +161,7 @@ func Bisync(ctx context.Context, fs1, fs2 fs.Fs, optArg *Options) (err error) {
 					markFailed(b.listing1)
 					markFailed(b.listing2)
 				}
-				err = b.removeLockFile()
+				b.removeLockFile()
 			}
 		})
 	}
@@ -179,10 +171,7 @@ func Bisync(ctx context.Context, fs1, fs2 fs.Fs, optArg *Options) (err error) {
 	// run bisync
 	err = b.runLocked(ctx)
 
-	removeLockErr := b.removeLockFile()
-	if err == nil {
-		err = removeLockErr
-	}
+	b.removeLockFile()
 
 	b.CleanupCompleted = true
 	if b.InGracefulShutdown {
@@ -273,7 +262,7 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 
 	// Generate Path1 and Path2 listings and copy any unique Path2 files to Path1
 	if opt.Resync {
-		return b.resync(fctx)
+		return b.resync(octx, fctx)
 	}
 
 	// Check for existence of prior Path1 and Path2 listings
@@ -308,7 +297,7 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 	}
 
 	fs.Infof(nil, "Building Path1 and Path2 listings")
-	b.march.ls1, b.march.ls2, err = b.makeMarchListing(fctx)
+	ls1, ls2, err = b.makeMarchListing(fctx)
 	if err != nil || accounting.Stats(fctx).Errored() {
 		fs.Error(nil, Color(terminal.RedFg, "There were errors while building listings. Aborting as it is too dangerous to continue."))
 		b.critical = true
@@ -318,7 +307,7 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 
 	// Check for Path1 deltas relative to the prior sync
 	fs.Infof(nil, "Path1 checking for diffs")
-	ds1, err := b.findDeltas(fctx, b.fs1, b.listing1, b.march.ls1, "Path1")
+	ds1, err := b.findDeltas(fctx, b.fs1, b.listing1, ls1, "Path1")
 	if err != nil {
 		return err
 	}
@@ -326,7 +315,7 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 
 	// Check for Path2 deltas relative to the prior sync
 	fs.Infof(nil, "Path2 checking for diffs")
-	ds2, err := b.findDeltas(fctx, b.fs2, b.listing2, b.march.ls2, "Path2")
+	ds2, err := b.findDeltas(fctx, b.fs2, b.listing2, ls2, "Path2")
 	if err != nil {
 		return err
 	}
@@ -400,7 +389,7 @@ func (b *bisyncRun) runLocked(octx context.Context) (err error) {
 		newl1, _ := b.loadListing(b.newListing1)
 		newl2, _ := b.loadListing(b.newListing2)
 		b.debug(b.DebugName, fmt.Sprintf("pre-saveOldListings, ls1 has name?: %v, ls2 has name?: %v", l1.has(b.DebugName), l2.has(b.DebugName)))
-		b.debug(b.DebugName, fmt.Sprintf("pre-saveOldListings, newls1 has name?: %v, ls2 has name?: %v", newl1.has(b.DebugName), newl2.has(b.DebugName)))
+		b.debug(b.DebugName, fmt.Sprintf("pre-saveOldListings, newls1 has name?: %v, newls2 has name?: %v", newl1.has(b.DebugName), newl2.has(b.DebugName)))
 	}
 	b.saveOldListings()
 	// save new listings
@@ -564,7 +553,7 @@ func (b *bisyncRun) setBackupDir(ctx context.Context, destPath int) context.Cont
 	return ctx
 }
 
-func (b *bisyncRun) overlappingPathsCheck(fctx context.Context, fs1, fs2 fs.Fs) (err error) {
+func (b *bisyncRun) overlappingPathsCheck(fctx context.Context, fs1, fs2 fs.Fs) error {
 	if operations.OverlappingFilterCheck(fctx, fs2, fs1) {
 		err = errors.New(Color(terminal.RedFg, "Overlapping paths detected. Cannot bisync between paths that overlap, unless excluded by filters."))
 		return err
@@ -597,7 +586,7 @@ func (b *bisyncRun) overlappingPathsCheck(fctx context.Context, fs1, fs2 fs.Fs)
 	return nil
 }
 
-func (b *bisyncRun) checkSyntax() (err error) {
+func (b *bisyncRun) checkSyntax() error {
 	// check for odd number of quotes in path, usually indicating an escaping issue
 	path1 := bilib.FsPath(b.fs1)
 	path2 := bilib.FsPath(b.fs2)
@@ -645,3 +634,25 @@ func waitFor(msg string, totalWait time.Duration, fn func() bool) (ok bool) {
 	}
 	return false
 }
+
+// mainly to make sure tests don't interfere with each other when running more than one
+func resetGlobals() {
+	downloadHash = false
+	logger = operations.NewLoggerOpt()
+	ignoreListingChecksum = false
+	ignoreListingModtime = false
+	hashTypes = nil
+	queueCI = nil
+	hashType = 0
+	fsrc, fdst = nil, nil
+	fcrypt = nil
+	Opt = Options{}
+	once = gosync.Once{}
+	downloadHashWarn = gosync.Once{}
+	firstDownloadHash = gosync.Once{}
+	ls1 = newFileList()
+	ls2 = newFileList()
+	err = nil
+	firstErr = nil
+	marchCtx = nil
+}

cmd/bisync/queue.go

@@ -51,19 +51,19 @@ func (rs *ResultsSlice) has(name string) bool {
 	return false
 }
 
-type bisyncQueueOpt struct {
-	logger                operations.LoggerOpt
+var (
+	logger                = operations.NewLoggerOpt()
 	lock                  mutex.Mutex
 	once                  mutex.Once
 	ignoreListingChecksum bool
 	ignoreListingModtime  bool
 	hashTypes             map[string]hash.Type
 	queueCI               *fs.ConfigInfo
-}
+)
 
 // allows us to get the right hashtype during the LoggerFn without knowing whether it's Path1/Path2
-func (b *bisyncRun) getHashType(fname string) hash.Type {
-	ht, ok := b.queueOpt.hashTypes[fname]
+func getHashType(fname string) hash.Type {
+	ht, ok := hashTypes[fname]
 	if ok {
 		return ht
 	}
@@ -106,9 +106,9 @@ func altName(name string, src, dst fs.DirEntry) string {
 }
 
 // WriteResults is Bisync's LoggerFn
-func (b *bisyncRun) WriteResults(ctx context.Context, sigil operations.Sigil, src, dst fs.DirEntry, err error) {
-	b.queueOpt.lock.Lock()
-	defer b.queueOpt.lock.Unlock()
+func WriteResults(ctx context.Context, sigil operations.Sigil, src, dst fs.DirEntry, err error) {
+	lock.Lock()
+	defer lock.Unlock()
 
 	opt := operations.GetLoggerOpt(ctx)
 	result := Results{
@@ -131,14 +131,14 @@ func (b *bisyncRun) WriteResults(ctx context.Context, sigil operations.Sigil, sr
 		result.Flags = "-"
 		if side != nil {
 			result.Size = side.Size()
-			if !b.queueOpt.ignoreListingModtime {
+			if !ignoreListingModtime {
 				result.Modtime = side.ModTime(ctx).In(TZ)
 			}
-			if !b.queueOpt.ignoreListingChecksum {
+			if !ignoreListingChecksum {
 				sideObj, ok := side.(fs.ObjectInfo)
 				if ok {
-					result.Hash, _ = sideObj.Hash(ctx, b.getHashType(sideObj.Fs().Name()))
-					result.Hash, _ = b.tryDownloadHash(ctx, sideObj, result.Hash)
+					result.Hash, _ = sideObj.Hash(ctx, getHashType(sideObj.Fs().Name()))
+					result.Hash, _ = tryDownloadHash(ctx, sideObj, result.Hash)
 				}
 
 			}
@@ -159,8 +159,8 @@ func (b *bisyncRun) WriteResults(ctx context.Context, sigil operations.Sigil, sr
 		}
 
 		prettyprint(result, "writing result", fs.LogLevelDebug)
-		if result.Size < 0 && result.Flags != "d" && ((b.queueOpt.queueCI.CheckSum && !b.downloadHashOpt.downloadHash) || b.queueOpt.queueCI.SizeOnly) {
-			b.queueOpt.once.Do(func() {
+		if result.Size < 0 && result.Flags != "d" && ((queueCI.CheckSum && !downloadHash) || queueCI.SizeOnly) {
+			once.Do(func() {
 				fs.Log(result.Name, Color(terminal.YellowFg, "Files of unknown size (such as Google Docs) do not sync reliably with --checksum or --size-only. Consider using modtime instead (the default) or --drive-skip-gdocs"))
 			})
 		}
@@ -189,14 +189,14 @@ func ReadResults(results io.Reader) []Results {
 
 // for setup code shared by both fastCopy and resyncDir
 func (b *bisyncRun) preCopy(ctx context.Context) context.Context {
-	b.queueOpt.queueCI = fs.GetConfig(ctx)
-	b.queueOpt.ignoreListingChecksum = b.opt.IgnoreListingChecksum
-	b.queueOpt.ignoreListingModtime = !b.opt.Compare.Modtime
-	b.queueOpt.hashTypes = map[string]hash.Type{
+	queueCI = fs.GetConfig(ctx)
+	ignoreListingChecksum = b.opt.IgnoreListingChecksum
+	ignoreListingModtime = !b.opt.Compare.Modtime
+	hashTypes = map[string]hash.Type{
 		b.fs1.Name(): b.opt.Compare.HashType1,
 		b.fs2.Name(): b.opt.Compare.HashType2,
 	}
-	b.queueOpt.logger.LoggerFn = b.WriteResults
+	logger.LoggerFn = WriteResults
 	overridingEqual := false
 	if (b.opt.Compare.Modtime && b.opt.Compare.Checksum) || b.opt.Compare.DownloadHash {
 		overridingEqual = true
@@ -209,15 +209,15 @@ func (b *bisyncRun) preCopy(ctx context.Context) context.Context {
 		fs.Debugf(nil, "overriding equal")
 		ctx = b.EqualFn(ctx)
 	}
-	ctxCopyLogger := operations.WithSyncLogger(ctx, b.queueOpt.logger)
+	ctxCopyLogger := operations.WithSyncLogger(ctx, logger)
 	if b.opt.Compare.Checksum && (b.opt.Compare.NoSlowHash || b.opt.Compare.SlowHashSyncOnly) && b.opt.Compare.SlowHashDetected {
 		// set here in case !b.opt.Compare.Modtime
-		b.queueOpt.queueCI = fs.GetConfig(ctxCopyLogger)
+		queueCI = fs.GetConfig(ctxCopyLogger)
 		if b.opt.Compare.NoSlowHash {
-			b.queueOpt.queueCI.CheckSum = false
+			queueCI.CheckSum = false
 		}
 		if b.opt.Compare.SlowHashSyncOnly && !overridingEqual {
-			b.queueOpt.queueCI.CheckSum = true
+			queueCI.CheckSum = true
 		}
 	}
 	return ctxCopyLogger
@@ -245,16 +245,14 @@ func (b *bisyncRun) fastCopy(ctx context.Context, fsrc, fdst fs.Fs, files bilib.
 		}
 	}
 
-	b.SyncCI = fs.GetConfig(ctxCopy) // allows us to request graceful shutdown
-	if accounting.MaxCompletedTransfers != -1 {
-		accounting.MaxCompletedTransfers = -1 // we need a complete list in the event of graceful shutdown
-	}
+	b.SyncCI = fs.GetConfig(ctxCopy)      // allows us to request graceful shutdown
+	accounting.MaxCompletedTransfers = -1 // we need a complete list in the event of graceful shutdown
 	ctxCopy, b.CancelSync = context.WithCancel(ctxCopy)
 	b.testFn()
 	err := sync.Sync(ctxCopy, fdst, fsrc, b.opt.CreateEmptySrcDirs)
-	prettyprint(b.queueOpt.logger, "b.queueOpt.logger", fs.LogLevelDebug)
+	prettyprint(logger, "logger", fs.LogLevelDebug)
 
-	getResults := ReadResults(b.queueOpt.logger.JSON)
+	getResults := ReadResults(logger.JSON)
 	fs.Debugf(nil, "Got %v results for %v", len(getResults), queueName)
 
 	lineFormat := "%s %8d %s %s %s %q\n"
@@ -294,9 +292,9 @@ func (b *bisyncRun) resyncDir(ctx context.Context, fsrc, fdst fs.Fs) ([]Results,
 	ctx = b.preCopy(ctx)
 
 	err := sync.CopyDir(ctx, fdst, fsrc, b.opt.CreateEmptySrcDirs)
-	prettyprint(b.queueOpt.logger, "b.queueOpt.logger", fs.LogLevelDebug)
+	prettyprint(logger, "logger", fs.LogLevelDebug)
 
-	getResults := ReadResults(b.queueOpt.logger.JSON)
+	getResults := ReadResults(logger.JSON)
 	fs.Debugf(nil, "Got %v results for %v", len(getResults), "resync")
 
 	return getResults, err

cmd/bisync/resolve.go

@@ -77,7 +77,7 @@ func (conflictLoserChoices) Type() string {
 // ConflictLoserList is a list of --conflict-loser flag choices used in the help
 var ConflictLoserList = Opt.ConflictLoser.Help()
 
-func (b *bisyncRun) setResolveDefaults() error {
+func (b *bisyncRun) setResolveDefaults(ctx context.Context) error {
 	if b.opt.ConflictLoser == ConflictLoserSkip {
 		b.opt.ConflictLoser = ConflictLoserNumber
 	}
@@ -135,7 +135,7 @@ type namePair struct {
 	newName string
 }
 
-func (b *bisyncRun) resolve(ctxMove context.Context, path1, path2, file, alias string, renameSkipped, copy1to2, copy2to1 *bilib.Names, ds1, ds2 *deltaSet) (err error) {
+func (b *bisyncRun) resolve(ctxMove context.Context, path1, path2, file, alias string, renameSkipped, copy1to2, copy2to1 *bilib.Names, ds1, ds2 *deltaSet) error {
 	winningPath := 0
 	if b.opt.ConflictResolve != PreferNone {
 		winningPath = b.conflictWinner(ds1, ds2, file, alias)
@@ -197,7 +197,7 @@ func (b *bisyncRun) resolve(ctxMove context.Context, path1, path2, file, alias s
 	// note also that deletes and renames are mutually exclusive -- we never delete one path and rename the other.
 	if b.opt.ConflictLoser == ConflictLoserDelete && winningPath == 1 {
 		// delete 2, copy 1 to 2
-		err = b.delete(ctxMove, r.path2, path2, b.fs2, 2, renameSkipped)
+		err = b.delete(ctxMove, r.path2, path2, path1, b.fs2, 2, 1, renameSkipped)
 		if err != nil {
 			return err
 		}
@@ -207,7 +207,7 @@ func (b *bisyncRun) resolve(ctxMove context.Context, path1, path2, file, alias s
 		copy1to2.Add(r.path1.oldName)
 	} else if b.opt.ConflictLoser == ConflictLoserDelete && winningPath == 2 {
 		// delete 1, copy 2 to 1
-		err = b.delete(ctxMove, r.path1, path1, b.fs1, 1, renameSkipped)
+		err = b.delete(ctxMove, r.path1, path1, path2, b.fs1, 1, 2, renameSkipped)
 		if err != nil {
 			return err
 		}
@@ -261,15 +261,15 @@ func (ri *renamesInfo) getNames(is1to2 bool) (srcOldName, srcNewName, dstOldName
 func (b *bisyncRun) numerate(ctx context.Context, startnum int, file, alias string) int {
 	for i := startnum; i < math.MaxInt; i++ {
 		iStr := fmt.Sprint(i)
-		if !b.march.ls1.has(SuffixName(ctx, file, b.opt.ConflictSuffix1+iStr)) &&
-			!b.march.ls1.has(SuffixName(ctx, alias, b.opt.ConflictSuffix1+iStr)) &&
-			!b.march.ls2.has(SuffixName(ctx, file, b.opt.ConflictSuffix2+iStr)) &&
-			!b.march.ls2.has(SuffixName(ctx, alias, b.opt.ConflictSuffix2+iStr)) {
+		if !ls1.has(SuffixName(ctx, file, b.opt.ConflictSuffix1+iStr)) &&
+			!ls1.has(SuffixName(ctx, alias, b.opt.ConflictSuffix1+iStr)) &&
+			!ls2.has(SuffixName(ctx, file, b.opt.ConflictSuffix2+iStr)) &&
+			!ls2.has(SuffixName(ctx, alias, b.opt.ConflictSuffix2+iStr)) {
 			// make sure it still holds true with suffixes switched (it should)
-			if !b.march.ls1.has(SuffixName(ctx, file, b.opt.ConflictSuffix2+iStr)) &&
-				!b.march.ls1.has(SuffixName(ctx, alias, b.opt.ConflictSuffix2+iStr)) &&
-				!b.march.ls2.has(SuffixName(ctx, file, b.opt.ConflictSuffix1+iStr)) &&
-				!b.march.ls2.has(SuffixName(ctx, alias, b.opt.ConflictSuffix1+iStr)) {
+			if !ls1.has(SuffixName(ctx, file, b.opt.ConflictSuffix2+iStr)) &&
+				!ls1.has(SuffixName(ctx, alias, b.opt.ConflictSuffix2+iStr)) &&
+				!ls2.has(SuffixName(ctx, file, b.opt.ConflictSuffix1+iStr)) &&
+				!ls2.has(SuffixName(ctx, alias, b.opt.ConflictSuffix1+iStr)) {
 				fs.Debugf(file, "The first available suffix is: %s", iStr)
 				return i
 			}
@@ -280,10 +280,10 @@ func (b *bisyncRun) numerate(ctx context.Context, startnum int, file, alias stri
 
 // like numerate, but consider only one side's suffix (for when suffixes are different)
 func (b *bisyncRun) numerateSingle(ctx context.Context, startnum int, file, alias string, path int) int {
-	lsA, lsB := b.march.ls1, b.march.ls2
+	lsA, lsB := ls1, ls2
 	suffix := b.opt.ConflictSuffix1
 	if path == 2 {
-		lsA, lsB = b.march.ls2, b.march.ls1
+		lsA, lsB = ls2, ls1
 		suffix = b.opt.ConflictSuffix2
 	}
 	for i := startnum; i < math.MaxInt; i++ {
@@ -299,7 +299,7 @@ func (b *bisyncRun) numerateSingle(ctx context.Context, startnum int, file, alia
 	return 0 // not really possible, as no one has 9223372036854775807 conflicts, and if they do, they have bigger problems
 }
 
-func (b *bisyncRun) rename(ctx context.Context, thisNamePair namePair, thisPath, thatPath string, thisFs fs.Fs, thisPathNum, thatPathNum, winningPath int, q, renameSkipped *bilib.Names) (err error) {
+func (b *bisyncRun) rename(ctx context.Context, thisNamePair namePair, thisPath, thatPath string, thisFs fs.Fs, thisPathNum, thatPathNum, winningPath int, q, renameSkipped *bilib.Names) error {
 	if winningPath == thisPathNum {
 		b.indent(fmt.Sprintf("!Path%d", thisPathNum), thisPath+thisNamePair.newName, fmt.Sprintf("Not renaming Path%d copy, as it was determined the winner", thisPathNum))
 	} else {
@@ -321,7 +321,7 @@ func (b *bisyncRun) rename(ctx context.Context, thisNamePair namePair, thisPath,
 	return nil
 }
 
-func (b *bisyncRun) delete(ctx context.Context, thisNamePair namePair, thisPath string, thisFs fs.Fs, thisPathNum int, renameSkipped *bilib.Names) (err error) {
+func (b *bisyncRun) delete(ctx context.Context, thisNamePair namePair, thisPath, thatPath string, thisFs fs.Fs, thisPathNum, thatPathNum int, renameSkipped *bilib.Names) error {
 	skip := operations.SkipDestructive(ctx, thisNamePair.oldName, "delete")
 	if !skip {
 		b.indent(fmt.Sprintf("!Path%d", thisPathNum), thisPath+thisNamePair.oldName, fmt.Sprintf("Deleting Path%d copy", thisPathNum))
@@ -359,17 +359,17 @@ func (b *bisyncRun) conflictWinner(ds1, ds2 *deltaSet, remote1, remote2 string)
 		return 2
 	case PreferNewer, PreferOlder:
 		t1, t2 := ds1.time[remote1], ds2.time[remote2]
-		return b.resolveNewerOlder(t1, t2, remote1, b.opt.ConflictResolve)
+		return b.resolveNewerOlder(t1, t2, remote1, remote2, b.opt.ConflictResolve)
 	case PreferLarger, PreferSmaller:
 		s1, s2 := ds1.size[remote1], ds2.size[remote2]
-		return b.resolveLargerSmaller(s1, s2, remote1, b.opt.ConflictResolve)
+		return b.resolveLargerSmaller(s1, s2, remote1, remote2, b.opt.ConflictResolve)
 	default:
 		return 0
 	}
 }
 
 // returns the winning path number, or 0 if winner can't be determined
-func (b *bisyncRun) resolveNewerOlder(t1, t2 time.Time, remote1 string, prefer Prefer) int {
+func (b *bisyncRun) resolveNewerOlder(t1, t2 time.Time, remote1, remote2 string, prefer Prefer) int {
 	if fs.GetModifyWindow(b.octx, b.fs1, b.fs2) == fs.ModTimeNotSupported {
 		fs.Infof(remote1, "Winner cannot be determined as at least one path lacks modtime support.")
 		return 0
@@ -380,31 +380,31 @@ func (b *bisyncRun) resolveNewerOlder(t1, t2 time.Time, remote1 string, prefer P
 	}
 	if t1.After(t2) {
 		if prefer == PreferNewer {
-			fs.Infof(remote1, "Path1 is newer. Path1: %v, Path2: %v, Difference: %s", t1.In(LogTZ), t2.In(LogTZ), t1.Sub(t2))
+			fs.Infof(remote1, "Path1 is newer. Path1: %v, Path2: %v, Difference: %s", t1.Local(), t2.Local(), t1.Sub(t2))
 			return 1
 		} else if prefer == PreferOlder {
-			fs.Infof(remote1, "Path2 is older. Path1: %v, Path2: %v, Difference: %s", t1.In(LogTZ), t2.In(LogTZ), t1.Sub(t2))
+			fs.Infof(remote1, "Path2 is older. Path1: %v, Path2: %v, Difference: %s", t1.Local(), t2.Local(), t1.Sub(t2))
 			return 2
 		}
 	} else if t1.Before(t2) {
 		if prefer == PreferNewer {
-			fs.Infof(remote1, "Path2 is newer. Path1: %v, Path2: %v, Difference: %s", t1.In(LogTZ), t2.In(LogTZ), t2.Sub(t1))
+			fs.Infof(remote1, "Path2 is newer. Path1: %v, Path2: %v, Difference: %s", t1.Local(), t2.Local(), t2.Sub(t1))
 			return 2
 		} else if prefer == PreferOlder {
-			fs.Infof(remote1, "Path1 is older. Path1: %v, Path2: %v, Difference: %s", t1.In(LogTZ), t2.In(LogTZ), t2.Sub(t1))
+			fs.Infof(remote1, "Path1 is older. Path1: %v, Path2: %v, Difference: %s", t1.Local(), t2.Local(), t2.Sub(t1))
 			return 1
 		}
 	}
 	if t1.Equal(t2) {
-		fs.Infof(remote1, "Winner cannot be determined as times are equal. Path1: %v, Path2: %v, Difference: %s", t1.In(LogTZ), t2.In(LogTZ), t2.Sub(t1))
+		fs.Infof(remote1, "Winner cannot be determined as times are equal. Path1: %v, Path2: %v, Difference: %s", t1.Local(), t2.Local(), t2.Sub(t1))
 		return 0
 	}
-	fs.Errorf(remote1, "Winner cannot be determined. Path1: %v, Path2: %v", t1.In(LogTZ), t2.In(LogTZ)) // shouldn't happen unless prefer is of wrong type
+	fs.Errorf(remote1, "Winner cannot be determined. Path1: %v, Path2: %v", t1.Local(), t2.Local()) // shouldn't happen unless prefer is of wrong type
 	return 0
 }
 
 // returns the winning path number, or 0 if winner can't be determined
-func (b *bisyncRun) resolveLargerSmaller(s1, s2 int64, remote1 string, prefer Prefer) int {
+func (b *bisyncRun) resolveLargerSmaller(s1, s2 int64, remote1, remote2 string, prefer Prefer) int {
 	if s1 < 0 || s2 < 0 {
 		fs.Infof(remote1, "Winner cannot be determined as at least one size is unknown. Path1: %v, Path2: %v", s1, s2)
 		return 0

cmd/bisync/resync.go

@@ -20,6 +20,7 @@ func (b *bisyncRun) setResyncDefaults() {
 	}
 	if b.opt.ResyncMode != PreferNone {
 		b.opt.Resync = true
+		Opt.Resync = true // shouldn't be using this one, but set to be safe
 	}
 
 	// checks and warnings
@@ -40,18 +41,18 @@ func (b *bisyncRun) setResyncDefaults() {
 // It will generate path1 and path2 listings,
 // copy any unique files to the opposite path,
 // and resolve any differing files according to the --resync-mode.
-func (b *bisyncRun) resync(fctx context.Context) (err error) {
+func (b *bisyncRun) resync(octx, fctx context.Context) error {
 	fs.Infof(nil, "Copying Path2 files to Path1")
 
 	// Save blank filelists (will be filled from sync results)
-	ls1 := newFileList()
-	ls2 := newFileList()
-	err = ls1.save(b.newListing1)
+	var ls1 = newFileList()
+	var ls2 = newFileList()
+	err = ls1.save(fctx, b.newListing1)
 	if err != nil {
 		b.handleErr(ls1, "error saving ls1 from resync", err, true, true)
 		b.abort = true
 	}
-	err = ls2.save(b.newListing2)
+	err = ls2.save(fctx, b.newListing2)
 	if err != nil {
 		b.handleErr(ls2, "error saving ls2 from resync", err, true, true)
 		b.abort = true

cmd/cachestats/cachestats.go

@@ -1,4 +1,4 @@
-//go:build !plan9 && !js && !wasm
+//go:build !plan9 && !js
 
 // Package cachestats provides the cachestats command.
 package cachestats

cmd/cachestats/cachestats_unsupported.go

@@ -1,7 +1,7 @@
 // Build for cache for unsupported platforms to stop go complaining
 // about "no buildable Go source files "
 
-//go:build plan9 || js || wasm
+//go:build plan9 || js
 
 // Package cachestats provides the cachestats command.
 package cachestats

cmd/mount/dir.go

@@ -130,12 +130,6 @@ func (d *Dir) ReadDirAll(ctx context.Context) (dirents []fuse.Dirent, err error)
 		if node.IsDir() {
 			dirent.Type = fuse.DT_Dir
 		}
-		switch node := node.(type) {
-		case *vfs.File:
-			if node.IsSymlink() {
-				dirent.Type = fuse.DT_Link
-			}
-		}
 		dirents = append(dirents, dirent)
 	}
 	itemsRead = len(dirents)